From 1b2e2d848ce67c1044dfdc68cefec5d33a9ceaff Mon Sep 17 00:00:00 2001 From: NoOneBtw Date: Sat, 15 May 2021 02:48:23 +0200 Subject: [PATCH] changed rustfmt to actually work hopefully (70 char limit) also more abstraction stuff --- rustfmt.toml | 4 +- src/backends/keycodes.rs | 209 +++++++ src/backends/mod.rs | 2 + src/backends/window_event.rs | 220 ++++++++ src/backends/xcb.rs | 81 ++- src/backends/xlib.rs | 34 -- src/backends/xlib/keysym.rs | 1028 ++++++++++++++++++++++++++++++++++ src/backends/xlib/mod.rs | 250 +++++++++ src/client_logic.rs | 55 +- src/clients.rs | 86 ++- src/clients2.rs | 57 +- src/main.rs | 10 +- src/state.rs | 134 +++-- src/xlib.rs | 162 ++++-- 14 files changed, 2134 insertions(+), 198 deletions(-) create mode 100644 src/backends/keycodes.rs create mode 100644 src/backends/window_event.rs delete mode 100644 src/backends/xlib.rs create mode 100644 src/backends/xlib/keysym.rs create mode 100644 src/backends/xlib/mod.rs diff --git a/rustfmt.toml b/rustfmt.toml index fa14856..04912d9 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -1,2 +1,2 @@ -#wrap_comments = true -max_width = 80 \ No newline at end of file +wrap_comments = true +max_width = 70 \ No newline at end of file diff --git a/src/backends/keycodes.rs b/src/backends/keycodes.rs new file mode 100644 index 0000000..38ef1d8 --- /dev/null +++ b/src/backends/keycodes.rs @@ -0,0 +1,209 @@ +#![allow(dead_code)] + +#[derive( + Debug, Hash, Ord, PartialOrd, PartialEq, Eq, Clone, Copy, +)] +pub enum MouseButton { + Left, + Middle, + Right, + ScrollUp, + ScrollDown, + ScrollLeft, + ScrollRight, + Forward, + Backward, +} + +/// from winit +#[derive( + Debug, Hash, Ord, PartialOrd, PartialEq, Eq, Clone, Copy, +)] +#[repr(u32)] +pub enum VirtualKeyCode { + Key1, + Key2, + Key3, + Key4, + Key5, + Key6, + Key7, + Key8, + Key9, + Key0, + A, + B, + C, + D, + E, + F, + G, + H, + I, + J, + K, + L, + M, + N, + O, + P, + Q, + R, + S, + T, + U, + V, + W, + X, + Y, + Z, + + /// The Escape key, next to F1. + Escape, + + F1, + F2, + F3, + F4, + F5, + F6, + F7, + F8, + F9, + F10, + F11, + F12, + F13, + F14, + F15, + F16, + F17, + F18, + F19, + F20, + F21, + F22, + F23, + F24, + + /// Print Screen/SysRq. + Snapshot, + /// Scroll Lock. + Scroll, + /// Pause/Break key, next to Scroll lock. + Pause, + + /// `Insert`, next to Backspace. + Insert, + Home, + Delete, + End, + PageDown, + PageUp, + + Left, + Up, + Right, + Down, + + /// The Backspace key, right over Enter. + // TODO: rename + Back, + /// The Enter key. + Return, + /// The space bar. + Space, + + /// The "Compose" key on Linux. + Compose, + + Caret, + + Numlock, + Numpad0, + Numpad1, + Numpad2, + Numpad3, + Numpad4, + Numpad5, + Numpad6, + Numpad7, + Numpad8, + Numpad9, + NumpadAdd, + NumpadDivide, + NumpadDecimal, + NumpadComma, + NumpadEnter, + NumpadEquals, + NumpadMultiply, + NumpadSubtract, + + AbntC1, + AbntC2, + Apostrophe, + Apps, + Asterisk, + At, + Ax, + Backslash, + Calculator, + Capital, + Colon, + Comma, + Convert, + Equals, + Grave, + Kana, + Kanji, + LAlt, + LBracket, + LControl, + LShift, + LWin, + Mail, + MediaSelect, + MediaStop, + Minus, + Mute, + MyComputer, + // also called "Next" + NavigateForward, + // also called "Prior" + NavigateBackward, + NextTrack, + NoConvert, + OEM102, + Period, + PlayPause, + Plus, + Power, + PrevTrack, + RAlt, + RBracket, + RControl, + RShift, + RWin, + Semicolon, + Slash, + Sleep, + Stop, + Sysrq, + Tab, + Underline, + Unlabeled, + VolumeDown, + VolumeUp, + Wake, + WebBack, + WebFavorites, + WebForward, + WebHome, + WebRefresh, + WebSearch, + WebStop, + Yen, + Copy, + Paste, + Cut, +} diff --git a/src/backends/mod.rs b/src/backends/mod.rs index 6d3aee4..d17d6ac 100644 --- a/src/backends/mod.rs +++ b/src/backends/mod.rs @@ -1,3 +1,5 @@ +mod keycodes; +mod window_event; mod xcb; mod xlib; diff --git a/src/backends/window_event.rs b/src/backends/window_event.rs new file mode 100644 index 0000000..2c7ccef --- /dev/null +++ b/src/backends/window_event.rs @@ -0,0 +1,220 @@ +#![allow(dead_code)] +use x11::xlib::Window; + +use super::keycodes::{MouseButton, VirtualKeyCode}; + +#[derive(Debug)] +pub enum WindowEvent { + KeyEvent { + window: Window, + event: KeyEvent, + }, + ButtonEvent { + window: Window, + event: ButtonEvent, + }, + MotionEvent { + window: Window, + event: MotionEvent, + }, + MapEvent { + window: Window, + event: MapEvent, + }, + UnmapEvent { + window: Window, + event: UnmapEvent, + }, + CreateEvent { + window: Window, + event: CreateEvent, + }, + DestroyEvent { + window: Window, + event: DestroyEvent, + }, + EnterEvent { + window: Window, + event: EnterEvent, + }, + ConfigureEvent { + window: Window, + event: ConfigureEvent, + }, + //1 { window: Window, event: 1 }, +} + +#[derive(Debug)] +pub enum KeyState { + Pressed, + Released, +} + +#[derive( + Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, +)] +#[repr(u8)] +pub enum ModifierKey { + Shift, + ShiftLock, + Control, + Alt, + AltGr, + /// Windows key on most keyboards + Super, + NumLock, +} + +#[derive(Default, Debug, Clone)] +pub struct ModifierState { + modifiers: std::collections::HashSet, +} + +impl ModifierState { + pub fn new() -> Self { + Self::default() + } + + pub fn set_modifier(&mut self, modifier: ModifierKey) { + self.modifiers.insert(modifier); + } + + pub fn unset_modifier(&mut self, modifier: ModifierKey) { + self.modifiers.remove(&modifier); + } + + pub fn get_modifier(&mut self, modifier: ModifierKey) -> bool { + self.modifiers.contains(&modifier) + } +} + +#[derive(Debug)] +pub struct KeyEvent { + state: KeyState, + keycode: VirtualKeyCode, + modifierstate: ModifierState, +} + +impl KeyEvent { + pub fn new( + state: KeyState, + keycode: VirtualKeyCode, + modifierstate: ModifierState, + ) -> Self { + Self { + state, + keycode, + modifierstate, + } + } +} + +#[derive(Debug)] +pub struct ButtonEvent { + state: KeyState, + keycode: MouseButton, + modifierstate: ModifierState, +} + +impl ButtonEvent { + pub fn new( + state: KeyState, + keycode: MouseButton, + modifierstate: ModifierState, + ) -> Self { + Self { + state, + keycode, + modifierstate, + } + } +} + +#[derive(Debug)] +pub struct MotionEvent { + position: [i32; 2], +} + +impl MotionEvent { + pub fn new(position: [i32; 2]) -> Self { + Self { position } + } +} + +#[derive(Debug)] +pub struct MapEvent { + window: Window, +} + +impl MapEvent { + pub fn new(window: Window) -> Self { + Self { window } + } +} + +#[derive(Debug)] +pub struct UnmapEvent { + window: Window, +} + +impl UnmapEvent { + pub fn new(window: Window) -> Self { + Self { window } + } +} + +#[derive(Debug)] +pub struct EnterEvent {} + +#[derive(Debug)] +pub struct DestroyEvent { + window: Window, +} + +impl DestroyEvent { + pub fn new(window: Window) -> Self { + Self { window } + } +} + +#[derive(Debug)] +pub struct CreateEvent { + window: Window, + position: [i32; 2], + size: [i32; 2], +} + +impl CreateEvent { + pub fn new( + window: Window, + position: [i32; 2], + size: [i32; 2], + ) -> Self { + Self { + window, + position, + size, + } + } +} + +#[derive(Debug)] +pub struct ConfigureEvent { + window: Window, + position: [i32; 2], + size: [i32; 2], +} + +impl ConfigureEvent { + pub fn new( + window: Window, + position: [i32; 2], + size: [i32; 2], + ) -> Self { + Self { + window, + position, + size, + } + } +} diff --git a/src/backends/xcb.rs b/src/backends/xcb.rs index 1ed2c90..c9470e1 100644 --- a/src/backends/xcb.rs +++ b/src/backends/xcb.rs @@ -12,8 +12,8 @@ use x11rb::{ errors::ReplyError, errors::ReplyOrIdError, protocol::xproto::{ - Atom, ChangeWindowAttributesAux, ConnectionExt, EventMask, Screen, - Setup, + Atom, ChangeWindowAttributesAux, ConnectionExt, EventMask, + Screen, Setup, }, }; @@ -41,12 +41,37 @@ mod tests { .enumerate() { println!( - "keycode: {:#x?}\tkeysyms: {:0x?}", + "keycode: {:#?}\tkeysyms: {:0x?}", xcb.setup().min_keycode as usize + i, keysyms ); } } + + #[test] + fn modifier_masks() { + let xcb = create_backend().unwrap(); + + let mapping = xcb + .connection + .get_modifier_mapping() + .unwrap() + .reply() + .unwrap(); + + for (modifier_index, keycodes) in mapping + .keycodes + .chunks(mapping.keycodes_per_modifier() as usize) + .enumerate() + { + println!( + "Mod: {}[{:#x?}] keycodes: {:?}", + modifier_index, + 1 << modifier_index, + keycodes + ); + } + } } #[repr(u8)] @@ -205,24 +230,29 @@ impl Atoms { where C: Connection, { - let wm_protocols = connection.intern_atom(false, b"WM_PROTOCOLS")?; + let wm_protocols = + connection.intern_atom(false, b"WM_PROTOCOLS")?; let wm_state = connection.intern_atom(false, b"WM_STATE")?; let wm_delete_window = connection.intern_atom(false, b"WM_DELETE_WINDOW")?; - let wm_take_focus = connection.intern_atom(false, b"WM_TAKE_FOCUS")?; - let net_supported = connection.intern_atom(false, b"_NET_SUPPORTED")?; + let wm_take_focus = + connection.intern_atom(false, b"WM_TAKE_FOCUS")?; + let net_supported = + connection.intern_atom(false, b"_NET_SUPPORTED")?; let net_active_window = connection.intern_atom(false, b"_NET_ACTIVE_WINDOW")?; let net_client_list = connection.intern_atom(false, b"_NET_CLIENT_LIST")?; - let net_wm_name = connection.intern_atom(false, b"_NET_WM_NAME")?; - let net_wm_state = connection.intern_atom(false, b"_NET_WM_STATE")?; - let net_wm_state_fullscreen = - connection.intern_atom(false, b"_NET_WM_STATE_FULLSCREEN")?; + let net_wm_name = + connection.intern_atom(false, b"_NET_WM_NAME")?; + let net_wm_state = + connection.intern_atom(false, b"_NET_WM_STATE")?; + let net_wm_state_fullscreen = connection + .intern_atom(false, b"_NET_WM_STATE_FULLSCREEN")?; let net_wm_window_type = connection.intern_atom(false, b"_NET_WM_WINDOW_TYPE")?; - let net_wm_window_type_dialog = - connection.intern_atom(false, b"_NET_WM_WINDOW_TYPE_DIALOG")?; + let net_wm_window_type_dialog = connection + .intern_atom(false, b"_NET_WM_WINDOW_TYPE_DIALOG")?; Ok(Self { wm_protocols: wm_protocols.reply()?.atom, @@ -234,9 +264,13 @@ impl Atoms { net_client_list: net_client_list.reply()?.atom, net_wm_name: net_wm_name.reply()?.atom, net_wm_state: net_wm_state.reply()?.atom, - net_wm_state_fullscreen: net_wm_state_fullscreen.reply()?.atom, + net_wm_state_fullscreen: net_wm_state_fullscreen + .reply()? + .atom, net_wm_window_type: net_wm_window_type.reply()?.atom, - net_wm_window_type_dialog: net_wm_window_type_dialog.reply()?.atom, + net_wm_window_type_dialog: net_wm_window_type_dialog + .reply()? + .atom, }) } } @@ -250,9 +284,10 @@ where atoms: Atoms, } -pub fn create_backend( -) -> Result, Box> -{ +pub fn create_backend() -> Result< + X11Backend, + Box, +> { let (connection, screen) = connect(None)?; Ok(X11Backend::new(Arc::new(connection), screen)?) @@ -338,10 +373,14 @@ where } } - pub fn request_substructure_events(&self) -> Result<(), ReplyError> { - let attributes = ChangeWindowAttributesAux::default().event_mask( - EventMask::SUBSTRUCTURE_REDIRECT | EventMask::SUBSTRUCTURE_NOTIFY, - ); + pub fn request_substructure_events( + &self, + ) -> Result<(), ReplyError> { + let attributes = ChangeWindowAttributesAux::default() + .event_mask( + EventMask::SUBSTRUCTURE_REDIRECT + | EventMask::SUBSTRUCTURE_NOTIFY, + ); match self .connection diff --git a/src/backends/xlib.rs b/src/backends/xlib.rs deleted file mode 100644 index 65b6eb5..0000000 --- a/src/backends/xlib.rs +++ /dev/null @@ -1,34 +0,0 @@ -use std::ptr::null; - -use x11::xlib::{Window, XRootWindow}; - -// xlib backend - -pub struct XLib { - display: *mut x11::xlib::Display, - screen: i32, -} - -impl Drop for XLib { - fn drop(&mut self) { - unsafe { - x11::xlib::XCloseDisplay(self.display); - } - } -} - -impl XLib { - pub fn new() -> Self { - let (display, screen) = unsafe { - let display = x11::xlib::XOpenDisplay(null()); - let screen = x11::xlib::XDefaultScreen(display); - - (display, screen) - }; - Self { display, screen } - } - - fn root_window(&self) -> Window { - unsafe { XRootWindow(self.display, self.screen) } - } -} diff --git a/src/backends/xlib/keysym.rs b/src/backends/xlib/keysym.rs new file mode 100644 index 0000000..e684e7e --- /dev/null +++ b/src/backends/xlib/keysym.rs @@ -0,0 +1,1028 @@ +use crate::backends::keycodes::{MouseButton, VirtualKeyCode}; + +pub fn xev_to_mouse_button( + button: &x11::xlib::XButtonEvent, +) -> Option { + match button.button { + 1 => Some(MouseButton::Left), + 2 => Some(MouseButton::Middle), + 3 => Some(MouseButton::Right), + 4 => Some(MouseButton::ScrollUp), + 5 => Some(MouseButton::ScrollDown), + 6 => Some(MouseButton::ScrollLeft), + 7 => Some(MouseButton::ScrollRight), + 8 => Some(MouseButton::Forward), + 9 => Some(MouseButton::Backward), + _ => None, + } +} + +/// from winit +pub fn keysym_to_virtual_keycode( + keysym: u32, +) -> Option { + Some(match keysym { + x11::keysym::XK_BackSpace => VirtualKeyCode::Back, + x11::keysym::XK_Tab => VirtualKeyCode::Tab, + //x11::keysym::XK_Linefeed => VirtualKeyCode::Linefeed, + //x11::keysym::XK_Clear => VirtualKeyCode::Clear, + x11::keysym::XK_Return => VirtualKeyCode::Return, + //x11::keysym::XK_Pause => VirtualKeyCode::Pause, + //x11::keysym::XK_Scroll_Lock => VirtualKeyCode::Scroll_lock, + //x11::keysym::XK_Sys_Req => VirtualKeyCode::Sys_req, + x11::keysym::XK_Escape => VirtualKeyCode::Escape, + x11::keysym::XK_Delete => VirtualKeyCode::Delete, + x11::keysym::XK_Multi_key => VirtualKeyCode::Compose, + //x11::keysym::XK_Kanji => VirtualKeyCode::Kanji, + //x11::keysym::XK_Muhenkan => VirtualKeyCode::Muhenkan, + //x11::keysym::XK_Henkan_Mode => VirtualKeyCode::Henkan_mode, + //x11::keysym::XK_Henkan => VirtualKeyCode::Henkan, + //x11::keysym::XK_Romaji => VirtualKeyCode::Romaji, + //x11::keysym::XK_Hiragana => VirtualKeyCode::Hiragana, + //x11::keysym::XK_Katakana => VirtualKeyCode::Katakana, + //x11::keysym::XK_Hiragana_Katakana => VirtualKeyCode::Hiragana_katakana, + //x11::keysym::XK_Zenkaku => VirtualKeyCode::Zenkaku, + //x11::keysym::XK_Hankaku => VirtualKeyCode::Hankaku, + //x11::keysym::XK_Zenkaku_Hankaku => VirtualKeyCode::Zenkaku_hankaku, + //x11::keysym::XK_Touroku => VirtualKeyCode::Touroku, + //x11::keysym::XK_Massyo => VirtualKeyCode::Massyo, + //x11::keysym::XK_Kana_Lock => VirtualKeyCode::Kana_lock, + //x11::keysym::XK_Kana_Shift => VirtualKeyCode::Kana_shift, + //x11::keysym::XK_Eisu_Shift => VirtualKeyCode::Eisu_shift, + //x11::keysym::XK_Eisu_toggle => VirtualKeyCode::Eisu_toggle, + x11::keysym::XK_Home => VirtualKeyCode::Home, + x11::keysym::XK_Left => VirtualKeyCode::Left, + x11::keysym::XK_Up => VirtualKeyCode::Up, + x11::keysym::XK_Right => VirtualKeyCode::Right, + x11::keysym::XK_Down => VirtualKeyCode::Down, + //x11::keysym::XK_Prior => VirtualKeyCode::Prior, + x11::keysym::XK_Page_Up => VirtualKeyCode::PageUp, + //x11::keysym::XK_Next => VirtualKeyCode::Next, + x11::keysym::XK_Page_Down => VirtualKeyCode::PageDown, + x11::keysym::XK_End => VirtualKeyCode::End, + //x11::keysym::XK_Begin => VirtualKeyCode::Begin, + //x11::keysym::XK_Win_L => VirtualKeyCode::Win_l, + //x11::keysym::XK_Win_R => VirtualKeyCode::Win_r, + //x11::keysym::XK_App => VirtualKeyCode::App, + //x11::keysym::XK_Select => VirtualKeyCode::Select, + //x11::keysym::XK_Print => VirtualKeyCode::Print, + //x11::keysym::XK_Execute => VirtualKeyCode::Execute, + x11::keysym::XK_Insert => VirtualKeyCode::Insert, + //x11::keysym::XK_Undo => VirtualKeyCode::Undo, + //x11::keysym::XK_Redo => VirtualKeyCode::Redo, + //x11::keysym::XK_Menu => VirtualKeyCode::Menu, + //x11::keysym::XK_Find => VirtualKeyCode::Find, + //x11::keysym::XK_Cancel => VirtualKeyCode::Cancel, + //x11::keysym::XK_Help => VirtualKeyCode::Help, + //x11::keysym::XK_Break => VirtualKeyCode::Break, + //x11::keysym::XK_Mode_switch => VirtualKeyCode::Mode_switch, + //x11::keysym::XK_script_switch => VirtualKeyCode::Script_switch, + //x11::keysym::XK_Num_Lock => VirtualKeyCode::Num_lock, + //x11::keysym::XK_KP_Space => VirtualKeyCode::Kp_space, + //x11::keysym::XK_KP_Tab => VirtualKeyCode::Kp_tab, + //x11::keysym::XK_KP_Enter => VirtualKeyCode::Kp_enter, + //x11::keysym::XK_KP_F1 => VirtualKeyCode::Kp_f1, + //x11::keysym::XK_KP_F2 => VirtualKeyCode::Kp_f2, + //x11::keysym::XK_KP_F3 => VirtualKeyCode::Kp_f3, + //x11::keysym::XK_KP_F4 => VirtualKeyCode::Kp_f4, + x11::keysym::XK_KP_Home => VirtualKeyCode::Home, + x11::keysym::XK_KP_Left => VirtualKeyCode::Left, + x11::keysym::XK_KP_Up => VirtualKeyCode::Up, + x11::keysym::XK_KP_Right => VirtualKeyCode::Right, + x11::keysym::XK_KP_Down => VirtualKeyCode::Down, + //x11::keysym::XK_KP_Prior => VirtualKeyCode::Kp_prior, + x11::keysym::XK_KP_Page_Up => VirtualKeyCode::PageUp, + //x11::keysym::XK_KP_Next => VirtualKeyCode::Kp_next, + x11::keysym::XK_KP_Page_Down => VirtualKeyCode::PageDown, + x11::keysym::XK_KP_End => VirtualKeyCode::End, + //x11::keysym::XK_KP_Begin => VirtualKeyCode::Kp_begin, + x11::keysym::XK_KP_Insert => VirtualKeyCode::Insert, + x11::keysym::XK_KP_Delete => VirtualKeyCode::Delete, + x11::keysym::XK_KP_Equal => VirtualKeyCode::NumpadEquals, + x11::keysym::XK_KP_Multiply => VirtualKeyCode::NumpadMultiply, + x11::keysym::XK_KP_Add => VirtualKeyCode::NumpadAdd, + //x11::keysym::XK_KP_Separator => VirtualKeyCode::Kp_separator, + x11::keysym::XK_KP_Subtract => VirtualKeyCode::NumpadSubtract, + x11::keysym::XK_KP_Decimal => VirtualKeyCode::NumpadDecimal, + x11::keysym::XK_KP_Divide => VirtualKeyCode::NumpadDivide, + x11::keysym::XK_KP_0 => VirtualKeyCode::Numpad0, + x11::keysym::XK_KP_1 => VirtualKeyCode::Numpad1, + x11::keysym::XK_KP_2 => VirtualKeyCode::Numpad2, + x11::keysym::XK_KP_3 => VirtualKeyCode::Numpad3, + x11::keysym::XK_KP_4 => VirtualKeyCode::Numpad4, + x11::keysym::XK_KP_5 => VirtualKeyCode::Numpad5, + x11::keysym::XK_KP_6 => VirtualKeyCode::Numpad6, + x11::keysym::XK_KP_7 => VirtualKeyCode::Numpad7, + x11::keysym::XK_KP_8 => VirtualKeyCode::Numpad8, + x11::keysym::XK_KP_9 => VirtualKeyCode::Numpad9, + x11::keysym::XK_F1 => VirtualKeyCode::F1, + x11::keysym::XK_F2 => VirtualKeyCode::F2, + x11::keysym::XK_F3 => VirtualKeyCode::F3, + x11::keysym::XK_F4 => VirtualKeyCode::F4, + x11::keysym::XK_F5 => VirtualKeyCode::F5, + x11::keysym::XK_F6 => VirtualKeyCode::F6, + x11::keysym::XK_F7 => VirtualKeyCode::F7, + x11::keysym::XK_F8 => VirtualKeyCode::F8, + x11::keysym::XK_F9 => VirtualKeyCode::F9, + x11::keysym::XK_F10 => VirtualKeyCode::F10, + x11::keysym::XK_F11 => VirtualKeyCode::F11, + //x11::keysym::XK_L1 => VirtualKeyCode::L1, + x11::keysym::XK_F12 => VirtualKeyCode::F12, + //x11::keysym::XK_L2 => VirtualKeyCode::L2, + x11::keysym::XK_F13 => VirtualKeyCode::F13, + //x11::keysym::XK_L3 => VirtualKeyCode::L3, + x11::keysym::XK_F14 => VirtualKeyCode::F14, + //x11::keysym::XK_L4 => VirtualKeyCode::L4, + x11::keysym::XK_F15 => VirtualKeyCode::F15, + //x11::keysym::XK_L5 => VirtualKeyCode::L5, + x11::keysym::XK_F16 => VirtualKeyCode::F16, + //x11::keysym::XK_L6 => VirtualKeyCode::L6, + x11::keysym::XK_F17 => VirtualKeyCode::F17, + //x11::keysym::XK_L7 => VirtualKeyCode::L7, + x11::keysym::XK_F18 => VirtualKeyCode::F18, + //x11::keysym::XK_L8 => VirtualKeyCode::L8, + x11::keysym::XK_F19 => VirtualKeyCode::F19, + //x11::keysym::XK_L9 => VirtualKeyCode::L9, + x11::keysym::XK_F20 => VirtualKeyCode::F20, + //x11::keysym::XK_L10 => VirtualKeyCode::L10, + x11::keysym::XK_F21 => VirtualKeyCode::F21, + //x11::keysym::XK_R1 => VirtualKeyCode::R1, + x11::keysym::XK_F22 => VirtualKeyCode::F22, + //x11::keysym::XK_R2 => VirtualKeyCode::R2, + x11::keysym::XK_F23 => VirtualKeyCode::F23, + //x11::keysym::XK_R3 => VirtualKeyCode::R3, + x11::keysym::XK_F24 => VirtualKeyCode::F24, + //x11::keysym::XK_R4 => VirtualKeyCode::R4, + //x11::keysym::XK_F25 => VirtualKeyCode::F25, + //x11::keysym::XK_R5 => VirtualKeyCode::R5, + //x11::keysym::XK_F26 => VirtualKeyCode::F26, + //x11::keysym::XK_R6 => VirtualKeyCode::R6, + //x11::keysym::XK_F27 => VirtualKeyCode::F27, + //x11::keysym::XK_R7 => VirtualKeyCode::R7, + //x11::keysym::XK_F28 => VirtualKeyCode::F28, + //x11::keysym::XK_R8 => VirtualKeyCode::R8, + //x11::keysym::XK_F29 => VirtualKeyCode::F29, + //x11::keysym::XK_R9 => VirtualKeyCode::R9, + //x11::keysym::XK_F30 => VirtualKeyCode::F30, + //x11::keysym::XK_R10 => VirtualKeyCode::R10, + //x11::keysym::XK_F31 => VirtualKeyCode::F31, + //x11::keysym::XK_R11 => VirtualKeyCode::R11, + //x11::keysym::XK_F32 => VirtualKeyCode::F32, + //x11::keysym::XK_R12 => VirtualKeyCode::R12, + //x11::keysym::XK_F33 => VirtualKeyCode::F33, + //x11::keysym::XK_R13 => VirtualKeyCode::R13, + //x11::keysym::XK_F34 => VirtualKeyCode::F34, + //x11::keysym::XK_R14 => VirtualKeyCode::R14, + //x11::keysym::XK_F35 => VirtualKeyCode::F35, + //x11::keysym::XK_R15 => VirtualKeyCode::R15, + x11::keysym::XK_Shift_L => VirtualKeyCode::LShift, + x11::keysym::XK_Shift_R => VirtualKeyCode::RShift, + x11::keysym::XK_Control_L => VirtualKeyCode::LControl, + x11::keysym::XK_Control_R => VirtualKeyCode::RControl, + //x11::keysym::XK_Caps_Lock => VirtualKeyCode::Caps_lock, + //x11::keysym::XK_Shift_Lock => VirtualKeyCode::Shift_lock, + //x11::keysym::XK_Meta_L => VirtualKeyCode::Meta_l, + //x11::keysym::XK_Meta_R => VirtualKeyCode::Meta_r, + x11::keysym::XK_Alt_L => VirtualKeyCode::LAlt, + x11::keysym::XK_Alt_R => VirtualKeyCode::RAlt, + //x11::keysym::XK_Super_L => VirtualKeyCode::Super_l, + //x11::keysym::XK_Super_R => VirtualKeyCode::Super_r, + //x11::keysym::XK_Hyper_L => VirtualKeyCode::Hyper_l, + //x11::keysym::XK_Hyper_R => VirtualKeyCode::Hyper_r, + x11::keysym::XK_ISO_Left_Tab => VirtualKeyCode::Tab, + x11::keysym::XK_space => VirtualKeyCode::Space, + //x11::keysym::XK_exclam => VirtualKeyCode::Exclam, + //x11::keysym::XK_quotedbl => VirtualKeyCode::Quotedbl, + //x11::keysym::XK_numbersign => VirtualKeyCode::Numbersign, + //x11::keysym::XK_dollar => VirtualKeyCode::Dollar, + //x11::keysym::XK_percent => VirtualKeyCode::Percent, + //x11::keysym::XK_ampersand => VirtualKeyCode::Ampersand, + x11::keysym::XK_apostrophe => VirtualKeyCode::Apostrophe, + //x11::keysym::XK_quoteright => VirtualKeyCode::Quoteright, + //x11::keysym::XK_parenleft => VirtualKeyCode::Parenleft, + //x11::keysym::XK_parenright => VirtualKeyCode::Parenright, + x11::keysym::XK_asterisk => VirtualKeyCode::Asterisk, + x11::keysym::XK_plus => VirtualKeyCode::Plus, + x11::keysym::XK_comma => VirtualKeyCode::Comma, + x11::keysym::XK_minus => VirtualKeyCode::Minus, + x11::keysym::XK_period => VirtualKeyCode::Period, + x11::keysym::XK_slash => VirtualKeyCode::Slash, + x11::keysym::XK_0 => VirtualKeyCode::Key0, + x11::keysym::XK_1 => VirtualKeyCode::Key1, + x11::keysym::XK_2 => VirtualKeyCode::Key2, + x11::keysym::XK_3 => VirtualKeyCode::Key3, + x11::keysym::XK_4 => VirtualKeyCode::Key4, + x11::keysym::XK_5 => VirtualKeyCode::Key5, + x11::keysym::XK_6 => VirtualKeyCode::Key6, + x11::keysym::XK_7 => VirtualKeyCode::Key7, + x11::keysym::XK_8 => VirtualKeyCode::Key8, + x11::keysym::XK_9 => VirtualKeyCode::Key9, + x11::keysym::XK_colon => VirtualKeyCode::Colon, + x11::keysym::XK_semicolon => VirtualKeyCode::Semicolon, + //x11::keysym::XK_less => VirtualKeyCode::Less, + x11::keysym::XK_equal => VirtualKeyCode::Equals, + //x11::keysym::XK_greater => VirtualKeyCode::Greater, + //x11::keysym::XK_question => VirtualKeyCode::Question, + x11::keysym::XK_at => VirtualKeyCode::At, + x11::keysym::XK_A => VirtualKeyCode::A, + x11::keysym::XK_B => VirtualKeyCode::B, + x11::keysym::XK_C => VirtualKeyCode::C, + x11::keysym::XK_D => VirtualKeyCode::D, + x11::keysym::XK_E => VirtualKeyCode::E, + x11::keysym::XK_F => VirtualKeyCode::F, + x11::keysym::XK_G => VirtualKeyCode::G, + x11::keysym::XK_H => VirtualKeyCode::H, + x11::keysym::XK_I => VirtualKeyCode::I, + x11::keysym::XK_J => VirtualKeyCode::J, + x11::keysym::XK_K => VirtualKeyCode::K, + x11::keysym::XK_L => VirtualKeyCode::L, + x11::keysym::XK_M => VirtualKeyCode::M, + x11::keysym::XK_N => VirtualKeyCode::N, + x11::keysym::XK_O => VirtualKeyCode::O, + x11::keysym::XK_P => VirtualKeyCode::P, + x11::keysym::XK_Q => VirtualKeyCode::Q, + x11::keysym::XK_R => VirtualKeyCode::R, + x11::keysym::XK_S => VirtualKeyCode::S, + x11::keysym::XK_T => VirtualKeyCode::T, + x11::keysym::XK_U => VirtualKeyCode::U, + x11::keysym::XK_V => VirtualKeyCode::V, + x11::keysym::XK_W => VirtualKeyCode::W, + x11::keysym::XK_X => VirtualKeyCode::X, + x11::keysym::XK_Y => VirtualKeyCode::Y, + x11::keysym::XK_Z => VirtualKeyCode::Z, + x11::keysym::XK_bracketleft => VirtualKeyCode::LBracket, + x11::keysym::XK_backslash => VirtualKeyCode::Backslash, + x11::keysym::XK_bracketright => VirtualKeyCode::RBracket, + //x11::keysym::XK_asciicircum => VirtualKeyCode::Asciicircum, + //x11::keysym::XK_underscore => VirtualKeyCode::Underscore, + x11::keysym::XK_grave => VirtualKeyCode::Grave, + //x11::keysym::XK_quoteleft => VirtualKeyCode::Quoteleft, + x11::keysym::XK_a => VirtualKeyCode::A, + x11::keysym::XK_b => VirtualKeyCode::B, + x11::keysym::XK_c => VirtualKeyCode::C, + x11::keysym::XK_d => VirtualKeyCode::D, + x11::keysym::XK_e => VirtualKeyCode::E, + x11::keysym::XK_f => VirtualKeyCode::F, + x11::keysym::XK_g => VirtualKeyCode::G, + x11::keysym::XK_h => VirtualKeyCode::H, + x11::keysym::XK_i => VirtualKeyCode::I, + x11::keysym::XK_j => VirtualKeyCode::J, + x11::keysym::XK_k => VirtualKeyCode::K, + x11::keysym::XK_l => VirtualKeyCode::L, + x11::keysym::XK_m => VirtualKeyCode::M, + x11::keysym::XK_n => VirtualKeyCode::N, + x11::keysym::XK_o => VirtualKeyCode::O, + x11::keysym::XK_p => VirtualKeyCode::P, + x11::keysym::XK_q => VirtualKeyCode::Q, + x11::keysym::XK_r => VirtualKeyCode::R, + x11::keysym::XK_s => VirtualKeyCode::S, + x11::keysym::XK_t => VirtualKeyCode::T, + x11::keysym::XK_u => VirtualKeyCode::U, + x11::keysym::XK_v => VirtualKeyCode::V, + x11::keysym::XK_w => VirtualKeyCode::W, + x11::keysym::XK_x => VirtualKeyCode::X, + x11::keysym::XK_y => VirtualKeyCode::Y, + x11::keysym::XK_z => VirtualKeyCode::Z, + //x11::keysym::XK_braceleft => VirtualKeyCode::Braceleft, + //x11::keysym::XK_bar => VirtualKeyCode::Bar, + //x11::keysym::XK_braceright => VirtualKeyCode::Braceright, + //x11::keysym::XK_asciitilde => VirtualKeyCode::Asciitilde, + //x11::keysym::XK_nobreakspace => VirtualKeyCode::Nobreakspace, + //x11::keysym::XK_exclamdown => VirtualKeyCode::Exclamdown, + //x11::keysym::XK_cent => VirtualKeyCode::Cent, + //x11::keysym::XK_sterling => VirtualKeyCode::Sterling, + //x11::keysym::XK_currency => VirtualKeyCode::Currency, + //x11::keysym::XK_yen => VirtualKeyCode::Yen, + //x11::keysym::XK_brokenbar => VirtualKeyCode::Brokenbar, + //x11::keysym::XK_section => VirtualKeyCode::Section, + //x11::keysym::XK_diaeresis => VirtualKeyCode::Diaeresis, + //x11::keysym::XK_copyright => VirtualKeyCode::Copyright, + //x11::keysym::XK_ordfeminine => VirtualKeyCode::Ordfeminine, + //x11::keysym::XK_guillemotleft => VirtualKeyCode::Guillemotleft, + //x11::keysym::XK_notsign => VirtualKeyCode::Notsign, + //x11::keysym::XK_hyphen => VirtualKeyCode::Hyphen, + //x11::keysym::XK_registered => VirtualKeyCode::Registered, + //x11::keysym::XK_macron => VirtualKeyCode::Macron, + //x11::keysym::XK_degree => VirtualKeyCode::Degree, + //x11::keysym::XK_plusminus => VirtualKeyCode::Plusminus, + //x11::keysym::XK_twosuperior => VirtualKeyCode::Twosuperior, + //x11::keysym::XK_threesuperior => VirtualKeyCode::Threesuperior, + //x11::keysym::XK_acute => VirtualKeyCode::Acute, + //x11::keysym::XK_mu => VirtualKeyCode::Mu, + //x11::keysym::XK_paragraph => VirtualKeyCode::Paragraph, + //x11::keysym::XK_periodcentered => VirtualKeyCode::Periodcentered, + //x11::keysym::XK_cedilla => VirtualKeyCode::Cedilla, + //x11::keysym::XK_onesuperior => VirtualKeyCode::Onesuperior, + //x11::keysym::XK_masculine => VirtualKeyCode::Masculine, + //x11::keysym::XK_guillemotright => VirtualKeyCode::Guillemotright, + //x11::keysym::XK_onequarter => VirtualKeyCode::Onequarter, + //x11::keysym::XK_onehalf => VirtualKeyCode::Onehalf, + //x11::keysym::XK_threequarters => VirtualKeyCode::Threequarters, + //x11::keysym::XK_questiondown => VirtualKeyCode::Questiondown, + //x11::keysym::XK_Agrave => VirtualKeyCode::Agrave, + //x11::keysym::XK_Aacute => VirtualKeyCode::Aacute, + //x11::keysym::XK_Acircumflex => VirtualKeyCode::Acircumflex, + //x11::keysym::XK_Atilde => VirtualKeyCode::Atilde, + //x11::keysym::XK_Adiaeresis => VirtualKeyCode::Adiaeresis, + //x11::keysym::XK_Aring => VirtualKeyCode::Aring, + //x11::keysym::XK_AE => VirtualKeyCode::Ae, + //x11::keysym::XK_Ccedilla => VirtualKeyCode::Ccedilla, + //x11::keysym::XK_Egrave => VirtualKeyCode::Egrave, + //x11::keysym::XK_Eacute => VirtualKeyCode::Eacute, + //x11::keysym::XK_Ecircumflex => VirtualKeyCode::Ecircumflex, + //x11::keysym::XK_Ediaeresis => VirtualKeyCode::Ediaeresis, + //x11::keysym::XK_Igrave => VirtualKeyCode::Igrave, + //x11::keysym::XK_Iacute => VirtualKeyCode::Iacute, + //x11::keysym::XK_Icircumflex => VirtualKeyCode::Icircumflex, + //x11::keysym::XK_Idiaeresis => VirtualKeyCode::Idiaeresis, + //x11::keysym::XK_ETH => VirtualKeyCode::Eth, + //x11::keysym::XK_Eth => VirtualKeyCode::Eth, + //x11::keysym::XK_Ntilde => VirtualKeyCode::Ntilde, + //x11::keysym::XK_Ograve => VirtualKeyCode::Ograve, + //x11::keysym::XK_Oacute => VirtualKeyCode::Oacute, + //x11::keysym::XK_Ocircumflex => VirtualKeyCode::Ocircumflex, + //x11::keysym::XK_Otilde => VirtualKeyCode::Otilde, + //x11::keysym::XK_Odiaeresis => VirtualKeyCode::Odiaeresis, + //x11::keysym::XK_multiply => VirtualKeyCode::Multiply, + //x11::keysym::XK_Ooblique => VirtualKeyCode::Ooblique, + //x11::keysym::XK_Ugrave => VirtualKeyCode::Ugrave, + //x11::keysym::XK_Uacute => VirtualKeyCode::Uacute, + //x11::keysym::XK_Ucircumflex => VirtualKeyCode::Ucircumflex, + //x11::keysym::XK_Udiaeresis => VirtualKeyCode::Udiaeresis, + //x11::keysym::XK_Yacute => VirtualKeyCode::Yacute, + //x11::keysym::XK_THORN => VirtualKeyCode::Thorn, + //x11::keysym::XK_Thorn => VirtualKeyCode::Thorn, + //x11::keysym::XK_ssharp => VirtualKeyCode::Ssharp, + //x11::keysym::XK_agrave => VirtualKeyCode::Agrave, + //x11::keysym::XK_aacute => VirtualKeyCode::Aacute, + //x11::keysym::XK_acircumflex => VirtualKeyCode::Acircumflex, + //x11::keysym::XK_atilde => VirtualKeyCode::Atilde, + //x11::keysym::XK_adiaeresis => VirtualKeyCode::Adiaeresis, + //x11::keysym::XK_aring => VirtualKeyCode::Aring, + //x11::keysym::XK_ae => VirtualKeyCode::Ae, + //x11::keysym::XK_ccedilla => VirtualKeyCode::Ccedilla, + //x11::keysym::XK_egrave => VirtualKeyCode::Egrave, + //x11::keysym::XK_eacute => VirtualKeyCode::Eacute, + //x11::keysym::XK_ecircumflex => VirtualKeyCode::Ecircumflex, + //x11::keysym::XK_ediaeresis => VirtualKeyCode::Ediaeresis, + //x11::keysym::XK_igrave => VirtualKeyCode::Igrave, + //x11::keysym::XK_iacute => VirtualKeyCode::Iacute, + //x11::keysym::XK_icircumflex => VirtualKeyCode::Icircumflex, + //x11::keysym::XK_idiaeresis => VirtualKeyCode::Idiaeresis, + //x11::keysym::XK_eth => VirtualKeyCode::Eth, + //x11::keysym::XK_ntilde => VirtualKeyCode::Ntilde, + //x11::keysym::XK_ograve => VirtualKeyCode::Ograve, + //x11::keysym::XK_oacute => VirtualKeyCode::Oacute, + //x11::keysym::XK_ocircumflex => VirtualKeyCode::Ocircumflex, + //x11::keysym::XK_otilde => VirtualKeyCode::Otilde, + //x11::keysym::XK_odiaeresis => VirtualKeyCode::Odiaeresis, + //x11::keysym::XK_division => VirtualKeyCode::Division, + //x11::keysym::XK_oslash => VirtualKeyCode::Oslash, + //x11::keysym::XK_ugrave => VirtualKeyCode::Ugrave, + //x11::keysym::XK_uacute => VirtualKeyCode::Uacute, + //x11::keysym::XK_ucircumflex => VirtualKeyCode::Ucircumflex, + //x11::keysym::XK_udiaeresis => VirtualKeyCode::Udiaeresis, + //x11::keysym::XK_yacute => VirtualKeyCode::Yacute, + //x11::keysym::XK_thorn => VirtualKeyCode::Thorn, + //x11::keysym::XK_ydiaeresis => VirtualKeyCode::Ydiaeresis, + //x11::keysym::XK_Aogonek => VirtualKeyCode::Aogonek, + //x11::keysym::XK_breve => VirtualKeyCode::Breve, + //x11::keysym::XK_Lstroke => VirtualKeyCode::Lstroke, + //x11::keysym::XK_Lcaron => VirtualKeyCode::Lcaron, + //x11::keysym::XK_Sacute => VirtualKeyCode::Sacute, + //x11::keysym::XK_Scaron => VirtualKeyCode::Scaron, + //x11::keysym::XK_Scedilla => VirtualKeyCode::Scedilla, + //x11::keysym::XK_Tcaron => VirtualKeyCode::Tcaron, + //x11::keysym::XK_Zacute => VirtualKeyCode::Zacute, + //x11::keysym::XK_Zcaron => VirtualKeyCode::Zcaron, + //x11::keysym::XK_Zabovedot => VirtualKeyCode::Zabovedot, + //x11::keysym::XK_aogonek => VirtualKeyCode::Aogonek, + //x11::keysym::XK_ogonek => VirtualKeyCode::Ogonek, + //x11::keysym::XK_lstroke => VirtualKeyCode::Lstroke, + //x11::keysym::XK_lcaron => VirtualKeyCode::Lcaron, + //x11::keysym::XK_sacute => VirtualKeyCode::Sacute, + //x11::keysym::XK_caron => VirtualKeyCode::Caron, + //x11::keysym::XK_scaron => VirtualKeyCode::Scaron, + //x11::keysym::XK_scedilla => VirtualKeyCode::Scedilla, + //x11::keysym::XK_tcaron => VirtualKeyCode::Tcaron, + //x11::keysym::XK_zacute => VirtualKeyCode::Zacute, + //x11::keysym::XK_doubleacute => VirtualKeyCode::Doubleacute, + //x11::keysym::XK_zcaron => VirtualKeyCode::Zcaron, + //x11::keysym::XK_zabovedot => VirtualKeyCode::Zabovedot, + //x11::keysym::XK_Racute => VirtualKeyCode::Racute, + //x11::keysym::XK_Abreve => VirtualKeyCode::Abreve, + //x11::keysym::XK_Lacute => VirtualKeyCode::Lacute, + //x11::keysym::XK_Cacute => VirtualKeyCode::Cacute, + //x11::keysym::XK_Ccaron => VirtualKeyCode::Ccaron, + //x11::keysym::XK_Eogonek => VirtualKeyCode::Eogonek, + //x11::keysym::XK_Ecaron => VirtualKeyCode::Ecaron, + //x11::keysym::XK_Dcaron => VirtualKeyCode::Dcaron, + //x11::keysym::XK_Dstroke => VirtualKeyCode::Dstroke, + //x11::keysym::XK_Nacute => VirtualKeyCode::Nacute, + //x11::keysym::XK_Ncaron => VirtualKeyCode::Ncaron, + //x11::keysym::XK_Odoubleacute => VirtualKeyCode::Odoubleacute, + //x11::keysym::XK_Rcaron => VirtualKeyCode::Rcaron, + //x11::keysym::XK_Uring => VirtualKeyCode::Uring, + //x11::keysym::XK_Udoubleacute => VirtualKeyCode::Udoubleacute, + //x11::keysym::XK_Tcedilla => VirtualKeyCode::Tcedilla, + //x11::keysym::XK_racute => VirtualKeyCode::Racute, + //x11::keysym::XK_abreve => VirtualKeyCode::Abreve, + //x11::keysym::XK_lacute => VirtualKeyCode::Lacute, + //x11::keysym::XK_cacute => VirtualKeyCode::Cacute, + //x11::keysym::XK_ccaron => VirtualKeyCode::Ccaron, + //x11::keysym::XK_eogonek => VirtualKeyCode::Eogonek, + //x11::keysym::XK_ecaron => VirtualKeyCode::Ecaron, + //x11::keysym::XK_dcaron => VirtualKeyCode::Dcaron, + //x11::keysym::XK_dstroke => VirtualKeyCode::Dstroke, + //x11::keysym::XK_nacute => VirtualKeyCode::Nacute, + //x11::keysym::XK_ncaron => VirtualKeyCode::Ncaron, + //x11::keysym::XK_odoubleacute => VirtualKeyCode::Odoubleacute, + //x11::keysym::XK_udoubleacute => VirtualKeyCode::Udoubleacute, + //x11::keysym::XK_rcaron => VirtualKeyCode::Rcaron, + //x11::keysym::XK_uring => VirtualKeyCode::Uring, + //x11::keysym::XK_tcedilla => VirtualKeyCode::Tcedilla, + //x11::keysym::XK_abovedot => VirtualKeyCode::Abovedot, + //x11::keysym::XK_Hstroke => VirtualKeyCode::Hstroke, + //x11::keysym::XK_Hcircumflex => VirtualKeyCode::Hcircumflex, + //x11::keysym::XK_Iabovedot => VirtualKeyCode::Iabovedot, + //x11::keysym::XK_Gbreve => VirtualKeyCode::Gbreve, + //x11::keysym::XK_Jcircumflex => VirtualKeyCode::Jcircumflex, + //x11::keysym::XK_hstroke => VirtualKeyCode::Hstroke, + //x11::keysym::XK_hcircumflex => VirtualKeyCode::Hcircumflex, + //x11::keysym::XK_idotless => VirtualKeyCode::Idotless, + //x11::keysym::XK_gbreve => VirtualKeyCode::Gbreve, + //x11::keysym::XK_jcircumflex => VirtualKeyCode::Jcircumflex, + //x11::keysym::XK_Cabovedot => VirtualKeyCode::Cabovedot, + //x11::keysym::XK_Ccircumflex => VirtualKeyCode::Ccircumflex, + //x11::keysym::XK_Gabovedot => VirtualKeyCode::Gabovedot, + //x11::keysym::XK_Gcircumflex => VirtualKeyCode::Gcircumflex, + //x11::keysym::XK_Ubreve => VirtualKeyCode::Ubreve, + //x11::keysym::XK_Scircumflex => VirtualKeyCode::Scircumflex, + //x11::keysym::XK_cabovedot => VirtualKeyCode::Cabovedot, + //x11::keysym::XK_ccircumflex => VirtualKeyCode::Ccircumflex, + //x11::keysym::XK_gabovedot => VirtualKeyCode::Gabovedot, + //x11::keysym::XK_gcircumflex => VirtualKeyCode::Gcircumflex, + //x11::keysym::XK_ubreve => VirtualKeyCode::Ubreve, + //x11::keysym::XK_scircumflex => VirtualKeyCode::Scircumflex, + //x11::keysym::XK_kra => VirtualKeyCode::Kra, + //x11::keysym::XK_kappa => VirtualKeyCode::Kappa, + //x11::keysym::XK_Rcedilla => VirtualKeyCode::Rcedilla, + //x11::keysym::XK_Itilde => VirtualKeyCode::Itilde, + //x11::keysym::XK_Lcedilla => VirtualKeyCode::Lcedilla, + //x11::keysym::XK_Emacron => VirtualKeyCode::Emacron, + //x11::keysym::XK_Gcedilla => VirtualKeyCode::Gcedilla, + //x11::keysym::XK_Tslash => VirtualKeyCode::Tslash, + //x11::keysym::XK_rcedilla => VirtualKeyCode::Rcedilla, + //x11::keysym::XK_itilde => VirtualKeyCode::Itilde, + //x11::keysym::XK_lcedilla => VirtualKeyCode::Lcedilla, + //x11::keysym::XK_emacron => VirtualKeyCode::Emacron, + //x11::keysym::XK_gcedilla => VirtualKeyCode::Gcedilla, + //x11::keysym::XK_tslash => VirtualKeyCode::Tslash, + //x11::keysym::XK_ENG => VirtualKeyCode::Eng, + //x11::keysym::XK_eng => VirtualKeyCode::Eng, + //x11::keysym::XK_Amacron => VirtualKeyCode::Amacron, + //x11::keysym::XK_Iogonek => VirtualKeyCode::Iogonek, + //x11::keysym::XK_Eabovedot => VirtualKeyCode::Eabovedot, + //x11::keysym::XK_Imacron => VirtualKeyCode::Imacron, + //x11::keysym::XK_Ncedilla => VirtualKeyCode::Ncedilla, + //x11::keysym::XK_Omacron => VirtualKeyCode::Omacron, + //x11::keysym::XK_Kcedilla => VirtualKeyCode::Kcedilla, + //x11::keysym::XK_Uogonek => VirtualKeyCode::Uogonek, + //x11::keysym::XK_Utilde => VirtualKeyCode::Utilde, + //x11::keysym::XK_Umacron => VirtualKeyCode::Umacron, + //x11::keysym::XK_amacron => VirtualKeyCode::Amacron, + //x11::keysym::XK_iogonek => VirtualKeyCode::Iogonek, + //x11::keysym::XK_eabovedot => VirtualKeyCode::Eabovedot, + //x11::keysym::XK_imacron => VirtualKeyCode::Imacron, + //x11::keysym::XK_ncedilla => VirtualKeyCode::Ncedilla, + //x11::keysym::XK_omacron => VirtualKeyCode::Omacron, + //x11::keysym::XK_kcedilla => VirtualKeyCode::Kcedilla, + //x11::keysym::XK_uogonek => VirtualKeyCode::Uogonek, + //x11::keysym::XK_utilde => VirtualKeyCode::Utilde, + //x11::keysym::XK_umacron => VirtualKeyCode::Umacron, + //x11::keysym::XK_overline => VirtualKeyCode::Overline, + //x11::keysym::XK_kana_fullstop => VirtualKeyCode::Kana_fullstop, + //x11::keysym::XK_kana_openingbracket => VirtualKeyCode::Kana_openingbracket, + //x11::keysym::XK_kana_closingbracket => VirtualKeyCode::Kana_closingbracket, + //x11::keysym::XK_kana_comma => VirtualKeyCode::Kana_comma, + //x11::keysym::XK_kana_conjunctive => VirtualKeyCode::Kana_conjunctive, + //x11::keysym::XK_kana_middledot => VirtualKeyCode::Kana_middledot, + //x11::keysym::XK_kana_WO => VirtualKeyCode::Kana_wo, + //x11::keysym::XK_kana_a => VirtualKeyCode::Kana_a, + //x11::keysym::XK_kana_i => VirtualKeyCode::Kana_i, + //x11::keysym::XK_kana_u => VirtualKeyCode::Kana_u, + //x11::keysym::XK_kana_e => VirtualKeyCode::Kana_e, + //x11::keysym::XK_kana_o => VirtualKeyCode::Kana_o, + //x11::keysym::XK_kana_ya => VirtualKeyCode::Kana_ya, + //x11::keysym::XK_kana_yu => VirtualKeyCode::Kana_yu, + //x11::keysym::XK_kana_yo => VirtualKeyCode::Kana_yo, + //x11::keysym::XK_kana_tsu => VirtualKeyCode::Kana_tsu, + //x11::keysym::XK_kana_tu => VirtualKeyCode::Kana_tu, + //x11::keysym::XK_prolongedsound => VirtualKeyCode::Prolongedsound, + //x11::keysym::XK_kana_A => VirtualKeyCode::Kana_a, + //x11::keysym::XK_kana_I => VirtualKeyCode::Kana_i, + //x11::keysym::XK_kana_U => VirtualKeyCode::Kana_u, + //x11::keysym::XK_kana_E => VirtualKeyCode::Kana_e, + //x11::keysym::XK_kana_O => VirtualKeyCode::Kana_o, + //x11::keysym::XK_kana_KA => VirtualKeyCode::Kana_ka, + //x11::keysym::XK_kana_KI => VirtualKeyCode::Kana_ki, + //x11::keysym::XK_kana_KU => VirtualKeyCode::Kana_ku, + //x11::keysym::XK_kana_KE => VirtualKeyCode::Kana_ke, + //x11::keysym::XK_kana_KO => VirtualKeyCode::Kana_ko, + //x11::keysym::XK_kana_SA => VirtualKeyCode::Kana_sa, + //x11::keysym::XK_kana_SHI => VirtualKeyCode::Kana_shi, + //x11::keysym::XK_kana_SU => VirtualKeyCode::Kana_su, + //x11::keysym::XK_kana_SE => VirtualKeyCode::Kana_se, + //x11::keysym::XK_kana_SO => VirtualKeyCode::Kana_so, + //x11::keysym::XK_kana_TA => VirtualKeyCode::Kana_ta, + //x11::keysym::XK_kana_CHI => VirtualKeyCode::Kana_chi, + //x11::keysym::XK_kana_TI => VirtualKeyCode::Kana_ti, + //x11::keysym::XK_kana_TSU => VirtualKeyCode::Kana_tsu, + //x11::keysym::XK_kana_TU => VirtualKeyCode::Kana_tu, + //x11::keysym::XK_kana_TE => VirtualKeyCode::Kana_te, + //x11::keysym::XK_kana_TO => VirtualKeyCode::Kana_to, + //x11::keysym::XK_kana_NA => VirtualKeyCode::Kana_na, + //x11::keysym::XK_kana_NI => VirtualKeyCode::Kana_ni, + //x11::keysym::XK_kana_NU => VirtualKeyCode::Kana_nu, + //x11::keysym::XK_kana_NE => VirtualKeyCode::Kana_ne, + //x11::keysym::XK_kana_NO => VirtualKeyCode::Kana_no, + //x11::keysym::XK_kana_HA => VirtualKeyCode::Kana_ha, + //x11::keysym::XK_kana_HI => VirtualKeyCode::Kana_hi, + //x11::keysym::XK_kana_FU => VirtualKeyCode::Kana_fu, + //x11::keysym::XK_kana_HU => VirtualKeyCode::Kana_hu, + //x11::keysym::XK_kana_HE => VirtualKeyCode::Kana_he, + //x11::keysym::XK_kana_HO => VirtualKeyCode::Kana_ho, + //x11::keysym::XK_kana_MA => VirtualKeyCode::Kana_ma, + //x11::keysym::XK_kana_MI => VirtualKeyCode::Kana_mi, + //x11::keysym::XK_kana_MU => VirtualKeyCode::Kana_mu, + //x11::keysym::XK_kana_ME => VirtualKeyCode::Kana_me, + //x11::keysym::XK_kana_MO => VirtualKeyCode::Kana_mo, + //x11::keysym::XK_kana_YA => VirtualKeyCode::Kana_ya, + //x11::keysym::XK_kana_YU => VirtualKeyCode::Kana_yu, + //x11::keysym::XK_kana_YO => VirtualKeyCode::Kana_yo, + //x11::keysym::XK_kana_RA => VirtualKeyCode::Kana_ra, + //x11::keysym::XK_kana_RI => VirtualKeyCode::Kana_ri, + //x11::keysym::XK_kana_RU => VirtualKeyCode::Kana_ru, + //x11::keysym::XK_kana_RE => VirtualKeyCode::Kana_re, + //x11::keysym::XK_kana_RO => VirtualKeyCode::Kana_ro, + //x11::keysym::XK_kana_WA => VirtualKeyCode::Kana_wa, + //x11::keysym::XK_kana_N => VirtualKeyCode::Kana_n, + //x11::keysym::XK_voicedsound => VirtualKeyCode::Voicedsound, + //x11::keysym::XK_semivoicedsound => VirtualKeyCode::Semivoicedsound, + //x11::keysym::XK_kana_switch => VirtualKeyCode::Kana_switch, + //x11::keysym::XK_Arabic_comma => VirtualKeyCode::Arabic_comma, + //x11::keysym::XK_Arabic_semicolon => VirtualKeyCode::Arabic_semicolon, + //x11::keysym::XK_Arabic_question_mark => VirtualKeyCode::Arabic_question_mark, + //x11::keysym::XK_Arabic_hamza => VirtualKeyCode::Arabic_hamza, + //x11::keysym::XK_Arabic_maddaonalef => VirtualKeyCode::Arabic_maddaonalef, + //x11::keysym::XK_Arabic_hamzaonalef => VirtualKeyCode::Arabic_hamzaonalef, + //x11::keysym::XK_Arabic_hamzaonwaw => VirtualKeyCode::Arabic_hamzaonwaw, + //x11::keysym::XK_Arabic_hamzaunderalef => VirtualKeyCode::Arabic_hamzaunderalef, + //x11::keysym::XK_Arabic_hamzaonyeh => VirtualKeyCode::Arabic_hamzaonyeh, + //x11::keysym::XK_Arabic_alef => VirtualKeyCode::Arabic_alef, + //x11::keysym::XK_Arabic_beh => VirtualKeyCode::Arabic_beh, + //x11::keysym::XK_Arabic_tehmarbuta => VirtualKeyCode::Arabic_tehmarbuta, + //x11::keysym::XK_Arabic_teh => VirtualKeyCode::Arabic_teh, + //x11::keysym::XK_Arabic_theh => VirtualKeyCode::Arabic_theh, + //x11::keysym::XK_Arabic_jeem => VirtualKeyCode::Arabic_jeem, + //x11::keysym::XK_Arabic_hah => VirtualKeyCode::Arabic_hah, + //x11::keysym::XK_Arabic_khah => VirtualKeyCode::Arabic_khah, + //x11::keysym::XK_Arabic_dal => VirtualKeyCode::Arabic_dal, + //x11::keysym::XK_Arabic_thal => VirtualKeyCode::Arabic_thal, + //x11::keysym::XK_Arabic_ra => VirtualKeyCode::Arabic_ra, + //x11::keysym::XK_Arabic_zain => VirtualKeyCode::Arabic_zain, + //x11::keysym::XK_Arabic_seen => VirtualKeyCode::Arabic_seen, + //x11::keysym::XK_Arabic_sheen => VirtualKeyCode::Arabic_sheen, + //x11::keysym::XK_Arabic_sad => VirtualKeyCode::Arabic_sad, + //x11::keysym::XK_Arabic_dad => VirtualKeyCode::Arabic_dad, + //x11::keysym::XK_Arabic_tah => VirtualKeyCode::Arabic_tah, + //x11::keysym::XK_Arabic_zah => VirtualKeyCode::Arabic_zah, + //x11::keysym::XK_Arabic_ain => VirtualKeyCode::Arabic_ain, + //x11::keysym::XK_Arabic_ghain => VirtualKeyCode::Arabic_ghain, + //x11::keysym::XK_Arabic_tatweel => VirtualKeyCode::Arabic_tatweel, + //x11::keysym::XK_Arabic_feh => VirtualKeyCode::Arabic_feh, + //x11::keysym::XK_Arabic_qaf => VirtualKeyCode::Arabic_qaf, + //x11::keysym::XK_Arabic_kaf => VirtualKeyCode::Arabic_kaf, + //x11::keysym::XK_Arabic_lam => VirtualKeyCode::Arabic_lam, + //x11::keysym::XK_Arabic_meem => VirtualKeyCode::Arabic_meem, + //x11::keysym::XK_Arabic_noon => VirtualKeyCode::Arabic_noon, + //x11::keysym::XK_Arabic_ha => VirtualKeyCode::Arabic_ha, + //x11::keysym::XK_Arabic_heh => VirtualKeyCode::Arabic_heh, + //x11::keysym::XK_Arabic_waw => VirtualKeyCode::Arabic_waw, + //x11::keysym::XK_Arabic_alefmaksura => VirtualKeyCode::Arabic_alefmaksura, + //x11::keysym::XK_Arabic_yeh => VirtualKeyCode::Arabic_yeh, + //x11::keysym::XK_Arabic_fathatan => VirtualKeyCode::Arabic_fathatan, + //x11::keysym::XK_Arabic_dammatan => VirtualKeyCode::Arabic_dammatan, + //x11::keysym::XK_Arabic_kasratan => VirtualKeyCode::Arabic_kasratan, + //x11::keysym::XK_Arabic_fatha => VirtualKeyCode::Arabic_fatha, + //x11::keysym::XK_Arabic_damma => VirtualKeyCode::Arabic_damma, + //x11::keysym::XK_Arabic_kasra => VirtualKeyCode::Arabic_kasra, + //x11::keysym::XK_Arabic_shadda => VirtualKeyCode::Arabic_shadda, + //x11::keysym::XK_Arabic_sukun => VirtualKeyCode::Arabic_sukun, + //x11::keysym::XK_Arabic_switch => VirtualKeyCode::Arabic_switch, + //x11::keysym::XK_Serbian_dje => VirtualKeyCode::Serbian_dje, + //x11::keysym::XK_Macedonia_gje => VirtualKeyCode::Macedonia_gje, + //x11::keysym::XK_Cyrillic_io => VirtualKeyCode::Cyrillic_io, + //x11::keysym::XK_Ukrainian_ie => VirtualKeyCode::Ukrainian_ie, + //x11::keysym::XK_Ukranian_je => VirtualKeyCode::Ukranian_je, + //x11::keysym::XK_Macedonia_dse => VirtualKeyCode::Macedonia_dse, + //x11::keysym::XK_Ukrainian_i => VirtualKeyCode::Ukrainian_i, + //x11::keysym::XK_Ukranian_i => VirtualKeyCode::Ukranian_i, + //x11::keysym::XK_Ukrainian_yi => VirtualKeyCode::Ukrainian_yi, + //x11::keysym::XK_Ukranian_yi => VirtualKeyCode::Ukranian_yi, + //x11::keysym::XK_Cyrillic_je => VirtualKeyCode::Cyrillic_je, + //x11::keysym::XK_Serbian_je => VirtualKeyCode::Serbian_je, + //x11::keysym::XK_Cyrillic_lje => VirtualKeyCode::Cyrillic_lje, + //x11::keysym::XK_Serbian_lje => VirtualKeyCode::Serbian_lje, + //x11::keysym::XK_Cyrillic_nje => VirtualKeyCode::Cyrillic_nje, + //x11::keysym::XK_Serbian_nje => VirtualKeyCode::Serbian_nje, + //x11::keysym::XK_Serbian_tshe => VirtualKeyCode::Serbian_tshe, + //x11::keysym::XK_Macedonia_kje => VirtualKeyCode::Macedonia_kje, + //x11::keysym::XK_Byelorussian_shortu => VirtualKeyCode::Byelorussian_shortu, + //x11::keysym::XK_Cyrillic_dzhe => VirtualKeyCode::Cyrillic_dzhe, + //x11::keysym::XK_Serbian_dze => VirtualKeyCode::Serbian_dze, + //x11::keysym::XK_numerosign => VirtualKeyCode::Numerosign, + //x11::keysym::XK_Serbian_DJE => VirtualKeyCode::Serbian_dje, + //x11::keysym::XK_Macedonia_GJE => VirtualKeyCode::Macedonia_gje, + //x11::keysym::XK_Cyrillic_IO => VirtualKeyCode::Cyrillic_io, + //x11::keysym::XK_Ukrainian_IE => VirtualKeyCode::Ukrainian_ie, + //x11::keysym::XK_Ukranian_JE => VirtualKeyCode::Ukranian_je, + //x11::keysym::XK_Macedonia_DSE => VirtualKeyCode::Macedonia_dse, + //x11::keysym::XK_Ukrainian_I => VirtualKeyCode::Ukrainian_i, + //x11::keysym::XK_Ukranian_I => VirtualKeyCode::Ukranian_i, + //x11::keysym::XK_Ukrainian_YI => VirtualKeyCode::Ukrainian_yi, + //x11::keysym::XK_Ukranian_YI => VirtualKeyCode::Ukranian_yi, + //x11::keysym::XK_Cyrillic_JE => VirtualKeyCode::Cyrillic_je, + //x11::keysym::XK_Serbian_JE => VirtualKeyCode::Serbian_je, + //x11::keysym::XK_Cyrillic_LJE => VirtualKeyCode::Cyrillic_lje, + //x11::keysym::XK_Serbian_LJE => VirtualKeyCode::Serbian_lje, + //x11::keysym::XK_Cyrillic_NJE => VirtualKeyCode::Cyrillic_nje, + //x11::keysym::XK_Serbian_NJE => VirtualKeyCode::Serbian_nje, + //x11::keysym::XK_Serbian_TSHE => VirtualKeyCode::Serbian_tshe, + //x11::keysym::XK_Macedonia_KJE => VirtualKeyCode::Macedonia_kje, + //x11::keysym::XK_Byelorussian_SHORTU => VirtualKeyCode::Byelorussian_shortu, + //x11::keysym::XK_Cyrillic_DZHE => VirtualKeyCode::Cyrillic_dzhe, + //x11::keysym::XK_Serbian_DZE => VirtualKeyCode::Serbian_dze, + //x11::keysym::XK_Cyrillic_yu => VirtualKeyCode::Cyrillic_yu, + //x11::keysym::XK_Cyrillic_a => VirtualKeyCode::Cyrillic_a, + //x11::keysym::XK_Cyrillic_be => VirtualKeyCode::Cyrillic_be, + //x11::keysym::XK_Cyrillic_tse => VirtualKeyCode::Cyrillic_tse, + //x11::keysym::XK_Cyrillic_de => VirtualKeyCode::Cyrillic_de, + //x11::keysym::XK_Cyrillic_ie => VirtualKeyCode::Cyrillic_ie, + //x11::keysym::XK_Cyrillic_ef => VirtualKeyCode::Cyrillic_ef, + //x11::keysym::XK_Cyrillic_ghe => VirtualKeyCode::Cyrillic_ghe, + //x11::keysym::XK_Cyrillic_ha => VirtualKeyCode::Cyrillic_ha, + //x11::keysym::XK_Cyrillic_i => VirtualKeyCode::Cyrillic_i, + //x11::keysym::XK_Cyrillic_shorti => VirtualKeyCode::Cyrillic_shorti, + //x11::keysym::XK_Cyrillic_ka => VirtualKeyCode::Cyrillic_ka, + //x11::keysym::XK_Cyrillic_el => VirtualKeyCode::Cyrillic_el, + //x11::keysym::XK_Cyrillic_em => VirtualKeyCode::Cyrillic_em, + //x11::keysym::XK_Cyrillic_en => VirtualKeyCode::Cyrillic_en, + //x11::keysym::XK_Cyrillic_o => VirtualKeyCode::Cyrillic_o, + //x11::keysym::XK_Cyrillic_pe => VirtualKeyCode::Cyrillic_pe, + //x11::keysym::XK_Cyrillic_ya => VirtualKeyCode::Cyrillic_ya, + //x11::keysym::XK_Cyrillic_er => VirtualKeyCode::Cyrillic_er, + //x11::keysym::XK_Cyrillic_es => VirtualKeyCode::Cyrillic_es, + //x11::keysym::XK_Cyrillic_te => VirtualKeyCode::Cyrillic_te, + //x11::keysym::XK_Cyrillic_u => VirtualKeyCode::Cyrillic_u, + //x11::keysym::XK_Cyrillic_zhe => VirtualKeyCode::Cyrillic_zhe, + //x11::keysym::XK_Cyrillic_ve => VirtualKeyCode::Cyrillic_ve, + //x11::keysym::XK_Cyrillic_softsign => VirtualKeyCode::Cyrillic_softsign, + //x11::keysym::XK_Cyrillic_yeru => VirtualKeyCode::Cyrillic_yeru, + //x11::keysym::XK_Cyrillic_ze => VirtualKeyCode::Cyrillic_ze, + //x11::keysym::XK_Cyrillic_sha => VirtualKeyCode::Cyrillic_sha, + //x11::keysym::XK_Cyrillic_e => VirtualKeyCode::Cyrillic_e, + //x11::keysym::XK_Cyrillic_shcha => VirtualKeyCode::Cyrillic_shcha, + //x11::keysym::XK_Cyrillic_che => VirtualKeyCode::Cyrillic_che, + //x11::keysym::XK_Cyrillic_hardsign => VirtualKeyCode::Cyrillic_hardsign, + //x11::keysym::XK_Cyrillic_YU => VirtualKeyCode::Cyrillic_yu, + //x11::keysym::XK_Cyrillic_A => VirtualKeyCode::Cyrillic_a, + //x11::keysym::XK_Cyrillic_BE => VirtualKeyCode::Cyrillic_be, + //x11::keysym::XK_Cyrillic_TSE => VirtualKeyCode::Cyrillic_tse, + //x11::keysym::XK_Cyrillic_DE => VirtualKeyCode::Cyrillic_de, + //x11::keysym::XK_Cyrillic_IE => VirtualKeyCode::Cyrillic_ie, + //x11::keysym::XK_Cyrillic_EF => VirtualKeyCode::Cyrillic_ef, + //x11::keysym::XK_Cyrillic_GHE => VirtualKeyCode::Cyrillic_ghe, + //x11::keysym::XK_Cyrillic_HA => VirtualKeyCode::Cyrillic_ha, + //x11::keysym::XK_Cyrillic_I => VirtualKeyCode::Cyrillic_i, + //x11::keysym::XK_Cyrillic_SHORTI => VirtualKeyCode::Cyrillic_shorti, + //x11::keysym::XK_Cyrillic_KA => VirtualKeyCode::Cyrillic_ka, + //x11::keysym::XK_Cyrillic_EL => VirtualKeyCode::Cyrillic_el, + //x11::keysym::XK_Cyrillic_EM => VirtualKeyCode::Cyrillic_em, + //x11::keysym::XK_Cyrillic_EN => VirtualKeyCode::Cyrillic_en, + //x11::keysym::XK_Cyrillic_O => VirtualKeyCode::Cyrillic_o, + //x11::keysym::XK_Cyrillic_PE => VirtualKeyCode::Cyrillic_pe, + //x11::keysym::XK_Cyrillic_YA => VirtualKeyCode::Cyrillic_ya, + //x11::keysym::XK_Cyrillic_ER => VirtualKeyCode::Cyrillic_er, + //x11::keysym::XK_Cyrillic_ES => VirtualKeyCode::Cyrillic_es, + //x11::keysym::XK_Cyrillic_TE => VirtualKeyCode::Cyrillic_te, + //x11::keysym::XK_Cyrillic_U => VirtualKeyCode::Cyrillic_u, + //x11::keysym::XK_Cyrillic_ZHE => VirtualKeyCode::Cyrillic_zhe, + //x11::keysym::XK_Cyrillic_VE => VirtualKeyCode::Cyrillic_ve, + //x11::keysym::XK_Cyrillic_SOFTSIGN => VirtualKeyCode::Cyrillic_softsign, + //x11::keysym::XK_Cyrillic_YERU => VirtualKeyCode::Cyrillic_yeru, + //x11::keysym::XK_Cyrillic_ZE => VirtualKeyCode::Cyrillic_ze, + //x11::keysym::XK_Cyrillic_SHA => VirtualKeyCode::Cyrillic_sha, + //x11::keysym::XK_Cyrillic_E => VirtualKeyCode::Cyrillic_e, + //x11::keysym::XK_Cyrillic_SHCHA => VirtualKeyCode::Cyrillic_shcha, + //x11::keysym::XK_Cyrillic_CHE => VirtualKeyCode::Cyrillic_che, + //x11::keysym::XK_Cyrillic_HARDSIGN => VirtualKeyCode::Cyrillic_hardsign, + //x11::keysym::XK_Greek_ALPHAaccent => VirtualKeyCode::Greek_alphaaccent, + //x11::keysym::XK_Greek_EPSILONaccent => VirtualKeyCode::Greek_epsilonaccent, + //x11::keysym::XK_Greek_ETAaccent => VirtualKeyCode::Greek_etaaccent, + //x11::keysym::XK_Greek_IOTAaccent => VirtualKeyCode::Greek_iotaaccent, + //x11::keysym::XK_Greek_IOTAdiaeresis => VirtualKeyCode::Greek_iotadiaeresis, + //x11::keysym::XK_Greek_OMICRONaccent => VirtualKeyCode::Greek_omicronaccent, + //x11::keysym::XK_Greek_UPSILONaccent => VirtualKeyCode::Greek_upsilonaccent, + //x11::keysym::XK_Greek_UPSILONdieresis => VirtualKeyCode::Greek_upsilondieresis, + //x11::keysym::XK_Greek_OMEGAaccent => VirtualKeyCode::Greek_omegaaccent, + //x11::keysym::XK_Greek_accentdieresis => VirtualKeyCode::Greek_accentdieresis, + //x11::keysym::XK_Greek_horizbar => VirtualKeyCode::Greek_horizbar, + //x11::keysym::XK_Greek_alphaaccent => VirtualKeyCode::Greek_alphaaccent, + //x11::keysym::XK_Greek_epsilonaccent => VirtualKeyCode::Greek_epsilonaccent, + //x11::keysym::XK_Greek_etaaccent => VirtualKeyCode::Greek_etaaccent, + //x11::keysym::XK_Greek_iotaaccent => VirtualKeyCode::Greek_iotaaccent, + //x11::keysym::XK_Greek_iotadieresis => VirtualKeyCode::Greek_iotadieresis, + //x11::keysym::XK_Greek_iotaaccentdieresis => VirtualKeyCode::Greek_iotaaccentdieresis, + //x11::keysym::XK_Greek_omicronaccent => VirtualKeyCode::Greek_omicronaccent, + //x11::keysym::XK_Greek_upsilonaccent => VirtualKeyCode::Greek_upsilonaccent, + //x11::keysym::XK_Greek_upsilondieresis => VirtualKeyCode::Greek_upsilondieresis, + //x11::keysym::XK_Greek_upsilonaccentdieresis => VirtualKeyCode::Greek_upsilonaccentdieresis, + //x11::keysym::XK_Greek_omegaaccent => VirtualKeyCode::Greek_omegaaccent, + //x11::keysym::XK_Greek_ALPHA => VirtualKeyCode::Greek_alpha, + //x11::keysym::XK_Greek_BETA => VirtualKeyCode::Greek_beta, + //x11::keysym::XK_Greek_GAMMA => VirtualKeyCode::Greek_gamma, + //x11::keysym::XK_Greek_DELTA => VirtualKeyCode::Greek_delta, + //x11::keysym::XK_Greek_EPSILON => VirtualKeyCode::Greek_epsilon, + //x11::keysym::XK_Greek_ZETA => VirtualKeyCode::Greek_zeta, + //x11::keysym::XK_Greek_ETA => VirtualKeyCode::Greek_eta, + //x11::keysym::XK_Greek_THETA => VirtualKeyCode::Greek_theta, + //x11::keysym::XK_Greek_IOTA => VirtualKeyCode::Greek_iota, + //x11::keysym::XK_Greek_KAPPA => VirtualKeyCode::Greek_kappa, + //x11::keysym::XK_Greek_LAMDA => VirtualKeyCode::Greek_lamda, + //x11::keysym::XK_Greek_LAMBDA => VirtualKeyCode::Greek_lambda, + //x11::keysym::XK_Greek_MU => VirtualKeyCode::Greek_mu, + //x11::keysym::XK_Greek_NU => VirtualKeyCode::Greek_nu, + //x11::keysym::XK_Greek_XI => VirtualKeyCode::Greek_xi, + //x11::keysym::XK_Greek_OMICRON => VirtualKeyCode::Greek_omicron, + //x11::keysym::XK_Greek_PI => VirtualKeyCode::Greek_pi, + //x11::keysym::XK_Greek_RHO => VirtualKeyCode::Greek_rho, + //x11::keysym::XK_Greek_SIGMA => VirtualKeyCode::Greek_sigma, + //x11::keysym::XK_Greek_TAU => VirtualKeyCode::Greek_tau, + //x11::keysym::XK_Greek_UPSILON => VirtualKeyCode::Greek_upsilon, + //x11::keysym::XK_Greek_PHI => VirtualKeyCode::Greek_phi, + //x11::keysym::XK_Greek_CHI => VirtualKeyCode::Greek_chi, + //x11::keysym::XK_Greek_PSI => VirtualKeyCode::Greek_psi, + //x11::keysym::XK_Greek_OMEGA => VirtualKeyCode::Greek_omega, + //x11::keysym::XK_Greek_alpha => VirtualKeyCode::Greek_alpha, + //x11::keysym::XK_Greek_beta => VirtualKeyCode::Greek_beta, + //x11::keysym::XK_Greek_gamma => VirtualKeyCode::Greek_gamma, + //x11::keysym::XK_Greek_delta => VirtualKeyCode::Greek_delta, + //x11::keysym::XK_Greek_epsilon => VirtualKeyCode::Greek_epsilon, + //x11::keysym::XK_Greek_zeta => VirtualKeyCode::Greek_zeta, + //x11::keysym::XK_Greek_eta => VirtualKeyCode::Greek_eta, + //x11::keysym::XK_Greek_theta => VirtualKeyCode::Greek_theta, + //x11::keysym::XK_Greek_iota => VirtualKeyCode::Greek_iota, + //x11::keysym::XK_Greek_kappa => VirtualKeyCode::Greek_kappa, + //x11::keysym::XK_Greek_lamda => VirtualKeyCode::Greek_lamda, + //x11::keysym::XK_Greek_lambda => VirtualKeyCode::Greek_lambda, + //x11::keysym::XK_Greek_mu => VirtualKeyCode::Greek_mu, + //x11::keysym::XK_Greek_nu => VirtualKeyCode::Greek_nu, + //x11::keysym::XK_Greek_xi => VirtualKeyCode::Greek_xi, + //x11::keysym::XK_Greek_omicron => VirtualKeyCode::Greek_omicron, + //x11::keysym::XK_Greek_pi => VirtualKeyCode::Greek_pi, + //x11::keysym::XK_Greek_rho => VirtualKeyCode::Greek_rho, + //x11::keysym::XK_Greek_sigma => VirtualKeyCode::Greek_sigma, + //x11::keysym::XK_Greek_finalsmallsigma => VirtualKeyCode::Greek_finalsmallsigma, + //x11::keysym::XK_Greek_tau => VirtualKeyCode::Greek_tau, + //x11::keysym::XK_Greek_upsilon => VirtualKeyCode::Greek_upsilon, + //x11::keysym::XK_Greek_phi => VirtualKeyCode::Greek_phi, + //x11::keysym::XK_Greek_chi => VirtualKeyCode::Greek_chi, + //x11::keysym::XK_Greek_psi => VirtualKeyCode::Greek_psi, + //x11::keysym::XK_Greek_omega => VirtualKeyCode::Greek_omega, + //x11::keysym::XK_Greek_switch => VirtualKeyCode::Greek_switch, + //x11::keysym::XK_leftradical => VirtualKeyCode::Leftradical, + //x11::keysym::XK_topleftradical => VirtualKeyCode::Topleftradical, + //x11::keysym::XK_horizconnector => VirtualKeyCode::Horizconnector, + //x11::keysym::XK_topintegral => VirtualKeyCode::Topintegral, + //x11::keysym::XK_botintegral => VirtualKeyCode::Botintegral, + //x11::keysym::XK_vertconnector => VirtualKeyCode::Vertconnector, + //x11::keysym::XK_topleftsqbracket => VirtualKeyCode::Topleftsqbracket, + //x11::keysym::XK_botleftsqbracket => VirtualKeyCode::Botleftsqbracket, + //x11::keysym::XK_toprightsqbracket => VirtualKeyCode::Toprightsqbracket, + //x11::keysym::XK_botrightsqbracket => VirtualKeyCode::Botrightsqbracket, + //x11::keysym::XK_topleftparens => VirtualKeyCode::Topleftparens, + //x11::keysym::XK_botleftparens => VirtualKeyCode::Botleftparens, + //x11::keysym::XK_toprightparens => VirtualKeyCode::Toprightparens, + //x11::keysym::XK_botrightparens => VirtualKeyCode::Botrightparens, + //x11::keysym::XK_leftmiddlecurlybrace => VirtualKeyCode::Leftmiddlecurlybrace, + //x11::keysym::XK_rightmiddlecurlybrace => VirtualKeyCode::Rightmiddlecurlybrace, + //x11::keysym::XK_topleftsummation => VirtualKeyCode::Topleftsummation, + //x11::keysym::XK_botleftsummation => VirtualKeyCode::Botleftsummation, + //x11::keysym::XK_topvertsummationconnector => VirtualKeyCode::Topvertsummationconnector, + //x11::keysym::XK_botvertsummationconnector => VirtualKeyCode::Botvertsummationconnector, + //x11::keysym::XK_toprightsummation => VirtualKeyCode::Toprightsummation, + //x11::keysym::XK_botrightsummation => VirtualKeyCode::Botrightsummation, + //x11::keysym::XK_rightmiddlesummation => VirtualKeyCode::Rightmiddlesummation, + //x11::keysym::XK_lessthanequal => VirtualKeyCode::Lessthanequal, + //x11::keysym::XK_notequal => VirtualKeyCode::Notequal, + //x11::keysym::XK_greaterthanequal => VirtualKeyCode::Greaterthanequal, + //x11::keysym::XK_integral => VirtualKeyCode::Integral, + //x11::keysym::XK_therefore => VirtualKeyCode::Therefore, + //x11::keysym::XK_variation => VirtualKeyCode::Variation, + //x11::keysym::XK_infinity => VirtualKeyCode::Infinity, + //x11::keysym::XK_nabla => VirtualKeyCode::Nabla, + //x11::keysym::XK_approximate => VirtualKeyCode::Approximate, + //x11::keysym::XK_similarequal => VirtualKeyCode::Similarequal, + //x11::keysym::XK_ifonlyif => VirtualKeyCode::Ifonlyif, + //x11::keysym::XK_implies => VirtualKeyCode::Implies, + //x11::keysym::XK_identical => VirtualKeyCode::Identical, + //x11::keysym::XK_radical => VirtualKeyCode::Radical, + //x11::keysym::XK_includedin => VirtualKeyCode::Includedin, + //x11::keysym::XK_includes => VirtualKeyCode::Includes, + //x11::keysym::XK_intersection => VirtualKeyCode::Intersection, + //x11::keysym::XK_union => VirtualKeyCode::Union, + //x11::keysym::XK_logicaland => VirtualKeyCode::Logicaland, + //x11::keysym::XK_logicalor => VirtualKeyCode::Logicalor, + //x11::keysym::XK_partialderivative => VirtualKeyCode::Partialderivative, + //x11::keysym::XK_function => VirtualKeyCode::Function, + //x11::keysym::XK_leftarrow => VirtualKeyCode::Leftarrow, + //x11::keysym::XK_uparrow => VirtualKeyCode::Uparrow, + //x11::keysym::XK_rightarrow => VirtualKeyCode::Rightarrow, + //x11::keysym::XK_downarrow => VirtualKeyCode::Downarrow, + //x11::keysym::XK_blank => VirtualKeyCode::Blank, + //x11::keysym::XK_soliddiamond => VirtualKeyCode::Soliddiamond, + //x11::keysym::XK_checkerboard => VirtualKeyCode::Checkerboard, + //x11::keysym::XK_ht => VirtualKeyCode::Ht, + //x11::keysym::XK_ff => VirtualKeyCode::Ff, + //x11::keysym::XK_cr => VirtualKeyCode::Cr, + //x11::keysym::XK_lf => VirtualKeyCode::Lf, + //x11::keysym::XK_nl => VirtualKeyCode::Nl, + //x11::keysym::XK_vt => VirtualKeyCode::Vt, + //x11::keysym::XK_lowrightcorner => VirtualKeyCode::Lowrightcorner, + //x11::keysym::XK_uprightcorner => VirtualKeyCode::Uprightcorner, + //x11::keysym::XK_upleftcorner => VirtualKeyCode::Upleftcorner, + //x11::keysym::XK_lowleftcorner => VirtualKeyCode::Lowleftcorner, + //x11::keysym::XK_crossinglines => VirtualKeyCode::Crossinglines, + //x11::keysym::XK_horizlinescan1 => VirtualKeyCode::Horizlinescan1, + //x11::keysym::XK_horizlinescan3 => VirtualKeyCode::Horizlinescan3, + //x11::keysym::XK_horizlinescan5 => VirtualKeyCode::Horizlinescan5, + //x11::keysym::XK_horizlinescan7 => VirtualKeyCode::Horizlinescan7, + //x11::keysym::XK_horizlinescan9 => VirtualKeyCode::Horizlinescan9, + //x11::keysym::XK_leftt => VirtualKeyCode::Leftt, + //x11::keysym::XK_rightt => VirtualKeyCode::Rightt, + //x11::keysym::XK_bott => VirtualKeyCode::Bott, + //x11::keysym::XK_topt => VirtualKeyCode::Topt, + //x11::keysym::XK_vertbar => VirtualKeyCode::Vertbar, + //x11::keysym::XK_emspace => VirtualKeyCode::Emspace, + //x11::keysym::XK_enspace => VirtualKeyCode::Enspace, + //x11::keysym::XK_em3space => VirtualKeyCode::Em3space, + //x11::keysym::XK_em4space => VirtualKeyCode::Em4space, + //x11::keysym::XK_digitspace => VirtualKeyCode::Digitspace, + //x11::keysym::XK_punctspace => VirtualKeyCode::Punctspace, + //x11::keysym::XK_thinspace => VirtualKeyCode::Thinspace, + //x11::keysym::XK_hairspace => VirtualKeyCode::Hairspace, + //x11::keysym::XK_emdash => VirtualKeyCode::Emdash, + //x11::keysym::XK_endash => VirtualKeyCode::Endash, + //x11::keysym::XK_signifblank => VirtualKeyCode::Signifblank, + //x11::keysym::XK_ellipsis => VirtualKeyCode::Ellipsis, + //x11::keysym::XK_doubbaselinedot => VirtualKeyCode::Doubbaselinedot, + //x11::keysym::XK_onethird => VirtualKeyCode::Onethird, + //x11::keysym::XK_twothirds => VirtualKeyCode::Twothirds, + //x11::keysym::XK_onefifth => VirtualKeyCode::Onefifth, + //x11::keysym::XK_twofifths => VirtualKeyCode::Twofifths, + //x11::keysym::XK_threefifths => VirtualKeyCode::Threefifths, + //x11::keysym::XK_fourfifths => VirtualKeyCode::Fourfifths, + //x11::keysym::XK_onesixth => VirtualKeyCode::Onesixth, + //x11::keysym::XK_fivesixths => VirtualKeyCode::Fivesixths, + //x11::keysym::XK_careof => VirtualKeyCode::Careof, + //x11::keysym::XK_figdash => VirtualKeyCode::Figdash, + //x11::keysym::XK_leftanglebracket => VirtualKeyCode::Leftanglebracket, + //x11::keysym::XK_decimalpoint => VirtualKeyCode::Decimalpoint, + //x11::keysym::XK_rightanglebracket => VirtualKeyCode::Rightanglebracket, + //x11::keysym::XK_marker => VirtualKeyCode::Marker, + //x11::keysym::XK_oneeighth => VirtualKeyCode::Oneeighth, + //x11::keysym::XK_threeeighths => VirtualKeyCode::Threeeighths, + //x11::keysym::XK_fiveeighths => VirtualKeyCode::Fiveeighths, + //x11::keysym::XK_seveneighths => VirtualKeyCode::Seveneighths, + //x11::keysym::XK_trademark => VirtualKeyCode::Trademark, + //x11::keysym::XK_signaturemark => VirtualKeyCode::Signaturemark, + //x11::keysym::XK_trademarkincircle => VirtualKeyCode::Trademarkincircle, + //x11::keysym::XK_leftopentriangle => VirtualKeyCode::Leftopentriangle, + //x11::keysym::XK_rightopentriangle => VirtualKeyCode::Rightopentriangle, + //x11::keysym::XK_emopencircle => VirtualKeyCode::Emopencircle, + //x11::keysym::XK_emopenrectangle => VirtualKeyCode::Emopenrectangle, + //x11::keysym::XK_leftsinglequotemark => VirtualKeyCode::Leftsinglequotemark, + //x11::keysym::XK_rightsinglequotemark => VirtualKeyCode::Rightsinglequotemark, + //x11::keysym::XK_leftdoublequotemark => VirtualKeyCode::Leftdoublequotemark, + //x11::keysym::XK_rightdoublequotemark => VirtualKeyCode::Rightdoublequotemark, + //x11::keysym::XK_prescription => VirtualKeyCode::Prescription, + //x11::keysym::XK_minutes => VirtualKeyCode::Minutes, + //x11::keysym::XK_seconds => VirtualKeyCode::Seconds, + //x11::keysym::XK_latincross => VirtualKeyCode::Latincross, + //x11::keysym::XK_hexagram => VirtualKeyCode::Hexagram, + //x11::keysym::XK_filledrectbullet => VirtualKeyCode::Filledrectbullet, + //x11::keysym::XK_filledlefttribullet => VirtualKeyCode::Filledlefttribullet, + //x11::keysym::XK_filledrighttribullet => VirtualKeyCode::Filledrighttribullet, + //x11::keysym::XK_emfilledcircle => VirtualKeyCode::Emfilledcircle, + //x11::keysym::XK_emfilledrect => VirtualKeyCode::Emfilledrect, + //x11::keysym::XK_enopencircbullet => VirtualKeyCode::Enopencircbullet, + //x11::keysym::XK_enopensquarebullet => VirtualKeyCode::Enopensquarebullet, + //x11::keysym::XK_openrectbullet => VirtualKeyCode::Openrectbullet, + //x11::keysym::XK_opentribulletup => VirtualKeyCode::Opentribulletup, + //x11::keysym::XK_opentribulletdown => VirtualKeyCode::Opentribulletdown, + //x11::keysym::XK_openstar => VirtualKeyCode::Openstar, + //x11::keysym::XK_enfilledcircbullet => VirtualKeyCode::Enfilledcircbullet, + //x11::keysym::XK_enfilledsqbullet => VirtualKeyCode::Enfilledsqbullet, + //x11::keysym::XK_filledtribulletup => VirtualKeyCode::Filledtribulletup, + //x11::keysym::XK_filledtribulletdown => VirtualKeyCode::Filledtribulletdown, + //x11::keysym::XK_leftpointer => VirtualKeyCode::Leftpointer, + //x11::keysym::XK_rightpointer => VirtualKeyCode::Rightpointer, + //x11::keysym::XK_club => VirtualKeyCode::Club, + //x11::keysym::XK_diamond => VirtualKeyCode::Diamond, + //x11::keysym::XK_heart => VirtualKeyCode::Heart, + //x11::keysym::XK_maltesecross => VirtualKeyCode::Maltesecross, + //x11::keysym::XK_dagger => VirtualKeyCode::Dagger, + //x11::keysym::XK_doubledagger => VirtualKeyCode::Doubledagger, + //x11::keysym::XK_checkmark => VirtualKeyCode::Checkmark, + //x11::keysym::XK_ballotcross => VirtualKeyCode::Ballotcross, + //x11::keysym::XK_musicalsharp => VirtualKeyCode::Musicalsharp, + //x11::keysym::XK_musicalflat => VirtualKeyCode::Musicalflat, + //x11::keysym::XK_malesymbol => VirtualKeyCode::Malesymbol, + //x11::keysym::XK_femalesymbol => VirtualKeyCode::Femalesymbol, + //x11::keysym::XK_telephone => VirtualKeyCode::Telephone, + //x11::keysym::XK_telephonerecorder => VirtualKeyCode::Telephonerecorder, + //x11::keysym::XK_phonographcopyright => VirtualKeyCode::Phonographcopyright, + //x11::keysym::XK_caret => VirtualKeyCode::Caret, + //x11::keysym::XK_singlelowquotemark => VirtualKeyCode::Singlelowquotemark, + //x11::keysym::XK_doublelowquotemark => VirtualKeyCode::Doublelowquotemark, + //x11::keysym::XK_cursor => VirtualKeyCode::Cursor, + //x11::keysym::XK_leftcaret => VirtualKeyCode::Leftcaret, + //x11::keysym::XK_rightcaret => VirtualKeyCode::Rightcaret, + //x11::keysym::XK_downcaret => VirtualKeyCode::Downcaret, + //x11::keysym::XK_upcaret => VirtualKeyCode::Upcaret, + //x11::keysym::XK_overbar => VirtualKeyCode::Overbar, + //x11::keysym::XK_downtack => VirtualKeyCode::Downtack, + //x11::keysym::XK_upshoe => VirtualKeyCode::Upshoe, + //x11::keysym::XK_downstile => VirtualKeyCode::Downstile, + //x11::keysym::XK_underbar => VirtualKeyCode::Underbar, + //x11::keysym::XK_jot => VirtualKeyCode::Jot, + //x11::keysym::XK_quad => VirtualKeyCode::Quad, + //x11::keysym::XK_uptack => VirtualKeyCode::Uptack, + //x11::keysym::XK_circle => VirtualKeyCode::Circle, + //x11::keysym::XK_upstile => VirtualKeyCode::Upstile, + //x11::keysym::XK_downshoe => VirtualKeyCode::Downshoe, + //x11::keysym::XK_rightshoe => VirtualKeyCode::Rightshoe, + //x11::keysym::XK_leftshoe => VirtualKeyCode::Leftshoe, + //x11::keysym::XK_lefttack => VirtualKeyCode::Lefttack, + //x11::keysym::XK_righttack => VirtualKeyCode::Righttack, + //x11::keysym::XK_hebrew_doublelowline => VirtualKeyCode::Hebrew_doublelowline, + //x11::keysym::XK_hebrew_aleph => VirtualKeyCode::Hebrew_aleph, + //x11::keysym::XK_hebrew_bet => VirtualKeyCode::Hebrew_bet, + //x11::keysym::XK_hebrew_beth => VirtualKeyCode::Hebrew_beth, + //x11::keysym::XK_hebrew_gimel => VirtualKeyCode::Hebrew_gimel, + //x11::keysym::XK_hebrew_gimmel => VirtualKeyCode::Hebrew_gimmel, + //x11::keysym::XK_hebrew_dalet => VirtualKeyCode::Hebrew_dalet, + //x11::keysym::XK_hebrew_daleth => VirtualKeyCode::Hebrew_daleth, + //x11::keysym::XK_hebrew_he => VirtualKeyCode::Hebrew_he, + //x11::keysym::XK_hebrew_waw => VirtualKeyCode::Hebrew_waw, + //x11::keysym::XK_hebrew_zain => VirtualKeyCode::Hebrew_zain, + //x11::keysym::XK_hebrew_zayin => VirtualKeyCode::Hebrew_zayin, + //x11::keysym::XK_hebrew_chet => VirtualKeyCode::Hebrew_chet, + //x11::keysym::XK_hebrew_het => VirtualKeyCode::Hebrew_het, + //x11::keysym::XK_hebrew_tet => VirtualKeyCode::Hebrew_tet, + //x11::keysym::XK_hebrew_teth => VirtualKeyCode::Hebrew_teth, + //x11::keysym::XK_hebrew_yod => VirtualKeyCode::Hebrew_yod, + //x11::keysym::XK_hebrew_finalkaph => VirtualKeyCode::Hebrew_finalkaph, + //x11::keysym::XK_hebrew_kaph => VirtualKeyCode::Hebrew_kaph, + //x11::keysym::XK_hebrew_lamed => VirtualKeyCode::Hebrew_lamed, + //x11::keysym::XK_hebrew_finalmem => VirtualKeyCode::Hebrew_finalmem, + //x11::keysym::XK_hebrew_mem => VirtualKeyCode::Hebrew_mem, + //x11::keysym::XK_hebrew_finalnun => VirtualKeyCode::Hebrew_finalnun, + //x11::keysym::XK_hebrew_nun => VirtualKeyCode::Hebrew_nun, + //x11::keysym::XK_hebrew_samech => VirtualKeyCode::Hebrew_samech, + //x11::keysym::XK_hebrew_samekh => VirtualKeyCode::Hebrew_samekh, + //x11::keysym::XK_hebrew_ayin => VirtualKeyCode::Hebrew_ayin, + //x11::keysym::XK_hebrew_finalpe => VirtualKeyCode::Hebrew_finalpe, + //x11::keysym::XK_hebrew_pe => VirtualKeyCode::Hebrew_pe, + //x11::keysym::XK_hebrew_finalzade => VirtualKeyCode::Hebrew_finalzade, + //x11::keysym::XK_hebrew_finalzadi => VirtualKeyCode::Hebrew_finalzadi, + //x11::keysym::XK_hebrew_zade => VirtualKeyCode::Hebrew_zade, + //x11::keysym::XK_hebrew_zadi => VirtualKeyCode::Hebrew_zadi, + //x11::keysym::XK_hebrew_qoph => VirtualKeyCode::Hebrew_qoph, + //x11::keysym::XK_hebrew_kuf => VirtualKeyCode::Hebrew_kuf, + //x11::keysym::XK_hebrew_resh => VirtualKeyCode::Hebrew_resh, + //x11::keysym::XK_hebrew_shin => VirtualKeyCode::Hebrew_shin, + //x11::keysym::XK_hebrew_taw => VirtualKeyCode::Hebrew_taw, + //x11::keysym::XK_hebrew_taf => VirtualKeyCode::Hebrew_taf, + //x11::keysym::XK_Hebrew_switch => VirtualKeyCode::Hebrew_switch, + x11::keysym::XF86XK_Back => VirtualKeyCode::NavigateBackward, + x11::keysym::XF86XK_Forward => { + VirtualKeyCode::NavigateForward + } + x11::keysym::XF86XK_Copy => VirtualKeyCode::Copy, + x11::keysym::XF86XK_Paste => VirtualKeyCode::Paste, + x11::keysym::XF86XK_Cut => VirtualKeyCode::Cut, + _ => return None, + }) +} diff --git a/src/backends/xlib/mod.rs b/src/backends/xlib/mod.rs new file mode 100644 index 0000000..3e8a292 --- /dev/null +++ b/src/backends/xlib/mod.rs @@ -0,0 +1,250 @@ +#![allow(non_upper_case_globals)] +pub mod keysym; + +use std::ptr::null; + +use x11::xlib::{ + ButtonPress, ButtonRelease, ConfigureRequest, CreateNotify, + DestroyNotify, EnterNotify, KeyPress, KeyRelease, MapRequest, + MotionNotify, UnmapNotify, Window, XAnyEvent, XButtonEvent, + XConfigureRequestEvent, XCreateWindowEvent, XDestroyWindowEvent, + XEvent, XKeyEvent, XLookupKeysym, XMapRequestEvent, XMotionEvent, + XNextEvent, XRootWindow, XUnmapEvent, +}; + +use crate::backends::window_event::{ + ButtonEvent, KeyEvent, KeyState, ModifierKey, +}; + +use self::keysym::{keysym_to_virtual_keycode, xev_to_mouse_button}; + +use super::window_event::{ + ConfigureEvent, CreateEvent, DestroyEvent, MapEvent, + ModifierState, MotionEvent, UnmapEvent, WindowEvent, +}; + +// xlib backend +pub struct XLib { + display: *mut x11::xlib::Display, + modifier_state: ModifierState, + screen: i32, +} + +impl Drop for XLib { + fn drop(&mut self) { + unsafe { + x11::xlib::XCloseDisplay(self.display); + } + } +} + +impl XLib { + pub fn new() -> Self { + let (display, screen) = unsafe { + let display = x11::xlib::XOpenDisplay(null()); + let screen = x11::xlib::XDefaultScreen(display); + + (display, screen) + }; + Self { + display, + screen, + modifier_state: Default::default(), + } + } + + fn root_window(&self) -> Window { + unsafe { XRootWindow(self.display, self.screen) } + } + + fn update_modifier_state( + &mut self, + keyevent: &x11::xlib::XKeyEvent, + ) { + //keyevent.keycode + let keysym = self.keyev_to_keysym(keyevent); + + use x11::keysym::*; + + let modifier = match keysym as u32 { + XK_Shift_L | XK_Shift_R => Some(ModifierKey::Shift), + XK_Control_L | XK_Control_R => Some(ModifierKey::Control), + XK_Alt_L | XK_Alt_R => Some(ModifierKey::Alt), + XK_ISO_Level3_Shift => Some(ModifierKey::AltGr), + XK_Caps_Lock => Some(ModifierKey::ShiftLock), + XK_Num_Lock => Some(ModifierKey::NumLock), + XK_Win_L | XK_Win_R => Some(ModifierKey::Super), + XK_Super_L | XK_Super_R => Some(ModifierKey::Super), + _ => None, + }; + + if let Some(modifier) = modifier { + match keyevent.type_ { + KeyPress => { + self.modifier_state.set_modifier(modifier) + } + KeyRelease => { + self.modifier_state.set_modifier(modifier) + } + _ => unreachable!( + "keyyevent != (KeyPress | KeyRelease)" + ), + } + } + } + + fn keyev_to_keysym(&self, keyev: &XKeyEvent) -> u32 { + unsafe { + XLookupKeysym(keyev as *const _ as *mut _, 0) as u32 + } + } + + pub fn next_event(&self) -> XEvent { + unsafe { + let mut event = std::mem::MaybeUninit::zeroed(); + XNextEvent(self.display, event.as_mut_ptr()); + + event.assume_init() + } + } + + fn next_window_event(&mut self) -> WindowEvent { + loop { + let event = self.next_event(); + + match event.get_type() { + KeyPress | KeyRelease => { + let key_ev: &XKeyEvent = event.as_ref(); + + self.update_modifier_state(key_ev); + + let keycode = keysym_to_virtual_keycode( + self.keyev_to_keysym(event.as_ref()), + ); + + if let Some(keycode) = keycode { + return WindowEvent::KeyEvent { + window: key_ev.subwindow, + event: KeyEvent::new( + match event.get_type() { + KeyPress => KeyState::Pressed, + KeyRelease => KeyState::Released, + _ => unreachable!(), + }, + keycode, + self.modifier_state.clone(), + ), + }; + } + } + ButtonPress | ButtonRelease => { + let button_ev: &XButtonEvent = event.as_ref(); + let button = xev_to_mouse_button(button_ev); + + if let Some(button) = button { + return WindowEvent::ButtonEvent { + window: button_ev.subwindow, + event: ButtonEvent::new( + match event.get_type() { + ButtonPress => KeyState::Pressed, + ButtonRelease => { + KeyState::Released + } + _ => unreachable!(), + }, + button, + self.modifier_state.clone(), + ), + }; + } + } + MotionNotify => { + let motion_ev: &XMotionEvent = event.as_ref(); + + return WindowEvent::MotionEvent { + window: motion_ev.subwindow, + event: MotionEvent::new([ + motion_ev.x_root, + motion_ev.y_root, + ]), + }; + } + MapRequest => { + // MapEvent + let map_ev: &XMapRequestEvent = event.as_ref(); + + return WindowEvent::MapEvent { + window: map_ev.window, + event: MapEvent::new(map_ev.window), + }; + } + UnmapNotify => { + // UnmapEvent + let unmap_ev: &XUnmapEvent = event.as_ref(); + + return WindowEvent::UnmapEvent { + window: unmap_ev.window, + event: UnmapEvent::new(unmap_ev.window), + }; + } + CreateNotify => { + // CreateEvent + let create_ev: &XCreateWindowEvent = + event.as_ref(); + + return WindowEvent::CreateEvent { + window: create_ev.window, + event: CreateEvent::new( + create_ev.window, + [create_ev.x, create_ev.y], + [create_ev.width, create_ev.height], + ), + }; + } + DestroyNotify => { + // DestroyEvent + let destroy_ev: &XDestroyWindowEvent = + event.as_ref(); + + return WindowEvent::DestroyEvent { + window: destroy_ev.window, + event: DestroyEvent::new(destroy_ev.window), + }; + } + ConfigureRequest => { + // ConfigureEvent + let configure_ev: &XConfigureRequestEvent = + event.as_ref(); + + return WindowEvent::ConfigureEvent { + window: configure_ev.window, + event: ConfigureEvent::new( + configure_ev.window, + [configure_ev.x, configure_ev.y], + [configure_ev.width, configure_ev.height], + ), + }; + } + _ => {} + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + //#[test] + // fn window_events() { + // let mut xlib = XLib::new(); + + // loop { + // if let Some(event) = + // xlib.xevent_to_window_event(xlib.next_event()) + // { + // println!("{:#?}", event); + // } + // } + // } +} diff --git a/src/client_logic.rs b/src/client_logic.rs index f1b64bd..f40e13b 100644 --- a/src/client_logic.rs +++ b/src/client_logic.rs @@ -185,7 +185,9 @@ where .map(move |&i| &self.workspaces[i]) } - fn get_current_mut(&mut self) -> impl Iterator> { + fn get_current_mut( + &mut self, + ) -> impl Iterator> { let current_indices = &self.current_indices; self.workspaces @@ -217,7 +219,9 @@ where .flat_map(|w| w.aux.iter()) } - fn iter_mut_current_master(&mut self) -> impl Iterator { + fn iter_mut_current_master( + &mut self, + ) -> impl Iterator { let current_indices = &self.current_indices; self.workspaces @@ -228,7 +232,9 @@ where .flat_map(|w| w.master.iter_mut()) } - fn iter_mut_current_aux(&mut self) -> impl Iterator { + fn iter_mut_current_aux( + &mut self, + ) -> impl Iterator { let current_indices = &self.current_indices; self.workspaces @@ -243,7 +249,9 @@ where self.workspaces.iter() } - fn iter_mut(&mut self) -> impl Iterator> { + fn iter_mut( + &mut self, + ) -> impl Iterator> { self.workspaces.iter_mut() } @@ -270,13 +278,18 @@ where where Vec: From, { - self.previous_indices = - Some(std::mem::replace(&mut self.current_indices, idx.into())); + self.previous_indices = Some(std::mem::replace( + &mut self.current_indices, + idx.into(), + )); } fn select_previous_workspaces(&mut self) { if let Some(previous_indices) = &mut self.previous_indices { - std::mem::swap(previous_indices, &mut self.current_indices); + std::mem::swap( + previous_indices, + &mut self.current_indices, + ); } } @@ -394,7 +407,8 @@ where (dimensions.0 - gap * 2, dimensions.1 - gap * 2) }; - let len_master = self.workspaces.iter_current_master().count(); + let len_master = + self.workspaces.iter_current_master().count(); let len_aux = self.workspaces.iter_current_aux().count(); let width_master = match len_aux { @@ -412,18 +426,23 @@ where n => height / n as i32, }; - for (i, id) in self.workspaces.iter_mut_current_master().enumerate() { + for (i, id) in + self.workspaces.iter_mut_current_master().enumerate() + { let size = ( width_master - gap * 2 - border * 2, height_master - gap * 2 - border * 2, ); - let position = (gap * 2, height_master * i as i32 + gap * 2); + let position = + (gap * 2, height_master * i as i32 + gap * 2); if let Some(client) = Option::<&mut Client>::from(self.store.get_mut(id)) { - if *client.position() != position || *client.size() != size { + if *client.position() != position + || *client.size() != size + { *client.position_mut() = position; *client.size_mut() = size; @@ -432,19 +451,25 @@ where } } - for (i, id) in self.workspaces.iter_mut_current_aux().enumerate() { + for (i, id) in + self.workspaces.iter_mut_current_aux().enumerate() + { let size = ( width_aux - gap * 2 - border * 2, height_aux - gap * 2 - border * 2, ); - let position = - (width_master + gap * 2, height_aux * i as i32 + gap * 2); + let position = ( + width_master + gap * 2, + height_aux * i as i32 + gap * 2, + ); if let Some(client) = Option::<&mut Client>::from(self.store.get_mut(id)) { - if *client.position() != position || *client.size() != size { + if *client.position() != position + || *client.size() != size + { *client.position_mut() = position; *client.size_mut() = size; diff --git a/src/clients.rs b/src/clients.rs index cd65dc1..7fedc7b 100644 --- a/src/clients.rs +++ b/src/clients.rs @@ -217,7 +217,8 @@ impl ClientState { if client.is_transient() && self.contains(&client.transient_for.unwrap()) { - let transient = self.get(&client.transient_for.unwrap()).unwrap(); + let transient = + self.get(&client.transient_for.unwrap()).unwrap(); client.position = { ( @@ -271,7 +272,9 @@ impl ClientState { || self.floating_clients.contains_key(&key) } - pub fn iter_floating(&self) -> impl Iterator { + pub fn iter_floating( + &self, + ) -> impl Iterator { self.floating_clients.iter() } @@ -283,32 +286,44 @@ impl ClientState { .filter(move |&(k, _)| self.is_client_visible(k)) } - fn iter_all_clients(&self) -> impl Iterator { + fn iter_all_clients( + &self, + ) -> impl Iterator { self.floating_clients.iter().chain(self.clients.iter()) } - pub fn iter_hidden(&self) -> impl Iterator { + pub fn iter_hidden( + &self, + ) -> impl Iterator { self.iter_all_clients() .filter(move |&(k, _)| !self.is_client_visible(k)) } - pub fn iter_transient(&self) -> impl Iterator { + pub fn iter_transient( + &self, + ) -> impl Iterator { self.iter_floating().filter(|&(_, c)| c.is_transient()) } - pub fn iter_visible(&self) -> impl Iterator { + pub fn iter_visible( + &self, + ) -> impl Iterator { self.iter_all_clients() .filter(move |&(k, _)| self.is_client_visible(k)) } #[allow(dead_code)] - pub fn iter_current_screen(&self) -> impl Iterator { + pub fn iter_current_screen( + &self, + ) -> impl Iterator { self.clients.iter().filter(move |&(k, _)| { self.virtual_screens.get_current().contains(k) }) } - pub fn iter_master_stack(&self) -> impl Iterator { + pub fn iter_master_stack( + &self, + ) -> impl Iterator { self.virtual_screens .get_current() .master @@ -316,7 +331,9 @@ impl ClientState { .map(move |k| (k, self.get(k).unwrap())) } - pub fn iter_aux_stack(&self) -> impl Iterator { + pub fn iter_aux_stack( + &self, + ) -> impl Iterator { self.virtual_screens .get_current() .aux @@ -441,12 +458,15 @@ impl ClientState { // transient clients cannot be tiled match floating_client.is_transient() { true => { - self.floating_clients.insert(key, floating_client); + self.floating_clients + .insert(key, floating_client); } false => { self.clients.insert(key, floating_client); - self.virtual_screens.get_mut_current().insert(&key); + self.virtual_screens + .get_mut_current() + .insert(&key); } } } @@ -464,7 +484,9 @@ impl ClientState { K: ClientKey, { if self.contains(key) { - if let Some(vs) = self.get_mut_virtualscreen_for_client(key) { + if let Some(vs) = + self.get_mut_virtualscreen_for_client(key) + { vs.remove(key); // we removed a client so the layout changed, rearrange @@ -473,7 +495,10 @@ impl ClientState { } } - fn get_virtualscreen_for_client(&self, key: &K) -> Option<&VirtualScreen> + fn get_virtualscreen_for_client( + &self, + key: &K, + ) -> Option<&VirtualScreen> where K: ClientKey, { @@ -502,7 +527,10 @@ impl ClientState { }) } - pub fn get_stack_for_client(&self, key: &K) -> Option<&Vec> + pub fn get_stack_for_client( + &self, + key: &K, + ) -> Option<&Vec> where K: ClientKey, { @@ -637,7 +665,8 @@ impl ClientState { self.master_size / 2.0 }; - let master_width = (effective_width as f32 * master_size) as i32; + let master_width = + (effective_width as f32 * master_size) as i32; let aux_width = effective_width - master_width; (master_width, aux_width) @@ -665,7 +694,8 @@ impl ClientState { master_height - gap * 2 - self.border_size * 2, ); - let position = (gap * 2, master_height * i as i32 + gap * 2); + let position = + (gap * 2, master_height * i as i32 + gap * 2); if let Some(client) = self.clients.get_mut(key) { *client = Client { @@ -683,8 +713,10 @@ impl ClientState { aux_height - gap * 2 - self.border_size * 2, ); - let position = - (master_width + gap * 2, aux_height * i as i32 + gap * 2); + let position = ( + master_width + gap * 2, + aux_height * i as i32 + gap * 2, + ); if let Some(client) = self.clients.get_mut(key) { *client = Client { @@ -720,7 +752,8 @@ impl VirtualScreen { where K: ClientKey, { - self.master.contains(&key.key()) || self.aux.contains(&key.key()) + self.master.contains(&key.key()) + || self.aux.contains(&key.key()) } fn is_in_master(&self, key: &K) -> bool @@ -766,8 +799,11 @@ impl VirtualScreen { self.aux.extend(self.master.drain(index..=index)); } None => { - let index = - self.aux.iter().position(|&k| k == key.key()).unwrap(); + let index = self + .aux + .iter() + .position(|&k| k == key.key()) + .unwrap(); self.master.extend(self.aux.drain(index..=index)); } } @@ -814,7 +850,9 @@ impl VirtualScreenStore { self.screens.iter() } - fn iter_mut(&mut self) -> impl Iterator { + fn iter_mut( + &mut self, + ) -> impl Iterator { self.screens.iter_mut() } @@ -861,7 +899,9 @@ impl Into> for ClientEntry { fn into(self) -> Option { match self { Self::Vacant => None, - Self::Tiled(client) | Self::Floating(client) => Some(client), + Self::Tiled(client) | Self::Floating(client) => { + Some(client) + } } } } diff --git a/src/clients2.rs b/src/clients2.rs index a47925b..2cfe850 100644 --- a/src/clients2.rs +++ b/src/clients2.rs @@ -47,7 +47,10 @@ impl PartialOrd for Client where T: PartialOrd, { - fn partial_cmp(&self, other: &Self) -> Option { + fn partial_cmp( + &self, + other: &Self, + ) -> Option { self.window_id.partial_cmp(&other.window_id) } } @@ -229,7 +232,10 @@ where Self::default() } - pub fn insert(&mut self, entry: Entry>) -> Entry<&Client> { + pub fn insert( + &mut self, + entry: Entry>, + ) -> Entry<&Client> { if let Some(key) = Option::<&Client>::from(&entry).map(|c| c.window_id()) { @@ -258,11 +264,16 @@ where pub fn remove(&mut self, key: &T) -> Entry> { if let Some(client) = self.tiled_clients.remove(key) { Entry::Tiled(client) - } else if let Some(client) = self.floating_clients.remove(key) { + } else if let Some(client) = self.floating_clients.remove(key) + { Entry::Floating(client) - } else if let Some(client) = self.transient_clients.remove(key) { + } else if let Some(client) = + self.transient_clients.remove(key) + { Entry::Transient(client) - } else if let Some(client) = self.fullscreen_clients.remove(key) { + } else if let Some(client) = + self.fullscreen_clients.remove(key) + { Entry::Fullscreen(client) } else { Entry::Vacant @@ -276,7 +287,8 @@ where Entry::Floating(client) } else if let Some(client) = self.transient_clients.get(key) { Entry::Transient(client) - } else if let Some(client) = self.fullscreen_clients.get(key) { + } else if let Some(client) = self.fullscreen_clients.get(key) + { Entry::Fullscreen(client) } else { Entry::Vacant @@ -286,11 +298,17 @@ where pub fn get_mut(&mut self, key: &T) -> Entry<&mut Client> { if let Some(client) = self.tiled_clients.get_mut(key) { Entry::Tiled(client) - } else if let Some(client) = self.floating_clients.get_mut(key) { + } else if let Some(client) = + self.floating_clients.get_mut(key) + { Entry::Floating(client) - } else if let Some(client) = self.transient_clients.get_mut(key) { + } else if let Some(client) = + self.transient_clients.get_mut(key) + { Entry::Transient(client) - } else if let Some(client) = self.fullscreen_clients.get_mut(key) { + } else if let Some(client) = + self.fullscreen_clients.get_mut(key) + { Entry::Fullscreen(client) } else { Entry::Vacant @@ -304,7 +322,9 @@ where || self.fullscreen_clients.contains_key(key) } - pub fn iter_tiled(&self) -> impl Iterator)> { + pub fn iter_tiled( + &self, + ) -> impl Iterator)> { self.tiled_clients.iter() } @@ -314,7 +334,9 @@ where self.tiled_clients.iter_mut() } - pub fn iter_floating(&self) -> impl Iterator)> { + pub fn iter_floating( + &self, + ) -> impl Iterator)> { self.floating_clients.iter() } @@ -324,7 +346,9 @@ where self.floating_clients.iter_mut() } - pub fn iter_transient(&self) -> impl Iterator)> { + pub fn iter_transient( + &self, + ) -> impl Iterator)> { self.transient_clients.iter() } @@ -334,7 +358,9 @@ where self.transient_clients.iter_mut() } - pub fn iter_fullscreen(&self) -> impl Iterator)> { + pub fn iter_fullscreen( + &self, + ) -> impl Iterator)> { self.fullscreen_clients.iter() } @@ -372,7 +398,10 @@ mod tests { Entry::Tiled(client.clone()), client_store.remove(&client.borrow()) ); - assert_eq!(Entry::Vacant, client_store.remove(&client.borrow())); + assert_eq!( + Entry::Vacant, + client_store.remove(&client.borrow()) + ); assert_eq!(Entry::Vacant, client_store.remove(&1)); assert!(client_store.contains(&client2.borrow())); diff --git a/src/main.rs b/src/main.rs index 808ab9f..a5cf9d0 100644 --- a/src/main.rs +++ b/src/main.rs @@ -23,9 +23,11 @@ fn init_logger() { "{d(%Y-%m-%d %H:%M:%S %Z)(utc)} │ {({M}::{f}:{L}):>25} │ {h({l:>5})} │ {m}{n}", )); - let stdout = ConsoleAppender::builder().encoder(encoder.clone()).build(); + let stdout = + ConsoleAppender::builder().encoder(encoder.clone()).build(); - let home = dirs::home_dir().expect("Failed to get $HOME env var."); + let home = + dirs::home_dir().expect("Failed to get $HOME env var."); let _logfile = FileAppender::builder() .encoder(encoder) @@ -33,7 +35,9 @@ fn init_logger() { .unwrap(); let config = Config::builder() - .appender(Appender::builder().build("stdout", Box::new(stdout))) + .appender( + Appender::builder().build("stdout", Box::new(stdout)), + ) //.appender(Appender::builder().build("logfile", Box::new(logfile))) .build( Root::builder() diff --git a/src/state.rs b/src/state.rs index 04c49ee..6abde68 100644 --- a/src/state.rs +++ b/src/state.rs @@ -151,7 +151,9 @@ impl WindowManager { .get_focused() .into_option() .map(|c| c.key()) - .and_then(|k| Some(wm.clients.toggle_floating(&k))); + .and_then(|k| { + Some(wm.clients.toggle_floating(&k)) + }); wm.arrange_clients(); }, @@ -224,15 +226,24 @@ impl WindowManager { } fn add_vs_switch_keybinds(&mut self) { - fn rotate_west(wm: &mut WindowManager, _: &XKeyEvent) { + fn rotate_west( + wm: &mut WindowManager, + _: &XKeyEvent, + ) { wm.rotate_virtual_screen(Direction::West(N)); } - fn rotate_east(wm: &mut WindowManager, _: &XKeyEvent) { + fn rotate_east( + wm: &mut WindowManager, + _: &XKeyEvent, + ) { wm.rotate_virtual_screen(Direction::East(N)); } - fn goto_nth(wm: &mut WindowManager, _: &XKeyEvent) { + fn goto_nth( + wm: &mut WindowManager, + _: &XKeyEvent, + ) { wm.go_to_nth_virtual_screen(N) } @@ -333,13 +344,23 @@ impl WindowManager { match event.get_type() { xlib::MapRequest => self.map_request(&event), xlib::UnmapNotify => self.unmap_notify(&event), - xlib::ConfigureRequest => self.configure_request(&event), + xlib::ConfigureRequest => { + self.configure_request(&event) + } xlib::EnterNotify => self.enter_notify(&event), xlib::DestroyNotify => self.destroy_notify(&event), - xlib::ButtonPress => self.button_press(event.as_ref()), - xlib::ButtonRelease => self.button_release(event.as_ref()), - xlib::MotionNotify => self.motion_notify(event.as_ref()), - xlib::KeyPress => self.handle_keybinds(event.as_ref()), + xlib::ButtonPress => { + self.button_press(event.as_ref()) + } + xlib::ButtonRelease => { + self.button_release(event.as_ref()) + } + xlib::MotionNotify => { + self.motion_notify(event.as_ref()) + } + xlib::KeyPress => { + self.handle_keybinds(event.as_ref()) + } _ => {} } } @@ -354,7 +375,8 @@ impl WindowManager { } fn kill_client(&mut self, _event: &XKeyEvent) { - if let Some(client) = self.clients.get_focused().into_option() { + if let Some(client) = self.clients.get_focused().into_option() + { self.xlib.kill_client(client); } } @@ -365,7 +387,8 @@ impl WindowManager { for kb in self.keybinds.clone().into_iter() { if let KeyOrButton::Key(keycode, modmask) = kb.key { if keycode as u32 == event.keycode - && modmask & clean_mask == event.state & clean_mask + && modmask & clean_mask + == event.state & clean_mask { (kb.closure)(self, event); } @@ -409,8 +432,12 @@ impl WindowManager { fn focus_any(&mut self) { // focus first client in all visible clients - let to_focus = - self.clients.iter_visible().next().map(|(k, _)| k).cloned(); + let to_focus = self + .clients + .iter_visible() + .next() + .map(|(k, _)| k) + .cloned(); if let Some(key) = to_focus { self.focus_client(&key, false); @@ -418,7 +445,8 @@ impl WindowManager { } fn focus_master_stack(&mut self) { - let focused = self.clients.get_focused().into_option().map(|c| c.key()); + let focused = + self.clients.get_focused().into_option().map(|c| c.key()); let k = self .clients @@ -436,7 +464,8 @@ impl WindowManager { } fn focus_aux_stack(&mut self) { - let focused = self.clients.get_focused().into_option().map(|c| c.key()); + let focused = + self.clients.get_focused().into_option().map(|c| c.key()); let k = self .clients @@ -454,12 +483,12 @@ impl WindowManager { } fn focus_up(&mut self) { - let focused = self.clients.get_focused().into_option().map(|c| c.key()); + let focused = + self.clients.get_focused().into_option().map(|c| c.key()); let k = focused.and_then(|focused| { - self.clients - .get_stack_for_client(&focused) - .and_then(|stack| { + self.clients.get_stack_for_client(&focused).and_then( + |stack| { stack .iter() .rev() @@ -467,7 +496,8 @@ impl WindowManager { .skip(1) .next() .cloned() - }) + }, + ) }); if let Some(k) = k { @@ -476,19 +506,20 @@ impl WindowManager { } fn focus_down(&mut self) { - let focused = self.clients.get_focused().into_option().map(|c| c.key()); + let focused = + self.clients.get_focused().into_option().map(|c| c.key()); let k = focused.and_then(|focused| { - self.clients - .get_stack_for_client(&focused) - .and_then(|stack| { + self.clients.get_stack_for_client(&focused).and_then( + |stack| { stack .iter() .skip_while(|&&k| k != focused) .skip(1) .next() .cloned() - }) + }, + ) }); if let Some(k) = k { @@ -573,7 +604,9 @@ impl WindowManager { { Client::new_transient( window, - self.xlib.get_window_size(window).unwrap_or((100, 100)), + self.xlib + .get_window_size(window) + .unwrap_or((100, 100)), transient_window, ) } else { @@ -632,7 +665,10 @@ impl WindowManager { } /// ensure event.subwindow refers to a valid client. - fn start_move_resize_window(&mut self, event: &XButtonPressedEvent) { + fn start_move_resize_window( + &mut self, + event: &XButtonPressedEvent, + ) { let window = event.subwindow; match event.button { @@ -641,15 +677,16 @@ impl WindowManager { self.arrange_clients(); } - self.move_resize_window = MoveResizeInfo::Move(MoveInfoInner { - window, - starting_cursor_pos: (event.x, event.y), - starting_window_pos: self - .clients - .get(&window) - .unwrap() - .position, - }); + self.move_resize_window = + MoveResizeInfo::Move(MoveInfoInner { + window, + starting_cursor_pos: (event.x, event.y), + starting_window_pos: self + .clients + .get(&window) + .unwrap() + .position, + }); } 3 => { if self.clients.set_floating(&window) { @@ -679,7 +716,10 @@ impl WindowManager { } } - fn end_move_resize_window(&mut self, event: &XButtonReleasedEvent) { + fn end_move_resize_window( + &mut self, + event: &XButtonReleasedEvent, + ) { if event.button == 1 || event.button == 3 { self.move_resize_window = MoveResizeInfo::None; } @@ -718,8 +758,14 @@ impl WindowManager { { let size = &mut client.size; - size.0 = std::cmp::max(1, info.starting_window_size.0 + x); - size.1 = std::cmp::max(1, info.starting_window_size.1 + y); + size.0 = std::cmp::max( + 1, + info.starting_window_size.0 + x, + ); + size.1 = std::cmp::max( + 1, + info.starting_window_size.1 + y, + ); self.xlib.resize_client(client); } @@ -734,10 +780,12 @@ impl WindowManager { match event.button { 1 | 3 => match self.move_resize_window { MoveResizeInfo::None - if self - .xlib - .are_masks_equal(event.state, self.config.mod_key) - && self.clients.contains(&event.subwindow) => + if self.xlib.are_masks_equal( + event.state, + self.config.mod_key, + ) && self + .clients + .contains(&event.subwindow) => { self.start_move_resize_window(event) } diff --git a/src/xlib.rs b/src/xlib.rs index a5c8f6f..9a54242 100644 --- a/src/xlib.rs +++ b/src/xlib.rs @@ -4,14 +4,16 @@ use std::{ffi::CString, rc::Rc}; use x11::xlib::{ self, AnyButton, AnyKey, AnyModifier, Atom, ButtonPressMask, - ButtonReleaseMask, CWEventMask, ControlMask, CurrentTime, EnterWindowMask, - FocusChangeMask, LockMask, Mod1Mask, Mod2Mask, Mod3Mask, Mod4Mask, - Mod5Mask, PointerMotionMask, PropertyChangeMask, ShiftMask, - StructureNotifyMask, SubstructureNotifyMask, SubstructureRedirectMask, - Window, XCloseDisplay, XConfigureRequestEvent, XDefaultScreen, XEvent, - XGetTransientForHint, XGrabPointer, XInternAtom, XKillClient, XMapWindow, - XOpenDisplay, XRaiseWindow, XRootWindow, XSetErrorHandler, XSync, - XUngrabButton, XUngrabKey, XUngrabPointer, XWarpPointer, XWindowAttributes, + ButtonReleaseMask, CWEventMask, ControlMask, CurrentTime, + EnterWindowMask, FocusChangeMask, LockMask, Mod1Mask, Mod2Mask, + Mod3Mask, Mod4Mask, Mod5Mask, PointerMotionMask, + PropertyChangeMask, ShiftMask, StructureNotifyMask, + SubstructureNotifyMask, SubstructureRedirectMask, Window, + XCloseDisplay, XConfigureRequestEvent, XDefaultScreen, XEvent, + XGetTransientForHint, XGrabPointer, XInternAtom, XKillClient, + XMapWindow, XOpenDisplay, XRaiseWindow, XRootWindow, + XSetErrorHandler, XSync, XUngrabButton, XUngrabKey, + XUngrabPointer, XWarpPointer, XWindowAttributes, }; use xlib::GrabModeAsync; @@ -45,7 +47,11 @@ impl KeyOrButton { pub fn key(keycode: i32, modmask: u32) -> Self { Self::Key(keycode, modmask) } - pub fn button(button: u32, modmask: u32, buttonmask: i64) -> Self { + pub fn button( + button: u32, + modmask: u32, + buttonmask: i64, + ) -> Self { Self::Button(button, modmask, buttonmask as u64) } } @@ -78,9 +84,10 @@ impl XLib { pub fn init(&mut self) { unsafe { - let mut window_attributes = - std::mem::MaybeUninit::::zeroed() - .assume_init(); + let mut window_attributes = std::mem::MaybeUninit::< + xlib::XSetWindowAttributes, + >::zeroed() + .assume_init(); window_attributes.event_mask = SubstructureRedirectMask | StructureNotifyMask @@ -117,7 +124,12 @@ impl XLib { #[allow(dead_code)] fn ungrab_global_keybings(&self, window: Window) { unsafe { - XUngrabButton(self.dpy(), AnyButton as u32, AnyModifier, window); + XUngrabButton( + self.dpy(), + AnyButton as u32, + AnyModifier, + window, + ); XUngrabKey(self.dpy(), AnyKey, AnyModifier, window); } } @@ -143,10 +155,14 @@ impl XLib { pub fn squash_event(&self, event_type: i32) -> XEvent { unsafe { let mut event = - std::mem::MaybeUninit::::zeroed().assume_init(); + std::mem::MaybeUninit::::zeroed() + .assume_init(); - while xlib::XCheckTypedEvent(self.dpy(), event_type, &mut event) - != 0 + while xlib::XCheckTypedEvent( + self.dpy(), + event_type, + &mut event, + ) != 0 {} event @@ -156,14 +172,19 @@ impl XLib { pub fn next_event(&self) -> XEvent { unsafe { let mut event = - std::mem::MaybeUninit::::zeroed().assume_init(); + std::mem::MaybeUninit::::zeroed() + .assume_init(); xlib::XNextEvent(self.dpy(), &mut event); event } } - pub fn grab_key_or_button(&self, window: Window, key: &KeyOrButton) { + pub fn grab_key_or_button( + &self, + window: Window, + key: &KeyOrButton, + ) { let numlock_mask = self.get_numlock_mask(); let modifiers = vec![0, LockMask, numlock_mask, LockMask | numlock_mask]; @@ -212,7 +233,8 @@ impl XLib { xlib::CurrentTime, ); - let screen = xlib::XDefaultScreenOfDisplay(self.dpy()).as_ref(); + let screen = + xlib::XDefaultScreenOfDisplay(self.dpy()).as_ref(); if let Some(screen) = screen { xlib::XSetWindowBorder( @@ -248,7 +270,8 @@ impl XLib { xlib::CurrentTime, ); - let screen = xlib::XDefaultScreenOfDisplay(self.dpy()).as_ref(); + let screen = + xlib::XDefaultScreenOfDisplay(self.dpy()).as_ref(); if let Some(screen) = screen { xlib::XSetWindowBorder( @@ -284,8 +307,10 @@ impl XLib { xlib::XConfigureWindow( self.dpy(), client.window, - (xlib::CWY | xlib::CWX | xlib::CWHeight | xlib::CWWidth) - as u32, + (xlib::CWY + | xlib::CWX + | xlib::CWHeight + | xlib::CWWidth) as u32, &mut windowchanges, ); @@ -376,14 +401,18 @@ impl XLib { } } - pub fn get_window_size(&self, window: Window) -> Option<(i32, i32)> { + pub fn get_window_size( + &self, + window: Window, + ) -> Option<(i32, i32)> { let mut wa = unsafe { std::mem::MaybeUninit::::zeroed() .assume_init() }; if unsafe { - xlib::XGetWindowAttributes(self.dpy(), window, &mut wa) != 0 + xlib::XGetWindowAttributes(self.dpy(), window, &mut wa) + != 0 } { Some((wa.width, wa.height)) } else { @@ -401,7 +430,8 @@ impl XLib { }; if unsafe { - xlib::XGetWindowAttributes(self.dpy(), window, &mut wa) != 0 + xlib::XGetWindowAttributes(self.dpy(), window, &mut wa) + != 0 } { Some(wa) } else { @@ -409,11 +439,18 @@ impl XLib { } } - pub fn get_transient_for_window(&self, window: Window) -> Option { + pub fn get_transient_for_window( + &self, + window: Window, + ) -> Option { let mut transient_for: Window = 0; if unsafe { - XGetTransientForHint(self.dpy(), window, &mut transient_for) != 0 + XGetTransientForHint( + self.dpy(), + window, + &mut transient_for, + ) != 0 } { Some(transient_for) } else { @@ -515,13 +552,21 @@ impl XLib { pub fn dimensions(&self) -> (i32, i32) { unsafe { - let mut wa = - std::mem::MaybeUninit::::zeroed() - .assume_init(); + let mut wa = std::mem::MaybeUninit::< + xlib::XWindowAttributes, + >::zeroed() + .assume_init(); - xlib::XGetWindowAttributes(self.dpy(), self.root, &mut wa); + xlib::XGetWindowAttributes( + self.dpy(), + self.root, + &mut wa, + ); - info!("Root window dimensions: {}, {}", wa.width, wa.height); + info!( + "Root window dimensions: {}, {}", + wa.width, wa.height + ); (wa.width, wa.height) } @@ -547,8 +592,9 @@ impl XLib { self.dpy(), self.root, 0, - (ButtonPressMask | ButtonReleaseMask | PointerMotionMask) - as u32, + (ButtonPressMask + | ButtonReleaseMask + | PointerMotionMask) as u32, GrabModeAsync, GrabModeAsync, 0, @@ -564,7 +610,11 @@ impl XLib { } } - pub fn move_cursor(&self, window: Option, position: (i32, i32)) { + pub fn move_cursor( + &self, + window: Option, + position: (i32, i32), + ) { unsafe { XWarpPointer( self.dpy(), @@ -580,7 +630,11 @@ impl XLib { } } - fn check_for_protocol(&self, client: &Client, proto: xlib::Atom) -> bool { + fn check_for_protocol( + &self, + client: &Client, + proto: xlib::Atom, + ) -> bool { let mut protos: *mut xlib::Atom = null_mut(); let mut num_protos: i32 = 0; @@ -603,7 +657,11 @@ impl XLib { return false; } - fn send_protocol(&self, client: &Client, proto: xlib::Atom) -> bool { + fn send_protocol( + &self, + client: &Client, + proto: xlib::Atom, + ) -> bool { if self.check_for_protocol(client, proto) { let mut data = xlib::ClientMessageData::default(); data.set_long(0, proto as i64); @@ -723,19 +781,37 @@ impl Atoms { Self { protocols: { let name = CString::new("WM_PROTOCOLS").unwrap(); - XInternAtom(display.get(), name.as_c_str().as_ptr(), 0) + XInternAtom( + display.get(), + name.as_c_str().as_ptr(), + 0, + ) }, delete_window: { - let name = CString::new("WM_DELETE_WINDOW").unwrap(); - XInternAtom(display.get(), name.as_c_str().as_ptr(), 0) + let name = + CString::new("WM_DELETE_WINDOW").unwrap(); + XInternAtom( + display.get(), + name.as_c_str().as_ptr(), + 0, + ) }, active_window: { - let name = CString::new("WM_ACTIVE_WINDOW").unwrap(); - XInternAtom(display.get(), name.as_c_str().as_ptr(), 0) + let name = + CString::new("WM_ACTIVE_WINDOW").unwrap(); + XInternAtom( + display.get(), + name.as_c_str().as_ptr(), + 0, + ) }, take_focus: { let name = CString::new("WM_TAKE_FOCUS").unwrap(); - XInternAtom(display.get(), name.as_c_str().as_ptr(), 0) + XInternAtom( + display.get(), + name.as_c_str().as_ptr(), + 0, + ) }, } }