xkb-0.3.0/.cargo_vcs_info.json0000644000000001360000000000100116200ustar { "git": { "sha1": "672702869ce1c5c81d545ccbac859d516c41fea6" }, "path_in_vcs": "" }xkb-0.3.0/.gitignore000064400000000000000000000000221046102023000123720ustar 00000000000000target Cargo.lock xkb-0.3.0/Cargo.toml0000644000000020030000000000100076110ustar # THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies. # # If you are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2021" name = "xkb" version = "0.3.0" authors = ["meh. "] description = "Rusty wrapper around libxkbcommon." keywords = [ "xkb", "xkbcommon", "x11", "xcb", ] license = "WTFPL" repository = "https://github.com/meh/rust-xkb" [dependencies.bitflags] version = "1" [dependencies.ffi] version = "1.4.1" package = "xkbcommon-sys" [dependencies.libc] version = "0.2" [dependencies.xcb] version = "1" features = ["xkb"] optional = true [features] static = ["ffi/static"] x11 = [ "ffi/x11", "xcb", ] xkb-0.3.0/Cargo.toml.orig000064400000000000000000000007771046102023000133120ustar 00000000000000[package] name = "xkb" version = "0.3.0" edition = "2021" authors = ["meh. "] license = "WTFPL" description = "Rusty wrapper around libxkbcommon." repository = "https://github.com/meh/rust-xkb" keywords = ["xkb", "xkbcommon", "x11", "xcb"] [dependencies] bitflags = "1" libc = "0.2" ffi = { package = "xkbcommon-sys", version = "1.4.1" } [dependencies.xcb] version = "1" features = ["xkb"] optional = true [features] static = ["ffi/static"] x11 = ["ffi/x11", "xcb"] xkb-0.3.0/flake.lock000064400000000000000000000040231046102023000123430ustar 00000000000000{ "nodes": { "fenix": { "inputs": { "nixpkgs": [ "nixpkgs" ], "rust-analyzer-src": "rust-analyzer-src" }, "locked": { "lastModified": 1627266442, "narHash": "sha256-jmHGpI0XYdAXV31iNBnZwLebd1IZ4EoDlgv7beKQ24c=", "owner": "nix-community", "repo": "fenix", "rev": "b099d59df490f63fb53387739f93c26c08d3b48f", "type": "github" }, "original": { "owner": "nix-community", "repo": "fenix", "type": "github" } }, "nixpkgs": { "locked": { "lastModified": 1627170405, "narHash": "sha256-6t7ISnt0Iqc2jxIf5+/su6eFmZNWnPAOA1JeOv9lLRE=", "owner": "NixOS", "repo": "nixpkgs", "rev": "ecaf3da9340231e5493eccc3db87604a3705da42", "type": "github" }, "original": { "owner": "NixOS", "ref": "nixpkgs-unstable", "repo": "nixpkgs", "type": "github" } }, "root": { "inputs": { "fenix": "fenix", "nixpkgs": "nixpkgs", "utils": "utils" } }, "rust-analyzer-src": { "flake": false, "locked": { "lastModified": 1627221155, "narHash": "sha256-NBUEhA4e9fAeXH+3BxnNJdTlGfhukzHIpqD7g2qK1RI=", "owner": "rust-analyzer", "repo": "rust-analyzer", "rev": "5983d3745ac8490c1c2798fdc963aa9fc803dd03", "type": "github" }, "original": { "owner": "rust-analyzer", "ref": "nightly", "repo": "rust-analyzer", "type": "github" } }, "utils": { "locked": { "lastModified": 1623875721, "narHash": "sha256-A8BU7bjS5GirpAUv4QA+QnJ4CceLHkcXdRp4xITDB0s=", "owner": "numtide", "repo": "flake-utils", "rev": "f7e004a55b120c02ecb6219596820fcd32ca8772", "type": "github" }, "original": { "owner": "numtide", "repo": "flake-utils", "type": "github" } } }, "root": "root", "version": 7 } xkb-0.3.0/flake.nix000064400000000000000000000015441046102023000122160ustar 00000000000000{ inputs = { nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable"; utils.url = "github:numtide/flake-utils"; fenix = { url = "github:nix-community/fenix"; inputs.nixpkgs.follows = "nixpkgs"; }; }; outputs = { self, utils, nixpkgs, fenix, }: utils.lib.eachDefaultSystem (system: let pkgs = nixpkgs.legacyPackages.${system}; rust = fenix.packages.${system}; lib = pkgs.lib; in { devShell = pkgs.mkShell { buildInputs = with pkgs; with llvmPackages; with python37Packages; [ # For building. clang rust.latest.toolchain pkg-config openssl libsodium libclang.lib libxkbcommon xorg.libxcb ]; LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib"; RUST_BACKTRACE = 1; # RUST_LOG = "info,sqlx::query=warn"; RUSTFLAGS = "-C target-cpu=native"; }; }); } xkb-0.3.0/src/base.rs000064400000000000000000000024751046102023000124670ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use ffi::*; macro_rules! define { ($name:ident, $base:ident) => ( #[derive(Eq, PartialEq, Copy, Clone, Debug)] pub struct $name(pub $base); impl From<$base> for $name { #[inline] fn from(value: $base) -> $name { $name(value) } } impl Into<$base> for $name { #[inline] fn into(self) -> $base { self.0 } } ); } define!(Keycode, xkb_keycode_t); define!(LayoutIndex, xkb_layout_index_t); define!(LayoutMask, xkb_layout_mask_t); define!(LevelIndex, xkb_level_index_t); define!(ModIndex, xkb_mod_index_t); define!(ModMask, xkb_mod_mask_t); define!(LedIndex, xkb_led_index_t); define!(LedMask, xkb_led_mask_t); #[repr(C)] #[derive(Eq, PartialEq, Copy, Clone, Debug)] pub enum LogLevel { Critical = 10, Error = 20, Warning = 30, Info = 40, Debug = 50, } xkb-0.3.0/src/compose/compile.rs000064400000000000000000000014301046102023000146400ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use ffi::*; use bitflags::bitflags; bitflags! { pub struct Flags: xkb_compose_compile_flags { const NO_FLAGS = XKB_COMPOSE_COMPILE_NO_FLAGS; } } pub const NO_FLAGS: Flags = Flags::NO_FLAGS; impl Default for Flags { fn default() -> Self { NO_FLAGS } } xkb-0.3.0/src/compose/mod.rs000064400000000000000000000017331046102023000137750ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use ffi::*; mod table; pub use self::table::Table; pub mod compile; pub mod state; pub use self::state::State; #[repr(C)] #[derive(Eq, PartialEq, Copy, Clone, Debug)] pub enum Status { Nothing, Composing, Composed, Cancelled, } #[repr(C)] #[derive(Eq, PartialEq, Copy, Clone, Debug)] pub enum Result { Ignored, Accepted, } #[repr(C)] #[derive(Eq, PartialEq, Copy, Clone, Debug)] pub enum Format { TextV1 = XKB_KEYMAP_FORMAT_TEXT_V1 as isize, } xkb-0.3.0/src/compose/state.rs000064400000000000000000000045101046102023000143320ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::mem; use std::ffi::CStr; use libc::size_t; use ffi::*; use bitflags::bitflags; use crate::Keysym; use crate::compose::{Table, Result, Status}; pub struct State(*mut xkb_compose_state); impl State { #[inline] pub unsafe fn from_ptr(ptr: *mut xkb_compose_state) -> Self { State(ptr) } #[inline] pub unsafe fn as_ptr(&self) -> *mut xkb_compose_state { self.0 } #[inline] pub fn table(&self) -> Table { unsafe { Table::from_ptr(xkb_compose_state_get_compose_table(self.0)) } } #[inline] pub fn feed>(&mut self, sym: T) -> Result { unsafe { mem::transmute(xkb_compose_state_feed(self.0, sym.into().into())) } } #[inline] pub fn reset(&mut self) { unsafe { xkb_compose_state_reset(self.0) } } #[inline] pub fn status(&self) -> Status { unsafe { mem::transmute(xkb_compose_state_get_status(self.0)) } } #[inline] pub fn utf8(&self) -> Option { unsafe { let mut buffer = [0; 64]; match xkb_compose_state_get_utf8(self.0, buffer.as_mut_ptr(), buffer.len() as size_t) { -1 => unreachable!(), 0 => None, _ => Some(CStr::from_ptr(buffer.as_ptr()).to_str().unwrap().into()), } } } #[inline] pub fn sym(&self) -> Option { unsafe { match xkb_compose_state_get_one_sym(self.0) { XKB_KEY_NoSymbol => None, sym => Some(sym.into()), } } } } impl Clone for State { #[inline] fn clone(&self) -> Self { unsafe { State(xkb_compose_state_ref(self.0)) } } } impl Drop for State { #[inline] fn drop(&mut self) { unsafe { xkb_compose_state_unref(self.0) } } } bitflags! { pub struct Flags: xkb_compose_state_flags { const NO_FLAGS = XKB_COMPOSE_STATE_NO_FLAGS; } } pub const NO_FLAGS: Flags = Flags::NO_FLAGS; impl Default for Flags { fn default() -> Self { NO_FLAGS } } xkb-0.3.0/src/compose/table.rs000064400000000000000000000041161046102023000143030ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::mem; use std::ffi::CString; use libc::size_t; use ffi::*; use crate::Context; use crate::compose::{compile, Format}; use crate::compose::state::{self, State}; pub struct Table(*mut xkb_compose_table); impl Table { #[inline] pub unsafe fn from_ptr(ptr: *mut xkb_compose_table) -> Self { Table(ptr) } #[inline] pub unsafe fn as_ptr(&self) -> *mut xkb_compose_table { self.0 } #[inline] pub fn new>(context: &Context, locale: L, flags: compile::Flags) -> Result { unsafe { let locale = CString::new(locale.as_ref()).unwrap(); xkb_compose_table_new_from_locale(context.as_ptr(), locale.as_ptr(), flags.bits()) .as_mut().map(|ptr| Table(ptr)).ok_or(()) } } #[inline] pub fn from_buffer, B: AsRef<[u8]>>(context: &Context, locale: L, buffer: B, format: Format, flags: compile::Flags) -> Result { unsafe { let buffer = buffer.as_ref(); let locale = CString::new(locale.as_ref()).unwrap(); xkb_compose_table_new_from_buffer(context.as_ptr(), buffer.as_ptr() as *const _, buffer.len() as size_t, locale.as_ptr(), mem::transmute(format), flags.bits()) .as_mut().map(|ptr| Table(ptr)).ok_or(()) } } #[inline] pub fn state(&self, flags: state::Flags) -> State { unsafe { State::from_ptr(xkb_compose_state_new(self.0, flags.bits())) } } } impl Clone for Table { #[inline] fn clone(&self) -> Self { unsafe { Table(xkb_compose_table_ref(self.0)) } } } impl Drop for Table { #[inline] fn drop(&mut self) { unsafe { xkb_compose_table_unref(self.0) } } } xkb-0.3.0/src/context/context.rs000064400000000000000000000025551046102023000147240ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use ffi::*; use crate::context::{Flags, Include, Log}; #[derive(Debug)] pub struct Context(*mut xkb_context); impl Default for Context { #[inline] fn default() -> Self { Context::new(Default::default()) } } impl Context { #[inline] pub unsafe fn from_ptr(ptr: *mut xkb_context) -> Self { Context(ptr) } #[inline] pub unsafe fn as_ptr(&self) -> *mut xkb_context { self.0 } #[inline] pub fn new(flags: Flags) -> Self { unsafe { Context(xkb_context_new(flags.bits())) } } #[inline] pub fn include(&mut self) -> Include { Include(self) } #[inline] pub fn log(&mut self) -> Log { Log(self) } } impl Clone for Context { #[inline] fn clone(&self) -> Self { unsafe { Context(xkb_context_ref(self.0)) } } } impl Drop for Context { #[inline] fn drop(&mut self) { unsafe { xkb_context_unref(self.0); } } } xkb-0.3.0/src/context/flag.rs000064400000000000000000000020351046102023000141420ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use ffi::*; use bitflags::bitflags; bitflags! { pub struct Flags: xkb_context_flags { const NO_FLAGS = XKB_CONTEXT_NO_FLAGS; const NO_DEFAULT_INCLUDES = XKB_CONTEXT_NO_DEFAULT_INCLUDES; const NO_ENVIRONMENT_NAMES = XKB_CONTEXT_NO_ENVIRONMENT_NAMES; } } pub const NO_FLAGS: Flags = Flags::NO_FLAGS; pub const NO_DEFAULT_INCLUDES: Flags = Flags::NO_DEFAULT_INCLUDES; pub const NO_ENVIRONMENT_NAMES: Flags = Flags::NO_ENVIRONMENT_NAMES; impl Default for Flags { fn default() -> Self { NO_FLAGS } } xkb-0.3.0/src/context/include.rs000064400000000000000000000026641046102023000146640ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::os::unix::ffi::OsStrExt; use std::path::Path; use ffi::*; use crate::context::Context; #[derive(Debug)] pub struct Include<'a>(pub &'a mut Context); impl<'a> Include<'a> { pub fn append>(&mut self, path: P) -> &mut Self { unsafe { xkb_context_include_path_append(self.0.as_ptr(), path.as_ref().as_os_str().as_bytes().as_ptr() as *const _); } self } pub fn default(&mut self) -> &mut Self { unsafe { xkb_context_include_path_append_default(self.0.as_ptr()); } self } pub fn reset(&mut self) -> &mut Self { unsafe { xkb_context_include_path_reset_defaults(self.0.as_ptr()); } self } pub fn clear(&mut self) -> &mut Self { unsafe { xkb_context_include_path_clear(self.0.as_ptr()); } self } pub fn len(&self) -> usize { unsafe { xkb_context_num_include_paths(self.0.as_ptr()) as usize } } } // TODO: Iterator // TODO: Index xkb-0.3.0/src/context/log.rs000064400000000000000000000017701046102023000140170ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::mem; use libc::c_int; use ffi::*; use crate::LogLevel; use crate::context::Context; #[derive(Debug)] pub struct Log<'a>(pub &'a mut Context); impl<'a> Log<'a> { pub fn level(&mut self, level: LogLevel) -> &mut Self { unsafe { xkb_context_set_log_level(self.0.as_ptr(), mem::transmute(level)); } self } pub fn verbosity(&mut self, verbosity: i32) -> &mut Self { unsafe { xkb_context_set_log_verbosity(self.0.as_ptr(), verbosity as c_int); } self } } xkb-0.3.0/src/context/mod.rs000064400000000000000000000012711046102023000140110ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. pub mod flag; pub use self::flag::Flags; mod include; pub use self::include::Include; mod log; pub use self::log::Log; mod context; pub use self::context::Context; xkb-0.3.0/src/key.rs000064400000000000000000004365341046102023000123540ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use ffi::*; use crate::Keysym; #[repr(C)] #[derive(Eq, PartialEq, Copy, Clone, Debug)] pub enum Direction { Up, Down, } pub const NoSymbol: Keysym = Keysym(XKB_KEY_NoSymbol); pub const VoidSymbol: Keysym = Keysym(XKB_KEY_VoidSymbol); pub const BackSpace: Keysym = Keysym(XKB_KEY_BackSpace); pub const Tab: Keysym = Keysym(XKB_KEY_Tab); pub const Linefeed: Keysym = Keysym(XKB_KEY_Linefeed); pub const Clear: Keysym = Keysym(XKB_KEY_Clear); pub const Return: Keysym = Keysym(XKB_KEY_Return); pub const Pause: Keysym = Keysym(XKB_KEY_Pause); pub const Scroll_Lock: Keysym = Keysym(XKB_KEY_Scroll_Lock); pub const Sys_Req: Keysym = Keysym(XKB_KEY_Sys_Req); pub const Escape: Keysym = Keysym(XKB_KEY_Escape); pub const Delete: Keysym = Keysym(XKB_KEY_Delete); pub const Multi_key: Keysym = Keysym(XKB_KEY_Multi_key); pub const Codeinput: Keysym = Keysym(XKB_KEY_Codeinput); pub const SingleCandidate: Keysym = Keysym(XKB_KEY_SingleCandidate); pub const MultipleCandidate: Keysym = Keysym(XKB_KEY_MultipleCandidate); pub const PreviousCandidate: Keysym = Keysym(XKB_KEY_PreviousCandidate); pub const Kanji: Keysym = Keysym(XKB_KEY_Kanji); pub const Muhenkan: Keysym = Keysym(XKB_KEY_Muhenkan); pub const Henkan_Mode: Keysym = Keysym(XKB_KEY_Henkan_Mode); pub const Henkan: Keysym = Keysym(XKB_KEY_Henkan); pub const Romaji: Keysym = Keysym(XKB_KEY_Romaji); pub const Hiragana: Keysym = Keysym(XKB_KEY_Hiragana); pub const Katakana: Keysym = Keysym(XKB_KEY_Katakana); pub const Hiragana_Katakana: Keysym = Keysym(XKB_KEY_Hiragana_Katakana); pub const Zenkaku: Keysym = Keysym(XKB_KEY_Zenkaku); pub const Hankaku: Keysym = Keysym(XKB_KEY_Hankaku); pub const Zenkaku_Hankaku: Keysym = Keysym(XKB_KEY_Zenkaku_Hankaku); pub const Touroku: Keysym = Keysym(XKB_KEY_Touroku); pub const Massyo: Keysym = Keysym(XKB_KEY_Massyo); pub const Kana_Lock: Keysym = Keysym(XKB_KEY_Kana_Lock); pub const Kana_Shift: Keysym = Keysym(XKB_KEY_Kana_Shift); pub const Eisu_Shift: Keysym = Keysym(XKB_KEY_Eisu_Shift); pub const Eisu_toggle: Keysym = Keysym(XKB_KEY_Eisu_toggle); pub const Kanji_Bangou: Keysym = Keysym(XKB_KEY_Kanji_Bangou); pub const Zen_Koho: Keysym = Keysym(XKB_KEY_Zen_Koho); pub const Mae_Koho: Keysym = Keysym(XKB_KEY_Mae_Koho); pub const Home: Keysym = Keysym(XKB_KEY_Home); pub const Left: Keysym = Keysym(XKB_KEY_Left); pub const Up: Keysym = Keysym(XKB_KEY_Up); pub const Right: Keysym = Keysym(XKB_KEY_Right); pub const Down: Keysym = Keysym(XKB_KEY_Down); pub const Prior: Keysym = Keysym(XKB_KEY_Prior); pub const Page_Up: Keysym = Keysym(XKB_KEY_Page_Up); pub const Next: Keysym = Keysym(XKB_KEY_Next); pub const Page_Down: Keysym = Keysym(XKB_KEY_Page_Down); pub const End: Keysym = Keysym(XKB_KEY_End); pub const Begin: Keysym = Keysym(XKB_KEY_Begin); pub const Select: Keysym = Keysym(XKB_KEY_Select); pub const Print: Keysym = Keysym(XKB_KEY_Print); pub const Execute: Keysym = Keysym(XKB_KEY_Execute); pub const Insert: Keysym = Keysym(XKB_KEY_Insert); pub const Undo: Keysym = Keysym(XKB_KEY_Undo); pub const Redo: Keysym = Keysym(XKB_KEY_Redo); pub const Menu: Keysym = Keysym(XKB_KEY_Menu); pub const Find: Keysym = Keysym(XKB_KEY_Find); pub const Cancel: Keysym = Keysym(XKB_KEY_Cancel); pub const Help: Keysym = Keysym(XKB_KEY_Help); pub const Break: Keysym = Keysym(XKB_KEY_Break); pub const Mode_switch: Keysym = Keysym(XKB_KEY_Mode_switch); pub const script_switch: Keysym = Keysym(XKB_KEY_script_switch); pub const Num_Lock: Keysym = Keysym(XKB_KEY_Num_Lock); pub const KP_Space: Keysym = Keysym(XKB_KEY_KP_Space); pub const KP_Tab: Keysym = Keysym(XKB_KEY_KP_Tab); pub const KP_Enter: Keysym = Keysym(XKB_KEY_KP_Enter); pub const KP_F1: Keysym = Keysym(XKB_KEY_KP_F1); pub const KP_F2: Keysym = Keysym(XKB_KEY_KP_F2); pub const KP_F3: Keysym = Keysym(XKB_KEY_KP_F3); pub const KP_F4: Keysym = Keysym(XKB_KEY_KP_F4); pub const KP_Home: Keysym = Keysym(XKB_KEY_KP_Home); pub const KP_Left: Keysym = Keysym(XKB_KEY_KP_Left); pub const KP_Up: Keysym = Keysym(XKB_KEY_KP_Up); pub const KP_Right: Keysym = Keysym(XKB_KEY_KP_Right); pub const KP_Down: Keysym = Keysym(XKB_KEY_KP_Down); pub const KP_Prior: Keysym = Keysym(XKB_KEY_KP_Prior); pub const KP_Page_Up: Keysym = Keysym(XKB_KEY_KP_Page_Up); pub const KP_Next: Keysym = Keysym(XKB_KEY_KP_Next); pub const KP_Page_Down: Keysym = Keysym(XKB_KEY_KP_Page_Down); pub const KP_End: Keysym = Keysym(XKB_KEY_KP_End); pub const KP_Begin: Keysym = Keysym(XKB_KEY_KP_Begin); pub const KP_Insert: Keysym = Keysym(XKB_KEY_KP_Insert); pub const KP_Delete: Keysym = Keysym(XKB_KEY_KP_Delete); pub const KP_Equal: Keysym = Keysym(XKB_KEY_KP_Equal); pub const KP_Multiply: Keysym = Keysym(XKB_KEY_KP_Multiply); pub const KP_Add: Keysym = Keysym(XKB_KEY_KP_Add); pub const KP_Separator: Keysym = Keysym(XKB_KEY_KP_Separator); pub const KP_Subtract: Keysym = Keysym(XKB_KEY_KP_Subtract); pub const KP_Decimal: Keysym = Keysym(XKB_KEY_KP_Decimal); pub const KP_Divide: Keysym = Keysym(XKB_KEY_KP_Divide); pub const KP_0: Keysym = Keysym(XKB_KEY_KP_0); pub const KP_1: Keysym = Keysym(XKB_KEY_KP_1); pub const KP_2: Keysym = Keysym(XKB_KEY_KP_2); pub const KP_3: Keysym = Keysym(XKB_KEY_KP_3); pub const KP_4: Keysym = Keysym(XKB_KEY_KP_4); pub const KP_5: Keysym = Keysym(XKB_KEY_KP_5); pub const KP_6: Keysym = Keysym(XKB_KEY_KP_6); pub const KP_7: Keysym = Keysym(XKB_KEY_KP_7); pub const KP_8: Keysym = Keysym(XKB_KEY_KP_8); pub const KP_9: Keysym = Keysym(XKB_KEY_KP_9); pub const F1: Keysym = Keysym(XKB_KEY_F1); pub const F2: Keysym = Keysym(XKB_KEY_F2); pub const F3: Keysym = Keysym(XKB_KEY_F3); pub const F4: Keysym = Keysym(XKB_KEY_F4); pub const F5: Keysym = Keysym(XKB_KEY_F5); pub const F6: Keysym = Keysym(XKB_KEY_F6); pub const F7: Keysym = Keysym(XKB_KEY_F7); pub const F8: Keysym = Keysym(XKB_KEY_F8); pub const F9: Keysym = Keysym(XKB_KEY_F9); pub const F10: Keysym = Keysym(XKB_KEY_F10); pub const F11: Keysym = Keysym(XKB_KEY_F11); pub const L1: Keysym = Keysym(XKB_KEY_L1); pub const F12: Keysym = Keysym(XKB_KEY_F12); pub const L2: Keysym = Keysym(XKB_KEY_L2); pub const F13: Keysym = Keysym(XKB_KEY_F13); pub const L3: Keysym = Keysym(XKB_KEY_L3); pub const F14: Keysym = Keysym(XKB_KEY_F14); pub const L4: Keysym = Keysym(XKB_KEY_L4); pub const F15: Keysym = Keysym(XKB_KEY_F15); pub const L5: Keysym = Keysym(XKB_KEY_L5); pub const F16: Keysym = Keysym(XKB_KEY_F16); pub const L6: Keysym = Keysym(XKB_KEY_L6); pub const F17: Keysym = Keysym(XKB_KEY_F17); pub const L7: Keysym = Keysym(XKB_KEY_L7); pub const F18: Keysym = Keysym(XKB_KEY_F18); pub const L8: Keysym = Keysym(XKB_KEY_L8); pub const F19: Keysym = Keysym(XKB_KEY_F19); pub const L9: Keysym = Keysym(XKB_KEY_L9); pub const F20: Keysym = Keysym(XKB_KEY_F20); pub const L10: Keysym = Keysym(XKB_KEY_L10); pub const F21: Keysym = Keysym(XKB_KEY_F21); pub const R1: Keysym = Keysym(XKB_KEY_R1); pub const F22: Keysym = Keysym(XKB_KEY_F22); pub const R2: Keysym = Keysym(XKB_KEY_R2); pub const F23: Keysym = Keysym(XKB_KEY_F23); pub const R3: Keysym = Keysym(XKB_KEY_R3); pub const F24: Keysym = Keysym(XKB_KEY_F24); pub const R4: Keysym = Keysym(XKB_KEY_R4); pub const F25: Keysym = Keysym(XKB_KEY_F25); pub const R5: Keysym = Keysym(XKB_KEY_R5); pub const F26: Keysym = Keysym(XKB_KEY_F26); pub const R6: Keysym = Keysym(XKB_KEY_R6); pub const F27: Keysym = Keysym(XKB_KEY_F27); pub const R7: Keysym = Keysym(XKB_KEY_R7); pub const F28: Keysym = Keysym(XKB_KEY_F28); pub const R8: Keysym = Keysym(XKB_KEY_R8); pub const F29: Keysym = Keysym(XKB_KEY_F29); pub const R9: Keysym = Keysym(XKB_KEY_R9); pub const F30: Keysym = Keysym(XKB_KEY_F30); pub const R10: Keysym = Keysym(XKB_KEY_R10); pub const F31: Keysym = Keysym(XKB_KEY_F31); pub const R11: Keysym = Keysym(XKB_KEY_R11); pub const F32: Keysym = Keysym(XKB_KEY_F32); pub const R12: Keysym = Keysym(XKB_KEY_R12); pub const F33: Keysym = Keysym(XKB_KEY_F33); pub const R13: Keysym = Keysym(XKB_KEY_R13); pub const F34: Keysym = Keysym(XKB_KEY_F34); pub const R14: Keysym = Keysym(XKB_KEY_R14); pub const F35: Keysym = Keysym(XKB_KEY_F35); pub const R15: Keysym = Keysym(XKB_KEY_R15); pub const Shift_L: Keysym = Keysym(XKB_KEY_Shift_L); pub const Shift_R: Keysym = Keysym(XKB_KEY_Shift_R); pub const Control_L: Keysym = Keysym(XKB_KEY_Control_L); pub const Control_R: Keysym = Keysym(XKB_KEY_Control_R); pub const Caps_Lock: Keysym = Keysym(XKB_KEY_Caps_Lock); pub const Shift_Lock: Keysym = Keysym(XKB_KEY_Shift_Lock); pub const Meta_L: Keysym = Keysym(XKB_KEY_Meta_L); pub const Meta_R: Keysym = Keysym(XKB_KEY_Meta_R); pub const Alt_L: Keysym = Keysym(XKB_KEY_Alt_L); pub const Alt_R: Keysym = Keysym(XKB_KEY_Alt_R); pub const Super_L: Keysym = Keysym(XKB_KEY_Super_L); pub const Super_R: Keysym = Keysym(XKB_KEY_Super_R); pub const Hyper_L: Keysym = Keysym(XKB_KEY_Hyper_L); pub const Hyper_R: Keysym = Keysym(XKB_KEY_Hyper_R); pub const ISO_Lock: Keysym = Keysym(XKB_KEY_ISO_Lock); pub const ISO_Level2_Latch: Keysym = Keysym(XKB_KEY_ISO_Level2_Latch); pub const ISO_Level3_Shift: Keysym = Keysym(XKB_KEY_ISO_Level3_Shift); pub const ISO_Level3_Latch: Keysym = Keysym(XKB_KEY_ISO_Level3_Latch); pub const ISO_Level3_Lock: Keysym = Keysym(XKB_KEY_ISO_Level3_Lock); pub const ISO_Level5_Shift: Keysym = Keysym(XKB_KEY_ISO_Level5_Shift); pub const ISO_Level5_Latch: Keysym = Keysym(XKB_KEY_ISO_Level5_Latch); pub const ISO_Level5_Lock: Keysym = Keysym(XKB_KEY_ISO_Level5_Lock); pub const ISO_Group_Shift: Keysym = Keysym(XKB_KEY_ISO_Group_Shift); pub const ISO_Group_Latch: Keysym = Keysym(XKB_KEY_ISO_Group_Latch); pub const ISO_Group_Lock: Keysym = Keysym(XKB_KEY_ISO_Group_Lock); pub const ISO_Next_Group: Keysym = Keysym(XKB_KEY_ISO_Next_Group); pub const ISO_Next_Group_Lock: Keysym = Keysym(XKB_KEY_ISO_Next_Group_Lock); pub const ISO_Prev_Group: Keysym = Keysym(XKB_KEY_ISO_Prev_Group); pub const ISO_Prev_Group_Lock: Keysym = Keysym(XKB_KEY_ISO_Prev_Group_Lock); pub const ISO_First_Group: Keysym = Keysym(XKB_KEY_ISO_First_Group); pub const ISO_First_Group_Lock: Keysym = Keysym(XKB_KEY_ISO_First_Group_Lock); pub const ISO_Last_Group: Keysym = Keysym(XKB_KEY_ISO_Last_Group); pub const ISO_Last_Group_Lock: Keysym = Keysym(XKB_KEY_ISO_Last_Group_Lock); pub const ISO_Left_Tab: Keysym = Keysym(XKB_KEY_ISO_Left_Tab); pub const ISO_Move_Line_Up: Keysym = Keysym(XKB_KEY_ISO_Move_Line_Up); pub const ISO_Move_Line_Down: Keysym = Keysym(XKB_KEY_ISO_Move_Line_Down); pub const ISO_Partial_Line_Up: Keysym = Keysym(XKB_KEY_ISO_Partial_Line_Up); pub const ISO_Partial_Line_Down: Keysym = Keysym(XKB_KEY_ISO_Partial_Line_Down); pub const ISO_Partial_Space_Left: Keysym = Keysym(XKB_KEY_ISO_Partial_Space_Left); pub const ISO_Partial_Space_Right: Keysym = Keysym(XKB_KEY_ISO_Partial_Space_Right); pub const ISO_Set_Margin_Left: Keysym = Keysym(XKB_KEY_ISO_Set_Margin_Left); pub const ISO_Set_Margin_Right: Keysym = Keysym(XKB_KEY_ISO_Set_Margin_Right); pub const ISO_Release_Margin_Left: Keysym = Keysym(XKB_KEY_ISO_Release_Margin_Left); pub const ISO_Release_Margin_Right: Keysym = Keysym(XKB_KEY_ISO_Release_Margin_Right); pub const ISO_Release_Both_Margins: Keysym = Keysym(XKB_KEY_ISO_Release_Both_Margins); pub const ISO_Fast_Cursor_Left: Keysym = Keysym(XKB_KEY_ISO_Fast_Cursor_Left); pub const ISO_Fast_Cursor_Right: Keysym = Keysym(XKB_KEY_ISO_Fast_Cursor_Right); pub const ISO_Fast_Cursor_Up: Keysym = Keysym(XKB_KEY_ISO_Fast_Cursor_Up); pub const ISO_Fast_Cursor_Down: Keysym = Keysym(XKB_KEY_ISO_Fast_Cursor_Down); pub const ISO_Continuous_Underline: Keysym = Keysym(XKB_KEY_ISO_Continuous_Underline); pub const ISO_Discontinuous_Underline: Keysym = Keysym(XKB_KEY_ISO_Discontinuous_Underline); pub const ISO_Emphasize: Keysym = Keysym(XKB_KEY_ISO_Emphasize); pub const ISO_Center_Object: Keysym = Keysym(XKB_KEY_ISO_Center_Object); pub const ISO_Enter: Keysym = Keysym(XKB_KEY_ISO_Enter); pub const dead_grave: Keysym = Keysym(XKB_KEY_dead_grave); pub const dead_acute: Keysym = Keysym(XKB_KEY_dead_acute); pub const dead_circumflex: Keysym = Keysym(XKB_KEY_dead_circumflex); pub const dead_tilde: Keysym = Keysym(XKB_KEY_dead_tilde); pub const dead_perispomeni: Keysym = Keysym(XKB_KEY_dead_perispomeni); pub const dead_macron: Keysym = Keysym(XKB_KEY_dead_macron); pub const dead_breve: Keysym = Keysym(XKB_KEY_dead_breve); pub const dead_abovedot: Keysym = Keysym(XKB_KEY_dead_abovedot); pub const dead_diaeresis: Keysym = Keysym(XKB_KEY_dead_diaeresis); pub const dead_abovering: Keysym = Keysym(XKB_KEY_dead_abovering); pub const dead_doubleacute: Keysym = Keysym(XKB_KEY_dead_doubleacute); pub const dead_caron: Keysym = Keysym(XKB_KEY_dead_caron); pub const dead_cedilla: Keysym = Keysym(XKB_KEY_dead_cedilla); pub const dead_ogonek: Keysym = Keysym(XKB_KEY_dead_ogonek); pub const dead_iota: Keysym = Keysym(XKB_KEY_dead_iota); pub const dead_voiced_sound: Keysym = Keysym(XKB_KEY_dead_voiced_sound); pub const dead_semivoiced_sound: Keysym = Keysym(XKB_KEY_dead_semivoiced_sound); pub const dead_belowdot: Keysym = Keysym(XKB_KEY_dead_belowdot); pub const dead_hook: Keysym = Keysym(XKB_KEY_dead_hook); pub const dead_horn: Keysym = Keysym(XKB_KEY_dead_horn); pub const dead_stroke: Keysym = Keysym(XKB_KEY_dead_stroke); pub const dead_abovecomma: Keysym = Keysym(XKB_KEY_dead_abovecomma); pub const dead_psili: Keysym = Keysym(XKB_KEY_dead_psili); pub const dead_abovereversedcomma: Keysym = Keysym(XKB_KEY_dead_abovereversedcomma); pub const dead_dasia: Keysym = Keysym(XKB_KEY_dead_dasia); pub const dead_doublegrave: Keysym = Keysym(XKB_KEY_dead_doublegrave); pub const dead_belowring: Keysym = Keysym(XKB_KEY_dead_belowring); pub const dead_belowmacron: Keysym = Keysym(XKB_KEY_dead_belowmacron); pub const dead_belowcircumflex: Keysym = Keysym(XKB_KEY_dead_belowcircumflex); pub const dead_belowtilde: Keysym = Keysym(XKB_KEY_dead_belowtilde); pub const dead_belowbreve: Keysym = Keysym(XKB_KEY_dead_belowbreve); pub const dead_belowdiaeresis: Keysym = Keysym(XKB_KEY_dead_belowdiaeresis); pub const dead_invertedbreve: Keysym = Keysym(XKB_KEY_dead_invertedbreve); pub const dead_belowcomma: Keysym = Keysym(XKB_KEY_dead_belowcomma); pub const dead_currency: Keysym = Keysym(XKB_KEY_dead_currency); pub const dead_lowline: Keysym = Keysym(XKB_KEY_dead_lowline); pub const dead_aboveverticalline: Keysym = Keysym(XKB_KEY_dead_aboveverticalline); pub const dead_belowverticalline: Keysym = Keysym(XKB_KEY_dead_belowverticalline); pub const dead_longsolidusoverlay: Keysym = Keysym(XKB_KEY_dead_longsolidusoverlay); pub const dead_a: Keysym = Keysym(XKB_KEY_dead_a); pub const dead_A: Keysym = Keysym(XKB_KEY_dead_A); pub const dead_e: Keysym = Keysym(XKB_KEY_dead_e); pub const dead_E: Keysym = Keysym(XKB_KEY_dead_E); pub const dead_i: Keysym = Keysym(XKB_KEY_dead_i); pub const dead_I: Keysym = Keysym(XKB_KEY_dead_I); pub const dead_o: Keysym = Keysym(XKB_KEY_dead_o); pub const dead_O: Keysym = Keysym(XKB_KEY_dead_O); pub const dead_u: Keysym = Keysym(XKB_KEY_dead_u); pub const dead_U: Keysym = Keysym(XKB_KEY_dead_U); pub const dead_small_schwa: Keysym = Keysym(XKB_KEY_dead_small_schwa); pub const dead_capital_schwa: Keysym = Keysym(XKB_KEY_dead_capital_schwa); pub const dead_greek: Keysym = Keysym(XKB_KEY_dead_greek); pub const First_Virtual_Screen: Keysym = Keysym(XKB_KEY_First_Virtual_Screen); pub const Prev_Virtual_Screen: Keysym = Keysym(XKB_KEY_Prev_Virtual_Screen); pub const Next_Virtual_Screen: Keysym = Keysym(XKB_KEY_Next_Virtual_Screen); pub const Last_Virtual_Screen: Keysym = Keysym(XKB_KEY_Last_Virtual_Screen); pub const Terminate_Server: Keysym = Keysym(XKB_KEY_Terminate_Server); pub const AccessX_Enable: Keysym = Keysym(XKB_KEY_AccessX_Enable); pub const AccessX_Feedback_Enable: Keysym = Keysym(XKB_KEY_AccessX_Feedback_Enable); pub const RepeatKeys_Enable: Keysym = Keysym(XKB_KEY_RepeatKeys_Enable); pub const SlowKeys_Enable: Keysym = Keysym(XKB_KEY_SlowKeys_Enable); pub const BounceKeys_Enable: Keysym = Keysym(XKB_KEY_BounceKeys_Enable); pub const StickyKeys_Enable: Keysym = Keysym(XKB_KEY_StickyKeys_Enable); pub const MouseKeys_Enable: Keysym = Keysym(XKB_KEY_MouseKeys_Enable); pub const MouseKeys_Accel_Enable: Keysym = Keysym(XKB_KEY_MouseKeys_Accel_Enable); pub const Overlay1_Enable: Keysym = Keysym(XKB_KEY_Overlay1_Enable); pub const Overlay2_Enable: Keysym = Keysym(XKB_KEY_Overlay2_Enable); pub const AudibleBell_Enable: Keysym = Keysym(XKB_KEY_AudibleBell_Enable); pub const Pointer_Left: Keysym = Keysym(XKB_KEY_Pointer_Left); pub const Pointer_Right: Keysym = Keysym(XKB_KEY_Pointer_Right); pub const Pointer_Up: Keysym = Keysym(XKB_KEY_Pointer_Up); pub const Pointer_Down: Keysym = Keysym(XKB_KEY_Pointer_Down); pub const Pointer_UpLeft: Keysym = Keysym(XKB_KEY_Pointer_UpLeft); pub const Pointer_UpRight: Keysym = Keysym(XKB_KEY_Pointer_UpRight); pub const Pointer_DownLeft: Keysym = Keysym(XKB_KEY_Pointer_DownLeft); pub const Pointer_DownRight: Keysym = Keysym(XKB_KEY_Pointer_DownRight); pub const Pointer_Button_Dflt: Keysym = Keysym(XKB_KEY_Pointer_Button_Dflt); pub const Pointer_Button1: Keysym = Keysym(XKB_KEY_Pointer_Button1); pub const Pointer_Button2: Keysym = Keysym(XKB_KEY_Pointer_Button2); pub const Pointer_Button3: Keysym = Keysym(XKB_KEY_Pointer_Button3); pub const Pointer_Button4: Keysym = Keysym(XKB_KEY_Pointer_Button4); pub const Pointer_Button5: Keysym = Keysym(XKB_KEY_Pointer_Button5); pub const Pointer_DblClick_Dflt: Keysym = Keysym(XKB_KEY_Pointer_DblClick_Dflt); pub const Pointer_DblClick1: Keysym = Keysym(XKB_KEY_Pointer_DblClick1); pub const Pointer_DblClick2: Keysym = Keysym(XKB_KEY_Pointer_DblClick2); pub const Pointer_DblClick3: Keysym = Keysym(XKB_KEY_Pointer_DblClick3); pub const Pointer_DblClick4: Keysym = Keysym(XKB_KEY_Pointer_DblClick4); pub const Pointer_DblClick5: Keysym = Keysym(XKB_KEY_Pointer_DblClick5); pub const Pointer_Drag_Dflt: Keysym = Keysym(XKB_KEY_Pointer_Drag_Dflt); pub const Pointer_Drag1: Keysym = Keysym(XKB_KEY_Pointer_Drag1); pub const Pointer_Drag2: Keysym = Keysym(XKB_KEY_Pointer_Drag2); pub const Pointer_Drag3: Keysym = Keysym(XKB_KEY_Pointer_Drag3); pub const Pointer_Drag4: Keysym = Keysym(XKB_KEY_Pointer_Drag4); pub const Pointer_Drag5: Keysym = Keysym(XKB_KEY_Pointer_Drag5); pub const Pointer_EnableKeys: Keysym = Keysym(XKB_KEY_Pointer_EnableKeys); pub const Pointer_Accelerate: Keysym = Keysym(XKB_KEY_Pointer_Accelerate); pub const Pointer_DfltBtnNext: Keysym = Keysym(XKB_KEY_Pointer_DfltBtnNext); pub const Pointer_DfltBtnPrev: Keysym = Keysym(XKB_KEY_Pointer_DfltBtnPrev); pub const ch: Keysym = Keysym(XKB_KEY_ch); pub const Ch: Keysym = Keysym(XKB_KEY_Ch); pub const CH: Keysym = Keysym(XKB_KEY_CH); pub const c_h: Keysym = Keysym(XKB_KEY_c_h); pub const C_h: Keysym = Keysym(XKB_KEY_C_h); pub const C_H: Keysym = Keysym(XKB_KEY_C_H); pub const _3270_Duplicate: Keysym = Keysym(XKB_KEY_3270_Duplicate); pub const _3270_FieldMark: Keysym = Keysym(XKB_KEY_3270_FieldMark); pub const _3270_Right2: Keysym = Keysym(XKB_KEY_3270_Right2); pub const _3270_Left2: Keysym = Keysym(XKB_KEY_3270_Left2); pub const _3270_BackTab: Keysym = Keysym(XKB_KEY_3270_BackTab); pub const _3270_EraseEOF: Keysym = Keysym(XKB_KEY_3270_EraseEOF); pub const _3270_EraseInput: Keysym = Keysym(XKB_KEY_3270_EraseInput); pub const _3270_Reset: Keysym = Keysym(XKB_KEY_3270_Reset); pub const _3270_Quit: Keysym = Keysym(XKB_KEY_3270_Quit); pub const _3270_PA1: Keysym = Keysym(XKB_KEY_3270_PA1); pub const _3270_PA2: Keysym = Keysym(XKB_KEY_3270_PA2); pub const _3270_PA3: Keysym = Keysym(XKB_KEY_3270_PA3); pub const _3270_Test: Keysym = Keysym(XKB_KEY_3270_Test); pub const _3270_Attn: Keysym = Keysym(XKB_KEY_3270_Attn); pub const _3270_CursorBlink: Keysym = Keysym(XKB_KEY_3270_CursorBlink); pub const _3270_AltCursor: Keysym = Keysym(XKB_KEY_3270_AltCursor); pub const _3270_KeyClick: Keysym = Keysym(XKB_KEY_3270_KeyClick); pub const _3270_Jump: Keysym = Keysym(XKB_KEY_3270_Jump); pub const _3270_Ident: Keysym = Keysym(XKB_KEY_3270_Ident); pub const _3270_Rule: Keysym = Keysym(XKB_KEY_3270_Rule); pub const _3270_Copy: Keysym = Keysym(XKB_KEY_3270_Copy); pub const _3270_Play: Keysym = Keysym(XKB_KEY_3270_Play); pub const _3270_Setup: Keysym = Keysym(XKB_KEY_3270_Setup); pub const _3270_Record: Keysym = Keysym(XKB_KEY_3270_Record); pub const _3270_ChangeScreen: Keysym = Keysym(XKB_KEY_3270_ChangeScreen); pub const _3270_DeleteWord: Keysym = Keysym(XKB_KEY_3270_DeleteWord); pub const _3270_ExSelect: Keysym = Keysym(XKB_KEY_3270_ExSelect); pub const _3270_CursorSelect: Keysym = Keysym(XKB_KEY_3270_CursorSelect); pub const _3270_PrintScreen: Keysym = Keysym(XKB_KEY_3270_PrintScreen); pub const _3270_Enter: Keysym = Keysym(XKB_KEY_3270_Enter); pub const space: Keysym = Keysym(XKB_KEY_space); pub const exclam: Keysym = Keysym(XKB_KEY_exclam); pub const quotedbl: Keysym = Keysym(XKB_KEY_quotedbl); pub const numbersign: Keysym = Keysym(XKB_KEY_numbersign); pub const dollar: Keysym = Keysym(XKB_KEY_dollar); pub const percent: Keysym = Keysym(XKB_KEY_percent); pub const ampersand: Keysym = Keysym(XKB_KEY_ampersand); pub const apostrophe: Keysym = Keysym(XKB_KEY_apostrophe); pub const quoteright: Keysym = Keysym(XKB_KEY_quoteright); pub const parenleft: Keysym = Keysym(XKB_KEY_parenleft); pub const parenright: Keysym = Keysym(XKB_KEY_parenright); pub const asterisk: Keysym = Keysym(XKB_KEY_asterisk); pub const plus: Keysym = Keysym(XKB_KEY_plus); pub const comma: Keysym = Keysym(XKB_KEY_comma); pub const minus: Keysym = Keysym(XKB_KEY_minus); pub const period: Keysym = Keysym(XKB_KEY_period); pub const slash: Keysym = Keysym(XKB_KEY_slash); pub const _0: Keysym = Keysym(XKB_KEY_0); pub const _1: Keysym = Keysym(XKB_KEY_1); pub const _2: Keysym = Keysym(XKB_KEY_2); pub const _3: Keysym = Keysym(XKB_KEY_3); pub const _4: Keysym = Keysym(XKB_KEY_4); pub const _5: Keysym = Keysym(XKB_KEY_5); pub const _6: Keysym = Keysym(XKB_KEY_6); pub const _7: Keysym = Keysym(XKB_KEY_7); pub const _8: Keysym = Keysym(XKB_KEY_8); pub const _9: Keysym = Keysym(XKB_KEY_9); pub const colon: Keysym = Keysym(XKB_KEY_colon); pub const semicolon: Keysym = Keysym(XKB_KEY_semicolon); pub const less: Keysym = Keysym(XKB_KEY_less); pub const equal: Keysym = Keysym(XKB_KEY_equal); pub const greater: Keysym = Keysym(XKB_KEY_greater); pub const question: Keysym = Keysym(XKB_KEY_question); pub const at: Keysym = Keysym(XKB_KEY_at); pub const A: Keysym = Keysym(XKB_KEY_A); pub const B: Keysym = Keysym(XKB_KEY_B); pub const C: Keysym = Keysym(XKB_KEY_C); pub const D: Keysym = Keysym(XKB_KEY_D); pub const E: Keysym = Keysym(XKB_KEY_E); pub const F: Keysym = Keysym(XKB_KEY_F); pub const G: Keysym = Keysym(XKB_KEY_G); pub const H: Keysym = Keysym(XKB_KEY_H); pub const I: Keysym = Keysym(XKB_KEY_I); pub const J: Keysym = Keysym(XKB_KEY_J); pub const K: Keysym = Keysym(XKB_KEY_K); pub const L: Keysym = Keysym(XKB_KEY_L); pub const M: Keysym = Keysym(XKB_KEY_M); pub const N: Keysym = Keysym(XKB_KEY_N); pub const O: Keysym = Keysym(XKB_KEY_O); pub const P: Keysym = Keysym(XKB_KEY_P); pub const Q: Keysym = Keysym(XKB_KEY_Q); pub const R: Keysym = Keysym(XKB_KEY_R); pub const S: Keysym = Keysym(XKB_KEY_S); pub const T: Keysym = Keysym(XKB_KEY_T); pub const U: Keysym = Keysym(XKB_KEY_U); pub const V: Keysym = Keysym(XKB_KEY_V); pub const W: Keysym = Keysym(XKB_KEY_W); pub const X: Keysym = Keysym(XKB_KEY_X); pub const Y: Keysym = Keysym(XKB_KEY_Y); pub const Z: Keysym = Keysym(XKB_KEY_Z); pub const bracketleft: Keysym = Keysym(XKB_KEY_bracketleft); pub const backslash: Keysym = Keysym(XKB_KEY_backslash); pub const bracketright: Keysym = Keysym(XKB_KEY_bracketright); pub const asciicircum: Keysym = Keysym(XKB_KEY_asciicircum); pub const underscore: Keysym = Keysym(XKB_KEY_underscore); pub const grave: Keysym = Keysym(XKB_KEY_grave); pub const quoteleft: Keysym = Keysym(XKB_KEY_quoteleft); pub const a: Keysym = Keysym(XKB_KEY_a); pub const b: Keysym = Keysym(XKB_KEY_b); pub const c: Keysym = Keysym(XKB_KEY_c); pub const d: Keysym = Keysym(XKB_KEY_d); pub const e: Keysym = Keysym(XKB_KEY_e); pub const f: Keysym = Keysym(XKB_KEY_f); pub const g: Keysym = Keysym(XKB_KEY_g); pub const h: Keysym = Keysym(XKB_KEY_h); pub const i: Keysym = Keysym(XKB_KEY_i); pub const j: Keysym = Keysym(XKB_KEY_j); pub const k: Keysym = Keysym(XKB_KEY_k); pub const l: Keysym = Keysym(XKB_KEY_l); pub const m: Keysym = Keysym(XKB_KEY_m); pub const n: Keysym = Keysym(XKB_KEY_n); pub const o: Keysym = Keysym(XKB_KEY_o); pub const p: Keysym = Keysym(XKB_KEY_p); pub const q: Keysym = Keysym(XKB_KEY_q); pub const r: Keysym = Keysym(XKB_KEY_r); pub const s: Keysym = Keysym(XKB_KEY_s); pub const t: Keysym = Keysym(XKB_KEY_t); pub const u: Keysym = Keysym(XKB_KEY_u); pub const v: Keysym = Keysym(XKB_KEY_v); pub const w: Keysym = Keysym(XKB_KEY_w); pub const x: Keysym = Keysym(XKB_KEY_x); pub const y: Keysym = Keysym(XKB_KEY_y); pub const z: Keysym = Keysym(XKB_KEY_z); pub const braceleft: Keysym = Keysym(XKB_KEY_braceleft); pub const bar: Keysym = Keysym(XKB_KEY_bar); pub const braceright: Keysym = Keysym(XKB_KEY_braceright); pub const asciitilde: Keysym = Keysym(XKB_KEY_asciitilde); pub const nobreakspace: Keysym = Keysym(XKB_KEY_nobreakspace); pub const exclamdown: Keysym = Keysym(XKB_KEY_exclamdown); pub const cent: Keysym = Keysym(XKB_KEY_cent); pub const sterling: Keysym = Keysym(XKB_KEY_sterling); pub const currency: Keysym = Keysym(XKB_KEY_currency); pub const yen: Keysym = Keysym(XKB_KEY_yen); pub const brokenbar: Keysym = Keysym(XKB_KEY_brokenbar); pub const section: Keysym = Keysym(XKB_KEY_section); pub const diaeresis: Keysym = Keysym(XKB_KEY_diaeresis); pub const copyright: Keysym = Keysym(XKB_KEY_copyright); pub const ordfeminine: Keysym = Keysym(XKB_KEY_ordfeminine); pub const guillemotleft: Keysym = Keysym(XKB_KEY_guillemotleft); pub const notsign: Keysym = Keysym(XKB_KEY_notsign); pub const hyphen: Keysym = Keysym(XKB_KEY_hyphen); pub const registered: Keysym = Keysym(XKB_KEY_registered); pub const macron: Keysym = Keysym(XKB_KEY_macron); pub const degree: Keysym = Keysym(XKB_KEY_degree); pub const plusminus: Keysym = Keysym(XKB_KEY_plusminus); pub const twosuperior: Keysym = Keysym(XKB_KEY_twosuperior); pub const threesuperior: Keysym = Keysym(XKB_KEY_threesuperior); pub const acute: Keysym = Keysym(XKB_KEY_acute); pub const mu: Keysym = Keysym(XKB_KEY_mu); pub const paragraph: Keysym = Keysym(XKB_KEY_paragraph); pub const periodcentered: Keysym = Keysym(XKB_KEY_periodcentered); pub const cedilla: Keysym = Keysym(XKB_KEY_cedilla); pub const onesuperior: Keysym = Keysym(XKB_KEY_onesuperior); pub const masculine: Keysym = Keysym(XKB_KEY_masculine); pub const guillemotright: Keysym = Keysym(XKB_KEY_guillemotright); pub const onequarter: Keysym = Keysym(XKB_KEY_onequarter); pub const onehalf: Keysym = Keysym(XKB_KEY_onehalf); pub const threequarters: Keysym = Keysym(XKB_KEY_threequarters); pub const questiondown: Keysym = Keysym(XKB_KEY_questiondown); pub const Agrave: Keysym = Keysym(XKB_KEY_Agrave); pub const Aacute: Keysym = Keysym(XKB_KEY_Aacute); pub const Acircumflex: Keysym = Keysym(XKB_KEY_Acircumflex); pub const Atilde: Keysym = Keysym(XKB_KEY_Atilde); pub const Adiaeresis: Keysym = Keysym(XKB_KEY_Adiaeresis); pub const Aring: Keysym = Keysym(XKB_KEY_Aring); pub const AE: Keysym = Keysym(XKB_KEY_AE); pub const Ccedilla: Keysym = Keysym(XKB_KEY_Ccedilla); pub const Egrave: Keysym = Keysym(XKB_KEY_Egrave); pub const Eacute: Keysym = Keysym(XKB_KEY_Eacute); pub const Ecircumflex: Keysym = Keysym(XKB_KEY_Ecircumflex); pub const Ediaeresis: Keysym = Keysym(XKB_KEY_Ediaeresis); pub const Igrave: Keysym = Keysym(XKB_KEY_Igrave); pub const Iacute: Keysym = Keysym(XKB_KEY_Iacute); pub const Icircumflex: Keysym = Keysym(XKB_KEY_Icircumflex); pub const Idiaeresis: Keysym = Keysym(XKB_KEY_Idiaeresis); pub const ETH: Keysym = Keysym(XKB_KEY_ETH); pub const Eth: Keysym = Keysym(XKB_KEY_Eth); pub const Ntilde: Keysym = Keysym(XKB_KEY_Ntilde); pub const Ograve: Keysym = Keysym(XKB_KEY_Ograve); pub const Oacute: Keysym = Keysym(XKB_KEY_Oacute); pub const Ocircumflex: Keysym = Keysym(XKB_KEY_Ocircumflex); pub const Otilde: Keysym = Keysym(XKB_KEY_Otilde); pub const Odiaeresis: Keysym = Keysym(XKB_KEY_Odiaeresis); pub const multiply: Keysym = Keysym(XKB_KEY_multiply); pub const Oslash: Keysym = Keysym(XKB_KEY_Oslash); pub const Ooblique: Keysym = Keysym(XKB_KEY_Ooblique); pub const Ugrave: Keysym = Keysym(XKB_KEY_Ugrave); pub const Uacute: Keysym = Keysym(XKB_KEY_Uacute); pub const Ucircumflex: Keysym = Keysym(XKB_KEY_Ucircumflex); pub const Udiaeresis: Keysym = Keysym(XKB_KEY_Udiaeresis); pub const Yacute: Keysym = Keysym(XKB_KEY_Yacute); pub const THORN: Keysym = Keysym(XKB_KEY_THORN); pub const Thorn: Keysym = Keysym(XKB_KEY_Thorn); pub const ssharp: Keysym = Keysym(XKB_KEY_ssharp); pub const agrave: Keysym = Keysym(XKB_KEY_agrave); pub const aacute: Keysym = Keysym(XKB_KEY_aacute); pub const acircumflex: Keysym = Keysym(XKB_KEY_acircumflex); pub const atilde: Keysym = Keysym(XKB_KEY_atilde); pub const adiaeresis: Keysym = Keysym(XKB_KEY_adiaeresis); pub const aring: Keysym = Keysym(XKB_KEY_aring); pub const ae: Keysym = Keysym(XKB_KEY_ae); pub const ccedilla: Keysym = Keysym(XKB_KEY_ccedilla); pub const egrave: Keysym = Keysym(XKB_KEY_egrave); pub const eacute: Keysym = Keysym(XKB_KEY_eacute); pub const ecircumflex: Keysym = Keysym(XKB_KEY_ecircumflex); pub const ediaeresis: Keysym = Keysym(XKB_KEY_ediaeresis); pub const igrave: Keysym = Keysym(XKB_KEY_igrave); pub const iacute: Keysym = Keysym(XKB_KEY_iacute); pub const icircumflex: Keysym = Keysym(XKB_KEY_icircumflex); pub const idiaeresis: Keysym = Keysym(XKB_KEY_idiaeresis); pub const eth: Keysym = Keysym(XKB_KEY_eth); pub const ntilde: Keysym = Keysym(XKB_KEY_ntilde); pub const ograve: Keysym = Keysym(XKB_KEY_ograve); pub const oacute: Keysym = Keysym(XKB_KEY_oacute); pub const ocircumflex: Keysym = Keysym(XKB_KEY_ocircumflex); pub const otilde: Keysym = Keysym(XKB_KEY_otilde); pub const odiaeresis: Keysym = Keysym(XKB_KEY_odiaeresis); pub const division: Keysym = Keysym(XKB_KEY_division); pub const oslash: Keysym = Keysym(XKB_KEY_oslash); pub const ooblique: Keysym = Keysym(XKB_KEY_ooblique); pub const ugrave: Keysym = Keysym(XKB_KEY_ugrave); pub const uacute: Keysym = Keysym(XKB_KEY_uacute); pub const ucircumflex: Keysym = Keysym(XKB_KEY_ucircumflex); pub const udiaeresis: Keysym = Keysym(XKB_KEY_udiaeresis); pub const yacute: Keysym = Keysym(XKB_KEY_yacute); pub const thorn: Keysym = Keysym(XKB_KEY_thorn); pub const ydiaeresis: Keysym = Keysym(XKB_KEY_ydiaeresis); pub const Aogonek: Keysym = Keysym(XKB_KEY_Aogonek); pub const breve: Keysym = Keysym(XKB_KEY_breve); pub const Lstroke: Keysym = Keysym(XKB_KEY_Lstroke); pub const Lcaron: Keysym = Keysym(XKB_KEY_Lcaron); pub const Sacute: Keysym = Keysym(XKB_KEY_Sacute); pub const Scaron: Keysym = Keysym(XKB_KEY_Scaron); pub const Scedilla: Keysym = Keysym(XKB_KEY_Scedilla); pub const Tcaron: Keysym = Keysym(XKB_KEY_Tcaron); pub const Zacute: Keysym = Keysym(XKB_KEY_Zacute); pub const Zcaron: Keysym = Keysym(XKB_KEY_Zcaron); pub const Zabovedot: Keysym = Keysym(XKB_KEY_Zabovedot); pub const aogonek: Keysym = Keysym(XKB_KEY_aogonek); pub const ogonek: Keysym = Keysym(XKB_KEY_ogonek); pub const lstroke: Keysym = Keysym(XKB_KEY_lstroke); pub const lcaron: Keysym = Keysym(XKB_KEY_lcaron); pub const sacute: Keysym = Keysym(XKB_KEY_sacute); pub const caron: Keysym = Keysym(XKB_KEY_caron); pub const scaron: Keysym = Keysym(XKB_KEY_scaron); pub const scedilla: Keysym = Keysym(XKB_KEY_scedilla); pub const tcaron: Keysym = Keysym(XKB_KEY_tcaron); pub const zacute: Keysym = Keysym(XKB_KEY_zacute); pub const doubleacute: Keysym = Keysym(XKB_KEY_doubleacute); pub const zcaron: Keysym = Keysym(XKB_KEY_zcaron); pub const zabovedot: Keysym = Keysym(XKB_KEY_zabovedot); pub const Racute: Keysym = Keysym(XKB_KEY_Racute); pub const Abreve: Keysym = Keysym(XKB_KEY_Abreve); pub const Lacute: Keysym = Keysym(XKB_KEY_Lacute); pub const Cacute: Keysym = Keysym(XKB_KEY_Cacute); pub const Ccaron: Keysym = Keysym(XKB_KEY_Ccaron); pub const Eogonek: Keysym = Keysym(XKB_KEY_Eogonek); pub const Ecaron: Keysym = Keysym(XKB_KEY_Ecaron); pub const Dcaron: Keysym = Keysym(XKB_KEY_Dcaron); pub const Dstroke: Keysym = Keysym(XKB_KEY_Dstroke); pub const Nacute: Keysym = Keysym(XKB_KEY_Nacute); pub const Ncaron: Keysym = Keysym(XKB_KEY_Ncaron); pub const Odoubleacute: Keysym = Keysym(XKB_KEY_Odoubleacute); pub const Rcaron: Keysym = Keysym(XKB_KEY_Rcaron); pub const Uring: Keysym = Keysym(XKB_KEY_Uring); pub const Udoubleacute: Keysym = Keysym(XKB_KEY_Udoubleacute); pub const Tcedilla: Keysym = Keysym(XKB_KEY_Tcedilla); pub const racute: Keysym = Keysym(XKB_KEY_racute); pub const abreve: Keysym = Keysym(XKB_KEY_abreve); pub const lacute: Keysym = Keysym(XKB_KEY_lacute); pub const cacute: Keysym = Keysym(XKB_KEY_cacute); pub const ccaron: Keysym = Keysym(XKB_KEY_ccaron); pub const eogonek: Keysym = Keysym(XKB_KEY_eogonek); pub const ecaron: Keysym = Keysym(XKB_KEY_ecaron); pub const dcaron: Keysym = Keysym(XKB_KEY_dcaron); pub const dstroke: Keysym = Keysym(XKB_KEY_dstroke); pub const nacute: Keysym = Keysym(XKB_KEY_nacute); pub const ncaron: Keysym = Keysym(XKB_KEY_ncaron); pub const odoubleacute: Keysym = Keysym(XKB_KEY_odoubleacute); pub const rcaron: Keysym = Keysym(XKB_KEY_rcaron); pub const uring: Keysym = Keysym(XKB_KEY_uring); pub const udoubleacute: Keysym = Keysym(XKB_KEY_udoubleacute); pub const tcedilla: Keysym = Keysym(XKB_KEY_tcedilla); pub const abovedot: Keysym = Keysym(XKB_KEY_abovedot); pub const Hstroke: Keysym = Keysym(XKB_KEY_Hstroke); pub const Hcircumflex: Keysym = Keysym(XKB_KEY_Hcircumflex); pub const Iabovedot: Keysym = Keysym(XKB_KEY_Iabovedot); pub const Gbreve: Keysym = Keysym(XKB_KEY_Gbreve); pub const Jcircumflex: Keysym = Keysym(XKB_KEY_Jcircumflex); pub const hstroke: Keysym = Keysym(XKB_KEY_hstroke); pub const hcircumflex: Keysym = Keysym(XKB_KEY_hcircumflex); pub const idotless: Keysym = Keysym(XKB_KEY_idotless); pub const gbreve: Keysym = Keysym(XKB_KEY_gbreve); pub const jcircumflex: Keysym = Keysym(XKB_KEY_jcircumflex); pub const Cabovedot: Keysym = Keysym(XKB_KEY_Cabovedot); pub const Ccircumflex: Keysym = Keysym(XKB_KEY_Ccircumflex); pub const Gabovedot: Keysym = Keysym(XKB_KEY_Gabovedot); pub const Gcircumflex: Keysym = Keysym(XKB_KEY_Gcircumflex); pub const Ubreve: Keysym = Keysym(XKB_KEY_Ubreve); pub const Scircumflex: Keysym = Keysym(XKB_KEY_Scircumflex); pub const cabovedot: Keysym = Keysym(XKB_KEY_cabovedot); pub const ccircumflex: Keysym = Keysym(XKB_KEY_ccircumflex); pub const gabovedot: Keysym = Keysym(XKB_KEY_gabovedot); pub const gcircumflex: Keysym = Keysym(XKB_KEY_gcircumflex); pub const ubreve: Keysym = Keysym(XKB_KEY_ubreve); pub const scircumflex: Keysym = Keysym(XKB_KEY_scircumflex); pub const kra: Keysym = Keysym(XKB_KEY_kra); pub const kappa: Keysym = Keysym(XKB_KEY_kappa); pub const Rcedilla: Keysym = Keysym(XKB_KEY_Rcedilla); pub const Itilde: Keysym = Keysym(XKB_KEY_Itilde); pub const Lcedilla: Keysym = Keysym(XKB_KEY_Lcedilla); pub const Emacron: Keysym = Keysym(XKB_KEY_Emacron); pub const Gcedilla: Keysym = Keysym(XKB_KEY_Gcedilla); pub const Tslash: Keysym = Keysym(XKB_KEY_Tslash); pub const rcedilla: Keysym = Keysym(XKB_KEY_rcedilla); pub const itilde: Keysym = Keysym(XKB_KEY_itilde); pub const lcedilla: Keysym = Keysym(XKB_KEY_lcedilla); pub const emacron: Keysym = Keysym(XKB_KEY_emacron); pub const gcedilla: Keysym = Keysym(XKB_KEY_gcedilla); pub const tslash: Keysym = Keysym(XKB_KEY_tslash); pub const ENG: Keysym = Keysym(XKB_KEY_ENG); pub const eng: Keysym = Keysym(XKB_KEY_eng); pub const Amacron: Keysym = Keysym(XKB_KEY_Amacron); pub const Iogonek: Keysym = Keysym(XKB_KEY_Iogonek); pub const Eabovedot: Keysym = Keysym(XKB_KEY_Eabovedot); pub const Imacron: Keysym = Keysym(XKB_KEY_Imacron); pub const Ncedilla: Keysym = Keysym(XKB_KEY_Ncedilla); pub const Omacron: Keysym = Keysym(XKB_KEY_Omacron); pub const Kcedilla: Keysym = Keysym(XKB_KEY_Kcedilla); pub const Uogonek: Keysym = Keysym(XKB_KEY_Uogonek); pub const Utilde: Keysym = Keysym(XKB_KEY_Utilde); pub const Umacron: Keysym = Keysym(XKB_KEY_Umacron); pub const amacron: Keysym = Keysym(XKB_KEY_amacron); pub const iogonek: Keysym = Keysym(XKB_KEY_iogonek); pub const eabovedot: Keysym = Keysym(XKB_KEY_eabovedot); pub const imacron: Keysym = Keysym(XKB_KEY_imacron); pub const ncedilla: Keysym = Keysym(XKB_KEY_ncedilla); pub const omacron: Keysym = Keysym(XKB_KEY_omacron); pub const kcedilla: Keysym = Keysym(XKB_KEY_kcedilla); pub const uogonek: Keysym = Keysym(XKB_KEY_uogonek); pub const utilde: Keysym = Keysym(XKB_KEY_utilde); pub const umacron: Keysym = Keysym(XKB_KEY_umacron); pub const Wcircumflex: Keysym = Keysym(XKB_KEY_Wcircumflex); pub const wcircumflex: Keysym = Keysym(XKB_KEY_wcircumflex); pub const Ycircumflex: Keysym = Keysym(XKB_KEY_Ycircumflex); pub const ycircumflex: Keysym = Keysym(XKB_KEY_ycircumflex); pub const Babovedot: Keysym = Keysym(XKB_KEY_Babovedot); pub const babovedot: Keysym = Keysym(XKB_KEY_babovedot); pub const Dabovedot: Keysym = Keysym(XKB_KEY_Dabovedot); pub const dabovedot: Keysym = Keysym(XKB_KEY_dabovedot); pub const Fabovedot: Keysym = Keysym(XKB_KEY_Fabovedot); pub const fabovedot: Keysym = Keysym(XKB_KEY_fabovedot); pub const Mabovedot: Keysym = Keysym(XKB_KEY_Mabovedot); pub const mabovedot: Keysym = Keysym(XKB_KEY_mabovedot); pub const Pabovedot: Keysym = Keysym(XKB_KEY_Pabovedot); pub const pabovedot: Keysym = Keysym(XKB_KEY_pabovedot); pub const Sabovedot: Keysym = Keysym(XKB_KEY_Sabovedot); pub const sabovedot: Keysym = Keysym(XKB_KEY_sabovedot); pub const Tabovedot: Keysym = Keysym(XKB_KEY_Tabovedot); pub const tabovedot: Keysym = Keysym(XKB_KEY_tabovedot); pub const Wgrave: Keysym = Keysym(XKB_KEY_Wgrave); pub const wgrave: Keysym = Keysym(XKB_KEY_wgrave); pub const Wacute: Keysym = Keysym(XKB_KEY_Wacute); pub const wacute: Keysym = Keysym(XKB_KEY_wacute); pub const Wdiaeresis: Keysym = Keysym(XKB_KEY_Wdiaeresis); pub const wdiaeresis: Keysym = Keysym(XKB_KEY_wdiaeresis); pub const Ygrave: Keysym = Keysym(XKB_KEY_Ygrave); pub const ygrave: Keysym = Keysym(XKB_KEY_ygrave); pub const OE: Keysym = Keysym(XKB_KEY_OE); pub const oe: Keysym = Keysym(XKB_KEY_oe); pub const Ydiaeresis: Keysym = Keysym(XKB_KEY_Ydiaeresis); pub const overline: Keysym = Keysym(XKB_KEY_overline); pub const kana_fullstop: Keysym = Keysym(XKB_KEY_kana_fullstop); pub const kana_openingbracket: Keysym = Keysym(XKB_KEY_kana_openingbracket); pub const kana_closingbracket: Keysym = Keysym(XKB_KEY_kana_closingbracket); pub const kana_comma: Keysym = Keysym(XKB_KEY_kana_comma); pub const kana_conjunctive: Keysym = Keysym(XKB_KEY_kana_conjunctive); pub const kana_middledot: Keysym = Keysym(XKB_KEY_kana_middledot); pub const kana_WO: Keysym = Keysym(XKB_KEY_kana_WO); pub const kana_a: Keysym = Keysym(XKB_KEY_kana_a); pub const kana_i: Keysym = Keysym(XKB_KEY_kana_i); pub const kana_u: Keysym = Keysym(XKB_KEY_kana_u); pub const kana_e: Keysym = Keysym(XKB_KEY_kana_e); pub const kana_o: Keysym = Keysym(XKB_KEY_kana_o); pub const kana_ya: Keysym = Keysym(XKB_KEY_kana_ya); pub const kana_yu: Keysym = Keysym(XKB_KEY_kana_yu); pub const kana_yo: Keysym = Keysym(XKB_KEY_kana_yo); pub const kana_tsu: Keysym = Keysym(XKB_KEY_kana_tsu); pub const kana_tu: Keysym = Keysym(XKB_KEY_kana_tu); pub const prolongedsound: Keysym = Keysym(XKB_KEY_prolongedsound); pub const kana_A: Keysym = Keysym(XKB_KEY_kana_A); pub const kana_I: Keysym = Keysym(XKB_KEY_kana_I); pub const kana_U: Keysym = Keysym(XKB_KEY_kana_U); pub const kana_E: Keysym = Keysym(XKB_KEY_kana_E); pub const kana_O: Keysym = Keysym(XKB_KEY_kana_O); pub const kana_KA: Keysym = Keysym(XKB_KEY_kana_KA); pub const kana_KI: Keysym = Keysym(XKB_KEY_kana_KI); pub const kana_KU: Keysym = Keysym(XKB_KEY_kana_KU); pub const kana_KE: Keysym = Keysym(XKB_KEY_kana_KE); pub const kana_KO: Keysym = Keysym(XKB_KEY_kana_KO); pub const kana_SA: Keysym = Keysym(XKB_KEY_kana_SA); pub const kana_SHI: Keysym = Keysym(XKB_KEY_kana_SHI); pub const kana_SU: Keysym = Keysym(XKB_KEY_kana_SU); pub const kana_SE: Keysym = Keysym(XKB_KEY_kana_SE); pub const kana_SO: Keysym = Keysym(XKB_KEY_kana_SO); pub const kana_TA: Keysym = Keysym(XKB_KEY_kana_TA); pub const kana_CHI: Keysym = Keysym(XKB_KEY_kana_CHI); pub const kana_TI: Keysym = Keysym(XKB_KEY_kana_TI); pub const kana_TSU: Keysym = Keysym(XKB_KEY_kana_TSU); pub const kana_TU: Keysym = Keysym(XKB_KEY_kana_TU); pub const kana_TE: Keysym = Keysym(XKB_KEY_kana_TE); pub const kana_TO: Keysym = Keysym(XKB_KEY_kana_TO); pub const kana_NA: Keysym = Keysym(XKB_KEY_kana_NA); pub const kana_NI: Keysym = Keysym(XKB_KEY_kana_NI); pub const kana_NU: Keysym = Keysym(XKB_KEY_kana_NU); pub const kana_NE: Keysym = Keysym(XKB_KEY_kana_NE); pub const kana_NO: Keysym = Keysym(XKB_KEY_kana_NO); pub const kana_HA: Keysym = Keysym(XKB_KEY_kana_HA); pub const kana_HI: Keysym = Keysym(XKB_KEY_kana_HI); pub const kana_FU: Keysym = Keysym(XKB_KEY_kana_FU); pub const kana_HU: Keysym = Keysym(XKB_KEY_kana_HU); pub const kana_HE: Keysym = Keysym(XKB_KEY_kana_HE); pub const kana_HO: Keysym = Keysym(XKB_KEY_kana_HO); pub const kana_MA: Keysym = Keysym(XKB_KEY_kana_MA); pub const kana_MI: Keysym = Keysym(XKB_KEY_kana_MI); pub const kana_MU: Keysym = Keysym(XKB_KEY_kana_MU); pub const kana_ME: Keysym = Keysym(XKB_KEY_kana_ME); pub const kana_MO: Keysym = Keysym(XKB_KEY_kana_MO); pub const kana_YA: Keysym = Keysym(XKB_KEY_kana_YA); pub const kana_YU: Keysym = Keysym(XKB_KEY_kana_YU); pub const kana_YO: Keysym = Keysym(XKB_KEY_kana_YO); pub const kana_RA: Keysym = Keysym(XKB_KEY_kana_RA); pub const kana_RI: Keysym = Keysym(XKB_KEY_kana_RI); pub const kana_RU: Keysym = Keysym(XKB_KEY_kana_RU); pub const kana_RE: Keysym = Keysym(XKB_KEY_kana_RE); pub const kana_RO: Keysym = Keysym(XKB_KEY_kana_RO); pub const kana_WA: Keysym = Keysym(XKB_KEY_kana_WA); pub const kana_N: Keysym = Keysym(XKB_KEY_kana_N); pub const voicedsound: Keysym = Keysym(XKB_KEY_voicedsound); pub const semivoicedsound: Keysym = Keysym(XKB_KEY_semivoicedsound); pub const kana_switch: Keysym = Keysym(XKB_KEY_kana_switch); pub const Farsi_0: Keysym = Keysym(XKB_KEY_Farsi_0); pub const Farsi_1: Keysym = Keysym(XKB_KEY_Farsi_1); pub const Farsi_2: Keysym = Keysym(XKB_KEY_Farsi_2); pub const Farsi_3: Keysym = Keysym(XKB_KEY_Farsi_3); pub const Farsi_4: Keysym = Keysym(XKB_KEY_Farsi_4); pub const Farsi_5: Keysym = Keysym(XKB_KEY_Farsi_5); pub const Farsi_6: Keysym = Keysym(XKB_KEY_Farsi_6); pub const Farsi_7: Keysym = Keysym(XKB_KEY_Farsi_7); pub const Farsi_8: Keysym = Keysym(XKB_KEY_Farsi_8); pub const Farsi_9: Keysym = Keysym(XKB_KEY_Farsi_9); pub const Arabic_percent: Keysym = Keysym(XKB_KEY_Arabic_percent); pub const Arabic_superscript_alef: Keysym = Keysym(XKB_KEY_Arabic_superscript_alef); pub const Arabic_tteh: Keysym = Keysym(XKB_KEY_Arabic_tteh); pub const Arabic_peh: Keysym = Keysym(XKB_KEY_Arabic_peh); pub const Arabic_tcheh: Keysym = Keysym(XKB_KEY_Arabic_tcheh); pub const Arabic_ddal: Keysym = Keysym(XKB_KEY_Arabic_ddal); pub const Arabic_rreh: Keysym = Keysym(XKB_KEY_Arabic_rreh); pub const Arabic_comma: Keysym = Keysym(XKB_KEY_Arabic_comma); pub const Arabic_fullstop: Keysym = Keysym(XKB_KEY_Arabic_fullstop); pub const Arabic_0: Keysym = Keysym(XKB_KEY_Arabic_0); pub const Arabic_1: Keysym = Keysym(XKB_KEY_Arabic_1); pub const Arabic_2: Keysym = Keysym(XKB_KEY_Arabic_2); pub const Arabic_3: Keysym = Keysym(XKB_KEY_Arabic_3); pub const Arabic_4: Keysym = Keysym(XKB_KEY_Arabic_4); pub const Arabic_5: Keysym = Keysym(XKB_KEY_Arabic_5); pub const Arabic_6: Keysym = Keysym(XKB_KEY_Arabic_6); pub const Arabic_7: Keysym = Keysym(XKB_KEY_Arabic_7); pub const Arabic_8: Keysym = Keysym(XKB_KEY_Arabic_8); pub const Arabic_9: Keysym = Keysym(XKB_KEY_Arabic_9); pub const Arabic_semicolon: Keysym = Keysym(XKB_KEY_Arabic_semicolon); pub const Arabic_question_mark: Keysym = Keysym(XKB_KEY_Arabic_question_mark); pub const Arabic_hamza: Keysym = Keysym(XKB_KEY_Arabic_hamza); pub const Arabic_maddaonalef: Keysym = Keysym(XKB_KEY_Arabic_maddaonalef); pub const Arabic_hamzaonalef: Keysym = Keysym(XKB_KEY_Arabic_hamzaonalef); pub const Arabic_hamzaonwaw: Keysym = Keysym(XKB_KEY_Arabic_hamzaonwaw); pub const Arabic_hamzaunderalef: Keysym = Keysym(XKB_KEY_Arabic_hamzaunderalef); pub const Arabic_hamzaonyeh: Keysym = Keysym(XKB_KEY_Arabic_hamzaonyeh); pub const Arabic_alef: Keysym = Keysym(XKB_KEY_Arabic_alef); pub const Arabic_beh: Keysym = Keysym(XKB_KEY_Arabic_beh); pub const Arabic_tehmarbuta: Keysym = Keysym(XKB_KEY_Arabic_tehmarbuta); pub const Arabic_teh: Keysym = Keysym(XKB_KEY_Arabic_teh); pub const Arabic_theh: Keysym = Keysym(XKB_KEY_Arabic_theh); pub const Arabic_jeem: Keysym = Keysym(XKB_KEY_Arabic_jeem); pub const Arabic_hah: Keysym = Keysym(XKB_KEY_Arabic_hah); pub const Arabic_khah: Keysym = Keysym(XKB_KEY_Arabic_khah); pub const Arabic_dal: Keysym = Keysym(XKB_KEY_Arabic_dal); pub const Arabic_thal: Keysym = Keysym(XKB_KEY_Arabic_thal); pub const Arabic_ra: Keysym = Keysym(XKB_KEY_Arabic_ra); pub const Arabic_zain: Keysym = Keysym(XKB_KEY_Arabic_zain); pub const Arabic_seen: Keysym = Keysym(XKB_KEY_Arabic_seen); pub const Arabic_sheen: Keysym = Keysym(XKB_KEY_Arabic_sheen); pub const Arabic_sad: Keysym = Keysym(XKB_KEY_Arabic_sad); pub const Arabic_dad: Keysym = Keysym(XKB_KEY_Arabic_dad); pub const Arabic_tah: Keysym = Keysym(XKB_KEY_Arabic_tah); pub const Arabic_zah: Keysym = Keysym(XKB_KEY_Arabic_zah); pub const Arabic_ain: Keysym = Keysym(XKB_KEY_Arabic_ain); pub const Arabic_ghain: Keysym = Keysym(XKB_KEY_Arabic_ghain); pub const Arabic_tatweel: Keysym = Keysym(XKB_KEY_Arabic_tatweel); pub const Arabic_feh: Keysym = Keysym(XKB_KEY_Arabic_feh); pub const Arabic_qaf: Keysym = Keysym(XKB_KEY_Arabic_qaf); pub const Arabic_kaf: Keysym = Keysym(XKB_KEY_Arabic_kaf); pub const Arabic_lam: Keysym = Keysym(XKB_KEY_Arabic_lam); pub const Arabic_meem: Keysym = Keysym(XKB_KEY_Arabic_meem); pub const Arabic_noon: Keysym = Keysym(XKB_KEY_Arabic_noon); pub const Arabic_ha: Keysym = Keysym(XKB_KEY_Arabic_ha); pub const Arabic_heh: Keysym = Keysym(XKB_KEY_Arabic_heh); pub const Arabic_waw: Keysym = Keysym(XKB_KEY_Arabic_waw); pub const Arabic_alefmaksura: Keysym = Keysym(XKB_KEY_Arabic_alefmaksura); pub const Arabic_yeh: Keysym = Keysym(XKB_KEY_Arabic_yeh); pub const Arabic_fathatan: Keysym = Keysym(XKB_KEY_Arabic_fathatan); pub const Arabic_dammatan: Keysym = Keysym(XKB_KEY_Arabic_dammatan); pub const Arabic_kasratan: Keysym = Keysym(XKB_KEY_Arabic_kasratan); pub const Arabic_fatha: Keysym = Keysym(XKB_KEY_Arabic_fatha); pub const Arabic_damma: Keysym = Keysym(XKB_KEY_Arabic_damma); pub const Arabic_kasra: Keysym = Keysym(XKB_KEY_Arabic_kasra); pub const Arabic_shadda: Keysym = Keysym(XKB_KEY_Arabic_shadda); pub const Arabic_sukun: Keysym = Keysym(XKB_KEY_Arabic_sukun); pub const Arabic_madda_above: Keysym = Keysym(XKB_KEY_Arabic_madda_above); pub const Arabic_hamza_above: Keysym = Keysym(XKB_KEY_Arabic_hamza_above); pub const Arabic_hamza_below: Keysym = Keysym(XKB_KEY_Arabic_hamza_below); pub const Arabic_jeh: Keysym = Keysym(XKB_KEY_Arabic_jeh); pub const Arabic_veh: Keysym = Keysym(XKB_KEY_Arabic_veh); pub const Arabic_keheh: Keysym = Keysym(XKB_KEY_Arabic_keheh); pub const Arabic_gaf: Keysym = Keysym(XKB_KEY_Arabic_gaf); pub const Arabic_noon_ghunna: Keysym = Keysym(XKB_KEY_Arabic_noon_ghunna); pub const Arabic_heh_doachashmee: Keysym = Keysym(XKB_KEY_Arabic_heh_doachashmee); pub const Farsi_yeh: Keysym = Keysym(XKB_KEY_Farsi_yeh); pub const Arabic_farsi_yeh: Keysym = Keysym(XKB_KEY_Arabic_farsi_yeh); pub const Arabic_yeh_baree: Keysym = Keysym(XKB_KEY_Arabic_yeh_baree); pub const Arabic_heh_goal: Keysym = Keysym(XKB_KEY_Arabic_heh_goal); pub const Arabic_switch: Keysym = Keysym(XKB_KEY_Arabic_switch); pub const Cyrillic_GHE_bar: Keysym = Keysym(XKB_KEY_Cyrillic_GHE_bar); pub const Cyrillic_ghe_bar: Keysym = Keysym(XKB_KEY_Cyrillic_ghe_bar); pub const Cyrillic_ZHE_descender: Keysym = Keysym(XKB_KEY_Cyrillic_ZHE_descender); pub const Cyrillic_zhe_descender: Keysym = Keysym(XKB_KEY_Cyrillic_zhe_descender); pub const Cyrillic_KA_descender: Keysym = Keysym(XKB_KEY_Cyrillic_KA_descender); pub const Cyrillic_ka_descender: Keysym = Keysym(XKB_KEY_Cyrillic_ka_descender); pub const Cyrillic_KA_vertstroke: Keysym = Keysym(XKB_KEY_Cyrillic_KA_vertstroke); pub const Cyrillic_ka_vertstroke: Keysym = Keysym(XKB_KEY_Cyrillic_ka_vertstroke); pub const Cyrillic_EN_descender: Keysym = Keysym(XKB_KEY_Cyrillic_EN_descender); pub const Cyrillic_en_descender: Keysym = Keysym(XKB_KEY_Cyrillic_en_descender); pub const Cyrillic_U_straight: Keysym = Keysym(XKB_KEY_Cyrillic_U_straight); pub const Cyrillic_u_straight: Keysym = Keysym(XKB_KEY_Cyrillic_u_straight); pub const Cyrillic_U_straight_bar: Keysym = Keysym(XKB_KEY_Cyrillic_U_straight_bar); pub const Cyrillic_u_straight_bar: Keysym = Keysym(XKB_KEY_Cyrillic_u_straight_bar); pub const Cyrillic_HA_descender: Keysym = Keysym(XKB_KEY_Cyrillic_HA_descender); pub const Cyrillic_ha_descender: Keysym = Keysym(XKB_KEY_Cyrillic_ha_descender); pub const Cyrillic_CHE_descender: Keysym = Keysym(XKB_KEY_Cyrillic_CHE_descender); pub const Cyrillic_che_descender: Keysym = Keysym(XKB_KEY_Cyrillic_che_descender); pub const Cyrillic_CHE_vertstroke: Keysym = Keysym(XKB_KEY_Cyrillic_CHE_vertstroke); pub const Cyrillic_che_vertstroke: Keysym = Keysym(XKB_KEY_Cyrillic_che_vertstroke); pub const Cyrillic_SHHA: Keysym = Keysym(XKB_KEY_Cyrillic_SHHA); pub const Cyrillic_shha: Keysym = Keysym(XKB_KEY_Cyrillic_shha); pub const Cyrillic_SCHWA: Keysym = Keysym(XKB_KEY_Cyrillic_SCHWA); pub const Cyrillic_schwa: Keysym = Keysym(XKB_KEY_Cyrillic_schwa); pub const Cyrillic_I_macron: Keysym = Keysym(XKB_KEY_Cyrillic_I_macron); pub const Cyrillic_i_macron: Keysym = Keysym(XKB_KEY_Cyrillic_i_macron); pub const Cyrillic_O_bar: Keysym = Keysym(XKB_KEY_Cyrillic_O_bar); pub const Cyrillic_o_bar: Keysym = Keysym(XKB_KEY_Cyrillic_o_bar); pub const Cyrillic_U_macron: Keysym = Keysym(XKB_KEY_Cyrillic_U_macron); pub const Cyrillic_u_macron: Keysym = Keysym(XKB_KEY_Cyrillic_u_macron); pub const Serbian_dje: Keysym = Keysym(XKB_KEY_Serbian_dje); pub const Macedonia_gje: Keysym = Keysym(XKB_KEY_Macedonia_gje); pub const Cyrillic_io: Keysym = Keysym(XKB_KEY_Cyrillic_io); pub const Ukrainian_ie: Keysym = Keysym(XKB_KEY_Ukrainian_ie); pub const Ukranian_je: Keysym = Keysym(XKB_KEY_Ukranian_je); pub const Macedonia_dse: Keysym = Keysym(XKB_KEY_Macedonia_dse); pub const Ukrainian_i: Keysym = Keysym(XKB_KEY_Ukrainian_i); pub const Ukranian_i: Keysym = Keysym(XKB_KEY_Ukranian_i); pub const Ukrainian_yi: Keysym = Keysym(XKB_KEY_Ukrainian_yi); pub const Ukranian_yi: Keysym = Keysym(XKB_KEY_Ukranian_yi); pub const Cyrillic_je: Keysym = Keysym(XKB_KEY_Cyrillic_je); pub const Serbian_je: Keysym = Keysym(XKB_KEY_Serbian_je); pub const Cyrillic_lje: Keysym = Keysym(XKB_KEY_Cyrillic_lje); pub const Serbian_lje: Keysym = Keysym(XKB_KEY_Serbian_lje); pub const Cyrillic_nje: Keysym = Keysym(XKB_KEY_Cyrillic_nje); pub const Serbian_nje: Keysym = Keysym(XKB_KEY_Serbian_nje); pub const Serbian_tshe: Keysym = Keysym(XKB_KEY_Serbian_tshe); pub const Macedonia_kje: Keysym = Keysym(XKB_KEY_Macedonia_kje); pub const Ukrainian_ghe_with_upturn: Keysym = Keysym(XKB_KEY_Ukrainian_ghe_with_upturn); pub const Byelorussian_shortu: Keysym = Keysym(XKB_KEY_Byelorussian_shortu); pub const Cyrillic_dzhe: Keysym = Keysym(XKB_KEY_Cyrillic_dzhe); pub const Serbian_dze: Keysym = Keysym(XKB_KEY_Serbian_dze); pub const numerosign: Keysym = Keysym(XKB_KEY_numerosign); pub const Serbian_DJE: Keysym = Keysym(XKB_KEY_Serbian_DJE); pub const Macedonia_GJE: Keysym = Keysym(XKB_KEY_Macedonia_GJE); pub const Cyrillic_IO: Keysym = Keysym(XKB_KEY_Cyrillic_IO); pub const Ukrainian_IE: Keysym = Keysym(XKB_KEY_Ukrainian_IE); pub const Ukranian_JE: Keysym = Keysym(XKB_KEY_Ukranian_JE); pub const Macedonia_DSE: Keysym = Keysym(XKB_KEY_Macedonia_DSE); pub const Ukrainian_I: Keysym = Keysym(XKB_KEY_Ukrainian_I); pub const Ukranian_I: Keysym = Keysym(XKB_KEY_Ukranian_I); pub const Ukrainian_YI: Keysym = Keysym(XKB_KEY_Ukrainian_YI); pub const Ukranian_YI: Keysym = Keysym(XKB_KEY_Ukranian_YI); pub const Cyrillic_JE: Keysym = Keysym(XKB_KEY_Cyrillic_JE); pub const Serbian_JE: Keysym = Keysym(XKB_KEY_Serbian_JE); pub const Cyrillic_LJE: Keysym = Keysym(XKB_KEY_Cyrillic_LJE); pub const Serbian_LJE: Keysym = Keysym(XKB_KEY_Serbian_LJE); pub const Cyrillic_NJE: Keysym = Keysym(XKB_KEY_Cyrillic_NJE); pub const Serbian_NJE: Keysym = Keysym(XKB_KEY_Serbian_NJE); pub const Serbian_TSHE: Keysym = Keysym(XKB_KEY_Serbian_TSHE); pub const Macedonia_KJE: Keysym = Keysym(XKB_KEY_Macedonia_KJE); pub const Ukrainian_GHE_WITH_UPTURN: Keysym = Keysym(XKB_KEY_Ukrainian_GHE_WITH_UPTURN); pub const Byelorussian_SHORTU: Keysym = Keysym(XKB_KEY_Byelorussian_SHORTU); pub const Cyrillic_DZHE: Keysym = Keysym(XKB_KEY_Cyrillic_DZHE); pub const Serbian_DZE: Keysym = Keysym(XKB_KEY_Serbian_DZE); pub const Cyrillic_yu: Keysym = Keysym(XKB_KEY_Cyrillic_yu); pub const Cyrillic_a: Keysym = Keysym(XKB_KEY_Cyrillic_a); pub const Cyrillic_be: Keysym = Keysym(XKB_KEY_Cyrillic_be); pub const Cyrillic_tse: Keysym = Keysym(XKB_KEY_Cyrillic_tse); pub const Cyrillic_de: Keysym = Keysym(XKB_KEY_Cyrillic_de); pub const Cyrillic_ie: Keysym = Keysym(XKB_KEY_Cyrillic_ie); pub const Cyrillic_ef: Keysym = Keysym(XKB_KEY_Cyrillic_ef); pub const Cyrillic_ghe: Keysym = Keysym(XKB_KEY_Cyrillic_ghe); pub const Cyrillic_ha: Keysym = Keysym(XKB_KEY_Cyrillic_ha); pub const Cyrillic_i: Keysym = Keysym(XKB_KEY_Cyrillic_i); pub const Cyrillic_shorti: Keysym = Keysym(XKB_KEY_Cyrillic_shorti); pub const Cyrillic_ka: Keysym = Keysym(XKB_KEY_Cyrillic_ka); pub const Cyrillic_el: Keysym = Keysym(XKB_KEY_Cyrillic_el); pub const Cyrillic_em: Keysym = Keysym(XKB_KEY_Cyrillic_em); pub const Cyrillic_en: Keysym = Keysym(XKB_KEY_Cyrillic_en); pub const Cyrillic_o: Keysym = Keysym(XKB_KEY_Cyrillic_o); pub const Cyrillic_pe: Keysym = Keysym(XKB_KEY_Cyrillic_pe); pub const Cyrillic_ya: Keysym = Keysym(XKB_KEY_Cyrillic_ya); pub const Cyrillic_er: Keysym = Keysym(XKB_KEY_Cyrillic_er); pub const Cyrillic_es: Keysym = Keysym(XKB_KEY_Cyrillic_es); pub const Cyrillic_te: Keysym = Keysym(XKB_KEY_Cyrillic_te); pub const Cyrillic_u: Keysym = Keysym(XKB_KEY_Cyrillic_u); pub const Cyrillic_zhe: Keysym = Keysym(XKB_KEY_Cyrillic_zhe); pub const Cyrillic_ve: Keysym = Keysym(XKB_KEY_Cyrillic_ve); pub const Cyrillic_softsign: Keysym = Keysym(XKB_KEY_Cyrillic_softsign); pub const Cyrillic_yeru: Keysym = Keysym(XKB_KEY_Cyrillic_yeru); pub const Cyrillic_ze: Keysym = Keysym(XKB_KEY_Cyrillic_ze); pub const Cyrillic_sha: Keysym = Keysym(XKB_KEY_Cyrillic_sha); pub const Cyrillic_e: Keysym = Keysym(XKB_KEY_Cyrillic_e); pub const Cyrillic_shcha: Keysym = Keysym(XKB_KEY_Cyrillic_shcha); pub const Cyrillic_che: Keysym = Keysym(XKB_KEY_Cyrillic_che); pub const Cyrillic_hardsign: Keysym = Keysym(XKB_KEY_Cyrillic_hardsign); pub const Cyrillic_YU: Keysym = Keysym(XKB_KEY_Cyrillic_YU); pub const Cyrillic_A: Keysym = Keysym(XKB_KEY_Cyrillic_A); pub const Cyrillic_BE: Keysym = Keysym(XKB_KEY_Cyrillic_BE); pub const Cyrillic_TSE: Keysym = Keysym(XKB_KEY_Cyrillic_TSE); pub const Cyrillic_DE: Keysym = Keysym(XKB_KEY_Cyrillic_DE); pub const Cyrillic_IE: Keysym = Keysym(XKB_KEY_Cyrillic_IE); pub const Cyrillic_EF: Keysym = Keysym(XKB_KEY_Cyrillic_EF); pub const Cyrillic_GHE: Keysym = Keysym(XKB_KEY_Cyrillic_GHE); pub const Cyrillic_HA: Keysym = Keysym(XKB_KEY_Cyrillic_HA); pub const Cyrillic_I: Keysym = Keysym(XKB_KEY_Cyrillic_I); pub const Cyrillic_SHORTI: Keysym = Keysym(XKB_KEY_Cyrillic_SHORTI); pub const Cyrillic_KA: Keysym = Keysym(XKB_KEY_Cyrillic_KA); pub const Cyrillic_EL: Keysym = Keysym(XKB_KEY_Cyrillic_EL); pub const Cyrillic_EM: Keysym = Keysym(XKB_KEY_Cyrillic_EM); pub const Cyrillic_EN: Keysym = Keysym(XKB_KEY_Cyrillic_EN); pub const Cyrillic_O: Keysym = Keysym(XKB_KEY_Cyrillic_O); pub const Cyrillic_PE: Keysym = Keysym(XKB_KEY_Cyrillic_PE); pub const Cyrillic_YA: Keysym = Keysym(XKB_KEY_Cyrillic_YA); pub const Cyrillic_ER: Keysym = Keysym(XKB_KEY_Cyrillic_ER); pub const Cyrillic_ES: Keysym = Keysym(XKB_KEY_Cyrillic_ES); pub const Cyrillic_TE: Keysym = Keysym(XKB_KEY_Cyrillic_TE); pub const Cyrillic_U: Keysym = Keysym(XKB_KEY_Cyrillic_U); pub const Cyrillic_ZHE: Keysym = Keysym(XKB_KEY_Cyrillic_ZHE); pub const Cyrillic_VE: Keysym = Keysym(XKB_KEY_Cyrillic_VE); pub const Cyrillic_SOFTSIGN: Keysym = Keysym(XKB_KEY_Cyrillic_SOFTSIGN); pub const Cyrillic_YERU: Keysym = Keysym(XKB_KEY_Cyrillic_YERU); pub const Cyrillic_ZE: Keysym = Keysym(XKB_KEY_Cyrillic_ZE); pub const Cyrillic_SHA: Keysym = Keysym(XKB_KEY_Cyrillic_SHA); pub const Cyrillic_E: Keysym = Keysym(XKB_KEY_Cyrillic_E); pub const Cyrillic_SHCHA: Keysym = Keysym(XKB_KEY_Cyrillic_SHCHA); pub const Cyrillic_CHE: Keysym = Keysym(XKB_KEY_Cyrillic_CHE); pub const Cyrillic_HARDSIGN: Keysym = Keysym(XKB_KEY_Cyrillic_HARDSIGN); pub const Greek_ALPHAaccent: Keysym = Keysym(XKB_KEY_Greek_ALPHAaccent); pub const Greek_EPSILONaccent: Keysym = Keysym(XKB_KEY_Greek_EPSILONaccent); pub const Greek_ETAaccent: Keysym = Keysym(XKB_KEY_Greek_ETAaccent); pub const Greek_IOTAaccent: Keysym = Keysym(XKB_KEY_Greek_IOTAaccent); pub const Greek_IOTAdieresis: Keysym = Keysym(XKB_KEY_Greek_IOTAdieresis); pub const Greek_IOTAdiaeresis: Keysym = Keysym(XKB_KEY_Greek_IOTAdiaeresis); pub const Greek_OMICRONaccent: Keysym = Keysym(XKB_KEY_Greek_OMICRONaccent); pub const Greek_UPSILONaccent: Keysym = Keysym(XKB_KEY_Greek_UPSILONaccent); pub const Greek_UPSILONdieresis: Keysym = Keysym(XKB_KEY_Greek_UPSILONdieresis); pub const Greek_OMEGAaccent: Keysym = Keysym(XKB_KEY_Greek_OMEGAaccent); pub const Greek_accentdieresis: Keysym = Keysym(XKB_KEY_Greek_accentdieresis); pub const Greek_horizbar: Keysym = Keysym(XKB_KEY_Greek_horizbar); pub const Greek_alphaaccent: Keysym = Keysym(XKB_KEY_Greek_alphaaccent); pub const Greek_epsilonaccent: Keysym = Keysym(XKB_KEY_Greek_epsilonaccent); pub const Greek_etaaccent: Keysym = Keysym(XKB_KEY_Greek_etaaccent); pub const Greek_iotaaccent: Keysym = Keysym(XKB_KEY_Greek_iotaaccent); pub const Greek_iotadieresis: Keysym = Keysym(XKB_KEY_Greek_iotadieresis); pub const Greek_iotaaccentdieresis: Keysym = Keysym(XKB_KEY_Greek_iotaaccentdieresis); pub const Greek_omicronaccent: Keysym = Keysym(XKB_KEY_Greek_omicronaccent); pub const Greek_upsilonaccent: Keysym = Keysym(XKB_KEY_Greek_upsilonaccent); pub const Greek_upsilondieresis: Keysym = Keysym(XKB_KEY_Greek_upsilondieresis); pub const Greek_upsilonaccentdieresis: Keysym = Keysym(XKB_KEY_Greek_upsilonaccentdieresis); pub const Greek_omegaaccent: Keysym = Keysym(XKB_KEY_Greek_omegaaccent); pub const Greek_ALPHA: Keysym = Keysym(XKB_KEY_Greek_ALPHA); pub const Greek_BETA: Keysym = Keysym(XKB_KEY_Greek_BETA); pub const Greek_GAMMA: Keysym = Keysym(XKB_KEY_Greek_GAMMA); pub const Greek_DELTA: Keysym = Keysym(XKB_KEY_Greek_DELTA); pub const Greek_EPSILON: Keysym = Keysym(XKB_KEY_Greek_EPSILON); pub const Greek_ZETA: Keysym = Keysym(XKB_KEY_Greek_ZETA); pub const Greek_ETA: Keysym = Keysym(XKB_KEY_Greek_ETA); pub const Greek_THETA: Keysym = Keysym(XKB_KEY_Greek_THETA); pub const Greek_IOTA: Keysym = Keysym(XKB_KEY_Greek_IOTA); pub const Greek_KAPPA: Keysym = Keysym(XKB_KEY_Greek_KAPPA); pub const Greek_LAMDA: Keysym = Keysym(XKB_KEY_Greek_LAMDA); pub const Greek_LAMBDA: Keysym = Keysym(XKB_KEY_Greek_LAMBDA); pub const Greek_MU: Keysym = Keysym(XKB_KEY_Greek_MU); pub const Greek_NU: Keysym = Keysym(XKB_KEY_Greek_NU); pub const Greek_XI: Keysym = Keysym(XKB_KEY_Greek_XI); pub const Greek_OMICRON: Keysym = Keysym(XKB_KEY_Greek_OMICRON); pub const Greek_PI: Keysym = Keysym(XKB_KEY_Greek_PI); pub const Greek_RHO: Keysym = Keysym(XKB_KEY_Greek_RHO); pub const Greek_SIGMA: Keysym = Keysym(XKB_KEY_Greek_SIGMA); pub const Greek_TAU: Keysym = Keysym(XKB_KEY_Greek_TAU); pub const Greek_UPSILON: Keysym = Keysym(XKB_KEY_Greek_UPSILON); pub const Greek_PHI: Keysym = Keysym(XKB_KEY_Greek_PHI); pub const Greek_CHI: Keysym = Keysym(XKB_KEY_Greek_CHI); pub const Greek_PSI: Keysym = Keysym(XKB_KEY_Greek_PSI); pub const Greek_OMEGA: Keysym = Keysym(XKB_KEY_Greek_OMEGA); pub const Greek_alpha: Keysym = Keysym(XKB_KEY_Greek_alpha); pub const Greek_beta: Keysym = Keysym(XKB_KEY_Greek_beta); pub const Greek_gamma: Keysym = Keysym(XKB_KEY_Greek_gamma); pub const Greek_delta: Keysym = Keysym(XKB_KEY_Greek_delta); pub const Greek_epsilon: Keysym = Keysym(XKB_KEY_Greek_epsilon); pub const Greek_zeta: Keysym = Keysym(XKB_KEY_Greek_zeta); pub const Greek_eta: Keysym = Keysym(XKB_KEY_Greek_eta); pub const Greek_theta: Keysym = Keysym(XKB_KEY_Greek_theta); pub const Greek_iota: Keysym = Keysym(XKB_KEY_Greek_iota); pub const Greek_kappa: Keysym = Keysym(XKB_KEY_Greek_kappa); pub const Greek_lamda: Keysym = Keysym(XKB_KEY_Greek_lamda); pub const Greek_lambda: Keysym = Keysym(XKB_KEY_Greek_lambda); pub const Greek_mu: Keysym = Keysym(XKB_KEY_Greek_mu); pub const Greek_nu: Keysym = Keysym(XKB_KEY_Greek_nu); pub const Greek_xi: Keysym = Keysym(XKB_KEY_Greek_xi); pub const Greek_omicron: Keysym = Keysym(XKB_KEY_Greek_omicron); pub const Greek_pi: Keysym = Keysym(XKB_KEY_Greek_pi); pub const Greek_rho: Keysym = Keysym(XKB_KEY_Greek_rho); pub const Greek_sigma: Keysym = Keysym(XKB_KEY_Greek_sigma); pub const Greek_finalsmallsigma: Keysym = Keysym(XKB_KEY_Greek_finalsmallsigma); pub const Greek_tau: Keysym = Keysym(XKB_KEY_Greek_tau); pub const Greek_upsilon: Keysym = Keysym(XKB_KEY_Greek_upsilon); pub const Greek_phi: Keysym = Keysym(XKB_KEY_Greek_phi); pub const Greek_chi: Keysym = Keysym(XKB_KEY_Greek_chi); pub const Greek_psi: Keysym = Keysym(XKB_KEY_Greek_psi); pub const Greek_omega: Keysym = Keysym(XKB_KEY_Greek_omega); pub const Greek_switch: Keysym = Keysym(XKB_KEY_Greek_switch); pub const leftradical: Keysym = Keysym(XKB_KEY_leftradical); pub const topleftradical: Keysym = Keysym(XKB_KEY_topleftradical); pub const horizconnector: Keysym = Keysym(XKB_KEY_horizconnector); pub const topintegral: Keysym = Keysym(XKB_KEY_topintegral); pub const botintegral: Keysym = Keysym(XKB_KEY_botintegral); pub const vertconnector: Keysym = Keysym(XKB_KEY_vertconnector); pub const topleftsqbracket: Keysym = Keysym(XKB_KEY_topleftsqbracket); pub const botleftsqbracket: Keysym = Keysym(XKB_KEY_botleftsqbracket); pub const toprightsqbracket: Keysym = Keysym(XKB_KEY_toprightsqbracket); pub const botrightsqbracket: Keysym = Keysym(XKB_KEY_botrightsqbracket); pub const topleftparens: Keysym = Keysym(XKB_KEY_topleftparens); pub const botleftparens: Keysym = Keysym(XKB_KEY_botleftparens); pub const toprightparens: Keysym = Keysym(XKB_KEY_toprightparens); pub const botrightparens: Keysym = Keysym(XKB_KEY_botrightparens); pub const leftmiddlecurlybrace: Keysym = Keysym(XKB_KEY_leftmiddlecurlybrace); pub const rightmiddlecurlybrace: Keysym = Keysym(XKB_KEY_rightmiddlecurlybrace); pub const topleftsummation: Keysym = Keysym(XKB_KEY_topleftsummation); pub const botleftsummation: Keysym = Keysym(XKB_KEY_botleftsummation); pub const topvertsummationconnector: Keysym = Keysym(XKB_KEY_topvertsummationconnector); pub const botvertsummationconnector: Keysym = Keysym(XKB_KEY_botvertsummationconnector); pub const toprightsummation: Keysym = Keysym(XKB_KEY_toprightsummation); pub const botrightsummation: Keysym = Keysym(XKB_KEY_botrightsummation); pub const rightmiddlesummation: Keysym = Keysym(XKB_KEY_rightmiddlesummation); pub const lessthanequal: Keysym = Keysym(XKB_KEY_lessthanequal); pub const notequal: Keysym = Keysym(XKB_KEY_notequal); pub const greaterthanequal: Keysym = Keysym(XKB_KEY_greaterthanequal); pub const integral: Keysym = Keysym(XKB_KEY_integral); pub const therefore: Keysym = Keysym(XKB_KEY_therefore); pub const variation: Keysym = Keysym(XKB_KEY_variation); pub const infinity: Keysym = Keysym(XKB_KEY_infinity); pub const nabla: Keysym = Keysym(XKB_KEY_nabla); pub const approximate: Keysym = Keysym(XKB_KEY_approximate); pub const similarequal: Keysym = Keysym(XKB_KEY_similarequal); pub const ifonlyif: Keysym = Keysym(XKB_KEY_ifonlyif); pub const implies: Keysym = Keysym(XKB_KEY_implies); pub const identical: Keysym = Keysym(XKB_KEY_identical); pub const radical: Keysym = Keysym(XKB_KEY_radical); pub const includedin: Keysym = Keysym(XKB_KEY_includedin); pub const includes: Keysym = Keysym(XKB_KEY_includes); pub const intersection: Keysym = Keysym(XKB_KEY_intersection); pub const union: Keysym = Keysym(XKB_KEY_union); pub const logicaland: Keysym = Keysym(XKB_KEY_logicaland); pub const logicalor: Keysym = Keysym(XKB_KEY_logicalor); pub const partialderivative: Keysym = Keysym(XKB_KEY_partialderivative); pub const function: Keysym = Keysym(XKB_KEY_function); pub const leftarrow: Keysym = Keysym(XKB_KEY_leftarrow); pub const uparrow: Keysym = Keysym(XKB_KEY_uparrow); pub const rightarrow: Keysym = Keysym(XKB_KEY_rightarrow); pub const downarrow: Keysym = Keysym(XKB_KEY_downarrow); pub const blank: Keysym = Keysym(XKB_KEY_blank); pub const soliddiamond: Keysym = Keysym(XKB_KEY_soliddiamond); pub const checkerboard: Keysym = Keysym(XKB_KEY_checkerboard); pub const ht: Keysym = Keysym(XKB_KEY_ht); pub const ff: Keysym = Keysym(XKB_KEY_ff); pub const cr: Keysym = Keysym(XKB_KEY_cr); pub const lf: Keysym = Keysym(XKB_KEY_lf); pub const nl: Keysym = Keysym(XKB_KEY_nl); pub const vt: Keysym = Keysym(XKB_KEY_vt); pub const lowrightcorner: Keysym = Keysym(XKB_KEY_lowrightcorner); pub const uprightcorner: Keysym = Keysym(XKB_KEY_uprightcorner); pub const upleftcorner: Keysym = Keysym(XKB_KEY_upleftcorner); pub const lowleftcorner: Keysym = Keysym(XKB_KEY_lowleftcorner); pub const crossinglines: Keysym = Keysym(XKB_KEY_crossinglines); pub const horizlinescan1: Keysym = Keysym(XKB_KEY_horizlinescan1); pub const horizlinescan3: Keysym = Keysym(XKB_KEY_horizlinescan3); pub const horizlinescan5: Keysym = Keysym(XKB_KEY_horizlinescan5); pub const horizlinescan7: Keysym = Keysym(XKB_KEY_horizlinescan7); pub const horizlinescan9: Keysym = Keysym(XKB_KEY_horizlinescan9); pub const leftt: Keysym = Keysym(XKB_KEY_leftt); pub const rightt: Keysym = Keysym(XKB_KEY_rightt); pub const bott: Keysym = Keysym(XKB_KEY_bott); pub const topt: Keysym = Keysym(XKB_KEY_topt); pub const vertbar: Keysym = Keysym(XKB_KEY_vertbar); pub const emspace: Keysym = Keysym(XKB_KEY_emspace); pub const enspace: Keysym = Keysym(XKB_KEY_enspace); pub const em3space: Keysym = Keysym(XKB_KEY_em3space); pub const em4space: Keysym = Keysym(XKB_KEY_em4space); pub const digitspace: Keysym = Keysym(XKB_KEY_digitspace); pub const punctspace: Keysym = Keysym(XKB_KEY_punctspace); pub const thinspace: Keysym = Keysym(XKB_KEY_thinspace); pub const hairspace: Keysym = Keysym(XKB_KEY_hairspace); pub const emdash: Keysym = Keysym(XKB_KEY_emdash); pub const endash: Keysym = Keysym(XKB_KEY_endash); pub const signifblank: Keysym = Keysym(XKB_KEY_signifblank); pub const ellipsis: Keysym = Keysym(XKB_KEY_ellipsis); pub const doubbaselinedot: Keysym = Keysym(XKB_KEY_doubbaselinedot); pub const onethird: Keysym = Keysym(XKB_KEY_onethird); pub const twothirds: Keysym = Keysym(XKB_KEY_twothirds); pub const onefifth: Keysym = Keysym(XKB_KEY_onefifth); pub const twofifths: Keysym = Keysym(XKB_KEY_twofifths); pub const threefifths: Keysym = Keysym(XKB_KEY_threefifths); pub const fourfifths: Keysym = Keysym(XKB_KEY_fourfifths); pub const onesixth: Keysym = Keysym(XKB_KEY_onesixth); pub const fivesixths: Keysym = Keysym(XKB_KEY_fivesixths); pub const careof: Keysym = Keysym(XKB_KEY_careof); pub const figdash: Keysym = Keysym(XKB_KEY_figdash); pub const leftanglebracket: Keysym = Keysym(XKB_KEY_leftanglebracket); pub const decimalpoint: Keysym = Keysym(XKB_KEY_decimalpoint); pub const rightanglebracket: Keysym = Keysym(XKB_KEY_rightanglebracket); pub const marker: Keysym = Keysym(XKB_KEY_marker); pub const oneeighth: Keysym = Keysym(XKB_KEY_oneeighth); pub const threeeighths: Keysym = Keysym(XKB_KEY_threeeighths); pub const fiveeighths: Keysym = Keysym(XKB_KEY_fiveeighths); pub const seveneighths: Keysym = Keysym(XKB_KEY_seveneighths); pub const trademark: Keysym = Keysym(XKB_KEY_trademark); pub const signaturemark: Keysym = Keysym(XKB_KEY_signaturemark); pub const trademarkincircle: Keysym = Keysym(XKB_KEY_trademarkincircle); pub const leftopentriangle: Keysym = Keysym(XKB_KEY_leftopentriangle); pub const rightopentriangle: Keysym = Keysym(XKB_KEY_rightopentriangle); pub const emopencircle: Keysym = Keysym(XKB_KEY_emopencircle); pub const emopenrectangle: Keysym = Keysym(XKB_KEY_emopenrectangle); pub const leftsinglequotemark: Keysym = Keysym(XKB_KEY_leftsinglequotemark); pub const rightsinglequotemark: Keysym = Keysym(XKB_KEY_rightsinglequotemark); pub const leftdoublequotemark: Keysym = Keysym(XKB_KEY_leftdoublequotemark); pub const rightdoublequotemark: Keysym = Keysym(XKB_KEY_rightdoublequotemark); pub const prescription: Keysym = Keysym(XKB_KEY_prescription); pub const permille: Keysym = Keysym(XKB_KEY_permille); pub const minutes: Keysym = Keysym(XKB_KEY_minutes); pub const seconds: Keysym = Keysym(XKB_KEY_seconds); pub const latincross: Keysym = Keysym(XKB_KEY_latincross); pub const hexagram: Keysym = Keysym(XKB_KEY_hexagram); pub const filledrectbullet: Keysym = Keysym(XKB_KEY_filledrectbullet); pub const filledlefttribullet: Keysym = Keysym(XKB_KEY_filledlefttribullet); pub const filledrighttribullet: Keysym = Keysym(XKB_KEY_filledrighttribullet); pub const emfilledcircle: Keysym = Keysym(XKB_KEY_emfilledcircle); pub const emfilledrect: Keysym = Keysym(XKB_KEY_emfilledrect); pub const enopencircbullet: Keysym = Keysym(XKB_KEY_enopencircbullet); pub const enopensquarebullet: Keysym = Keysym(XKB_KEY_enopensquarebullet); pub const openrectbullet: Keysym = Keysym(XKB_KEY_openrectbullet); pub const opentribulletup: Keysym = Keysym(XKB_KEY_opentribulletup); pub const opentribulletdown: Keysym = Keysym(XKB_KEY_opentribulletdown); pub const openstar: Keysym = Keysym(XKB_KEY_openstar); pub const enfilledcircbullet: Keysym = Keysym(XKB_KEY_enfilledcircbullet); pub const enfilledsqbullet: Keysym = Keysym(XKB_KEY_enfilledsqbullet); pub const filledtribulletup: Keysym = Keysym(XKB_KEY_filledtribulletup); pub const filledtribulletdown: Keysym = Keysym(XKB_KEY_filledtribulletdown); pub const leftpointer: Keysym = Keysym(XKB_KEY_leftpointer); pub const rightpointer: Keysym = Keysym(XKB_KEY_rightpointer); pub const club: Keysym = Keysym(XKB_KEY_club); pub const diamond: Keysym = Keysym(XKB_KEY_diamond); pub const heart: Keysym = Keysym(XKB_KEY_heart); pub const maltesecross: Keysym = Keysym(XKB_KEY_maltesecross); pub const dagger: Keysym = Keysym(XKB_KEY_dagger); pub const doubledagger: Keysym = Keysym(XKB_KEY_doubledagger); pub const checkmark: Keysym = Keysym(XKB_KEY_checkmark); pub const ballotcross: Keysym = Keysym(XKB_KEY_ballotcross); pub const musicalsharp: Keysym = Keysym(XKB_KEY_musicalsharp); pub const musicalflat: Keysym = Keysym(XKB_KEY_musicalflat); pub const malesymbol: Keysym = Keysym(XKB_KEY_malesymbol); pub const femalesymbol: Keysym = Keysym(XKB_KEY_femalesymbol); pub const telephone: Keysym = Keysym(XKB_KEY_telephone); pub const telephonerecorder: Keysym = Keysym(XKB_KEY_telephonerecorder); pub const phonographcopyright: Keysym = Keysym(XKB_KEY_phonographcopyright); pub const caret: Keysym = Keysym(XKB_KEY_caret); pub const singlelowquotemark: Keysym = Keysym(XKB_KEY_singlelowquotemark); pub const doublelowquotemark: Keysym = Keysym(XKB_KEY_doublelowquotemark); pub const cursor: Keysym = Keysym(XKB_KEY_cursor); pub const leftcaret: Keysym = Keysym(XKB_KEY_leftcaret); pub const rightcaret: Keysym = Keysym(XKB_KEY_rightcaret); pub const downcaret: Keysym = Keysym(XKB_KEY_downcaret); pub const upcaret: Keysym = Keysym(XKB_KEY_upcaret); pub const overbar: Keysym = Keysym(XKB_KEY_overbar); pub const downtack: Keysym = Keysym(XKB_KEY_downtack); pub const upshoe: Keysym = Keysym(XKB_KEY_upshoe); pub const downstile: Keysym = Keysym(XKB_KEY_downstile); pub const underbar: Keysym = Keysym(XKB_KEY_underbar); pub const jot: Keysym = Keysym(XKB_KEY_jot); pub const quad: Keysym = Keysym(XKB_KEY_quad); pub const uptack: Keysym = Keysym(XKB_KEY_uptack); pub const circle: Keysym = Keysym(XKB_KEY_circle); pub const upstile: Keysym = Keysym(XKB_KEY_upstile); pub const downshoe: Keysym = Keysym(XKB_KEY_downshoe); pub const rightshoe: Keysym = Keysym(XKB_KEY_rightshoe); pub const leftshoe: Keysym = Keysym(XKB_KEY_leftshoe); pub const lefttack: Keysym = Keysym(XKB_KEY_lefttack); pub const righttack: Keysym = Keysym(XKB_KEY_righttack); pub const hebrew_doublelowline: Keysym = Keysym(XKB_KEY_hebrew_doublelowline); pub const hebrew_aleph: Keysym = Keysym(XKB_KEY_hebrew_aleph); pub const hebrew_bet: Keysym = Keysym(XKB_KEY_hebrew_bet); pub const hebrew_beth: Keysym = Keysym(XKB_KEY_hebrew_beth); pub const hebrew_gimel: Keysym = Keysym(XKB_KEY_hebrew_gimel); pub const hebrew_gimmel: Keysym = Keysym(XKB_KEY_hebrew_gimmel); pub const hebrew_dalet: Keysym = Keysym(XKB_KEY_hebrew_dalet); pub const hebrew_daleth: Keysym = Keysym(XKB_KEY_hebrew_daleth); pub const hebrew_he: Keysym = Keysym(XKB_KEY_hebrew_he); pub const hebrew_waw: Keysym = Keysym(XKB_KEY_hebrew_waw); pub const hebrew_zain: Keysym = Keysym(XKB_KEY_hebrew_zain); pub const hebrew_zayin: Keysym = Keysym(XKB_KEY_hebrew_zayin); pub const hebrew_chet: Keysym = Keysym(XKB_KEY_hebrew_chet); pub const hebrew_het: Keysym = Keysym(XKB_KEY_hebrew_het); pub const hebrew_tet: Keysym = Keysym(XKB_KEY_hebrew_tet); pub const hebrew_teth: Keysym = Keysym(XKB_KEY_hebrew_teth); pub const hebrew_yod: Keysym = Keysym(XKB_KEY_hebrew_yod); pub const hebrew_finalkaph: Keysym = Keysym(XKB_KEY_hebrew_finalkaph); pub const hebrew_kaph: Keysym = Keysym(XKB_KEY_hebrew_kaph); pub const hebrew_lamed: Keysym = Keysym(XKB_KEY_hebrew_lamed); pub const hebrew_finalmem: Keysym = Keysym(XKB_KEY_hebrew_finalmem); pub const hebrew_mem: Keysym = Keysym(XKB_KEY_hebrew_mem); pub const hebrew_finalnun: Keysym = Keysym(XKB_KEY_hebrew_finalnun); pub const hebrew_nun: Keysym = Keysym(XKB_KEY_hebrew_nun); pub const hebrew_samech: Keysym = Keysym(XKB_KEY_hebrew_samech); pub const hebrew_samekh: Keysym = Keysym(XKB_KEY_hebrew_samekh); pub const hebrew_ayin: Keysym = Keysym(XKB_KEY_hebrew_ayin); pub const hebrew_finalpe: Keysym = Keysym(XKB_KEY_hebrew_finalpe); pub const hebrew_pe: Keysym = Keysym(XKB_KEY_hebrew_pe); pub const hebrew_finalzade: Keysym = Keysym(XKB_KEY_hebrew_finalzade); pub const hebrew_finalzadi: Keysym = Keysym(XKB_KEY_hebrew_finalzadi); pub const hebrew_zade: Keysym = Keysym(XKB_KEY_hebrew_zade); pub const hebrew_zadi: Keysym = Keysym(XKB_KEY_hebrew_zadi); pub const hebrew_qoph: Keysym = Keysym(XKB_KEY_hebrew_qoph); pub const hebrew_kuf: Keysym = Keysym(XKB_KEY_hebrew_kuf); pub const hebrew_resh: Keysym = Keysym(XKB_KEY_hebrew_resh); pub const hebrew_shin: Keysym = Keysym(XKB_KEY_hebrew_shin); pub const hebrew_taw: Keysym = Keysym(XKB_KEY_hebrew_taw); pub const hebrew_taf: Keysym = Keysym(XKB_KEY_hebrew_taf); pub const Hebrew_switch: Keysym = Keysym(XKB_KEY_Hebrew_switch); pub const Thai_kokai: Keysym = Keysym(XKB_KEY_Thai_kokai); pub const Thai_khokhai: Keysym = Keysym(XKB_KEY_Thai_khokhai); pub const Thai_khokhuat: Keysym = Keysym(XKB_KEY_Thai_khokhuat); pub const Thai_khokhwai: Keysym = Keysym(XKB_KEY_Thai_khokhwai); pub const Thai_khokhon: Keysym = Keysym(XKB_KEY_Thai_khokhon); pub const Thai_khorakhang: Keysym = Keysym(XKB_KEY_Thai_khorakhang); pub const Thai_ngongu: Keysym = Keysym(XKB_KEY_Thai_ngongu); pub const Thai_chochan: Keysym = Keysym(XKB_KEY_Thai_chochan); pub const Thai_choching: Keysym = Keysym(XKB_KEY_Thai_choching); pub const Thai_chochang: Keysym = Keysym(XKB_KEY_Thai_chochang); pub const Thai_soso: Keysym = Keysym(XKB_KEY_Thai_soso); pub const Thai_chochoe: Keysym = Keysym(XKB_KEY_Thai_chochoe); pub const Thai_yoying: Keysym = Keysym(XKB_KEY_Thai_yoying); pub const Thai_dochada: Keysym = Keysym(XKB_KEY_Thai_dochada); pub const Thai_topatak: Keysym = Keysym(XKB_KEY_Thai_topatak); pub const Thai_thothan: Keysym = Keysym(XKB_KEY_Thai_thothan); pub const Thai_thonangmontho: Keysym = Keysym(XKB_KEY_Thai_thonangmontho); pub const Thai_thophuthao: Keysym = Keysym(XKB_KEY_Thai_thophuthao); pub const Thai_nonen: Keysym = Keysym(XKB_KEY_Thai_nonen); pub const Thai_dodek: Keysym = Keysym(XKB_KEY_Thai_dodek); pub const Thai_totao: Keysym = Keysym(XKB_KEY_Thai_totao); pub const Thai_thothung: Keysym = Keysym(XKB_KEY_Thai_thothung); pub const Thai_thothahan: Keysym = Keysym(XKB_KEY_Thai_thothahan); pub const Thai_thothong: Keysym = Keysym(XKB_KEY_Thai_thothong); pub const Thai_nonu: Keysym = Keysym(XKB_KEY_Thai_nonu); pub const Thai_bobaimai: Keysym = Keysym(XKB_KEY_Thai_bobaimai); pub const Thai_popla: Keysym = Keysym(XKB_KEY_Thai_popla); pub const Thai_phophung: Keysym = Keysym(XKB_KEY_Thai_phophung); pub const Thai_fofa: Keysym = Keysym(XKB_KEY_Thai_fofa); pub const Thai_phophan: Keysym = Keysym(XKB_KEY_Thai_phophan); pub const Thai_fofan: Keysym = Keysym(XKB_KEY_Thai_fofan); pub const Thai_phosamphao: Keysym = Keysym(XKB_KEY_Thai_phosamphao); pub const Thai_moma: Keysym = Keysym(XKB_KEY_Thai_moma); pub const Thai_yoyak: Keysym = Keysym(XKB_KEY_Thai_yoyak); pub const Thai_rorua: Keysym = Keysym(XKB_KEY_Thai_rorua); pub const Thai_ru: Keysym = Keysym(XKB_KEY_Thai_ru); pub const Thai_loling: Keysym = Keysym(XKB_KEY_Thai_loling); pub const Thai_lu: Keysym = Keysym(XKB_KEY_Thai_lu); pub const Thai_wowaen: Keysym = Keysym(XKB_KEY_Thai_wowaen); pub const Thai_sosala: Keysym = Keysym(XKB_KEY_Thai_sosala); pub const Thai_sorusi: Keysym = Keysym(XKB_KEY_Thai_sorusi); pub const Thai_sosua: Keysym = Keysym(XKB_KEY_Thai_sosua); pub const Thai_hohip: Keysym = Keysym(XKB_KEY_Thai_hohip); pub const Thai_lochula: Keysym = Keysym(XKB_KEY_Thai_lochula); pub const Thai_oang: Keysym = Keysym(XKB_KEY_Thai_oang); pub const Thai_honokhuk: Keysym = Keysym(XKB_KEY_Thai_honokhuk); pub const Thai_paiyannoi: Keysym = Keysym(XKB_KEY_Thai_paiyannoi); pub const Thai_saraa: Keysym = Keysym(XKB_KEY_Thai_saraa); pub const Thai_maihanakat: Keysym = Keysym(XKB_KEY_Thai_maihanakat); pub const Thai_saraaa: Keysym = Keysym(XKB_KEY_Thai_saraaa); pub const Thai_saraam: Keysym = Keysym(XKB_KEY_Thai_saraam); pub const Thai_sarai: Keysym = Keysym(XKB_KEY_Thai_sarai); pub const Thai_saraii: Keysym = Keysym(XKB_KEY_Thai_saraii); pub const Thai_saraue: Keysym = Keysym(XKB_KEY_Thai_saraue); pub const Thai_sarauee: Keysym = Keysym(XKB_KEY_Thai_sarauee); pub const Thai_sarau: Keysym = Keysym(XKB_KEY_Thai_sarau); pub const Thai_sarauu: Keysym = Keysym(XKB_KEY_Thai_sarauu); pub const Thai_phinthu: Keysym = Keysym(XKB_KEY_Thai_phinthu); pub const Thai_maihanakat_maitho: Keysym = Keysym(XKB_KEY_Thai_maihanakat_maitho); pub const Thai_baht: Keysym = Keysym(XKB_KEY_Thai_baht); pub const Thai_sarae: Keysym = Keysym(XKB_KEY_Thai_sarae); pub const Thai_saraae: Keysym = Keysym(XKB_KEY_Thai_saraae); pub const Thai_sarao: Keysym = Keysym(XKB_KEY_Thai_sarao); pub const Thai_saraaimaimuan: Keysym = Keysym(XKB_KEY_Thai_saraaimaimuan); pub const Thai_saraaimaimalai: Keysym = Keysym(XKB_KEY_Thai_saraaimaimalai); pub const Thai_lakkhangyao: Keysym = Keysym(XKB_KEY_Thai_lakkhangyao); pub const Thai_maiyamok: Keysym = Keysym(XKB_KEY_Thai_maiyamok); pub const Thai_maitaikhu: Keysym = Keysym(XKB_KEY_Thai_maitaikhu); pub const Thai_maiek: Keysym = Keysym(XKB_KEY_Thai_maiek); pub const Thai_maitho: Keysym = Keysym(XKB_KEY_Thai_maitho); pub const Thai_maitri: Keysym = Keysym(XKB_KEY_Thai_maitri); pub const Thai_maichattawa: Keysym = Keysym(XKB_KEY_Thai_maichattawa); pub const Thai_thanthakhat: Keysym = Keysym(XKB_KEY_Thai_thanthakhat); pub const Thai_nikhahit: Keysym = Keysym(XKB_KEY_Thai_nikhahit); pub const Thai_leksun: Keysym = Keysym(XKB_KEY_Thai_leksun); pub const Thai_leknung: Keysym = Keysym(XKB_KEY_Thai_leknung); pub const Thai_leksong: Keysym = Keysym(XKB_KEY_Thai_leksong); pub const Thai_leksam: Keysym = Keysym(XKB_KEY_Thai_leksam); pub const Thai_leksi: Keysym = Keysym(XKB_KEY_Thai_leksi); pub const Thai_lekha: Keysym = Keysym(XKB_KEY_Thai_lekha); pub const Thai_lekhok: Keysym = Keysym(XKB_KEY_Thai_lekhok); pub const Thai_lekchet: Keysym = Keysym(XKB_KEY_Thai_lekchet); pub const Thai_lekpaet: Keysym = Keysym(XKB_KEY_Thai_lekpaet); pub const Thai_lekkao: Keysym = Keysym(XKB_KEY_Thai_lekkao); pub const Hangul: Keysym = Keysym(XKB_KEY_Hangul); pub const Hangul_Start: Keysym = Keysym(XKB_KEY_Hangul_Start); pub const Hangul_End: Keysym = Keysym(XKB_KEY_Hangul_End); pub const Hangul_Hanja: Keysym = Keysym(XKB_KEY_Hangul_Hanja); pub const Hangul_Jamo: Keysym = Keysym(XKB_KEY_Hangul_Jamo); pub const Hangul_Romaja: Keysym = Keysym(XKB_KEY_Hangul_Romaja); pub const Hangul_Codeinput: Keysym = Keysym(XKB_KEY_Hangul_Codeinput); pub const Hangul_Jeonja: Keysym = Keysym(XKB_KEY_Hangul_Jeonja); pub const Hangul_Banja: Keysym = Keysym(XKB_KEY_Hangul_Banja); pub const Hangul_PreHanja: Keysym = Keysym(XKB_KEY_Hangul_PreHanja); pub const Hangul_PostHanja: Keysym = Keysym(XKB_KEY_Hangul_PostHanja); pub const Hangul_SingleCandidate: Keysym = Keysym(XKB_KEY_Hangul_SingleCandidate); pub const Hangul_MultipleCandidate: Keysym = Keysym(XKB_KEY_Hangul_MultipleCandidate); pub const Hangul_PreviousCandidate: Keysym = Keysym(XKB_KEY_Hangul_PreviousCandidate); pub const Hangul_Special: Keysym = Keysym(XKB_KEY_Hangul_Special); pub const Hangul_switch: Keysym = Keysym(XKB_KEY_Hangul_switch); pub const Hangul_Kiyeog: Keysym = Keysym(XKB_KEY_Hangul_Kiyeog); pub const Hangul_SsangKiyeog: Keysym = Keysym(XKB_KEY_Hangul_SsangKiyeog); pub const Hangul_KiyeogSios: Keysym = Keysym(XKB_KEY_Hangul_KiyeogSios); pub const Hangul_Nieun: Keysym = Keysym(XKB_KEY_Hangul_Nieun); pub const Hangul_NieunJieuj: Keysym = Keysym(XKB_KEY_Hangul_NieunJieuj); pub const Hangul_NieunHieuh: Keysym = Keysym(XKB_KEY_Hangul_NieunHieuh); pub const Hangul_Dikeud: Keysym = Keysym(XKB_KEY_Hangul_Dikeud); pub const Hangul_SsangDikeud: Keysym = Keysym(XKB_KEY_Hangul_SsangDikeud); pub const Hangul_Rieul: Keysym = Keysym(XKB_KEY_Hangul_Rieul); pub const Hangul_RieulKiyeog: Keysym = Keysym(XKB_KEY_Hangul_RieulKiyeog); pub const Hangul_RieulMieum: Keysym = Keysym(XKB_KEY_Hangul_RieulMieum); pub const Hangul_RieulPieub: Keysym = Keysym(XKB_KEY_Hangul_RieulPieub); pub const Hangul_RieulSios: Keysym = Keysym(XKB_KEY_Hangul_RieulSios); pub const Hangul_RieulTieut: Keysym = Keysym(XKB_KEY_Hangul_RieulTieut); pub const Hangul_RieulPhieuf: Keysym = Keysym(XKB_KEY_Hangul_RieulPhieuf); pub const Hangul_RieulHieuh: Keysym = Keysym(XKB_KEY_Hangul_RieulHieuh); pub const Hangul_Mieum: Keysym = Keysym(XKB_KEY_Hangul_Mieum); pub const Hangul_Pieub: Keysym = Keysym(XKB_KEY_Hangul_Pieub); pub const Hangul_SsangPieub: Keysym = Keysym(XKB_KEY_Hangul_SsangPieub); pub const Hangul_PieubSios: Keysym = Keysym(XKB_KEY_Hangul_PieubSios); pub const Hangul_Sios: Keysym = Keysym(XKB_KEY_Hangul_Sios); pub const Hangul_SsangSios: Keysym = Keysym(XKB_KEY_Hangul_SsangSios); pub const Hangul_Ieung: Keysym = Keysym(XKB_KEY_Hangul_Ieung); pub const Hangul_Jieuj: Keysym = Keysym(XKB_KEY_Hangul_Jieuj); pub const Hangul_SsangJieuj: Keysym = Keysym(XKB_KEY_Hangul_SsangJieuj); pub const Hangul_Cieuc: Keysym = Keysym(XKB_KEY_Hangul_Cieuc); pub const Hangul_Khieuq: Keysym = Keysym(XKB_KEY_Hangul_Khieuq); pub const Hangul_Tieut: Keysym = Keysym(XKB_KEY_Hangul_Tieut); pub const Hangul_Phieuf: Keysym = Keysym(XKB_KEY_Hangul_Phieuf); pub const Hangul_Hieuh: Keysym = Keysym(XKB_KEY_Hangul_Hieuh); pub const Hangul_A: Keysym = Keysym(XKB_KEY_Hangul_A); pub const Hangul_AE: Keysym = Keysym(XKB_KEY_Hangul_AE); pub const Hangul_YA: Keysym = Keysym(XKB_KEY_Hangul_YA); pub const Hangul_YAE: Keysym = Keysym(XKB_KEY_Hangul_YAE); pub const Hangul_EO: Keysym = Keysym(XKB_KEY_Hangul_EO); pub const Hangul_E: Keysym = Keysym(XKB_KEY_Hangul_E); pub const Hangul_YEO: Keysym = Keysym(XKB_KEY_Hangul_YEO); pub const Hangul_YE: Keysym = Keysym(XKB_KEY_Hangul_YE); pub const Hangul_O: Keysym = Keysym(XKB_KEY_Hangul_O); pub const Hangul_WA: Keysym = Keysym(XKB_KEY_Hangul_WA); pub const Hangul_WAE: Keysym = Keysym(XKB_KEY_Hangul_WAE); pub const Hangul_OE: Keysym = Keysym(XKB_KEY_Hangul_OE); pub const Hangul_YO: Keysym = Keysym(XKB_KEY_Hangul_YO); pub const Hangul_U: Keysym = Keysym(XKB_KEY_Hangul_U); pub const Hangul_WEO: Keysym = Keysym(XKB_KEY_Hangul_WEO); pub const Hangul_WE: Keysym = Keysym(XKB_KEY_Hangul_WE); pub const Hangul_WI: Keysym = Keysym(XKB_KEY_Hangul_WI); pub const Hangul_YU: Keysym = Keysym(XKB_KEY_Hangul_YU); pub const Hangul_EU: Keysym = Keysym(XKB_KEY_Hangul_EU); pub const Hangul_YI: Keysym = Keysym(XKB_KEY_Hangul_YI); pub const Hangul_I: Keysym = Keysym(XKB_KEY_Hangul_I); pub const Hangul_J_Kiyeog: Keysym = Keysym(XKB_KEY_Hangul_J_Kiyeog); pub const Hangul_J_SsangKiyeog: Keysym = Keysym(XKB_KEY_Hangul_J_SsangKiyeog); pub const Hangul_J_KiyeogSios: Keysym = Keysym(XKB_KEY_Hangul_J_KiyeogSios); pub const Hangul_J_Nieun: Keysym = Keysym(XKB_KEY_Hangul_J_Nieun); pub const Hangul_J_NieunJieuj: Keysym = Keysym(XKB_KEY_Hangul_J_NieunJieuj); pub const Hangul_J_NieunHieuh: Keysym = Keysym(XKB_KEY_Hangul_J_NieunHieuh); pub const Hangul_J_Dikeud: Keysym = Keysym(XKB_KEY_Hangul_J_Dikeud); pub const Hangul_J_Rieul: Keysym = Keysym(XKB_KEY_Hangul_J_Rieul); pub const Hangul_J_RieulKiyeog: Keysym = Keysym(XKB_KEY_Hangul_J_RieulKiyeog); pub const Hangul_J_RieulMieum: Keysym = Keysym(XKB_KEY_Hangul_J_RieulMieum); pub const Hangul_J_RieulPieub: Keysym = Keysym(XKB_KEY_Hangul_J_RieulPieub); pub const Hangul_J_RieulSios: Keysym = Keysym(XKB_KEY_Hangul_J_RieulSios); pub const Hangul_J_RieulTieut: Keysym = Keysym(XKB_KEY_Hangul_J_RieulTieut); pub const Hangul_J_RieulPhieuf: Keysym = Keysym(XKB_KEY_Hangul_J_RieulPhieuf); pub const Hangul_J_RieulHieuh: Keysym = Keysym(XKB_KEY_Hangul_J_RieulHieuh); pub const Hangul_J_Mieum: Keysym = Keysym(XKB_KEY_Hangul_J_Mieum); pub const Hangul_J_Pieub: Keysym = Keysym(XKB_KEY_Hangul_J_Pieub); pub const Hangul_J_PieubSios: Keysym = Keysym(XKB_KEY_Hangul_J_PieubSios); pub const Hangul_J_Sios: Keysym = Keysym(XKB_KEY_Hangul_J_Sios); pub const Hangul_J_SsangSios: Keysym = Keysym(XKB_KEY_Hangul_J_SsangSios); pub const Hangul_J_Ieung: Keysym = Keysym(XKB_KEY_Hangul_J_Ieung); pub const Hangul_J_Jieuj: Keysym = Keysym(XKB_KEY_Hangul_J_Jieuj); pub const Hangul_J_Cieuc: Keysym = Keysym(XKB_KEY_Hangul_J_Cieuc); pub const Hangul_J_Khieuq: Keysym = Keysym(XKB_KEY_Hangul_J_Khieuq); pub const Hangul_J_Tieut: Keysym = Keysym(XKB_KEY_Hangul_J_Tieut); pub const Hangul_J_Phieuf: Keysym = Keysym(XKB_KEY_Hangul_J_Phieuf); pub const Hangul_J_Hieuh: Keysym = Keysym(XKB_KEY_Hangul_J_Hieuh); pub const Hangul_RieulYeorinHieuh: Keysym = Keysym(XKB_KEY_Hangul_RieulYeorinHieuh); pub const Hangul_SunkyeongeumMieum: Keysym = Keysym(XKB_KEY_Hangul_SunkyeongeumMieum); pub const Hangul_SunkyeongeumPieub: Keysym = Keysym(XKB_KEY_Hangul_SunkyeongeumPieub); pub const Hangul_PanSios: Keysym = Keysym(XKB_KEY_Hangul_PanSios); pub const Hangul_KkogjiDalrinIeung: Keysym = Keysym(XKB_KEY_Hangul_KkogjiDalrinIeung); pub const Hangul_SunkyeongeumPhieuf: Keysym = Keysym(XKB_KEY_Hangul_SunkyeongeumPhieuf); pub const Hangul_YeorinHieuh: Keysym = Keysym(XKB_KEY_Hangul_YeorinHieuh); pub const Hangul_AraeA: Keysym = Keysym(XKB_KEY_Hangul_AraeA); pub const Hangul_AraeAE: Keysym = Keysym(XKB_KEY_Hangul_AraeAE); pub const Hangul_J_PanSios: Keysym = Keysym(XKB_KEY_Hangul_J_PanSios); pub const Hangul_J_KkogjiDalrinIeung: Keysym = Keysym(XKB_KEY_Hangul_J_KkogjiDalrinIeung); pub const Hangul_J_YeorinHieuh: Keysym = Keysym(XKB_KEY_Hangul_J_YeorinHieuh); pub const Korean_Won: Keysym = Keysym(XKB_KEY_Korean_Won); pub const Armenian_ligature_ew: Keysym = Keysym(XKB_KEY_Armenian_ligature_ew); pub const Armenian_full_stop: Keysym = Keysym(XKB_KEY_Armenian_full_stop); pub const Armenian_verjaket: Keysym = Keysym(XKB_KEY_Armenian_verjaket); pub const Armenian_separation_mark: Keysym = Keysym(XKB_KEY_Armenian_separation_mark); pub const Armenian_but: Keysym = Keysym(XKB_KEY_Armenian_but); pub const Armenian_hyphen: Keysym = Keysym(XKB_KEY_Armenian_hyphen); pub const Armenian_yentamna: Keysym = Keysym(XKB_KEY_Armenian_yentamna); pub const Armenian_exclam: Keysym = Keysym(XKB_KEY_Armenian_exclam); pub const Armenian_amanak: Keysym = Keysym(XKB_KEY_Armenian_amanak); pub const Armenian_accent: Keysym = Keysym(XKB_KEY_Armenian_accent); pub const Armenian_shesht: Keysym = Keysym(XKB_KEY_Armenian_shesht); pub const Armenian_question: Keysym = Keysym(XKB_KEY_Armenian_question); pub const Armenian_paruyk: Keysym = Keysym(XKB_KEY_Armenian_paruyk); pub const Armenian_AYB: Keysym = Keysym(XKB_KEY_Armenian_AYB); pub const Armenian_ayb: Keysym = Keysym(XKB_KEY_Armenian_ayb); pub const Armenian_BEN: Keysym = Keysym(XKB_KEY_Armenian_BEN); pub const Armenian_ben: Keysym = Keysym(XKB_KEY_Armenian_ben); pub const Armenian_GIM: Keysym = Keysym(XKB_KEY_Armenian_GIM); pub const Armenian_gim: Keysym = Keysym(XKB_KEY_Armenian_gim); pub const Armenian_DA: Keysym = Keysym(XKB_KEY_Armenian_DA); pub const Armenian_da: Keysym = Keysym(XKB_KEY_Armenian_da); pub const Armenian_YECH: Keysym = Keysym(XKB_KEY_Armenian_YECH); pub const Armenian_yech: Keysym = Keysym(XKB_KEY_Armenian_yech); pub const Armenian_ZA: Keysym = Keysym(XKB_KEY_Armenian_ZA); pub const Armenian_za: Keysym = Keysym(XKB_KEY_Armenian_za); pub const Armenian_E: Keysym = Keysym(XKB_KEY_Armenian_E); pub const Armenian_e: Keysym = Keysym(XKB_KEY_Armenian_e); pub const Armenian_AT: Keysym = Keysym(XKB_KEY_Armenian_AT); pub const Armenian_at: Keysym = Keysym(XKB_KEY_Armenian_at); pub const Armenian_TO: Keysym = Keysym(XKB_KEY_Armenian_TO); pub const Armenian_to: Keysym = Keysym(XKB_KEY_Armenian_to); pub const Armenian_ZHE: Keysym = Keysym(XKB_KEY_Armenian_ZHE); pub const Armenian_zhe: Keysym = Keysym(XKB_KEY_Armenian_zhe); pub const Armenian_INI: Keysym = Keysym(XKB_KEY_Armenian_INI); pub const Armenian_ini: Keysym = Keysym(XKB_KEY_Armenian_ini); pub const Armenian_LYUN: Keysym = Keysym(XKB_KEY_Armenian_LYUN); pub const Armenian_lyun: Keysym = Keysym(XKB_KEY_Armenian_lyun); pub const Armenian_KHE: Keysym = Keysym(XKB_KEY_Armenian_KHE); pub const Armenian_khe: Keysym = Keysym(XKB_KEY_Armenian_khe); pub const Armenian_TSA: Keysym = Keysym(XKB_KEY_Armenian_TSA); pub const Armenian_tsa: Keysym = Keysym(XKB_KEY_Armenian_tsa); pub const Armenian_KEN: Keysym = Keysym(XKB_KEY_Armenian_KEN); pub const Armenian_ken: Keysym = Keysym(XKB_KEY_Armenian_ken); pub const Armenian_HO: Keysym = Keysym(XKB_KEY_Armenian_HO); pub const Armenian_ho: Keysym = Keysym(XKB_KEY_Armenian_ho); pub const Armenian_DZA: Keysym = Keysym(XKB_KEY_Armenian_DZA); pub const Armenian_dza: Keysym = Keysym(XKB_KEY_Armenian_dza); pub const Armenian_GHAT: Keysym = Keysym(XKB_KEY_Armenian_GHAT); pub const Armenian_ghat: Keysym = Keysym(XKB_KEY_Armenian_ghat); pub const Armenian_TCHE: Keysym = Keysym(XKB_KEY_Armenian_TCHE); pub const Armenian_tche: Keysym = Keysym(XKB_KEY_Armenian_tche); pub const Armenian_MEN: Keysym = Keysym(XKB_KEY_Armenian_MEN); pub const Armenian_men: Keysym = Keysym(XKB_KEY_Armenian_men); pub const Armenian_HI: Keysym = Keysym(XKB_KEY_Armenian_HI); pub const Armenian_hi: Keysym = Keysym(XKB_KEY_Armenian_hi); pub const Armenian_NU: Keysym = Keysym(XKB_KEY_Armenian_NU); pub const Armenian_nu: Keysym = Keysym(XKB_KEY_Armenian_nu); pub const Armenian_SHA: Keysym = Keysym(XKB_KEY_Armenian_SHA); pub const Armenian_sha: Keysym = Keysym(XKB_KEY_Armenian_sha); pub const Armenian_VO: Keysym = Keysym(XKB_KEY_Armenian_VO); pub const Armenian_vo: Keysym = Keysym(XKB_KEY_Armenian_vo); pub const Armenian_CHA: Keysym = Keysym(XKB_KEY_Armenian_CHA); pub const Armenian_cha: Keysym = Keysym(XKB_KEY_Armenian_cha); pub const Armenian_PE: Keysym = Keysym(XKB_KEY_Armenian_PE); pub const Armenian_pe: Keysym = Keysym(XKB_KEY_Armenian_pe); pub const Armenian_JE: Keysym = Keysym(XKB_KEY_Armenian_JE); pub const Armenian_je: Keysym = Keysym(XKB_KEY_Armenian_je); pub const Armenian_RA: Keysym = Keysym(XKB_KEY_Armenian_RA); pub const Armenian_ra: Keysym = Keysym(XKB_KEY_Armenian_ra); pub const Armenian_SE: Keysym = Keysym(XKB_KEY_Armenian_SE); pub const Armenian_se: Keysym = Keysym(XKB_KEY_Armenian_se); pub const Armenian_VEV: Keysym = Keysym(XKB_KEY_Armenian_VEV); pub const Armenian_vev: Keysym = Keysym(XKB_KEY_Armenian_vev); pub const Armenian_TYUN: Keysym = Keysym(XKB_KEY_Armenian_TYUN); pub const Armenian_tyun: Keysym = Keysym(XKB_KEY_Armenian_tyun); pub const Armenian_RE: Keysym = Keysym(XKB_KEY_Armenian_RE); pub const Armenian_re: Keysym = Keysym(XKB_KEY_Armenian_re); pub const Armenian_TSO: Keysym = Keysym(XKB_KEY_Armenian_TSO); pub const Armenian_tso: Keysym = Keysym(XKB_KEY_Armenian_tso); pub const Armenian_VYUN: Keysym = Keysym(XKB_KEY_Armenian_VYUN); pub const Armenian_vyun: Keysym = Keysym(XKB_KEY_Armenian_vyun); pub const Armenian_PYUR: Keysym = Keysym(XKB_KEY_Armenian_PYUR); pub const Armenian_pyur: Keysym = Keysym(XKB_KEY_Armenian_pyur); pub const Armenian_KE: Keysym = Keysym(XKB_KEY_Armenian_KE); pub const Armenian_ke: Keysym = Keysym(XKB_KEY_Armenian_ke); pub const Armenian_O: Keysym = Keysym(XKB_KEY_Armenian_O); pub const Armenian_o: Keysym = Keysym(XKB_KEY_Armenian_o); pub const Armenian_FE: Keysym = Keysym(XKB_KEY_Armenian_FE); pub const Armenian_fe: Keysym = Keysym(XKB_KEY_Armenian_fe); pub const Armenian_apostrophe: Keysym = Keysym(XKB_KEY_Armenian_apostrophe); pub const Georgian_an: Keysym = Keysym(XKB_KEY_Georgian_an); pub const Georgian_ban: Keysym = Keysym(XKB_KEY_Georgian_ban); pub const Georgian_gan: Keysym = Keysym(XKB_KEY_Georgian_gan); pub const Georgian_don: Keysym = Keysym(XKB_KEY_Georgian_don); pub const Georgian_en: Keysym = Keysym(XKB_KEY_Georgian_en); pub const Georgian_vin: Keysym = Keysym(XKB_KEY_Georgian_vin); pub const Georgian_zen: Keysym = Keysym(XKB_KEY_Georgian_zen); pub const Georgian_tan: Keysym = Keysym(XKB_KEY_Georgian_tan); pub const Georgian_in: Keysym = Keysym(XKB_KEY_Georgian_in); pub const Georgian_kan: Keysym = Keysym(XKB_KEY_Georgian_kan); pub const Georgian_las: Keysym = Keysym(XKB_KEY_Georgian_las); pub const Georgian_man: Keysym = Keysym(XKB_KEY_Georgian_man); pub const Georgian_nar: Keysym = Keysym(XKB_KEY_Georgian_nar); pub const Georgian_on: Keysym = Keysym(XKB_KEY_Georgian_on); pub const Georgian_par: Keysym = Keysym(XKB_KEY_Georgian_par); pub const Georgian_zhar: Keysym = Keysym(XKB_KEY_Georgian_zhar); pub const Georgian_rae: Keysym = Keysym(XKB_KEY_Georgian_rae); pub const Georgian_san: Keysym = Keysym(XKB_KEY_Georgian_san); pub const Georgian_tar: Keysym = Keysym(XKB_KEY_Georgian_tar); pub const Georgian_un: Keysym = Keysym(XKB_KEY_Georgian_un); pub const Georgian_phar: Keysym = Keysym(XKB_KEY_Georgian_phar); pub const Georgian_khar: Keysym = Keysym(XKB_KEY_Georgian_khar); pub const Georgian_ghan: Keysym = Keysym(XKB_KEY_Georgian_ghan); pub const Georgian_qar: Keysym = Keysym(XKB_KEY_Georgian_qar); pub const Georgian_shin: Keysym = Keysym(XKB_KEY_Georgian_shin); pub const Georgian_chin: Keysym = Keysym(XKB_KEY_Georgian_chin); pub const Georgian_can: Keysym = Keysym(XKB_KEY_Georgian_can); pub const Georgian_jil: Keysym = Keysym(XKB_KEY_Georgian_jil); pub const Georgian_cil: Keysym = Keysym(XKB_KEY_Georgian_cil); pub const Georgian_char: Keysym = Keysym(XKB_KEY_Georgian_char); pub const Georgian_xan: Keysym = Keysym(XKB_KEY_Georgian_xan); pub const Georgian_jhan: Keysym = Keysym(XKB_KEY_Georgian_jhan); pub const Georgian_hae: Keysym = Keysym(XKB_KEY_Georgian_hae); pub const Georgian_he: Keysym = Keysym(XKB_KEY_Georgian_he); pub const Georgian_hie: Keysym = Keysym(XKB_KEY_Georgian_hie); pub const Georgian_we: Keysym = Keysym(XKB_KEY_Georgian_we); pub const Georgian_har: Keysym = Keysym(XKB_KEY_Georgian_har); pub const Georgian_hoe: Keysym = Keysym(XKB_KEY_Georgian_hoe); pub const Georgian_fi: Keysym = Keysym(XKB_KEY_Georgian_fi); pub const Xabovedot: Keysym = Keysym(XKB_KEY_Xabovedot); pub const Ibreve: Keysym = Keysym(XKB_KEY_Ibreve); pub const Zstroke: Keysym = Keysym(XKB_KEY_Zstroke); pub const Gcaron: Keysym = Keysym(XKB_KEY_Gcaron); pub const Ocaron: Keysym = Keysym(XKB_KEY_Ocaron); pub const Obarred: Keysym = Keysym(XKB_KEY_Obarred); pub const xabovedot: Keysym = Keysym(XKB_KEY_xabovedot); pub const ibreve: Keysym = Keysym(XKB_KEY_ibreve); pub const zstroke: Keysym = Keysym(XKB_KEY_zstroke); pub const gcaron: Keysym = Keysym(XKB_KEY_gcaron); pub const ocaron: Keysym = Keysym(XKB_KEY_ocaron); pub const obarred: Keysym = Keysym(XKB_KEY_obarred); pub const SCHWA: Keysym = Keysym(XKB_KEY_SCHWA); pub const schwa: Keysym = Keysym(XKB_KEY_schwa); pub const EZH: Keysym = Keysym(XKB_KEY_EZH); pub const ezh: Keysym = Keysym(XKB_KEY_ezh); pub const Lbelowdot: Keysym = Keysym(XKB_KEY_Lbelowdot); pub const lbelowdot: Keysym = Keysym(XKB_KEY_lbelowdot); pub const Abelowdot: Keysym = Keysym(XKB_KEY_Abelowdot); pub const abelowdot: Keysym = Keysym(XKB_KEY_abelowdot); pub const Ahook: Keysym = Keysym(XKB_KEY_Ahook); pub const ahook: Keysym = Keysym(XKB_KEY_ahook); pub const Acircumflexacute: Keysym = Keysym(XKB_KEY_Acircumflexacute); pub const acircumflexacute: Keysym = Keysym(XKB_KEY_acircumflexacute); pub const Acircumflexgrave: Keysym = Keysym(XKB_KEY_Acircumflexgrave); pub const acircumflexgrave: Keysym = Keysym(XKB_KEY_acircumflexgrave); pub const Acircumflexhook: Keysym = Keysym(XKB_KEY_Acircumflexhook); pub const acircumflexhook: Keysym = Keysym(XKB_KEY_acircumflexhook); pub const Acircumflextilde: Keysym = Keysym(XKB_KEY_Acircumflextilde); pub const acircumflextilde: Keysym = Keysym(XKB_KEY_acircumflextilde); pub const Acircumflexbelowdot: Keysym = Keysym(XKB_KEY_Acircumflexbelowdot); pub const acircumflexbelowdot: Keysym = Keysym(XKB_KEY_acircumflexbelowdot); pub const Abreveacute: Keysym = Keysym(XKB_KEY_Abreveacute); pub const abreveacute: Keysym = Keysym(XKB_KEY_abreveacute); pub const Abrevegrave: Keysym = Keysym(XKB_KEY_Abrevegrave); pub const abrevegrave: Keysym = Keysym(XKB_KEY_abrevegrave); pub const Abrevehook: Keysym = Keysym(XKB_KEY_Abrevehook); pub const abrevehook: Keysym = Keysym(XKB_KEY_abrevehook); pub const Abrevetilde: Keysym = Keysym(XKB_KEY_Abrevetilde); pub const abrevetilde: Keysym = Keysym(XKB_KEY_abrevetilde); pub const Abrevebelowdot: Keysym = Keysym(XKB_KEY_Abrevebelowdot); pub const abrevebelowdot: Keysym = Keysym(XKB_KEY_abrevebelowdot); pub const Ebelowdot: Keysym = Keysym(XKB_KEY_Ebelowdot); pub const ebelowdot: Keysym = Keysym(XKB_KEY_ebelowdot); pub const Ehook: Keysym = Keysym(XKB_KEY_Ehook); pub const ehook: Keysym = Keysym(XKB_KEY_ehook); pub const Etilde: Keysym = Keysym(XKB_KEY_Etilde); pub const etilde: Keysym = Keysym(XKB_KEY_etilde); pub const Ecircumflexacute: Keysym = Keysym(XKB_KEY_Ecircumflexacute); pub const ecircumflexacute: Keysym = Keysym(XKB_KEY_ecircumflexacute); pub const Ecircumflexgrave: Keysym = Keysym(XKB_KEY_Ecircumflexgrave); pub const ecircumflexgrave: Keysym = Keysym(XKB_KEY_ecircumflexgrave); pub const Ecircumflexhook: Keysym = Keysym(XKB_KEY_Ecircumflexhook); pub const ecircumflexhook: Keysym = Keysym(XKB_KEY_ecircumflexhook); pub const Ecircumflextilde: Keysym = Keysym(XKB_KEY_Ecircumflextilde); pub const ecircumflextilde: Keysym = Keysym(XKB_KEY_ecircumflextilde); pub const Ecircumflexbelowdot: Keysym = Keysym(XKB_KEY_Ecircumflexbelowdot); pub const ecircumflexbelowdot: Keysym = Keysym(XKB_KEY_ecircumflexbelowdot); pub const Ihook: Keysym = Keysym(XKB_KEY_Ihook); pub const ihook: Keysym = Keysym(XKB_KEY_ihook); pub const Ibelowdot: Keysym = Keysym(XKB_KEY_Ibelowdot); pub const ibelowdot: Keysym = Keysym(XKB_KEY_ibelowdot); pub const Obelowdot: Keysym = Keysym(XKB_KEY_Obelowdot); pub const obelowdot: Keysym = Keysym(XKB_KEY_obelowdot); pub const Ohook: Keysym = Keysym(XKB_KEY_Ohook); pub const ohook: Keysym = Keysym(XKB_KEY_ohook); pub const Ocircumflexacute: Keysym = Keysym(XKB_KEY_Ocircumflexacute); pub const ocircumflexacute: Keysym = Keysym(XKB_KEY_ocircumflexacute); pub const Ocircumflexgrave: Keysym = Keysym(XKB_KEY_Ocircumflexgrave); pub const ocircumflexgrave: Keysym = Keysym(XKB_KEY_ocircumflexgrave); pub const Ocircumflexhook: Keysym = Keysym(XKB_KEY_Ocircumflexhook); pub const ocircumflexhook: Keysym = Keysym(XKB_KEY_ocircumflexhook); pub const Ocircumflextilde: Keysym = Keysym(XKB_KEY_Ocircumflextilde); pub const ocircumflextilde: Keysym = Keysym(XKB_KEY_ocircumflextilde); pub const Ocircumflexbelowdot: Keysym = Keysym(XKB_KEY_Ocircumflexbelowdot); pub const ocircumflexbelowdot: Keysym = Keysym(XKB_KEY_ocircumflexbelowdot); pub const Ohornacute: Keysym = Keysym(XKB_KEY_Ohornacute); pub const ohornacute: Keysym = Keysym(XKB_KEY_ohornacute); pub const Ohorngrave: Keysym = Keysym(XKB_KEY_Ohorngrave); pub const ohorngrave: Keysym = Keysym(XKB_KEY_ohorngrave); pub const Ohornhook: Keysym = Keysym(XKB_KEY_Ohornhook); pub const ohornhook: Keysym = Keysym(XKB_KEY_ohornhook); pub const Ohorntilde: Keysym = Keysym(XKB_KEY_Ohorntilde); pub const ohorntilde: Keysym = Keysym(XKB_KEY_ohorntilde); pub const Ohornbelowdot: Keysym = Keysym(XKB_KEY_Ohornbelowdot); pub const ohornbelowdot: Keysym = Keysym(XKB_KEY_ohornbelowdot); pub const Ubelowdot: Keysym = Keysym(XKB_KEY_Ubelowdot); pub const ubelowdot: Keysym = Keysym(XKB_KEY_ubelowdot); pub const Uhook: Keysym = Keysym(XKB_KEY_Uhook); pub const uhook: Keysym = Keysym(XKB_KEY_uhook); pub const Uhornacute: Keysym = Keysym(XKB_KEY_Uhornacute); pub const uhornacute: Keysym = Keysym(XKB_KEY_uhornacute); pub const Uhorngrave: Keysym = Keysym(XKB_KEY_Uhorngrave); pub const uhorngrave: Keysym = Keysym(XKB_KEY_uhorngrave); pub const Uhornhook: Keysym = Keysym(XKB_KEY_Uhornhook); pub const uhornhook: Keysym = Keysym(XKB_KEY_uhornhook); pub const Uhorntilde: Keysym = Keysym(XKB_KEY_Uhorntilde); pub const uhorntilde: Keysym = Keysym(XKB_KEY_uhorntilde); pub const Uhornbelowdot: Keysym = Keysym(XKB_KEY_Uhornbelowdot); pub const uhornbelowdot: Keysym = Keysym(XKB_KEY_uhornbelowdot); pub const Ybelowdot: Keysym = Keysym(XKB_KEY_Ybelowdot); pub const ybelowdot: Keysym = Keysym(XKB_KEY_ybelowdot); pub const Yhook: Keysym = Keysym(XKB_KEY_Yhook); pub const yhook: Keysym = Keysym(XKB_KEY_yhook); pub const Ytilde: Keysym = Keysym(XKB_KEY_Ytilde); pub const ytilde: Keysym = Keysym(XKB_KEY_ytilde); pub const Ohorn: Keysym = Keysym(XKB_KEY_Ohorn); pub const ohorn: Keysym = Keysym(XKB_KEY_ohorn); pub const Uhorn: Keysym = Keysym(XKB_KEY_Uhorn); pub const uhorn: Keysym = Keysym(XKB_KEY_uhorn); pub const EcuSign: Keysym = Keysym(XKB_KEY_EcuSign); pub const ColonSign: Keysym = Keysym(XKB_KEY_ColonSign); pub const CruzeiroSign: Keysym = Keysym(XKB_KEY_CruzeiroSign); pub const FFrancSign: Keysym = Keysym(XKB_KEY_FFrancSign); pub const LiraSign: Keysym = Keysym(XKB_KEY_LiraSign); pub const MillSign: Keysym = Keysym(XKB_KEY_MillSign); pub const NairaSign: Keysym = Keysym(XKB_KEY_NairaSign); pub const PesetaSign: Keysym = Keysym(XKB_KEY_PesetaSign); pub const RupeeSign: Keysym = Keysym(XKB_KEY_RupeeSign); pub const WonSign: Keysym = Keysym(XKB_KEY_WonSign); pub const NewSheqelSign: Keysym = Keysym(XKB_KEY_NewSheqelSign); pub const DongSign: Keysym = Keysym(XKB_KEY_DongSign); pub const EuroSign: Keysym = Keysym(XKB_KEY_EuroSign); pub const zerosuperior: Keysym = Keysym(XKB_KEY_zerosuperior); pub const foursuperior: Keysym = Keysym(XKB_KEY_foursuperior); pub const fivesuperior: Keysym = Keysym(XKB_KEY_fivesuperior); pub const sixsuperior: Keysym = Keysym(XKB_KEY_sixsuperior); pub const sevensuperior: Keysym = Keysym(XKB_KEY_sevensuperior); pub const eightsuperior: Keysym = Keysym(XKB_KEY_eightsuperior); pub const ninesuperior: Keysym = Keysym(XKB_KEY_ninesuperior); pub const zerosubscript: Keysym = Keysym(XKB_KEY_zerosubscript); pub const onesubscript: Keysym = Keysym(XKB_KEY_onesubscript); pub const twosubscript: Keysym = Keysym(XKB_KEY_twosubscript); pub const threesubscript: Keysym = Keysym(XKB_KEY_threesubscript); pub const foursubscript: Keysym = Keysym(XKB_KEY_foursubscript); pub const fivesubscript: Keysym = Keysym(XKB_KEY_fivesubscript); pub const sixsubscript: Keysym = Keysym(XKB_KEY_sixsubscript); pub const sevensubscript: Keysym = Keysym(XKB_KEY_sevensubscript); pub const eightsubscript: Keysym = Keysym(XKB_KEY_eightsubscript); pub const ninesubscript: Keysym = Keysym(XKB_KEY_ninesubscript); pub const partdifferential: Keysym = Keysym(XKB_KEY_partdifferential); pub const emptyset: Keysym = Keysym(XKB_KEY_emptyset); pub const elementof: Keysym = Keysym(XKB_KEY_elementof); pub const notelementof: Keysym = Keysym(XKB_KEY_notelementof); pub const containsas: Keysym = Keysym(XKB_KEY_containsas); pub const squareroot: Keysym = Keysym(XKB_KEY_squareroot); pub const cuberoot: Keysym = Keysym(XKB_KEY_cuberoot); pub const fourthroot: Keysym = Keysym(XKB_KEY_fourthroot); pub const dintegral: Keysym = Keysym(XKB_KEY_dintegral); pub const tintegral: Keysym = Keysym(XKB_KEY_tintegral); pub const because: Keysym = Keysym(XKB_KEY_because); pub const approxeq: Keysym = Keysym(XKB_KEY_approxeq); pub const notapproxeq: Keysym = Keysym(XKB_KEY_notapproxeq); pub const notidentical: Keysym = Keysym(XKB_KEY_notidentical); pub const stricteq: Keysym = Keysym(XKB_KEY_stricteq); pub const braille_dot_1: Keysym = Keysym(XKB_KEY_braille_dot_1); pub const braille_dot_2: Keysym = Keysym(XKB_KEY_braille_dot_2); pub const braille_dot_3: Keysym = Keysym(XKB_KEY_braille_dot_3); pub const braille_dot_4: Keysym = Keysym(XKB_KEY_braille_dot_4); pub const braille_dot_5: Keysym = Keysym(XKB_KEY_braille_dot_5); pub const braille_dot_6: Keysym = Keysym(XKB_KEY_braille_dot_6); pub const braille_dot_7: Keysym = Keysym(XKB_KEY_braille_dot_7); pub const braille_dot_8: Keysym = Keysym(XKB_KEY_braille_dot_8); pub const braille_dot_9: Keysym = Keysym(XKB_KEY_braille_dot_9); pub const braille_dot_10: Keysym = Keysym(XKB_KEY_braille_dot_10); pub const braille_blank: Keysym = Keysym(XKB_KEY_braille_blank); pub const braille_dots_1: Keysym = Keysym(XKB_KEY_braille_dots_1); pub const braille_dots_2: Keysym = Keysym(XKB_KEY_braille_dots_2); pub const braille_dots_12: Keysym = Keysym(XKB_KEY_braille_dots_12); pub const braille_dots_3: Keysym = Keysym(XKB_KEY_braille_dots_3); pub const braille_dots_13: Keysym = Keysym(XKB_KEY_braille_dots_13); pub const braille_dots_23: Keysym = Keysym(XKB_KEY_braille_dots_23); pub const braille_dots_123: Keysym = Keysym(XKB_KEY_braille_dots_123); pub const braille_dots_4: Keysym = Keysym(XKB_KEY_braille_dots_4); pub const braille_dots_14: Keysym = Keysym(XKB_KEY_braille_dots_14); pub const braille_dots_24: Keysym = Keysym(XKB_KEY_braille_dots_24); pub const braille_dots_124: Keysym = Keysym(XKB_KEY_braille_dots_124); pub const braille_dots_34: Keysym = Keysym(XKB_KEY_braille_dots_34); pub const braille_dots_134: Keysym = Keysym(XKB_KEY_braille_dots_134); pub const braille_dots_234: Keysym = Keysym(XKB_KEY_braille_dots_234); pub const braille_dots_1234: Keysym = Keysym(XKB_KEY_braille_dots_1234); pub const braille_dots_5: Keysym = Keysym(XKB_KEY_braille_dots_5); pub const braille_dots_15: Keysym = Keysym(XKB_KEY_braille_dots_15); pub const braille_dots_25: Keysym = Keysym(XKB_KEY_braille_dots_25); pub const braille_dots_125: Keysym = Keysym(XKB_KEY_braille_dots_125); pub const braille_dots_35: Keysym = Keysym(XKB_KEY_braille_dots_35); pub const braille_dots_135: Keysym = Keysym(XKB_KEY_braille_dots_135); pub const braille_dots_235: Keysym = Keysym(XKB_KEY_braille_dots_235); pub const braille_dots_1235: Keysym = Keysym(XKB_KEY_braille_dots_1235); pub const braille_dots_45: Keysym = Keysym(XKB_KEY_braille_dots_45); pub const braille_dots_145: Keysym = Keysym(XKB_KEY_braille_dots_145); pub const braille_dots_245: Keysym = Keysym(XKB_KEY_braille_dots_245); pub const braille_dots_1245: Keysym = Keysym(XKB_KEY_braille_dots_1245); pub const braille_dots_345: Keysym = Keysym(XKB_KEY_braille_dots_345); pub const braille_dots_1345: Keysym = Keysym(XKB_KEY_braille_dots_1345); pub const braille_dots_2345: Keysym = Keysym(XKB_KEY_braille_dots_2345); pub const braille_dots_12345: Keysym = Keysym(XKB_KEY_braille_dots_12345); pub const braille_dots_6: Keysym = Keysym(XKB_KEY_braille_dots_6); pub const braille_dots_16: Keysym = Keysym(XKB_KEY_braille_dots_16); pub const braille_dots_26: Keysym = Keysym(XKB_KEY_braille_dots_26); pub const braille_dots_126: Keysym = Keysym(XKB_KEY_braille_dots_126); pub const braille_dots_36: Keysym = Keysym(XKB_KEY_braille_dots_36); pub const braille_dots_136: Keysym = Keysym(XKB_KEY_braille_dots_136); pub const braille_dots_236: Keysym = Keysym(XKB_KEY_braille_dots_236); pub const braille_dots_1236: Keysym = Keysym(XKB_KEY_braille_dots_1236); pub const braille_dots_46: Keysym = Keysym(XKB_KEY_braille_dots_46); pub const braille_dots_146: Keysym = Keysym(XKB_KEY_braille_dots_146); pub const braille_dots_246: Keysym = Keysym(XKB_KEY_braille_dots_246); pub const braille_dots_1246: Keysym = Keysym(XKB_KEY_braille_dots_1246); pub const braille_dots_346: Keysym = Keysym(XKB_KEY_braille_dots_346); pub const braille_dots_1346: Keysym = Keysym(XKB_KEY_braille_dots_1346); pub const braille_dots_2346: Keysym = Keysym(XKB_KEY_braille_dots_2346); pub const braille_dots_12346: Keysym = Keysym(XKB_KEY_braille_dots_12346); pub const braille_dots_56: Keysym = Keysym(XKB_KEY_braille_dots_56); pub const braille_dots_156: Keysym = Keysym(XKB_KEY_braille_dots_156); pub const braille_dots_256: Keysym = Keysym(XKB_KEY_braille_dots_256); pub const braille_dots_1256: Keysym = Keysym(XKB_KEY_braille_dots_1256); pub const braille_dots_356: Keysym = Keysym(XKB_KEY_braille_dots_356); pub const braille_dots_1356: Keysym = Keysym(XKB_KEY_braille_dots_1356); pub const braille_dots_2356: Keysym = Keysym(XKB_KEY_braille_dots_2356); pub const braille_dots_12356: Keysym = Keysym(XKB_KEY_braille_dots_12356); pub const braille_dots_456: Keysym = Keysym(XKB_KEY_braille_dots_456); pub const braille_dots_1456: Keysym = Keysym(XKB_KEY_braille_dots_1456); pub const braille_dots_2456: Keysym = Keysym(XKB_KEY_braille_dots_2456); pub const braille_dots_12456: Keysym = Keysym(XKB_KEY_braille_dots_12456); pub const braille_dots_3456: Keysym = Keysym(XKB_KEY_braille_dots_3456); pub const braille_dots_13456: Keysym = Keysym(XKB_KEY_braille_dots_13456); pub const braille_dots_23456: Keysym = Keysym(XKB_KEY_braille_dots_23456); pub const braille_dots_123456: Keysym = Keysym(XKB_KEY_braille_dots_123456); pub const braille_dots_7: Keysym = Keysym(XKB_KEY_braille_dots_7); pub const braille_dots_17: Keysym = Keysym(XKB_KEY_braille_dots_17); pub const braille_dots_27: Keysym = Keysym(XKB_KEY_braille_dots_27); pub const braille_dots_127: Keysym = Keysym(XKB_KEY_braille_dots_127); pub const braille_dots_37: Keysym = Keysym(XKB_KEY_braille_dots_37); pub const braille_dots_137: Keysym = Keysym(XKB_KEY_braille_dots_137); pub const braille_dots_237: Keysym = Keysym(XKB_KEY_braille_dots_237); pub const braille_dots_1237: Keysym = Keysym(XKB_KEY_braille_dots_1237); pub const braille_dots_47: Keysym = Keysym(XKB_KEY_braille_dots_47); pub const braille_dots_147: Keysym = Keysym(XKB_KEY_braille_dots_147); pub const braille_dots_247: Keysym = Keysym(XKB_KEY_braille_dots_247); pub const braille_dots_1247: Keysym = Keysym(XKB_KEY_braille_dots_1247); pub const braille_dots_347: Keysym = Keysym(XKB_KEY_braille_dots_347); pub const braille_dots_1347: Keysym = Keysym(XKB_KEY_braille_dots_1347); pub const braille_dots_2347: Keysym = Keysym(XKB_KEY_braille_dots_2347); pub const braille_dots_12347: Keysym = Keysym(XKB_KEY_braille_dots_12347); pub const braille_dots_57: Keysym = Keysym(XKB_KEY_braille_dots_57); pub const braille_dots_157: Keysym = Keysym(XKB_KEY_braille_dots_157); pub const braille_dots_257: Keysym = Keysym(XKB_KEY_braille_dots_257); pub const braille_dots_1257: Keysym = Keysym(XKB_KEY_braille_dots_1257); pub const braille_dots_357: Keysym = Keysym(XKB_KEY_braille_dots_357); pub const braille_dots_1357: Keysym = Keysym(XKB_KEY_braille_dots_1357); pub const braille_dots_2357: Keysym = Keysym(XKB_KEY_braille_dots_2357); pub const braille_dots_12357: Keysym = Keysym(XKB_KEY_braille_dots_12357); pub const braille_dots_457: Keysym = Keysym(XKB_KEY_braille_dots_457); pub const braille_dots_1457: Keysym = Keysym(XKB_KEY_braille_dots_1457); pub const braille_dots_2457: Keysym = Keysym(XKB_KEY_braille_dots_2457); pub const braille_dots_12457: Keysym = Keysym(XKB_KEY_braille_dots_12457); pub const braille_dots_3457: Keysym = Keysym(XKB_KEY_braille_dots_3457); pub const braille_dots_13457: Keysym = Keysym(XKB_KEY_braille_dots_13457); pub const braille_dots_23457: Keysym = Keysym(XKB_KEY_braille_dots_23457); pub const braille_dots_123457: Keysym = Keysym(XKB_KEY_braille_dots_123457); pub const braille_dots_67: Keysym = Keysym(XKB_KEY_braille_dots_67); pub const braille_dots_167: Keysym = Keysym(XKB_KEY_braille_dots_167); pub const braille_dots_267: Keysym = Keysym(XKB_KEY_braille_dots_267); pub const braille_dots_1267: Keysym = Keysym(XKB_KEY_braille_dots_1267); pub const braille_dots_367: Keysym = Keysym(XKB_KEY_braille_dots_367); pub const braille_dots_1367: Keysym = Keysym(XKB_KEY_braille_dots_1367); pub const braille_dots_2367: Keysym = Keysym(XKB_KEY_braille_dots_2367); pub const braille_dots_12367: Keysym = Keysym(XKB_KEY_braille_dots_12367); pub const braille_dots_467: Keysym = Keysym(XKB_KEY_braille_dots_467); pub const braille_dots_1467: Keysym = Keysym(XKB_KEY_braille_dots_1467); pub const braille_dots_2467: Keysym = Keysym(XKB_KEY_braille_dots_2467); pub const braille_dots_12467: Keysym = Keysym(XKB_KEY_braille_dots_12467); pub const braille_dots_3467: Keysym = Keysym(XKB_KEY_braille_dots_3467); pub const braille_dots_13467: Keysym = Keysym(XKB_KEY_braille_dots_13467); pub const braille_dots_23467: Keysym = Keysym(XKB_KEY_braille_dots_23467); pub const braille_dots_123467: Keysym = Keysym(XKB_KEY_braille_dots_123467); pub const braille_dots_567: Keysym = Keysym(XKB_KEY_braille_dots_567); pub const braille_dots_1567: Keysym = Keysym(XKB_KEY_braille_dots_1567); pub const braille_dots_2567: Keysym = Keysym(XKB_KEY_braille_dots_2567); pub const braille_dots_12567: Keysym = Keysym(XKB_KEY_braille_dots_12567); pub const braille_dots_3567: Keysym = Keysym(XKB_KEY_braille_dots_3567); pub const braille_dots_13567: Keysym = Keysym(XKB_KEY_braille_dots_13567); pub const braille_dots_23567: Keysym = Keysym(XKB_KEY_braille_dots_23567); pub const braille_dots_123567: Keysym = Keysym(XKB_KEY_braille_dots_123567); pub const braille_dots_4567: Keysym = Keysym(XKB_KEY_braille_dots_4567); pub const braille_dots_14567: Keysym = Keysym(XKB_KEY_braille_dots_14567); pub const braille_dots_24567: Keysym = Keysym(XKB_KEY_braille_dots_24567); pub const braille_dots_124567: Keysym = Keysym(XKB_KEY_braille_dots_124567); pub const braille_dots_34567: Keysym = Keysym(XKB_KEY_braille_dots_34567); pub const braille_dots_134567: Keysym = Keysym(XKB_KEY_braille_dots_134567); pub const braille_dots_234567: Keysym = Keysym(XKB_KEY_braille_dots_234567); pub const braille_dots_1234567: Keysym = Keysym(XKB_KEY_braille_dots_1234567); pub const braille_dots_8: Keysym = Keysym(XKB_KEY_braille_dots_8); pub const braille_dots_18: Keysym = Keysym(XKB_KEY_braille_dots_18); pub const braille_dots_28: Keysym = Keysym(XKB_KEY_braille_dots_28); pub const braille_dots_128: Keysym = Keysym(XKB_KEY_braille_dots_128); pub const braille_dots_38: Keysym = Keysym(XKB_KEY_braille_dots_38); pub const braille_dots_138: Keysym = Keysym(XKB_KEY_braille_dots_138); pub const braille_dots_238: Keysym = Keysym(XKB_KEY_braille_dots_238); pub const braille_dots_1238: Keysym = Keysym(XKB_KEY_braille_dots_1238); pub const braille_dots_48: Keysym = Keysym(XKB_KEY_braille_dots_48); pub const braille_dots_148: Keysym = Keysym(XKB_KEY_braille_dots_148); pub const braille_dots_248: Keysym = Keysym(XKB_KEY_braille_dots_248); pub const braille_dots_1248: Keysym = Keysym(XKB_KEY_braille_dots_1248); pub const braille_dots_348: Keysym = Keysym(XKB_KEY_braille_dots_348); pub const braille_dots_1348: Keysym = Keysym(XKB_KEY_braille_dots_1348); pub const braille_dots_2348: Keysym = Keysym(XKB_KEY_braille_dots_2348); pub const braille_dots_12348: Keysym = Keysym(XKB_KEY_braille_dots_12348); pub const braille_dots_58: Keysym = Keysym(XKB_KEY_braille_dots_58); pub const braille_dots_158: Keysym = Keysym(XKB_KEY_braille_dots_158); pub const braille_dots_258: Keysym = Keysym(XKB_KEY_braille_dots_258); pub const braille_dots_1258: Keysym = Keysym(XKB_KEY_braille_dots_1258); pub const braille_dots_358: Keysym = Keysym(XKB_KEY_braille_dots_358); pub const braille_dots_1358: Keysym = Keysym(XKB_KEY_braille_dots_1358); pub const braille_dots_2358: Keysym = Keysym(XKB_KEY_braille_dots_2358); pub const braille_dots_12358: Keysym = Keysym(XKB_KEY_braille_dots_12358); pub const braille_dots_458: Keysym = Keysym(XKB_KEY_braille_dots_458); pub const braille_dots_1458: Keysym = Keysym(XKB_KEY_braille_dots_1458); pub const braille_dots_2458: Keysym = Keysym(XKB_KEY_braille_dots_2458); pub const braille_dots_12458: Keysym = Keysym(XKB_KEY_braille_dots_12458); pub const braille_dots_3458: Keysym = Keysym(XKB_KEY_braille_dots_3458); pub const braille_dots_13458: Keysym = Keysym(XKB_KEY_braille_dots_13458); pub const braille_dots_23458: Keysym = Keysym(XKB_KEY_braille_dots_23458); pub const braille_dots_123458: Keysym = Keysym(XKB_KEY_braille_dots_123458); pub const braille_dots_68: Keysym = Keysym(XKB_KEY_braille_dots_68); pub const braille_dots_168: Keysym = Keysym(XKB_KEY_braille_dots_168); pub const braille_dots_268: Keysym = Keysym(XKB_KEY_braille_dots_268); pub const braille_dots_1268: Keysym = Keysym(XKB_KEY_braille_dots_1268); pub const braille_dots_368: Keysym = Keysym(XKB_KEY_braille_dots_368); pub const braille_dots_1368: Keysym = Keysym(XKB_KEY_braille_dots_1368); pub const braille_dots_2368: Keysym = Keysym(XKB_KEY_braille_dots_2368); pub const braille_dots_12368: Keysym = Keysym(XKB_KEY_braille_dots_12368); pub const braille_dots_468: Keysym = Keysym(XKB_KEY_braille_dots_468); pub const braille_dots_1468: Keysym = Keysym(XKB_KEY_braille_dots_1468); pub const braille_dots_2468: Keysym = Keysym(XKB_KEY_braille_dots_2468); pub const braille_dots_12468: Keysym = Keysym(XKB_KEY_braille_dots_12468); pub const braille_dots_3468: Keysym = Keysym(XKB_KEY_braille_dots_3468); pub const braille_dots_13468: Keysym = Keysym(XKB_KEY_braille_dots_13468); pub const braille_dots_23468: Keysym = Keysym(XKB_KEY_braille_dots_23468); pub const braille_dots_123468: Keysym = Keysym(XKB_KEY_braille_dots_123468); pub const braille_dots_568: Keysym = Keysym(XKB_KEY_braille_dots_568); pub const braille_dots_1568: Keysym = Keysym(XKB_KEY_braille_dots_1568); pub const braille_dots_2568: Keysym = Keysym(XKB_KEY_braille_dots_2568); pub const braille_dots_12568: Keysym = Keysym(XKB_KEY_braille_dots_12568); pub const braille_dots_3568: Keysym = Keysym(XKB_KEY_braille_dots_3568); pub const braille_dots_13568: Keysym = Keysym(XKB_KEY_braille_dots_13568); pub const braille_dots_23568: Keysym = Keysym(XKB_KEY_braille_dots_23568); pub const braille_dots_123568: Keysym = Keysym(XKB_KEY_braille_dots_123568); pub const braille_dots_4568: Keysym = Keysym(XKB_KEY_braille_dots_4568); pub const braille_dots_14568: Keysym = Keysym(XKB_KEY_braille_dots_14568); pub const braille_dots_24568: Keysym = Keysym(XKB_KEY_braille_dots_24568); pub const braille_dots_124568: Keysym = Keysym(XKB_KEY_braille_dots_124568); pub const braille_dots_34568: Keysym = Keysym(XKB_KEY_braille_dots_34568); pub const braille_dots_134568: Keysym = Keysym(XKB_KEY_braille_dots_134568); pub const braille_dots_234568: Keysym = Keysym(XKB_KEY_braille_dots_234568); pub const braille_dots_1234568: Keysym = Keysym(XKB_KEY_braille_dots_1234568); pub const braille_dots_78: Keysym = Keysym(XKB_KEY_braille_dots_78); pub const braille_dots_178: Keysym = Keysym(XKB_KEY_braille_dots_178); pub const braille_dots_278: Keysym = Keysym(XKB_KEY_braille_dots_278); pub const braille_dots_1278: Keysym = Keysym(XKB_KEY_braille_dots_1278); pub const braille_dots_378: Keysym = Keysym(XKB_KEY_braille_dots_378); pub const braille_dots_1378: Keysym = Keysym(XKB_KEY_braille_dots_1378); pub const braille_dots_2378: Keysym = Keysym(XKB_KEY_braille_dots_2378); pub const braille_dots_12378: Keysym = Keysym(XKB_KEY_braille_dots_12378); pub const braille_dots_478: Keysym = Keysym(XKB_KEY_braille_dots_478); pub const braille_dots_1478: Keysym = Keysym(XKB_KEY_braille_dots_1478); pub const braille_dots_2478: Keysym = Keysym(XKB_KEY_braille_dots_2478); pub const braille_dots_12478: Keysym = Keysym(XKB_KEY_braille_dots_12478); pub const braille_dots_3478: Keysym = Keysym(XKB_KEY_braille_dots_3478); pub const braille_dots_13478: Keysym = Keysym(XKB_KEY_braille_dots_13478); pub const braille_dots_23478: Keysym = Keysym(XKB_KEY_braille_dots_23478); pub const braille_dots_123478: Keysym = Keysym(XKB_KEY_braille_dots_123478); pub const braille_dots_578: Keysym = Keysym(XKB_KEY_braille_dots_578); pub const braille_dots_1578: Keysym = Keysym(XKB_KEY_braille_dots_1578); pub const braille_dots_2578: Keysym = Keysym(XKB_KEY_braille_dots_2578); pub const braille_dots_12578: Keysym = Keysym(XKB_KEY_braille_dots_12578); pub const braille_dots_3578: Keysym = Keysym(XKB_KEY_braille_dots_3578); pub const braille_dots_13578: Keysym = Keysym(XKB_KEY_braille_dots_13578); pub const braille_dots_23578: Keysym = Keysym(XKB_KEY_braille_dots_23578); pub const braille_dots_123578: Keysym = Keysym(XKB_KEY_braille_dots_123578); pub const braille_dots_4578: Keysym = Keysym(XKB_KEY_braille_dots_4578); pub const braille_dots_14578: Keysym = Keysym(XKB_KEY_braille_dots_14578); pub const braille_dots_24578: Keysym = Keysym(XKB_KEY_braille_dots_24578); pub const braille_dots_124578: Keysym = Keysym(XKB_KEY_braille_dots_124578); pub const braille_dots_34578: Keysym = Keysym(XKB_KEY_braille_dots_34578); pub const braille_dots_134578: Keysym = Keysym(XKB_KEY_braille_dots_134578); pub const braille_dots_234578: Keysym = Keysym(XKB_KEY_braille_dots_234578); pub const braille_dots_1234578: Keysym = Keysym(XKB_KEY_braille_dots_1234578); pub const braille_dots_678: Keysym = Keysym(XKB_KEY_braille_dots_678); pub const braille_dots_1678: Keysym = Keysym(XKB_KEY_braille_dots_1678); pub const braille_dots_2678: Keysym = Keysym(XKB_KEY_braille_dots_2678); pub const braille_dots_12678: Keysym = Keysym(XKB_KEY_braille_dots_12678); pub const braille_dots_3678: Keysym = Keysym(XKB_KEY_braille_dots_3678); pub const braille_dots_13678: Keysym = Keysym(XKB_KEY_braille_dots_13678); pub const braille_dots_23678: Keysym = Keysym(XKB_KEY_braille_dots_23678); pub const braille_dots_123678: Keysym = Keysym(XKB_KEY_braille_dots_123678); pub const braille_dots_4678: Keysym = Keysym(XKB_KEY_braille_dots_4678); pub const braille_dots_14678: Keysym = Keysym(XKB_KEY_braille_dots_14678); pub const braille_dots_24678: Keysym = Keysym(XKB_KEY_braille_dots_24678); pub const braille_dots_124678: Keysym = Keysym(XKB_KEY_braille_dots_124678); pub const braille_dots_34678: Keysym = Keysym(XKB_KEY_braille_dots_34678); pub const braille_dots_134678: Keysym = Keysym(XKB_KEY_braille_dots_134678); pub const braille_dots_234678: Keysym = Keysym(XKB_KEY_braille_dots_234678); pub const braille_dots_1234678: Keysym = Keysym(XKB_KEY_braille_dots_1234678); pub const braille_dots_5678: Keysym = Keysym(XKB_KEY_braille_dots_5678); pub const braille_dots_15678: Keysym = Keysym(XKB_KEY_braille_dots_15678); pub const braille_dots_25678: Keysym = Keysym(XKB_KEY_braille_dots_25678); pub const braille_dots_125678: Keysym = Keysym(XKB_KEY_braille_dots_125678); pub const braille_dots_35678: Keysym = Keysym(XKB_KEY_braille_dots_35678); pub const braille_dots_135678: Keysym = Keysym(XKB_KEY_braille_dots_135678); pub const braille_dots_235678: Keysym = Keysym(XKB_KEY_braille_dots_235678); pub const braille_dots_1235678: Keysym = Keysym(XKB_KEY_braille_dots_1235678); pub const braille_dots_45678: Keysym = Keysym(XKB_KEY_braille_dots_45678); pub const braille_dots_145678: Keysym = Keysym(XKB_KEY_braille_dots_145678); pub const braille_dots_245678: Keysym = Keysym(XKB_KEY_braille_dots_245678); pub const braille_dots_1245678: Keysym = Keysym(XKB_KEY_braille_dots_1245678); pub const braille_dots_345678: Keysym = Keysym(XKB_KEY_braille_dots_345678); pub const braille_dots_1345678: Keysym = Keysym(XKB_KEY_braille_dots_1345678); pub const braille_dots_2345678: Keysym = Keysym(XKB_KEY_braille_dots_2345678); pub const braille_dots_12345678: Keysym = Keysym(XKB_KEY_braille_dots_12345678); pub const Sinh_ng: Keysym = Keysym(XKB_KEY_Sinh_ng); pub const Sinh_h2: Keysym = Keysym(XKB_KEY_Sinh_h2); pub const Sinh_a: Keysym = Keysym(XKB_KEY_Sinh_a); pub const Sinh_aa: Keysym = Keysym(XKB_KEY_Sinh_aa); pub const Sinh_ae: Keysym = Keysym(XKB_KEY_Sinh_ae); pub const Sinh_aee: Keysym = Keysym(XKB_KEY_Sinh_aee); pub const Sinh_i: Keysym = Keysym(XKB_KEY_Sinh_i); pub const Sinh_ii: Keysym = Keysym(XKB_KEY_Sinh_ii); pub const Sinh_u: Keysym = Keysym(XKB_KEY_Sinh_u); pub const Sinh_uu: Keysym = Keysym(XKB_KEY_Sinh_uu); pub const Sinh_ri: Keysym = Keysym(XKB_KEY_Sinh_ri); pub const Sinh_rii: Keysym = Keysym(XKB_KEY_Sinh_rii); pub const Sinh_lu: Keysym = Keysym(XKB_KEY_Sinh_lu); pub const Sinh_luu: Keysym = Keysym(XKB_KEY_Sinh_luu); pub const Sinh_e: Keysym = Keysym(XKB_KEY_Sinh_e); pub const Sinh_ee: Keysym = Keysym(XKB_KEY_Sinh_ee); pub const Sinh_ai: Keysym = Keysym(XKB_KEY_Sinh_ai); pub const Sinh_o: Keysym = Keysym(XKB_KEY_Sinh_o); pub const Sinh_oo: Keysym = Keysym(XKB_KEY_Sinh_oo); pub const Sinh_au: Keysym = Keysym(XKB_KEY_Sinh_au); pub const Sinh_ka: Keysym = Keysym(XKB_KEY_Sinh_ka); pub const Sinh_kha: Keysym = Keysym(XKB_KEY_Sinh_kha); pub const Sinh_ga: Keysym = Keysym(XKB_KEY_Sinh_ga); pub const Sinh_gha: Keysym = Keysym(XKB_KEY_Sinh_gha); pub const Sinh_ng2: Keysym = Keysym(XKB_KEY_Sinh_ng2); pub const Sinh_nga: Keysym = Keysym(XKB_KEY_Sinh_nga); pub const Sinh_ca: Keysym = Keysym(XKB_KEY_Sinh_ca); pub const Sinh_cha: Keysym = Keysym(XKB_KEY_Sinh_cha); pub const Sinh_ja: Keysym = Keysym(XKB_KEY_Sinh_ja); pub const Sinh_jha: Keysym = Keysym(XKB_KEY_Sinh_jha); pub const Sinh_nya: Keysym = Keysym(XKB_KEY_Sinh_nya); pub const Sinh_jnya: Keysym = Keysym(XKB_KEY_Sinh_jnya); pub const Sinh_nja: Keysym = Keysym(XKB_KEY_Sinh_nja); pub const Sinh_tta: Keysym = Keysym(XKB_KEY_Sinh_tta); pub const Sinh_ttha: Keysym = Keysym(XKB_KEY_Sinh_ttha); pub const Sinh_dda: Keysym = Keysym(XKB_KEY_Sinh_dda); pub const Sinh_ddha: Keysym = Keysym(XKB_KEY_Sinh_ddha); pub const Sinh_nna: Keysym = Keysym(XKB_KEY_Sinh_nna); pub const Sinh_ndda: Keysym = Keysym(XKB_KEY_Sinh_ndda); pub const Sinh_tha: Keysym = Keysym(XKB_KEY_Sinh_tha); pub const Sinh_thha: Keysym = Keysym(XKB_KEY_Sinh_thha); pub const Sinh_dha: Keysym = Keysym(XKB_KEY_Sinh_dha); pub const Sinh_dhha: Keysym = Keysym(XKB_KEY_Sinh_dhha); pub const Sinh_na: Keysym = Keysym(XKB_KEY_Sinh_na); pub const Sinh_ndha: Keysym = Keysym(XKB_KEY_Sinh_ndha); pub const Sinh_pa: Keysym = Keysym(XKB_KEY_Sinh_pa); pub const Sinh_pha: Keysym = Keysym(XKB_KEY_Sinh_pha); pub const Sinh_ba: Keysym = Keysym(XKB_KEY_Sinh_ba); pub const Sinh_bha: Keysym = Keysym(XKB_KEY_Sinh_bha); pub const Sinh_ma: Keysym = Keysym(XKB_KEY_Sinh_ma); pub const Sinh_mba: Keysym = Keysym(XKB_KEY_Sinh_mba); pub const Sinh_ya: Keysym = Keysym(XKB_KEY_Sinh_ya); pub const Sinh_ra: Keysym = Keysym(XKB_KEY_Sinh_ra); pub const Sinh_la: Keysym = Keysym(XKB_KEY_Sinh_la); pub const Sinh_va: Keysym = Keysym(XKB_KEY_Sinh_va); pub const Sinh_sha: Keysym = Keysym(XKB_KEY_Sinh_sha); pub const Sinh_ssha: Keysym = Keysym(XKB_KEY_Sinh_ssha); pub const Sinh_sa: Keysym = Keysym(XKB_KEY_Sinh_sa); pub const Sinh_ha: Keysym = Keysym(XKB_KEY_Sinh_ha); pub const Sinh_lla: Keysym = Keysym(XKB_KEY_Sinh_lla); pub const Sinh_fa: Keysym = Keysym(XKB_KEY_Sinh_fa); pub const Sinh_al: Keysym = Keysym(XKB_KEY_Sinh_al); pub const Sinh_aa2: Keysym = Keysym(XKB_KEY_Sinh_aa2); pub const Sinh_ae2: Keysym = Keysym(XKB_KEY_Sinh_ae2); pub const Sinh_aee2: Keysym = Keysym(XKB_KEY_Sinh_aee2); pub const Sinh_i2: Keysym = Keysym(XKB_KEY_Sinh_i2); pub const Sinh_ii2: Keysym = Keysym(XKB_KEY_Sinh_ii2); pub const Sinh_u2: Keysym = Keysym(XKB_KEY_Sinh_u2); pub const Sinh_uu2: Keysym = Keysym(XKB_KEY_Sinh_uu2); pub const Sinh_ru2: Keysym = Keysym(XKB_KEY_Sinh_ru2); pub const Sinh_e2: Keysym = Keysym(XKB_KEY_Sinh_e2); pub const Sinh_ee2: Keysym = Keysym(XKB_KEY_Sinh_ee2); pub const Sinh_ai2: Keysym = Keysym(XKB_KEY_Sinh_ai2); pub const Sinh_o2: Keysym = Keysym(XKB_KEY_Sinh_o2); pub const Sinh_oo2: Keysym = Keysym(XKB_KEY_Sinh_oo2); pub const Sinh_au2: Keysym = Keysym(XKB_KEY_Sinh_au2); pub const Sinh_lu2: Keysym = Keysym(XKB_KEY_Sinh_lu2); pub const Sinh_ruu2: Keysym = Keysym(XKB_KEY_Sinh_ruu2); pub const Sinh_luu2: Keysym = Keysym(XKB_KEY_Sinh_luu2); pub const Sinh_kunddaliya: Keysym = Keysym(XKB_KEY_Sinh_kunddaliya); pub const XF86ModeLock: Keysym = Keysym(XKB_KEY_XF86ModeLock); pub const XF86MonBrightnessUp: Keysym = Keysym(XKB_KEY_XF86MonBrightnessUp); pub const XF86MonBrightnessDown: Keysym = Keysym(XKB_KEY_XF86MonBrightnessDown); pub const XF86KbdLightOnOff: Keysym = Keysym(XKB_KEY_XF86KbdLightOnOff); pub const XF86KbdBrightnessUp: Keysym = Keysym(XKB_KEY_XF86KbdBrightnessUp); pub const XF86KbdBrightnessDown: Keysym = Keysym(XKB_KEY_XF86KbdBrightnessDown); pub const XF86Standby: Keysym = Keysym(XKB_KEY_XF86Standby); pub const XF86AudioLowerVolume: Keysym = Keysym(XKB_KEY_XF86AudioLowerVolume); pub const XF86AudioMute: Keysym = Keysym(XKB_KEY_XF86AudioMute); pub const XF86AudioRaiseVolume: Keysym = Keysym(XKB_KEY_XF86AudioRaiseVolume); pub const XF86AudioPlay: Keysym = Keysym(XKB_KEY_XF86AudioPlay); pub const XF86AudioStop: Keysym = Keysym(XKB_KEY_XF86AudioStop); pub const XF86AudioPrev: Keysym = Keysym(XKB_KEY_XF86AudioPrev); pub const XF86AudioNext: Keysym = Keysym(XKB_KEY_XF86AudioNext); pub const XF86HomePage: Keysym = Keysym(XKB_KEY_XF86HomePage); pub const XF86Mail: Keysym = Keysym(XKB_KEY_XF86Mail); pub const XF86Start: Keysym = Keysym(XKB_KEY_XF86Start); pub const XF86Search: Keysym = Keysym(XKB_KEY_XF86Search); pub const XF86AudioRecord: Keysym = Keysym(XKB_KEY_XF86AudioRecord); pub const XF86Calculator: Keysym = Keysym(XKB_KEY_XF86Calculator); pub const XF86Memo: Keysym = Keysym(XKB_KEY_XF86Memo); pub const XF86ToDoList: Keysym = Keysym(XKB_KEY_XF86ToDoList); pub const XF86Calendar: Keysym = Keysym(XKB_KEY_XF86Calendar); pub const XF86PowerDown: Keysym = Keysym(XKB_KEY_XF86PowerDown); pub const XF86ContrastAdjust: Keysym = Keysym(XKB_KEY_XF86ContrastAdjust); pub const XF86RockerUp: Keysym = Keysym(XKB_KEY_XF86RockerUp); pub const XF86RockerDown: Keysym = Keysym(XKB_KEY_XF86RockerDown); pub const XF86RockerEnter: Keysym = Keysym(XKB_KEY_XF86RockerEnter); pub const XF86Back: Keysym = Keysym(XKB_KEY_XF86Back); pub const XF86Forward: Keysym = Keysym(XKB_KEY_XF86Forward); pub const XF86Stop: Keysym = Keysym(XKB_KEY_XF86Stop); pub const XF86Refresh: Keysym = Keysym(XKB_KEY_XF86Refresh); pub const XF86PowerOff: Keysym = Keysym(XKB_KEY_XF86PowerOff); pub const XF86WakeUp: Keysym = Keysym(XKB_KEY_XF86WakeUp); pub const XF86Eject: Keysym = Keysym(XKB_KEY_XF86Eject); pub const XF86ScreenSaver: Keysym = Keysym(XKB_KEY_XF86ScreenSaver); pub const XF86WWW: Keysym = Keysym(XKB_KEY_XF86WWW); pub const XF86Sleep: Keysym = Keysym(XKB_KEY_XF86Sleep); pub const XF86Favorites: Keysym = Keysym(XKB_KEY_XF86Favorites); pub const XF86AudioPause: Keysym = Keysym(XKB_KEY_XF86AudioPause); pub const XF86AudioMedia: Keysym = Keysym(XKB_KEY_XF86AudioMedia); pub const XF86MyComputer: Keysym = Keysym(XKB_KEY_XF86MyComputer); pub const XF86VendorHome: Keysym = Keysym(XKB_KEY_XF86VendorHome); pub const XF86LightBulb: Keysym = Keysym(XKB_KEY_XF86LightBulb); pub const XF86Shop: Keysym = Keysym(XKB_KEY_XF86Shop); pub const XF86History: Keysym = Keysym(XKB_KEY_XF86History); pub const XF86OpenURL: Keysym = Keysym(XKB_KEY_XF86OpenURL); pub const XF86AddFavorite: Keysym = Keysym(XKB_KEY_XF86AddFavorite); pub const XF86HotLinks: Keysym = Keysym(XKB_KEY_XF86HotLinks); pub const XF86BrightnessAdjust: Keysym = Keysym(XKB_KEY_XF86BrightnessAdjust); pub const XF86Finance: Keysym = Keysym(XKB_KEY_XF86Finance); pub const XF86Community: Keysym = Keysym(XKB_KEY_XF86Community); pub const XF86AudioRewind: Keysym = Keysym(XKB_KEY_XF86AudioRewind); pub const XF86BackForward: Keysym = Keysym(XKB_KEY_XF86BackForward); pub const XF86Launch0: Keysym = Keysym(XKB_KEY_XF86Launch0); pub const XF86Launch1: Keysym = Keysym(XKB_KEY_XF86Launch1); pub const XF86Launch2: Keysym = Keysym(XKB_KEY_XF86Launch2); pub const XF86Launch3: Keysym = Keysym(XKB_KEY_XF86Launch3); pub const XF86Launch4: Keysym = Keysym(XKB_KEY_XF86Launch4); pub const XF86Launch5: Keysym = Keysym(XKB_KEY_XF86Launch5); pub const XF86Launch6: Keysym = Keysym(XKB_KEY_XF86Launch6); pub const XF86Launch7: Keysym = Keysym(XKB_KEY_XF86Launch7); pub const XF86Launch8: Keysym = Keysym(XKB_KEY_XF86Launch8); pub const XF86Launch9: Keysym = Keysym(XKB_KEY_XF86Launch9); pub const XF86LaunchA: Keysym = Keysym(XKB_KEY_XF86LaunchA); pub const XF86LaunchB: Keysym = Keysym(XKB_KEY_XF86LaunchB); pub const XF86LaunchC: Keysym = Keysym(XKB_KEY_XF86LaunchC); pub const XF86LaunchD: Keysym = Keysym(XKB_KEY_XF86LaunchD); pub const XF86LaunchE: Keysym = Keysym(XKB_KEY_XF86LaunchE); pub const XF86LaunchF: Keysym = Keysym(XKB_KEY_XF86LaunchF); pub const XF86ApplicationLeft: Keysym = Keysym(XKB_KEY_XF86ApplicationLeft); pub const XF86ApplicationRight: Keysym = Keysym(XKB_KEY_XF86ApplicationRight); pub const XF86Book: Keysym = Keysym(XKB_KEY_XF86Book); pub const XF86CD: Keysym = Keysym(XKB_KEY_XF86CD); pub const XF86Calculater: Keysym = Keysym(XKB_KEY_XF86Calculater); pub const XF86Clear: Keysym = Keysym(XKB_KEY_XF86Clear); pub const XF86Close: Keysym = Keysym(XKB_KEY_XF86Close); pub const XF86Copy: Keysym = Keysym(XKB_KEY_XF86Copy); pub const XF86Cut: Keysym = Keysym(XKB_KEY_XF86Cut); pub const XF86Display: Keysym = Keysym(XKB_KEY_XF86Display); pub const XF86DOS: Keysym = Keysym(XKB_KEY_XF86DOS); pub const XF86Documents: Keysym = Keysym(XKB_KEY_XF86Documents); pub const XF86Excel: Keysym = Keysym(XKB_KEY_XF86Excel); pub const XF86Explorer: Keysym = Keysym(XKB_KEY_XF86Explorer); pub const XF86Game: Keysym = Keysym(XKB_KEY_XF86Game); pub const XF86Go: Keysym = Keysym(XKB_KEY_XF86Go); pub const XF86iTouch: Keysym = Keysym(XKB_KEY_XF86iTouch); pub const XF86LogOff: Keysym = Keysym(XKB_KEY_XF86LogOff); pub const XF86Market: Keysym = Keysym(XKB_KEY_XF86Market); pub const XF86Meeting: Keysym = Keysym(XKB_KEY_XF86Meeting); pub const XF86MenuKB: Keysym = Keysym(XKB_KEY_XF86MenuKB); pub const XF86MenuPB: Keysym = Keysym(XKB_KEY_XF86MenuPB); pub const XF86MySites: Keysym = Keysym(XKB_KEY_XF86MySites); pub const XF86New: Keysym = Keysym(XKB_KEY_XF86New); pub const XF86News: Keysym = Keysym(XKB_KEY_XF86News); pub const XF86OfficeHome: Keysym = Keysym(XKB_KEY_XF86OfficeHome); pub const XF86Open: Keysym = Keysym(XKB_KEY_XF86Open); pub const XF86Option: Keysym = Keysym(XKB_KEY_XF86Option); pub const XF86Paste: Keysym = Keysym(XKB_KEY_XF86Paste); pub const XF86Phone: Keysym = Keysym(XKB_KEY_XF86Phone); pub const XF86Q: Keysym = Keysym(XKB_KEY_XF86Q); pub const XF86Reply: Keysym = Keysym(XKB_KEY_XF86Reply); pub const XF86Reload: Keysym = Keysym(XKB_KEY_XF86Reload); pub const XF86RotateWindows: Keysym = Keysym(XKB_KEY_XF86RotateWindows); pub const XF86RotationPB: Keysym = Keysym(XKB_KEY_XF86RotationPB); pub const XF86RotationKB: Keysym = Keysym(XKB_KEY_XF86RotationKB); pub const XF86Save: Keysym = Keysym(XKB_KEY_XF86Save); pub const XF86ScrollUp: Keysym = Keysym(XKB_KEY_XF86ScrollUp); pub const XF86ScrollDown: Keysym = Keysym(XKB_KEY_XF86ScrollDown); pub const XF86ScrollClick: Keysym = Keysym(XKB_KEY_XF86ScrollClick); pub const XF86Send: Keysym = Keysym(XKB_KEY_XF86Send); pub const XF86Spell: Keysym = Keysym(XKB_KEY_XF86Spell); pub const XF86SplitScreen: Keysym = Keysym(XKB_KEY_XF86SplitScreen); pub const XF86Support: Keysym = Keysym(XKB_KEY_XF86Support); pub const XF86TaskPane: Keysym = Keysym(XKB_KEY_XF86TaskPane); pub const XF86Terminal: Keysym = Keysym(XKB_KEY_XF86Terminal); pub const XF86Tools: Keysym = Keysym(XKB_KEY_XF86Tools); pub const XF86Travel: Keysym = Keysym(XKB_KEY_XF86Travel); pub const XF86UserPB: Keysym = Keysym(XKB_KEY_XF86UserPB); pub const XF86User1KB: Keysym = Keysym(XKB_KEY_XF86User1KB); pub const XF86User2KB: Keysym = Keysym(XKB_KEY_XF86User2KB); pub const XF86Video: Keysym = Keysym(XKB_KEY_XF86Video); pub const XF86WheelButton: Keysym = Keysym(XKB_KEY_XF86WheelButton); pub const XF86Word: Keysym = Keysym(XKB_KEY_XF86Word); pub const XF86Xfer: Keysym = Keysym(XKB_KEY_XF86Xfer); pub const XF86ZoomIn: Keysym = Keysym(XKB_KEY_XF86ZoomIn); pub const XF86ZoomOut: Keysym = Keysym(XKB_KEY_XF86ZoomOut); pub const XF86Away: Keysym = Keysym(XKB_KEY_XF86Away); pub const XF86Messenger: Keysym = Keysym(XKB_KEY_XF86Messenger); pub const XF86WebCam: Keysym = Keysym(XKB_KEY_XF86WebCam); pub const XF86MailForward: Keysym = Keysym(XKB_KEY_XF86MailForward); pub const XF86Pictures: Keysym = Keysym(XKB_KEY_XF86Pictures); pub const XF86Music: Keysym = Keysym(XKB_KEY_XF86Music); pub const XF86Battery: Keysym = Keysym(XKB_KEY_XF86Battery); pub const XF86Bluetooth: Keysym = Keysym(XKB_KEY_XF86Bluetooth); pub const XF86WLAN: Keysym = Keysym(XKB_KEY_XF86WLAN); pub const XF86UWB: Keysym = Keysym(XKB_KEY_XF86UWB); pub const XF86AudioForward: Keysym = Keysym(XKB_KEY_XF86AudioForward); pub const XF86AudioRepeat: Keysym = Keysym(XKB_KEY_XF86AudioRepeat); pub const XF86AudioRandomPlay: Keysym = Keysym(XKB_KEY_XF86AudioRandomPlay); pub const XF86Subtitle: Keysym = Keysym(XKB_KEY_XF86Subtitle); pub const XF86AudioCycleTrack: Keysym = Keysym(XKB_KEY_XF86AudioCycleTrack); pub const XF86CycleAngle: Keysym = Keysym(XKB_KEY_XF86CycleAngle); pub const XF86FrameBack: Keysym = Keysym(XKB_KEY_XF86FrameBack); pub const XF86FrameForward: Keysym = Keysym(XKB_KEY_XF86FrameForward); pub const XF86Time: Keysym = Keysym(XKB_KEY_XF86Time); pub const XF86Select: Keysym = Keysym(XKB_KEY_XF86Select); pub const XF86View: Keysym = Keysym(XKB_KEY_XF86View); pub const XF86TopMenu: Keysym = Keysym(XKB_KEY_XF86TopMenu); pub const XF86Red: Keysym = Keysym(XKB_KEY_XF86Red); pub const XF86Green: Keysym = Keysym(XKB_KEY_XF86Green); pub const XF86Yellow: Keysym = Keysym(XKB_KEY_XF86Yellow); pub const XF86Blue: Keysym = Keysym(XKB_KEY_XF86Blue); pub const XF86Suspend: Keysym = Keysym(XKB_KEY_XF86Suspend); pub const XF86Hibernate: Keysym = Keysym(XKB_KEY_XF86Hibernate); pub const XF86TouchpadToggle: Keysym = Keysym(XKB_KEY_XF86TouchpadToggle); pub const XF86TouchpadOn: Keysym = Keysym(XKB_KEY_XF86TouchpadOn); pub const XF86TouchpadOff: Keysym = Keysym(XKB_KEY_XF86TouchpadOff); pub const XF86AudioMicMute: Keysym = Keysym(XKB_KEY_XF86AudioMicMute); pub const XF86Switch_VT_1: Keysym = Keysym(XKB_KEY_XF86Switch_VT_1); pub const XF86Switch_VT_2: Keysym = Keysym(XKB_KEY_XF86Switch_VT_2); pub const XF86Switch_VT_3: Keysym = Keysym(XKB_KEY_XF86Switch_VT_3); pub const XF86Switch_VT_4: Keysym = Keysym(XKB_KEY_XF86Switch_VT_4); pub const XF86Switch_VT_5: Keysym = Keysym(XKB_KEY_XF86Switch_VT_5); pub const XF86Switch_VT_6: Keysym = Keysym(XKB_KEY_XF86Switch_VT_6); pub const XF86Switch_VT_7: Keysym = Keysym(XKB_KEY_XF86Switch_VT_7); pub const XF86Switch_VT_8: Keysym = Keysym(XKB_KEY_XF86Switch_VT_8); pub const XF86Switch_VT_9: Keysym = Keysym(XKB_KEY_XF86Switch_VT_9); pub const XF86Switch_VT_10: Keysym = Keysym(XKB_KEY_XF86Switch_VT_10); pub const XF86Switch_VT_11: Keysym = Keysym(XKB_KEY_XF86Switch_VT_11); pub const XF86Switch_VT_12: Keysym = Keysym(XKB_KEY_XF86Switch_VT_12); pub const XF86Ungrab: Keysym = Keysym(XKB_KEY_XF86Ungrab); pub const XF86ClearGrab: Keysym = Keysym(XKB_KEY_XF86ClearGrab); pub const XF86Next_VMode: Keysym = Keysym(XKB_KEY_XF86Next_VMode); pub const XF86Prev_VMode: Keysym = Keysym(XKB_KEY_XF86Prev_VMode); pub const XF86LogWindowTree: Keysym = Keysym(XKB_KEY_XF86LogWindowTree); pub const XF86LogGrabInfo: Keysym = Keysym(XKB_KEY_XF86LogGrabInfo); pub const SunFA_Grave: Keysym = Keysym(XKB_KEY_SunFA_Grave); pub const SunFA_Circum: Keysym = Keysym(XKB_KEY_SunFA_Circum); pub const SunFA_Tilde: Keysym = Keysym(XKB_KEY_SunFA_Tilde); pub const SunFA_Acute: Keysym = Keysym(XKB_KEY_SunFA_Acute); pub const SunFA_Diaeresis: Keysym = Keysym(XKB_KEY_SunFA_Diaeresis); pub const SunFA_Cedilla: Keysym = Keysym(XKB_KEY_SunFA_Cedilla); pub const SunF36: Keysym = Keysym(XKB_KEY_SunF36); pub const SunF37: Keysym = Keysym(XKB_KEY_SunF37); pub const SunSys_Req: Keysym = Keysym(XKB_KEY_SunSys_Req); pub const SunPrint_Screen: Keysym = Keysym(XKB_KEY_SunPrint_Screen); pub const SunCompose: Keysym = Keysym(XKB_KEY_SunCompose); pub const SunAltGraph: Keysym = Keysym(XKB_KEY_SunAltGraph); pub const SunPageUp: Keysym = Keysym(XKB_KEY_SunPageUp); pub const SunPageDown: Keysym = Keysym(XKB_KEY_SunPageDown); pub const SunUndo: Keysym = Keysym(XKB_KEY_SunUndo); pub const SunAgain: Keysym = Keysym(XKB_KEY_SunAgain); pub const SunFind: Keysym = Keysym(XKB_KEY_SunFind); pub const SunStop: Keysym = Keysym(XKB_KEY_SunStop); pub const SunProps: Keysym = Keysym(XKB_KEY_SunProps); pub const SunFront: Keysym = Keysym(XKB_KEY_SunFront); pub const SunCopy: Keysym = Keysym(XKB_KEY_SunCopy); pub const SunOpen: Keysym = Keysym(XKB_KEY_SunOpen); pub const SunPaste: Keysym = Keysym(XKB_KEY_SunPaste); pub const SunCut: Keysym = Keysym(XKB_KEY_SunCut); pub const SunPowerSwitch: Keysym = Keysym(XKB_KEY_SunPowerSwitch); pub const SunAudioLowerVolume: Keysym = Keysym(XKB_KEY_SunAudioLowerVolume); pub const SunAudioMute: Keysym = Keysym(XKB_KEY_SunAudioMute); pub const SunAudioRaiseVolume: Keysym = Keysym(XKB_KEY_SunAudioRaiseVolume); pub const SunVideoDegauss: Keysym = Keysym(XKB_KEY_SunVideoDegauss); pub const SunVideoLowerBrightness: Keysym = Keysym(XKB_KEY_SunVideoLowerBrightness); pub const SunVideoRaiseBrightness: Keysym = Keysym(XKB_KEY_SunVideoRaiseBrightness); pub const SunPowerSwitchShift: Keysym = Keysym(XKB_KEY_SunPowerSwitchShift); pub const Dring_accent: Keysym = Keysym(XKB_KEY_Dring_accent); pub const Dcircumflex_accent: Keysym = Keysym(XKB_KEY_Dcircumflex_accent); pub const Dcedilla_accent: Keysym = Keysym(XKB_KEY_Dcedilla_accent); pub const Dacute_accent: Keysym = Keysym(XKB_KEY_Dacute_accent); pub const Dgrave_accent: Keysym = Keysym(XKB_KEY_Dgrave_accent); pub const Dtilde: Keysym = Keysym(XKB_KEY_Dtilde); pub const Ddiaeresis: Keysym = Keysym(XKB_KEY_Ddiaeresis); pub const DRemove: Keysym = Keysym(XKB_KEY_DRemove); pub const hpClearLine: Keysym = Keysym(XKB_KEY_hpClearLine); pub const hpInsertLine: Keysym = Keysym(XKB_KEY_hpInsertLine); pub const hpDeleteLine: Keysym = Keysym(XKB_KEY_hpDeleteLine); pub const hpInsertChar: Keysym = Keysym(XKB_KEY_hpInsertChar); pub const hpDeleteChar: Keysym = Keysym(XKB_KEY_hpDeleteChar); pub const hpBackTab: Keysym = Keysym(XKB_KEY_hpBackTab); pub const hpKP_BackTab: Keysym = Keysym(XKB_KEY_hpKP_BackTab); pub const hpModelock1: Keysym = Keysym(XKB_KEY_hpModelock1); pub const hpModelock2: Keysym = Keysym(XKB_KEY_hpModelock2); pub const hpReset: Keysym = Keysym(XKB_KEY_hpReset); pub const hpSystem: Keysym = Keysym(XKB_KEY_hpSystem); pub const hpUser: Keysym = Keysym(XKB_KEY_hpUser); pub const hpmute_acute: Keysym = Keysym(XKB_KEY_hpmute_acute); pub const hpmute_grave: Keysym = Keysym(XKB_KEY_hpmute_grave); pub const hpmute_asciicircum: Keysym = Keysym(XKB_KEY_hpmute_asciicircum); pub const hpmute_diaeresis: Keysym = Keysym(XKB_KEY_hpmute_diaeresis); pub const hpmute_asciitilde: Keysym = Keysym(XKB_KEY_hpmute_asciitilde); pub const hplira: Keysym = Keysym(XKB_KEY_hplira); pub const hpguilder: Keysym = Keysym(XKB_KEY_hpguilder); pub const hpYdiaeresis: Keysym = Keysym(XKB_KEY_hpYdiaeresis); pub const hpIO: Keysym = Keysym(XKB_KEY_hpIO); pub const hplongminus: Keysym = Keysym(XKB_KEY_hplongminus); pub const hpblock: Keysym = Keysym(XKB_KEY_hpblock); pub const osfCopy: Keysym = Keysym(XKB_KEY_osfCopy); pub const osfCut: Keysym = Keysym(XKB_KEY_osfCut); pub const osfPaste: Keysym = Keysym(XKB_KEY_osfPaste); pub const osfBackTab: Keysym = Keysym(XKB_KEY_osfBackTab); pub const osfBackSpace: Keysym = Keysym(XKB_KEY_osfBackSpace); pub const osfClear: Keysym = Keysym(XKB_KEY_osfClear); pub const osfEscape: Keysym = Keysym(XKB_KEY_osfEscape); pub const osfAddMode: Keysym = Keysym(XKB_KEY_osfAddMode); pub const osfPrimaryPaste: Keysym = Keysym(XKB_KEY_osfPrimaryPaste); pub const osfQuickPaste: Keysym = Keysym(XKB_KEY_osfQuickPaste); pub const osfPageLeft: Keysym = Keysym(XKB_KEY_osfPageLeft); pub const osfPageUp: Keysym = Keysym(XKB_KEY_osfPageUp); pub const osfPageDown: Keysym = Keysym(XKB_KEY_osfPageDown); pub const osfPageRight: Keysym = Keysym(XKB_KEY_osfPageRight); pub const osfActivate: Keysym = Keysym(XKB_KEY_osfActivate); pub const osfMenuBar: Keysym = Keysym(XKB_KEY_osfMenuBar); pub const osfLeft: Keysym = Keysym(XKB_KEY_osfLeft); pub const osfUp: Keysym = Keysym(XKB_KEY_osfUp); pub const osfRight: Keysym = Keysym(XKB_KEY_osfRight); pub const osfDown: Keysym = Keysym(XKB_KEY_osfDown); pub const osfEndLine: Keysym = Keysym(XKB_KEY_osfEndLine); pub const osfBeginLine: Keysym = Keysym(XKB_KEY_osfBeginLine); pub const osfEndData: Keysym = Keysym(XKB_KEY_osfEndData); pub const osfBeginData: Keysym = Keysym(XKB_KEY_osfBeginData); pub const osfPrevMenu: Keysym = Keysym(XKB_KEY_osfPrevMenu); pub const osfNextMenu: Keysym = Keysym(XKB_KEY_osfNextMenu); pub const osfPrevField: Keysym = Keysym(XKB_KEY_osfPrevField); pub const osfNextField: Keysym = Keysym(XKB_KEY_osfNextField); pub const osfSelect: Keysym = Keysym(XKB_KEY_osfSelect); pub const osfInsert: Keysym = Keysym(XKB_KEY_osfInsert); pub const osfUndo: Keysym = Keysym(XKB_KEY_osfUndo); pub const osfMenu: Keysym = Keysym(XKB_KEY_osfMenu); pub const osfCancel: Keysym = Keysym(XKB_KEY_osfCancel); pub const osfHelp: Keysym = Keysym(XKB_KEY_osfHelp); pub const osfSelectAll: Keysym = Keysym(XKB_KEY_osfSelectAll); pub const osfDeselectAll: Keysym = Keysym(XKB_KEY_osfDeselectAll); pub const osfReselect: Keysym = Keysym(XKB_KEY_osfReselect); pub const osfExtend: Keysym = Keysym(XKB_KEY_osfExtend); pub const osfRestore: Keysym = Keysym(XKB_KEY_osfRestore); pub const osfDelete: Keysym = Keysym(XKB_KEY_osfDelete); xkb-0.3.0/src/keymap/compile.rs000064400000000000000000000014261046102023000144660ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use ffi::*; use bitflags::bitflags; bitflags! { pub struct Flags: xkb_keymap_compile_flags { const NO_FLAGS = XKB_KEYMAP_COMPILE_NO_FLAGS; } } pub const NO_FLAGS: Flags = Flags::NO_FLAGS; impl Default for Flags { fn default() -> Self { NO_FLAGS } } xkb-0.3.0/src/keymap/key.rs000064400000000000000000000027741046102023000136350ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::ptr; use ffi::*; use crate::{Keymap, Keycode, Keysym}; use crate::{LayoutIndex, LevelIndex}; #[derive(Debug)] pub struct Key<'a>(pub &'a Keymap, pub Keycode); impl<'a> Key<'a> { pub fn layouts(&self) -> usize { unsafe { xkb_keymap_num_layouts_for_key(self.0.as_ptr(), self.1.into()) as usize } } pub fn levels(&self, layout: LayoutIndex) -> usize { unsafe { xkb_keymap_num_levels_for_key(self.0.as_ptr(), self.1.into(), layout.into()) as usize } } pub fn repeats(&self) -> bool { unsafe { xkb_keymap_key_repeats(self.0.as_ptr(), self.1.into()) != 0 } } pub fn syms(&self, layout: LayoutIndex, level: LevelIndex) -> Vec { unsafe { let mut syms = ptr::null(); let len = xkb_keymap_key_get_syms_by_level(self.0.as_ptr(), self.1.into(), layout.into(), level.into(), &mut syms); let mut result = Vec::with_capacity(len as usize); for i in 0 .. len { result.push(Keysym::from(*syms.offset(i as isize))); } result } } } xkb-0.3.0/src/keymap/keymap.rs000064400000000000000000000025041046102023000143220ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use ffi::*; use crate::Keycode; use crate::keymap::{Mods, Layouts, Leds, Key}; use crate::state::State; #[derive(Debug)] pub struct Keymap(*mut xkb_keymap); impl Keymap { pub unsafe fn from_ptr(ptr: *mut xkb_keymap) -> Self { Keymap(ptr) } pub unsafe fn as_ptr(&self) -> *mut xkb_keymap { self.0 } pub fn mods(&self) -> Mods { Mods(self) } pub fn layouts(&self) -> Layouts { Layouts(self) } pub fn leds(&self) -> Leds { Leds(self) } pub fn key(&self, key: Keycode) -> Key { Key(self, key) } pub fn state(&self) -> State { unsafe { State::from_ptr(xkb_state_new(self.0)) } } } impl Clone for Keymap { fn clone(&self) -> Self { unsafe { Keymap(xkb_keymap_ref(self.0)) } } } impl Drop for Keymap { fn drop(&mut self) { unsafe { xkb_keymap_unref(self.0); } } } xkb-0.3.0/src/keymap/layouts.rs000064400000000000000000000041661046102023000145420ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::ffi::{CStr, CString}; use ffi::*; use crate::keymap::Keymap; #[derive(Debug)] pub struct Layouts<'a>(pub &'a Keymap); impl<'a> Layouts<'a> { pub fn len(&self) -> usize { unsafe { xkb_keymap_num_mods(self.0.as_ptr()) as usize } } pub fn by_index(&self, index: usize) -> Option<&str> { unsafe { xkb_keymap_layout_get_name(self.0.as_ptr(), index as xkb_layout_index_t) .as_ref().map(|ptr| CStr::from_ptr(ptr).to_str().unwrap()) } } pub fn by_name>(&self, name: S) -> Option { unsafe { let string = CString::new(name.as_ref()).unwrap(); match xkb_keymap_layout_get_index(self.0.as_ptr(), string.as_ptr()) { XKB_LAYOUT_INVALID => None, index => Some(index as usize) } } } pub fn iter(&self) -> Iter { Iter::new(self) } } pub struct Iter<'a> { inner: &'a Layouts<'a>, current: xkb_layout_index_t, length: xkb_layout_index_t, } impl<'a> Iter<'a> { fn new(inner: &'a Layouts<'a>) -> Iter<'a> { Iter { inner: inner, current: 0, length: inner.len() as xkb_layout_index_t, } } } impl<'a> Iterator for Iter<'a> { type Item = (usize, &'a str); fn next(&mut self) -> Option { if self.current == self.length { return None; } unsafe { let index = self.current; let name = xkb_keymap_layout_get_name(self.inner.0.as_ptr(), index); self.current += 1; Some((index as usize, CStr::from_ptr(name).to_str().unwrap())) } } } impl<'a> IntoIterator for &'a Layouts<'a> { type Item = (usize, &'a str); type IntoIter = Iter<'a>; fn into_iter(self) -> Self::IntoIter { self.iter() } } xkb-0.3.0/src/keymap/leds.rs000064400000000000000000000041171046102023000137650ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::ffi::{CStr, CString}; use ffi::*; use crate::keymap::Keymap; #[derive(Debug)] pub struct Leds<'a>(pub &'a Keymap); impl<'a> Leds<'a> { pub fn len(&self) -> usize { unsafe { xkb_keymap_num_leds(self.0.as_ptr()) as usize } } pub fn by_index(&self, index: usize) -> Option<&str> { unsafe { xkb_keymap_led_get_name(self.0.as_ptr(), index as xkb_led_index_t) .as_ref().map(|ptr| CStr::from_ptr(ptr).to_str().unwrap()) } } pub fn by_name>(&self, name: S) -> Option { unsafe { let string = CString::new(name.as_ref()).unwrap(); match xkb_keymap_led_get_index(self.0.as_ptr(), string.as_ptr()) { XKB_LED_INVALID => None, index => Some(index as usize) } } } pub fn iter(&self) -> Iter { Iter::new(self) } } pub struct Iter<'a> { inner: &'a Leds<'a>, current: xkb_led_index_t, length: xkb_led_index_t, } impl<'a> Iter<'a> { fn new(inner: &'a Leds<'a>) -> Iter<'a> { Iter { inner: inner, current: 0, length: inner.len() as xkb_led_index_t, } } } impl<'a> Iterator for Iter<'a> { type Item = (usize, &'a str); fn next(&mut self) -> Option { if self.current == self.length { return None; } unsafe { let index = self.current; let name = xkb_keymap_led_get_name(self.inner.0.as_ptr(), index); self.current += 1; Some((index as usize, CStr::from_ptr(name).to_str().unwrap())) } } } impl<'a> IntoIterator for &'a Leds<'a> { type Item = (usize, &'a str); type IntoIter = Iter<'a>; fn into_iter(self) -> Self::IntoIter { self.iter() } } xkb-0.3.0/src/keymap/mod.rs000064400000000000000000000013501046102023000136110ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. mod keymap; pub use self::keymap::Keymap; mod mods; pub use self::mods::Mods; mod layouts; pub use self::layouts::Layouts; mod leds; pub use self::leds::Leds; mod key; pub use self::key::Key; pub mod compile; xkb-0.3.0/src/keymap/mods.rs000064400000000000000000000041171046102023000140000ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::ffi::{CStr, CString}; use ffi::*; use crate::keymap::Keymap; #[derive(Debug)] pub struct Mods<'a>(pub &'a Keymap); impl<'a> Mods<'a> { pub fn len(&self) -> usize { unsafe { xkb_keymap_num_mods(self.0.as_ptr()) as usize } } pub fn by_index(&self, index: usize) -> Option<&str> { unsafe { xkb_keymap_mod_get_name(self.0.as_ptr(), index as xkb_mod_index_t) .as_ref().map(|ptr| CStr::from_ptr(ptr).to_str().unwrap()) } } pub fn by_name>(&self, name: S) -> Option { unsafe { let string = CString::new(name.as_ref()).unwrap(); match xkb_keymap_mod_get_index(self.0.as_ptr(), string.as_ptr()) { XKB_MOD_INVALID => None, index => Some(index as usize) } } } pub fn iter(&self) -> Iter { Iter::new(self) } } pub struct Iter<'a> { inner: &'a Mods<'a>, current: xkb_mod_index_t, length: xkb_mod_index_t, } impl<'a> Iter<'a> { fn new(inner: &'a Mods<'a>) -> Iter<'a> { Iter { inner: inner, current: 0, length: inner.len() as xkb_mod_index_t, } } } impl<'a> Iterator for Iter<'a> { type Item = (usize, &'a str); fn next(&mut self) -> Option { if self.current == self.length { return None; } unsafe { let index = self.current; let name = xkb_keymap_mod_get_name(self.inner.0.as_ptr(), index); self.current += 1; Some((index as usize, CStr::from_ptr(name).to_str().unwrap())) } } } impl<'a> IntoIterator for &'a Mods<'a> { type Item = (usize, &'a str); type IntoIter = Iter<'a>; fn into_iter(self) -> Self::IntoIter { self.iter() } } xkb-0.3.0/src/keysym.rs000064400000000000000000000047131046102023000130730ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::fmt; use std::str; use std::ffi::{CStr, CString}; use libc::{size_t}; use ffi::*; define!(Keysym, xkb_keysym_t); impl Keysym { #[inline] pub fn utf8(&self) -> String { unsafe { let mut buffer = [0; 64]; match xkb_keysym_to_utf8(self.0, buffer.as_mut_ptr(), buffer.len() as size_t) { -1 => unreachable!(), 0 => "".into(), _ => CStr::from_ptr(buffer.as_ptr()).to_str().unwrap().into(), } } } #[inline] pub fn utf32(&self) -> u32 { unsafe { xkb_keysym_to_utf32(self.0) } } } impl fmt::Display for Keysym { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { unsafe { let mut buffer = [0; 64]; if xkb_keysym_get_name(self.0, buffer.as_mut_ptr(), buffer.len() as size_t) < 0 { return Err(fmt::Error); } f.write_str(CStr::from_ptr(buffer.as_ptr()).to_str().ok().ok_or(fmt::Error)?) } } } impl str::FromStr for Keysym { type Err = (); fn from_str(s: &str) -> Result { unsafe { let name = CString::new(s).ok().ok_or(())?; match xkb_keysym_from_name(name.as_ptr(), XKB_KEYSYM_NO_FLAGS) { XKB_KEY_NoSymbol => match xkb_keysym_from_name(name.as_ptr(), XKB_KEYSYM_CASE_INSENSITIVE) { XKB_KEY_NoSymbol => Err(()), value => Ok(Keysym(value)), }, value => Ok(Keysym(value)) } } } } #[cfg(test)] mod tests { use ffi::*; use super::*; #[test] fn parse() { assert_eq!(Keysym::from(XKB_KEY_a), "a".parse().unwrap()); assert_eq!(Keysym::from(XKB_KEY_A), "A".parse().unwrap()); assert_eq!(Keysym::from(XKB_KEY_Sys_Req), "Sys_Req".parse().unwrap()); assert_eq!(Keysym::from(XKB_KEY_Sys_Req), "sys_req".parse().unwrap()); } #[test] fn display() { assert_eq!("a", Keysym::from(XKB_KEY_a).to_string()); assert_eq!("A", Keysym::from(XKB_KEY_A).to_string()); } #[test] fn utf8() { assert_eq!("a", Keysym::from(XKB_KEY_a).utf8()); assert_eq!("Á", Keysym::from(XKB_KEY_Aacute).utf8()); } } xkb-0.3.0/src/lib.rs000064400000000000000000000016011046102023000123110ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. #![allow(non_upper_case_globals)] #[cfg(feature = "x11")] extern crate xcb; #[macro_use] mod base; pub use self::base::*; mod keysym; pub use keysym::Keysym; pub mod context; pub use context::Context; pub mod keymap; pub use keymap::Keymap; pub mod state; pub use state::State; pub mod name; pub mod key; pub mod compose; #[cfg(feature = "x11")] pub mod x11; xkb-0.3.0/src/name.rs000064400000000000000000000025011046102023000124630ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. pub mod mods { use ffi::*; use libc::c_char; pub const SHIFT: *const c_char = XKB_MOD_NAME_SHIFT.as_ptr().cast::(); pub const CAPS: *const c_char = XKB_MOD_NAME_CAPS.as_ptr().cast::(); pub const CTRL: *const c_char = XKB_MOD_NAME_CTRL.as_ptr().cast::(); pub const ALT: *const c_char = XKB_MOD_NAME_ALT.as_ptr().cast::(); pub const NUM: *const c_char = XKB_MOD_NAME_NUM.as_ptr().cast::(); pub const LOGO: *const c_char = XKB_MOD_NAME_LOGO.as_ptr().cast::(); } pub mod leds { use ffi::*; use libc::c_char; pub const CAPS: *const c_char = XKB_LED_NAME_CAPS.as_ptr().cast::(); pub const NUM: *const c_char = XKB_LED_NAME_NUM.as_ptr().cast::(); pub const SCROLL: *const c_char = XKB_LED_NAME_SCROLL.as_ptr().cast::(); } xkb-0.3.0/src/state/component.rs000064400000000000000000000032511046102023000146700ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use ffi::*; use bitflags::bitflags; bitflags! { pub struct Components: xkb_state_component { const MODS_DEPRESSED = XKB_STATE_MODS_DEPRESSED; const MODS_LATCHED = XKB_STATE_MODS_LATCHED; const MODS_LOCKED = XKB_STATE_MODS_LOCKED; const MODS_EFFECTIVE = XKB_STATE_MODS_EFFECTIVE; const LAYOUT_DEPRESSED = XKB_STATE_LAYOUT_DEPRESSED; const LAYOUT_LATCHED = XKB_STATE_LAYOUT_LATCHED; const LAYOUT_LOCKED = XKB_STATE_LAYOUT_LOCKED; const LAYOUT_EFFECTIVE = XKB_STATE_LAYOUT_EFFECTIVE; const LEDS = XKB_STATE_LEDS; } } pub const MODS_DEPRESSED: Components = Components::MODS_DEPRESSED; pub const MODS_LATCHED: Components = Components::MODS_LATCHED; pub const MODS_LOCKED: Components = Components::MODS_LOCKED; pub const MODS_EFFECTIVE: Components = Components::MODS_EFFECTIVE; pub const LAYOUT_DEPRESSED: Components = Components::LAYOUT_DEPRESSED; pub const LAYOUT_LATCHED: Components = Components::LAYOUT_LATCHED; pub const LAYOUT_LOCKED: Components = Components::LAYOUT_LOCKED; pub const LAYOUT_EFFECTIVE: Components = Components::LAYOUT_EFFECTIVE; pub const LEDS: Components = Components::LEDS; xkb-0.3.0/src/state/key.rs000064400000000000000000000047441046102023000134660ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::ptr; use std::mem; use std::ffi::CStr; use libc::size_t; use ffi::*; use crate::{State, Keycode, Keysym}; use crate::{LayoutIndex, LevelIndex, ModMask}; use crate::state::Consumed; #[derive(Debug)] pub struct Key<'a>(pub &'a State, pub Keycode); impl<'a> Key<'a> { #[inline] pub fn layout(&self) -> Option { unsafe { match xkb_state_key_get_layout(self.0.as_ptr(), self.1.into()) { XKB_LAYOUT_INVALID => None, value => Some(value as usize) } } } #[inline] pub fn level(&self, layout: LayoutIndex) -> Option { unsafe { match xkb_state_key_get_level(self.0.as_ptr(), self.1.into(), layout.into()) { XKB_LEVEL_INVALID => None, value => Some(value.into()), } } } #[inline] pub fn consumed(&self, mode: Consumed) -> ModMask { unsafe { xkb_state_key_get_consumed_mods2(self.0.as_ptr(), self.1.into(), mem::transmute(mode)).into() } } #[inline] pub fn utf8(&self) -> Option { unsafe { let mut buffer = [0; 64]; match xkb_state_key_get_utf8(self.0.as_ptr(), self.1.into(), buffer.as_mut_ptr(), buffer.len() as size_t) { -1 => unreachable!(), 0 => None, _ => Some(CStr::from_ptr(buffer.as_ptr()).to_str().unwrap().into()), } } } #[inline] pub fn utf32(&self) -> Option { unsafe { match xkb_state_key_get_utf32(self.0.as_ptr(), self.1.into()) { 0 => None, n => Some(n), } } } #[inline] pub fn sym(&self) -> Option { unsafe { match xkb_state_key_get_one_sym(self.0.as_ptr(), self.1.into()) { XKB_KEY_NoSymbol => None, value => Some(Keysym::from(value)) } } } #[inline] pub fn syms(&self) -> Vec { unsafe { let mut syms = ptr::null(); let len = xkb_state_key_get_syms(self.0.as_ptr(), self.1.into(), &mut syms); let mut result = Vec::with_capacity(len as usize); for i in 0 .. len { result.push(Keysym::from(*syms.offset(i as isize))); } result } } } xkb-0.3.0/src/state/layouts.rs000064400000000000000000000035241046102023000143710ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::ffi::{CString, CStr}; use libc::c_char; use ffi::*; use crate::{State, LayoutIndex}; use crate::state::Components; #[derive(Debug)] pub struct Layouts<'a>(pub &'a State); impl<'a> Layouts<'a> { pub fn active>(&self, parameter: P, component: Components) -> bool { unsafe { match parameter.into() { Parameter::Name(name) => xkb_state_layout_name_is_active(self.0.as_ptr(), name.as_ptr(), component.bits()) != 0, Parameter::Index(index) => xkb_state_layout_index_is_active(self.0.as_ptr(), index.into(), component.bits()) != 0, } } } } #[derive(Debug)] pub enum Parameter { Name(CString), Index(LayoutIndex), } impl From<*const c_char> for Parameter { fn from(value: *const c_char) -> Parameter { unsafe { Parameter::Name(CStr::from_ptr(value).to_owned()) } } } impl<'a> From<&'a str> for Parameter { fn from(value: &str) -> Parameter { Parameter::Name(CString::new(value).unwrap()) } } impl<'a> From for Parameter { fn from(value: String) -> Parameter { Parameter::Name(CString::new(value).unwrap()) } } impl From for Parameter { fn from(value: LayoutIndex) -> Parameter { Parameter::Index(value) } } impl From for Parameter { fn from(value: xkb_layout_index_t) -> Parameter { Parameter::Index(value.into()) } } xkb-0.3.0/src/state/leds.rs000064400000000000000000000033271046102023000136210ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::ffi::{CString, CStr}; use ffi::*; use crate::{State, LedIndex}; #[derive(Debug)] pub struct Leds<'a>(pub &'a State); impl<'a> Leds<'a> { pub fn active>(&self, parameter: P) -> bool { unsafe { match parameter.into() { Parameter::Name(name) => xkb_state_led_name_is_active(self.0.as_ptr(), name.as_ptr()) != 0, Parameter::Index(index) => xkb_state_led_index_is_active(self.0.as_ptr(), index.into()) != 0, } } } } #[derive(Debug)] pub enum Parameter { Name(CString), Index(LedIndex), } impl<'a> From<&'a [u8]> for Parameter { fn from(value: &[u8]) -> Parameter { unsafe { Parameter::Name(CStr::from_ptr(value.as_ptr() as *const _).to_owned()) } } } impl<'a> From<&'a str> for Parameter { fn from(value: &str) -> Parameter { Parameter::Name(CString::new(value).unwrap()) } } impl<'a> From for Parameter { fn from(value: String) -> Parameter { Parameter::Name(CString::new(value).unwrap()) } } impl From for Parameter { fn from(value: LedIndex) -> Parameter { Parameter::Index(value) } } impl From for Parameter { fn from(value: xkb_led_index_t) -> Parameter { Parameter::Index(value.into()) } } xkb-0.3.0/src/state/mod.rs000064400000000000000000000017061046102023000134500ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. mod state; pub use self::state::State; mod key; pub use self::key::Key; mod serialize; pub use self::serialize::Serialize; mod update; pub use self::update::Update; mod mods; pub use self::mods::Mods; mod layouts; pub use self::layouts::Layouts; mod leds; pub use self::leds::Leds; pub mod component; pub use self::component::Components; #[repr(C)] #[derive(Eq, PartialEq, Copy, Clone, Debug)] pub enum Consumed { Xkb, Gtk, } xkb-0.3.0/src/state/mods.rs000064400000000000000000000034661046102023000136400ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::ffi::{CString, CStr}; use libc::c_char; use ffi::*; use crate::{State, ModIndex}; use crate::state::Components; #[derive(Debug)] pub struct Mods<'a>(pub &'a State); impl<'a> Mods<'a> { pub fn active>(&self, parameter: P, component: Components) -> bool { unsafe { match parameter.into() { Parameter::Name(name) => xkb_state_mod_name_is_active(self.0.as_ptr(), name.as_ptr(), component.bits()) != 0, Parameter::Index(index) => xkb_state_mod_index_is_active(self.0.as_ptr(), index.into(), component.bits()) != 0, } } } } #[derive(Debug)] pub enum Parameter { Name(CString), Index(ModIndex), } impl From<*const c_char> for Parameter { fn from(value: *const c_char) -> Parameter { unsafe { Parameter::Name(CStr::from_ptr(value).to_owned()) } } } impl<'a> From<&'a str> for Parameter { fn from(value: &str) -> Parameter { Parameter::Name(CString::new(value).unwrap()) } } impl<'a> From for Parameter { fn from(value: String) -> Parameter { Parameter::Name(CString::new(value).unwrap()) } } impl From for Parameter { fn from(value: ModIndex) -> Parameter { Parameter::Index(value) } } impl From for Parameter { fn from(value: xkb_mod_index_t) -> Parameter { Parameter::Index(value.into()) } } xkb-0.3.0/src/state/serialize.rs000064400000000000000000000020171046102023000146540ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use ffi::*; use crate::{ModMask, LayoutIndex}; use crate::state::{State, Components}; #[derive(Debug)] pub struct Serialize<'a>(pub &'a mut State); impl<'a> Serialize<'a> { #[inline] pub fn mods(&mut self, components: Components) -> ModMask { unsafe { xkb_state_serialize_mods(self.0.as_ptr(), components.bits()).into() } } #[inline] pub fn layouts(&mut self, components: Components) -> LayoutIndex { unsafe { xkb_state_serialize_layout(self.0.as_ptr(), components.bits()).into() } } } xkb-0.3.0/src/state/state.rs000064400000000000000000000031171046102023000140070ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use ffi::*; use crate::{Keymap, Keycode}; use crate::state::{Key, Serialize, Update, Mods, Layouts, Leds}; #[derive(Debug)] pub struct State(*mut xkb_state); impl State { #[inline] pub unsafe fn from_ptr(ptr: *mut xkb_state) -> Self { State(ptr) } #[inline] pub unsafe fn as_ptr(&self) -> *mut xkb_state { self.0 } #[inline] pub fn keymap(&self) -> Keymap { unsafe { Keymap::from_ptr(xkb_state_get_keymap(self.0)) } } #[inline] pub fn key>(&self, code: T) -> Key { Key(self, code.into()) } #[inline] pub fn serialize(&mut self) -> Serialize { Serialize(self) } #[inline] pub fn update(&mut self) -> Update { Update(self) } #[inline] pub fn mods(&self) -> Mods { Mods(self) } #[inline] pub fn layouts(&self) -> Layouts { Layouts(self) } #[inline] pub fn leds(&self) -> Leds { Leds(self) } } impl Clone for State { #[inline] fn clone(&self) -> Self { unsafe { State(xkb_state_ref(self.0)) } } } impl Drop for State { #[inline] fn drop(&mut self) { unsafe { xkb_state_unref(self.0); } } } xkb-0.3.0/src/state/update.rs000064400000000000000000000030311046102023000141440ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use std::mem; use ffi::*; use crate::{key, Keycode, ModMask, LayoutMask}; use crate::state::{State, Components}; #[derive(Debug)] pub struct Update<'a>(pub &'a mut State); impl<'a> Update<'a> { #[inline] pub fn key(&mut self, key: Keycode, direction: key::Direction) -> Components { unsafe { Components::from_bits(xkb_state_update_key(self.0.as_ptr(), key.into(), mem::transmute(direction))).unwrap() } } #[inline] pub fn mask(&mut self, depressed_mods: M1, latched_mods: M2, locked_mods: M3, depressed_layout: L1, latched_layout: L2, locked_layout: L3) -> Components where M1: Into, M2: Into, M3: Into, L1: Into, L2: Into, L3: Into { unsafe { Components::from_bits(xkb_state_update_mask(self.0.as_ptr(), depressed_mods.into().into(), latched_mods.into().into(), locked_mods.into().into(), depressed_layout.into().into(), latched_layout.into().into(), locked_layout.into().into())).unwrap() } } } xkb-0.3.0/src/x11.rs000064400000000000000000000041201046102023000121530ustar 00000000000000// DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // Version 2, December 2004 // // Copyleft (ↄ) meh. | http://meh.schizofreni.co // // Everyone is permitted to copy and distribute verbatim or modified // copies of this license document, and changing it is allowed as long // as the name is changed. // // DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE // TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION // // 0. You just DO WHAT THE FUCK YOU WANT TO. use xcb; use ffi::*; use crate::{Keycode, ModMask, LayoutMask}; use crate::{Context, Keymap, State}; use crate::keymap::compile; pub const MIN_MAJOR_XKB_VERSION: u16 = XKB_X11_MIN_MAJOR_XKB_VERSION as u16; pub const MIN_MINOR_XKB_VERSION: u16 = XKB_X11_MIN_MINOR_XKB_VERSION as u16; impl From for Keycode { fn from(value: u8) -> Self { Keycode(value as xkb_keycode_t) } } impl From for ModMask { fn from(value: u8) -> Self { ModMask(value as xkb_mod_mask_t) } } impl From for ModMask { fn from(value: i16) -> Self { ModMask(value as xkb_mod_mask_t) } } impl From for LayoutMask { fn from(value: u8) -> Self { LayoutMask(value as xkb_layout_mask_t) } } impl From for LayoutMask { fn from(value: i16) -> Self { LayoutMask(value as xkb_layout_mask_t) } } #[inline] pub fn device(connection: &xcb::Connection) -> Result { unsafe { match xkb_x11_get_core_keyboard_device_id(connection.get_raw_conn() as *mut _) { -1 => Err(()), id => Ok(id) } } } #[inline] pub fn keymap(connection: &xcb::Connection, device: i32, context: &Context, flags: compile::Flags) -> Result { unsafe { xkb_x11_keymap_new_from_device(context.as_ptr(), connection.get_raw_conn() as *mut _, device, flags.bits()) .as_mut().map(|ptr| Keymap::from_ptr(ptr)).ok_or(()) } } #[inline] pub fn state(connection: &xcb::Connection, device: i32, keymap: &Keymap) -> Result { unsafe { xkb_x11_state_new_from_device(keymap.as_ptr(), connection.get_raw_conn() as *mut _, device) .as_mut().map(|ptr| State::from_ptr(ptr)).ok_or(()) } }