detectlib 0.2.2

extern crate x11;

use std::ptr;
pub use x11::{xlib,xtest::XTestFakeKeyEvent};
use std::cell::RefCell;

pub struct Input {
    display: *mut xlib::Display,
    prev_keys: RefCell<[u8; 32]>,
    prev_mbs: Vec<u8>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum KeyCode {
    Esc, Num1, Num2, Num3, Num4, Num5, Num6, Num7, Num8, Num9, Num0,
    Minus, Equals,
    Q, W, E, R, T, Y, U, I, O, P,
    LeftBracket, RightBracket,
    A,
    S,
    D,
    F,
    G,
    H,
    J,
    K,
    L,
    Semicolon,
    Apostrophe,
    Backtick,
    Backslash,
    Z,
    X,
    C,
    V,
    B,
    N,
    M,
    Comma,
    Period,
    Slash,
    Enter,
    Space,
    ShiftL,
    ShiftR,
    ControlL,
    ControlR,
    AltL,
    AltR,
    SuperL,
    SuperR,
    CapsLock,
    Tab,
    Backspace,
    F1,
    F2,
    F3,
    F4,
    F5,
    F6,
    F7,
    F8,
    F9,
    F10,
    F11,
    F12,
    Print,
    ScrollLock,
    Pause,
    Insert,
    Delete,
    Home,
    End,
    PageUp,
    PageDown,
    LeftArrow,
    RightArrow,
    UpArrow,
    DownArrow,
    NumLock,
    KpEnter,
    KpAdd,
    KpSubtract,
    KpMultiply,
    KpDivide,
    Kp0,
    Kp1,
    Kp2,
    Kp3,
    Kp4,
    Kp5,
    Kp6,
    Kp7,
    Kp8,
    Kp9,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum MouseButton {
    Left,
    Middle,
    Right,
    ScrollUp,
    ScrollDown,
    ScrollLeft,
    ScrollRight,
    ExtraButton1,
    ExtraButton2,
}


impl KeyCode {
    /// Returns the X11 keycode associated with the `KeyCode` enum.
    pub fn to_x11_keycode(&self) -> u8 {
        match self {
            KeyCode::Esc => 9,
            KeyCode::Num1 => 10,
            KeyCode::Num2 => 11,
            KeyCode::Num3 => 12,
            KeyCode::Num4 => 13,
            KeyCode::Num5 => 14,
            KeyCode::Num6 => 15,
            KeyCode::Num7 => 16,
            KeyCode::Num8 => 17,
            KeyCode::Num9 => 18,
            KeyCode::Num0 => 19,
            KeyCode::Minus => 20,
            KeyCode::Equals => 21,
            KeyCode::Q => 24,
            KeyCode::W => 25,
            KeyCode::E => 26,
            KeyCode::R => 27,
            KeyCode::T => 28,
            KeyCode::Y => 29,
            KeyCode::U => 30,
            KeyCode::I => 31,
            KeyCode::O => 32,
            KeyCode::P => 33,
            KeyCode::LeftBracket => 34,
            KeyCode::RightBracket => 35,
            KeyCode::A => 38,
            KeyCode::S => 39,
            KeyCode::D => 40,
            KeyCode::F => 41,
            KeyCode::G => 42,
            KeyCode::H => 43,
            KeyCode::J => 44,
            KeyCode::K => 45,
            KeyCode::L => 46,
            KeyCode::Semicolon => 47,
            KeyCode::Apostrophe => 48,
            KeyCode::Backtick => 49,
            KeyCode::Backslash => 51,
            KeyCode::Z => 52,
            KeyCode::X => 53,
            KeyCode::C => 54,
            KeyCode::V => 55,
            KeyCode::B => 56,
            KeyCode::N => 57,
            KeyCode::M => 58,
            KeyCode::Comma => 59,
            KeyCode::Period => 60,
            KeyCode::Slash => 61,
            KeyCode::Enter => 36,
            KeyCode::Space => 65,
            KeyCode::ShiftL => 50,
            KeyCode::ShiftR => 62,
            KeyCode::ControlL => 37,
            KeyCode::ControlR => 105,
            KeyCode::AltL => 64,
            KeyCode::AltR => 108,
            KeyCode::SuperL => 133,
            KeyCode::SuperR => 134,
            KeyCode::CapsLock => 66,
            KeyCode::Tab => 23,
            KeyCode::Backspace => 22,
            KeyCode::F1 => 67,
            KeyCode::F2 => 68,
            KeyCode::F3 => 69,
            KeyCode::F4 => 70,
            KeyCode::F5 => 71,
            KeyCode::F6 => 72,
            KeyCode::F7 => 73,
            KeyCode::F8 => 74,
            KeyCode::F9 => 75,
            KeyCode::F10 => 76,
            KeyCode::F11 => 95,
            KeyCode::F12 => 96,
            KeyCode::Print => 107,
            KeyCode::ScrollLock => 78,
            KeyCode::Pause => 127,
            KeyCode::Insert => 118,
            KeyCode::Delete => 119,
            KeyCode::Home => 110,
            KeyCode::End => 115,
            KeyCode::PageUp => 112,
            KeyCode::PageDown => 117,
            KeyCode::LeftArrow => 113,
            KeyCode::RightArrow => 114,
            KeyCode::UpArrow => 111,
            KeyCode::DownArrow => 116,
            KeyCode::NumLock => 77,
            KeyCode::KpEnter => 104,
            KeyCode::KpAdd => 86,
            KeyCode::KpSubtract => 82,
            KeyCode::KpMultiply => 63,
            KeyCode::KpDivide => 106,
            KeyCode::Kp0 => 90,
            KeyCode::Kp1 => 87,
            KeyCode::Kp2 => 88,
            KeyCode::Kp3 => 89,
            KeyCode::Kp4 => 83,
            KeyCode::Kp5 => 84,
            KeyCode::Kp6 => 85,
            KeyCode::Kp7 => 79,
            KeyCode::Kp8 => 80,
            KeyCode::Kp9 => 81,
        }
    }
}
impl MouseButton {
    /// Returns the X11 button code associated with the `MouseButton` enum.
    pub fn to_x11_buttoncode(&self) -> u8 {
        match self {
            MouseButton::Left => 1,
            MouseButton::Middle => 2,
            MouseButton::Right => 3,
            MouseButton::ScrollUp => 4,
            MouseButton::ScrollDown => 5,
            MouseButton::ScrollLeft => 6,
            MouseButton::ScrollRight => 7,
            MouseButton::ExtraButton1 => 8,
            MouseButton::ExtraButton2 => 9,
        }
    }
}
impl Input {
    /// Initializes the X11KeyChecker by opening the X11 display.
    pub fn new() -> Option<Self> {
        unsafe {
            let display = xlib::XOpenDisplay(ptr::null());
            if display.is_null() {
                return None;
            }
            Some(Input {
                display,
                prev_keys: RefCell::new([0; 32]),
                prev_mbs: vec![],
            })
        }
    }
    pub fn getkeydown(&self, kc: KeyCode) -> bool {
        // Allocate a 32-byte array to hold the current key states
        let mut curr_keys: [u8; 32] = [0; 32];

        // Get the current key states
        unsafe {
            xlib::XQueryKeymap(self.display, curr_keys.as_mut_ptr() as *mut i8);
        }
        let keycode = kc.to_x11_keycode();

        // Calculate the byte and bit position for the keycode
        let byte_index = (keycode / 8) as usize;
        let bit_index = (keycode % 8) as usize;

        // Check if the key was not pressed previously but is pressed now
        let was_not_pressed = (self.prev_keys.borrow()[byte_index] & (1 << bit_index)) == 0;
        let is_pressed_now = (curr_keys[byte_index] & (1 << bit_index)) != 0;

        // Update the previous keys array with the current state
        self.prev_keys.borrow_mut().copy_from_slice(&curr_keys);

        // Return true if the key was just pressed down
        was_not_pressed && is_pressed_now
    }
    pub fn getkeyup(&self, kc: KeyCode) -> bool {
        // Allocate a 32-byte array to hold the current key states
        let mut curr_keys: [u8; 32] = [0; 32];

        // Get the current key states
        unsafe {
            xlib::XQueryKeymap(self.display, curr_keys.as_mut_ptr() as *mut i8);
        }
        let keycode = kc.to_x11_keycode();

        // Calculate the byte and bit position for the keycode
        let byte_index = (keycode / 8) as usize;
        let bit_index = (keycode % 8) as usize;

        // Check if the key was not pressed previously but is pressed now
        let was_pressed = (self.prev_keys.borrow()[byte_index] & (1 << bit_index)) != 0;
        let is_not_pressed_now = (curr_keys[byte_index] & (1 << bit_index)) == 0;

        // Update the previous keys array with the current state
        self.prev_keys.borrow_mut().copy_from_slice(&curr_keys);

        // Return true if the key was just pressed down
        was_pressed && is_not_pressed_now
    }
    pub fn getkey(&self, kc: KeyCode) -> bool {
        unsafe {
            // Allocate a 32-byte array to hold key states
            let mut keys: [u8; 32] = [0; 32];
    
            // Get the current key states
            xlib::XQueryKeymap(self.display, keys.as_mut_ptr() as *mut i8);
    
            // Get the min and max keycode for the keyboard
            let mut min_keycode: i32 = 0;
            let mut max_keycode: i32 = 0;
            xlib::XDisplayKeycodes(self.display, &mut min_keycode, &mut max_keycode);
    
            // Create a vector to store pressed keycodes
            let mut pressed_keys: Vec<u8> = Vec::new();
    
            // Check which keys are pressed
            for keycode in min_keycode..=max_keycode {
                let byte_index = (keycode / 8) as usize;
                let bit_index = (keycode % 8) as usize;
    
                if (keys[byte_index] & (1 << bit_index)) != 0 {
                    pressed_keys.push(keycode as u8);
                }
            }
            pressed_keys.contains(&kc.to_x11_keycode())
        }
    }
    pub fn getmousebutton(&self, button: MouseButton) -> bool {
        unsafe {
            // Get the root window
            let root = xlib::XDefaultRootWindow(self.display);
    
            // Variables to hold the pointer position and mask state
            let mut root_return: xlib::Window = 0;
            let mut child_return: xlib::Window = 0;
            let mut root_x_return: i32 = 0;
            let mut root_y_return: i32 = 0;
            let mut win_x_return: i32 = 0;
            let mut win_y_return: i32 = 0;
            let mut mask_return: u32 = 0;
    
            // Query the pointer
            let status = xlib::XQueryPointer(
                self.display,
                root,
                &mut root_return,
                &mut child_return,
                &mut root_x_return,
                &mut root_y_return,
                &mut win_x_return,
                &mut win_y_return,
                &mut mask_return,
            );
    
            // Check if the query was successful
            if status == 0 {
                eprintln!("XQueryPointer failed");
                return false;
            }
    
            // Create a vector to store pressed button codes
            let mut pressed_buttons: Vec<u8> = Vec::new();
            if mask_return & xlib::Button1Mask != 0 {
                pressed_buttons.push(1);
            }
            if mask_return & xlib::Button2Mask != 0 {
                pressed_buttons.push(2);
            }
            if mask_return & xlib::Button3Mask != 0 {
                pressed_buttons.push(3);
            }
            if mask_return & xlib::Button4Mask != 0 {
                pressed_buttons.push(4);
            }
            if mask_return & xlib::Button5Mask != 0 {
                pressed_buttons.push(5);
            }
            if mask_return & 8192 != 0 { // Button 6
                pressed_buttons.push(6);
            }
            if mask_return & (1 << 9) != 0 { // Button 7
                pressed_buttons.push(7);
            }
            if mask_return & (1 << 10) != 0 { // Button 8
                pressed_buttons.push(8);
            }
            if mask_return & (1 << 11) != 0 { // Button 9
                pressed_buttons.push(9);
            }

            pressed_buttons.contains(&button.to_x11_buttoncode())
        }
    }
    pub fn getmousebuttondown(&mut self, button: MouseButton) -> bool {
        unsafe {
            // Get the root window
            let root = xlib::XDefaultRootWindow(self.display);
    
            // Variables to hold the pointer position and mask state
            let mut root_return: xlib::Window = 0;
            let mut child_return: xlib::Window = 0;
            let mut root_x_return: i32 = 0;
            let mut root_y_return: i32 = 0;
            let mut win_x_return: i32 = 0;
            let mut win_y_return: i32 = 0;
            let mut mask_return: u32 = 0;
    
            // Query the pointer
            let status = xlib::XQueryPointer(
                self.display,
                root,
                &mut root_return,
                &mut child_return,
                &mut root_x_return,
                &mut root_y_return,
                &mut win_x_return,
                &mut win_y_return,
                &mut mask_return,
            );
    
            // Check if the query was successful
            if status == 0 {
                eprintln!("XQueryPointer failed");
                return false;
            }
    
            // Create a vector to store pressed button codes
            let mut pressed_buttons: Vec<u8> = Vec::new();
            if mask_return & xlib::Button1Mask != 0 {
                pressed_buttons.push(1);
            }
            if mask_return & xlib::Button2Mask != 0 {
                pressed_buttons.push(2);
            }
            if mask_return & xlib::Button3Mask != 0 {
                pressed_buttons.push(3);
            }
            if mask_return & xlib::Button4Mask != 0 {
                pressed_buttons.push(4);
            }
            if mask_return & xlib::Button5Mask != 0 {
                pressed_buttons.push(5);
            }
            if mask_return & 8192 != 0 { // Button 6
                pressed_buttons.push(6);
            }
            if mask_return & (1 << 9) != 0 { // Button 7
                pressed_buttons.push(7);
            }
            if mask_return & (1 << 10) != 0 { // Button 8
                pressed_buttons.push(8);
            }
            if mask_return & (1 << 11) != 0 { // Button 9
                pressed_buttons.push(9);
            }
            
            let res = pressed_buttons.contains(&button.to_x11_buttoncode()) && !self.prev_mbs.contains(&button.to_x11_buttoncode());

            self.prev_mbs = pressed_buttons;
            res
        }
    }
    pub fn getmousebuttonup(&mut self, button: MouseButton) -> bool {
        unsafe {
            // Get the root window
            let root = xlib::XDefaultRootWindow(self.display);
    
            // Variables to hold the pointer position and mask state
            let mut root_return: xlib::Window = 0;
            let mut child_return: xlib::Window = 0;
            let mut root_x_return: i32 = 0;
            let mut root_y_return: i32 = 0;
            let mut win_x_return: i32 = 0;
            let mut win_y_return: i32 = 0;
            let mut mask_return: u32 = 0;
    
            // Query the pointer
            let status = xlib::XQueryPointer(
                self.display,
                root,
                &mut root_return,
                &mut child_return,
                &mut root_x_return,
                &mut root_y_return,
                &mut win_x_return,
                &mut win_y_return,
                &mut mask_return,
            );
    
            // Check if the query was successful
            if status == 0 {
                eprintln!("XQueryPointer failed");
                return false;
            }
    
            // Create a vector to store pressed button codes
            let mut pressed_buttons: Vec<u8> = Vec::new();
            if mask_return & xlib::Button1Mask != 0 {
                pressed_buttons.push(1);
            }
            if mask_return & xlib::Button2Mask != 0 {
                pressed_buttons.push(2);
            }
            if mask_return & xlib::Button3Mask != 0 {
                pressed_buttons.push(3);
            }
            if mask_return & xlib::Button4Mask != 0 {
                pressed_buttons.push(4);
            }
            if mask_return & xlib::Button5Mask != 0 {
                pressed_buttons.push(5);
            }
            if mask_return & 8192 != 0 { // Button 6
                pressed_buttons.push(6);
            }
            if mask_return & (1 << 9) != 0 { // Button 7
                pressed_buttons.push(7);
            }
            if mask_return & (1 << 10) != 0 { // Button 8
                pressed_buttons.push(8);
            }
            if mask_return & (1 << 11) != 0 { // Button 9
                pressed_buttons.push(9);
            }
            
            let res = !pressed_buttons.contains(&button.to_x11_buttoncode()) && self.prev_mbs.contains(&button.to_x11_buttoncode());

            self.prev_mbs = pressed_buttons;
            res
        }
    }
    pub fn getmousepos(&self) -> (u16, u16) {
        unsafe {
    
            // Get the root window
            let root = xlib::XDefaultRootWindow(self.display);
    
            // Variables to hold the pointer position and mask state
            let mut root_return: xlib::Window = 0;
            let mut child_return: xlib::Window = 0;
            let mut root_x_return: i32 = 0;
            let mut root_y_return: i32 = 0;
            let mut win_x_return: i32 = 0;
            let mut win_y_return: i32 = 0;
            let mut mask_return: u32 = 0;
    
            // Query the pointer
            let status = xlib::XQueryPointer(
                self.display,
                root,
                &mut root_return,
                &mut child_return,
                &mut root_x_return,
                &mut root_y_return,
                &mut win_x_return,
                &mut win_y_return,
                &mut mask_return,
            );
    
            // Check if the query was successful
            if status == 0 {
                eprintln!("XQueryPointer failed");
                return (0, 0);
            }
            (root_x_return as u16, root_y_return as u16)
        }
    }
    pub fn write(&self, text: &'static str) {
        for i in 0..text.chars().count() {
            unsafe {
                match text.chars().collect::<Vec<char>>()[i] {
                    'A' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::A.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::A.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'B' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::B.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::B.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'C' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::C.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::C.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'D' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::D.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::D.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'E' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::E.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::E.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'F' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::F.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::F.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'G' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::G.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::G.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'H' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::H.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::H.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'I' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::I.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::I.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'J' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::J.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::J.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'K' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::K.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::K.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'L' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::L.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::L.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'M' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::M.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::M.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'N' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::N.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::N.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'O' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::O.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::O.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'P' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::P.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::P.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'Q' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Q.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Q.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'R' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::R.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::R.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'S' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::S.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::S.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'T' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::T.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::T.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'U' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::U.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::U.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'V' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::V.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::V.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'W' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::W.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::W.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'X' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::X.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::X.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'Y' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Y.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Y.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'Z' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Z.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Z.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'a' => {
                        XTestFakeKeyEvent(self.display, KeyCode::A.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::A.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'b' => {
                        XTestFakeKeyEvent(self.display, KeyCode::B.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::B.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'c' => {
                        XTestFakeKeyEvent(self.display, KeyCode::C.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::C.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'd' => {
                        XTestFakeKeyEvent(self.display, KeyCode::D.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::D.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'e' => {
                        XTestFakeKeyEvent(self.display, KeyCode::E.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::E.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'f' => {
                        XTestFakeKeyEvent(self.display, KeyCode::F.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::F.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'g' => {
                        XTestFakeKeyEvent(self.display, KeyCode::G.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::G.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'h' => {
                        XTestFakeKeyEvent(self.display, KeyCode::H.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::H.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'i' => {
                        XTestFakeKeyEvent(self.display, KeyCode::I.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::I.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'j' => {
                        XTestFakeKeyEvent(self.display, KeyCode::J.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::J.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'k' => {
                        XTestFakeKeyEvent(self.display, KeyCode::K.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::K.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'l' => {
                        XTestFakeKeyEvent(self.display, KeyCode::L.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::L.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'm' => {
                        XTestFakeKeyEvent(self.display, KeyCode::M.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::M.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'n' => {
                        XTestFakeKeyEvent(self.display, KeyCode::N.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::N.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'o' => {
                        XTestFakeKeyEvent(self.display, KeyCode::O.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::O.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'p' => {
                        XTestFakeKeyEvent(self.display, KeyCode::P.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::P.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'q' => {
                        XTestFakeKeyEvent(self.display, KeyCode::Q.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Q.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'r' => {
                        XTestFakeKeyEvent(self.display, KeyCode::R.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::R.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    's' => {
                        XTestFakeKeyEvent(self.display, KeyCode::S.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::S.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    't' => {
                        XTestFakeKeyEvent(self.display, KeyCode::T.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::T.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'u' => {
                        XTestFakeKeyEvent(self.display, KeyCode::U.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::U.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'v' => {
                        XTestFakeKeyEvent(self.display, KeyCode::V.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::V.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'w' => {
                        XTestFakeKeyEvent(self.display, KeyCode::W.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::W.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'x' => {
                        XTestFakeKeyEvent(self.display, KeyCode::X.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::X.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'y' => {
                        XTestFakeKeyEvent(self.display, KeyCode::Y.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Y.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    'z' => {
                        XTestFakeKeyEvent(self.display, KeyCode::Z.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Z.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    ';' => {
                        XTestFakeKeyEvent(self.display, KeyCode::Semicolon.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Semicolon.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    ':' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Semicolon.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Semicolon.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    ',' => {
                        XTestFakeKeyEvent(self.display, KeyCode::Comma.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Comma.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    '<' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Comma.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Comma.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    '.' => {
                        XTestFakeKeyEvent(self.display, KeyCode::Period.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Period.to_x11_keycode() as u32, xlib::False, 0);
                    },
                    '>' => {
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Period.to_x11_keycode() as u32, xlib::True, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::Period.to_x11_keycode() as u32, xlib::False, 0);
                        XTestFakeKeyEvent(self.display, KeyCode::ShiftL.to_x11_keycode() as u32, xlib::False, 0);
                    },
					'0' => {
						XTestFakeKeyEvent(self.display, KeyCode::Num0.to_x11_keycode() as u32, xlib::True, 0);
						XTestFakeKeyEvent(self.display, KeyCode::Num0.to_x11_keycode() as u32, xlib::False, 0);
					},
					'1' => {
						XTestFakeKeyEvent(self.display, KeyCode::Num1.to_x11_keycode() as u32, xlib::True, 0);
						XTestFakeKeyEvent(self.display, KeyCode::Num1.to_x11_keycode() as u32, xlib::False, 0);
					},
					'2' => {
						XTestFakeKeyEvent(self.display, KeyCode::Num2.to_x11_keycode() as u32, xlib::True, 0);
						XTestFakeKeyEvent(self.display, KeyCode::Num2.to_x11_keycode() as u32, xlib::False, 0);
					},
					'3' => {
						XTestFakeKeyEvent(self.display, KeyCode::Num3.to_x11_keycode() as u32, xlib::True, 0);
						XTestFakeKeyEvent(self.display, KeyCode::Num3.to_x11_keycode() as u32, xlib::False, 0);
					},
					'4' => {
						XTestFakeKeyEvent(self.display, KeyCode::Num4.to_x11_keycode() as u32, xlib::True, 0);
						XTestFakeKeyEvent(self.display, KeyCode::Num4.to_x11_keycode() as u32, xlib::False, 0);
					},
					'5' => {
						XTestFakeKeyEvent(self.display, KeyCode::Num5.to_x11_keycode() as u32, xlib::True, 0);
						XTestFakeKeyEvent(self.display, KeyCode::Num5.to_x11_keycode() as u32, xlib::False, 0);
					},
					'6' => {
						XTestFakeKeyEvent(self.display, KeyCode::Num6.to_x11_keycode() as u32, xlib::True, 0);
						XTestFakeKeyEvent(self.display, KeyCode::Num6.to_x11_keycode() as u32, xlib::False, 0);
					},
					'7' => {
						XTestFakeKeyEvent(self.display, KeyCode::Num7.to_x11_keycode() as u32, xlib::True, 0);
						XTestFakeKeyEvent(self.display, KeyCode::Num7.to_x11_keycode() as u32, xlib::False, 0);
					},
					'8' => {
						XTestFakeKeyEvent(self.display, KeyCode::Num8.to_x11_keycode() as u32, xlib::True, 0);
						XTestFakeKeyEvent(self.display, KeyCode::Num8.to_x11_keycode() as u32, xlib::False, 0);
					},
					'9' => {
						XTestFakeKeyEvent(self.display, KeyCode::Num9.to_x11_keycode() as u32, xlib::True, 0);
						XTestFakeKeyEvent(self.display, KeyCode::Num9.to_x11_keycode() as u32, xlib::False, 0);
					},
                    _ => {}
                }
                xlib::XFlush(self.display);
            }
        }
    }
    pub fn hotkey(&self, keyvec: Vec<KeyCode>) {
        unsafe {
            for i in &keyvec {
                XTestFakeKeyEvent(self.display, i.to_x11_keycode() as u32, xlib::True, 0);
            }
            for i in &keyvec.into_iter().rev().collect::<Vec<KeyCode>>() {
                XTestFakeKeyEvent(self.display, i.to_x11_keycode() as u32, xlib::False, 0);
            }
        }
    }
    pub fn press(&self, key: KeyCode) {
        unsafe {
            XTestFakeKeyEvent(self.display, key.to_x11_keycode() as u32, xlib::True, 0);
        }
    }
    pub fn release(&self, key: KeyCode) {
        unsafe {
            XTestFakeKeyEvent(self.display, key.to_x11_keycode() as u32, xlib::False, 0);
        }
    }
}

impl Drop for Input {
    /// Closes the X11 display when the X11KeyChecker is dropped.
    fn drop(&mut self) {
        unsafe {
            xlib::XCloseDisplay(self.display);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test() {
        let input = Input::new().expect("unable to create input");
        input.press(KeyCode::SuperL);
        input.release(KeyCode::SuperL);
    }
}