ParseResult<&'a str, Output> + 'a> {
98 | Box::new(move |input| {
99 | map_res(
100 | tuple((tag_custom(from_token), terminated(take_until(to_token), tag_custom(to_token)))),
101 | |(_, input)| {
102 | let (input, res) = parser(input)?;
103 | if !input.is_empty() {
104 | return Err(make_generic_nom_err_new(input));
105 | }
106 | Ok(res)
107 | },
108 | )(input)
109 | })
110 | }
111 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
map2
3 | Linux input remapping
Remap your keyboard, mouse, controller and more!
4 |
5 | [](https://github.com/shiro/map2)
6 | [](https://github.com/shiro/map2/blob/master/LICENSE)
7 | [](https://discord.gg/brKgH43XQN)
8 | [](https://github.com/shiro/map2/actions/workflows/CI.yml)
9 | [](https://ko-fi.com/C0C3RTCCI)
10 |
11 |
12 | Want to remap your input devices like keyboards, mice, controllers and more?
13 | There's nothing you can't remap with **map2**!
14 |
15 | - 🖱️ **Remap keys, mouse events, controllers, pedals, and more!**
16 | - 🔧 **Highly configurable**, using Python
17 | - 🚀 **Blazingly fast**, written in Rust
18 | - 📦 **Tiny install size** (around 5Mb), almost no dependencies
19 | - ❤️ **Open source**, made with love
20 |
21 | Visit our [official documentation](https://shiro.github.io/map2/en/basics/introduction)
22 | for the full feature list and API.
23 |
24 | ---
25 |
26 |
27 |
If you like open source, consider supporting
28 |
29 |
30 |
31 |
160 |
161 |
162 | | Key names |
163 | Description |
164 |
165 |
166 | {(key) =>
167 |
168 |
169 |
170 | {aliases[key]}
171 |
172 |
173 | {key}
174 | |
175 | {descriptions[key]} |
176 |
177 | }
178 |
179 |
180 |
181 |
182 | );
183 | }
184 |
185 | export default ValidKeysTable;
186 |
--------------------------------------------------------------------------------
/evdev-rs/evdev-sys/build.rs:
--------------------------------------------------------------------------------
1 | use std::env;
2 | use std::ffi::OsString;
3 | use std::fs;
4 | use std::path::{Path, PathBuf};
5 | use std::process::Command;
6 |
7 | #[cfg(feature = "libevdev-1-10")]
8 | // ver_str is string of the form "major.minor.patch"
9 | fn parse_version(ver_str: &str) -> Option<(u32, u32, u32)> {
10 | let mut major_minor_patch = ver_str
11 | .split(".")
12 | .map(|str| str.parse::().unwrap());
13 | let major = major_minor_patch.next()?;
14 | let minor = major_minor_patch.next()?;
15 | let patch = major_minor_patch.next()?;
16 | Some((major, minor, patch))
17 | }
18 |
19 | fn main() -> Result<(), Box> {
20 | if env::var_os("TARGET") == env::var_os("HOST") {
21 | let mut config = pkg_config::Config::new();
22 | config.print_system_libs(false);
23 |
24 | match config.probe("libevdev") {
25 | Ok(lib) => {
26 | // panic if feature 1.10 is enabled and the installed library
27 | // is older than 1.10
28 | #[cfg(feature = "libevdev-1-10")]
29 | {
30 | let (major, minor, patch) = parse_version(&lib.version)
31 | .expect("Could not parse version information");
32 | assert_eq!(major, 1, "evdev-rs works only with libevdev 1");
33 | assert!(minor >= 10,
34 | "Feature libevdev-1-10 was enabled, when compiling \
35 | for a system with libevdev version {}.{}.{}",
36 | major,
37 | minor,
38 | patch,
39 | );
40 | }
41 | for path in &lib.include_paths {
42 | println!("cargo:include={}", path.display());
43 | }
44 | return Ok(());
45 | }
46 | Err(e) => eprintln!(
47 | "Couldn't find libevdev from pkgconfig ({:?}), \
48 | compiling it from source...",
49 | e
50 | ),
51 | };
52 | }
53 |
54 | if !Path::new("libevdev/.git").exists() {
55 | let mut download = Command::new("git");
56 | download.args(&["submodule", "update", "--init", "--depth", "1"]);
57 | run_ignore_error(&mut download)?;
58 | }
59 |
60 | let dst = PathBuf::from(env::var_os("OUT_DIR").unwrap());
61 | let src = env::current_dir()?;
62 | let mut cp = Command::new("cp");
63 | cp.arg("-r")
64 | .arg(&src.join("libevdev/"))
65 | .arg(&dst)
66 | .current_dir(&src);
67 | run(&mut cp)?;
68 |
69 | println!("cargo:rustc-link-search={}/lib", dst.display());
70 | println!("cargo:root={}", dst.display());
71 | println!("cargo:include={}/include", dst.display());
72 | println!("cargo:rerun-if-changed=libevdev");
73 |
74 | println!("cargo:rustc-link-lib=static=evdev");
75 | let cfg = cc::Build::new();
76 | let compiler = cfg.get_compiler();
77 |
78 | if !&dst.join("build").exists() {
79 | fs::create_dir(&dst.join("build"))?;
80 | }
81 |
82 | let mut autogen = Command::new("sh");
83 | let mut cflags = OsString::new();
84 | for arg in compiler.args() {
85 | cflags.push(arg);
86 | cflags.push(" ");
87 | }
88 | autogen
89 | .env("CC", compiler.path())
90 | .env("CFLAGS", cflags)
91 | .current_dir(&dst.join("build"))
92 | .arg(
93 | dst.join("libevdev/autogen.sh")
94 | .to_str()
95 | .unwrap()
96 | .replace("C:\\", "/c/")
97 | .replace("\\", "/"),
98 | );
99 | if let Ok(h) = env::var("HOST") {
100 | autogen.arg(format!("--host={}", h));
101 | }
102 | if let Ok(t) = env::var("TARGET") {
103 | autogen.arg(format!("--target={}", t));
104 | }
105 | autogen.arg(format!("--prefix={}", sanitize_sh(&dst)));
106 | run(&mut autogen)?;
107 |
108 | let mut make = Command::new("make");
109 | make.arg(&format!("-j{}", env::var("NUM_JOBS").unwrap()))
110 | .current_dir(&dst.join("build"));
111 | run(&mut make)?;
112 |
113 | let mut install = Command::new("make");
114 | install.arg("install").current_dir(&dst.join("build"));
115 | run(&mut install)?;
116 | Ok(())
117 | }
118 |
119 | fn run(cmd: &mut Command) -> std::io::Result<()> {
120 | println!("running: {:?}", cmd);
121 | assert!(cmd.status()?.success());
122 | Ok(())
123 | }
124 |
125 | fn run_ignore_error(cmd: &mut Command) -> std::io::Result<()> {
126 | println!("running: {:?}", cmd);
127 | let _ = cmd.status();
128 | Ok(())
129 | }
130 |
131 | fn sanitize_sh(path: &Path) -> String {
132 | let path = path.to_str().unwrap().replace("\\", "/");
133 | return change_drive(&path).unwrap_or(path);
134 |
135 | fn change_drive(s: &str) -> Option {
136 | let mut ch = s.chars();
137 | let drive = ch.next().unwrap_or('C');
138 | if ch.next() != Some(':') {
139 | return None;
140 | }
141 | if ch.next() != Some('/') {
142 | return None;
143 | }
144 | Some(format!("/{}/{}", drive, &s[drive.len_utf8() + 2..]))
145 | }
146 | }
147 |
--------------------------------------------------------------------------------
/src/python.rs:
--------------------------------------------------------------------------------
1 | pub use pyo3::exceptions::PyRuntimeError;
2 | pub use pyo3::impl_::wrap::OkWrap;
3 | pub use pyo3::prelude::*;
4 | pub use pyo3::types::PyDict;
5 | pub use pyo3::PyClass;
6 | use signal_hook::{consts::SIGINT, iterator::Signals};
7 | use tokio::runtime::Runtime;
8 |
9 | use crate::virtual_writer::VirtualWriter;
10 | use crate::window::Window;
11 | use crate::*;
12 |
13 | #[pyclass]
14 | struct PyKey {
15 | #[pyo3(get, set)]
16 | code: u32,
17 | #[pyo3(get, set)]
18 | value: i32,
19 | }
20 |
21 | #[pyfunction]
22 | #[pyo3(signature = (* * options))]
23 | fn default(options: Option<&PyDict>) -> PyResult<()> {
24 | let options: HashMap<&str, &PyAny> = match options {
25 | Some(py_dict) => py_dict.extract().unwrap(),
26 | None => HashMap::new(),
27 | };
28 |
29 | let kbd_model: Option = options.get("model").and_then(|x| x.extract().ok());
30 | let kbd_layout: Option = options.get("layout").and_then(|x| x.extract().ok());
31 | let kbd_variant: Option> = options.get("variant").and_then(|x| x.extract().ok());
32 | let kbd_options: Option> = options.get("options").and_then(|x| x.extract().ok());
33 |
34 | if kbd_model.is_some() || kbd_layout.is_some() || kbd_variant.is_some() || kbd_options.is_some() {
35 | let mut default_params = global::DEFAULT_TRANSFORMER_PARAMS.write().unwrap();
36 |
37 | if let Some(model) = kbd_model {
38 | default_params.model = model;
39 | }
40 | if let Some(layout) = kbd_layout {
41 | default_params.layout = layout;
42 | }
43 | if let Some(variant) = kbd_variant {
44 | default_params.variant = variant;
45 | }
46 | if let Some(options) = kbd_options {
47 | default_params.options = options;
48 | }
49 | }
50 | Ok(())
51 | }
52 |
53 | #[pyfunction]
54 | fn link(py: Python, mut chain: Vec) -> PyResult<()> {
55 | let mut prev: Option> = None;
56 |
57 | if chain.len() < 2 {
58 | return Err(PyRuntimeError::new_err("expected at least 2 nodes"));
59 | }
60 |
61 | let chain_len = chain.len();
62 |
63 | let last = node_to_link_dst(chain.remove(chain_len - 1).as_ref(py)).ok_or_else(|| {
64 | PyRuntimeError::new_err(format!("expected node at index {} to be a source node", chain_len - 1))
65 | })?;
66 |
67 | let mut prev = node_to_link_src(chain.remove(0).as_ref(py))
68 | .ok_or_else(|| PyRuntimeError::new_err("expected node at index 0 to be a source node"))?;
69 |
70 | let chain = chain
71 | .into_iter()
72 | .enumerate()
73 | .map(|(idx, node)| {
74 | Ok((
75 | node_to_link_src(node.as_ref(py)).ok_or_else(|| {
76 | PyRuntimeError::new_err(format!(
77 | "expected node at index {} to be a source/desination node",
78 | idx + 1
79 | ))
80 | })?,
81 | node_to_link_dst(node.as_ref(py)).ok_or_else(|| {
82 | PyRuntimeError::new_err(format!(
83 | "expected node at index {} to be a source/desination node",
84 | idx + 1
85 | ))
86 | })?,
87 | ))
88 | })
89 | .collect::, PyErr>>()?;
90 |
91 | chain.into_iter().for_each(|node| {
92 | prev.link_to(node.1.clone());
93 | node.1.link_from(prev.clone());
94 | prev = node.0;
95 | });
96 |
97 | prev.link_to(last.clone());
98 | last.link_from(prev);
99 |
100 | Ok(())
101 | }
102 |
103 | pub fn err_to_py(err: anyhow::Error) -> PyErr {
104 | PyRuntimeError::new_err(err.to_string())
105 | }
106 |
107 | pub fn get_runtime<'a>() -> &'a Runtime {
108 | pyo3_asyncio::tokio::get_runtime()
109 | }
110 |
111 | #[pyfunction]
112 | fn wait(py: Python) {
113 | #[cfg(not(feature = "integration"))]
114 | py.allow_threads(|| {
115 | let mut signals = Signals::new(&[SIGINT]).unwrap();
116 | for _ in signals.forever() {
117 | std::process::exit(0);
118 | }
119 | });
120 | }
121 |
122 | #[pyfunction]
123 | fn exit(exit_code: Option) {
124 | #[cfg(not(feature = "integration"))]
125 | std::process::exit(exit_code.unwrap_or(0));
126 | }
127 |
128 | #[cfg(feature = "integration")]
129 | #[pyfunction]
130 | fn __test() -> PyResult> {
131 | Ok(global::TEST_PIPE.lock().unwrap().iter().map(|x| serde_json::to_string(x).unwrap()).collect())
132 | }
133 |
134 | #[pymodule]
135 | fn map2(_py: Python, m: &PyModule) -> PyResult<()> {
136 | m.add_function(wrap_pyfunction!(wait, m)?)?;
137 | m.add_function(wrap_pyfunction!(exit, m)?)?;
138 | m.add_function(wrap_pyfunction!(default, m)?)?;
139 | m.add_function(wrap_pyfunction!(link, m)?)?;
140 | #[cfg(feature = "integration")]
141 | m.add_function(wrap_pyfunction!(__test, m)?)?;
142 | m.add_class::()?;
143 | m.add_class::()?;
144 | m.add_class::()?;
145 | m.add_class::()?;
146 | m.add_class::()?;
147 | m.add_class::()?;
148 | m.add_class::()?;
149 | m.add_class::()?;
150 |
151 | Ok(())
152 | }
153 |
--------------------------------------------------------------------------------