[ { "path": ".devcontainer/devcontainer.json", "content": "{\n\t\"name\": \"Rust\",\n\t\"image\": \"mcr.microsoft.com/devcontainers/rust:1-buster\"\n\n\t// Features to add to the dev container. More info: https://containers.dev/implementors/features.\n\t// \"features\": {},\n\n\t// Use 'forwardPorts' to make a list of ports inside the container available locally.\n\t// \"forwardPorts\": [],\n\n\t// Use 'postCreateCommand' to run commands after the container is created.\n\t// \"postCreateCommand\": \"rustc --version\",\n\n\t// Configure tool-specific properties.\n\t// \"customizations\": {},\n\n\t// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.\n\t// \"remoteUser\": \"root\"\n}\n" }, { "path": ".gitattributes", "content": "* text=auto eol=lf\n" }, { "path": ".github/ISSUE_TEMPLATE/bug_report.yml", "content": "name: \"Bug report\"\ndescription: Create a report to help the project improve.\nlabels: [\"bug\"]\nassignees: [\"jtroo\"]\ntitle: \"Bug: title_goes_here\"\nbody:\n - type: checkboxes\n attributes:\n label: Requirements\n description: Before you create a bug report, please check the following\n options:\n - label: I've searched [platform-specific issues](https://github.com/jtroo/kanata/blob/main/docs/platform-known-issues.adoc), [issues](https://github.com/jtroo/kanata/issues) and [discussions](https://github.com/jtroo/kanata/discussions) to see if this has been reported before.\n required: true\n - label: My issue does not involve multiple simultaneous key presses, OR it does but I've confirmed it is not [key rollover or ghosting](https://github.com/jtroo/kanata/discussions/822).\n required: true\n - type: textarea\n id: summary\n attributes:\n label: Describe the bug\n description: |\n A clear and concise description of what the bug is.\n Ensure any config snippets are either in the next section or are code formatted.\n validations:\n required: true\n - type: textarea\n id: config\n attributes:\n label: Relevant kanata config\n render: text\n description: E.g. defcfg, defsrc, deflayer, defalias items. If in doubt, feel free to include your entire config.\n validations:\n required: false\n - type: textarea\n id: reproduce\n attributes:\n label: To Reproduce\n description: |\n Walk through the steps needed to reproduce the bug.\n Use the simulator if it is not device/OS related: https://jtroo.github.io/.\n validations:\n required: true\n - type: textarea\n id: expected\n attributes:\n label: Expected behavior\n description: A clear and concise description of what you expected to happen.\n validations:\n required: true\n - type: input\n id: version\n attributes:\n label: Kanata version\n description: The kanata version prints in the log on startup, or you can also print it by passing the `--version` flag when running on the command line.\n placeholder: e.g. kanata 1.3.0\n validations:\n required: true\n - type: textarea\n id: logs\n attributes:\n label: Debug logs\n description: If you think it might help with a non-obvious issue, run kanata from the command line and pass the `--debug` flag. This will print more info. Include the relevant log outputs this section if you did so.\n render: text\n validations:\n required: false\n - type: input\n id: os\n attributes:\n label: Operating system and I/O mechanism\n description: E.g. Linux, macOS, Windows 10, Windows 11 with Interception driver\n placeholder: e.g. Linux\n validations:\n required: true\n - type: textarea\n id: additional\n attributes:\n label: Additional context\n description: Add any other context about the problem here.\n validations:\n required: false\n" }, { "path": ".github/ISSUE_TEMPLATE/config.yml", "content": "blank_issues_enabled: true\ncontact_links:\n - name: Discussions\n url: https://github.com/jtroo/kanata/discussions\n about: Ask for help or interact with the community." }, { "path": ".github/ISSUE_TEMPLATE/feature_request.yml", "content": "name: \"Feature request\"\ndescription: Suggest an idea for this project\ntitle: 'Feature request: feature_summary_goes_here'\nlabels: [\"enhancement\"]\nassignees: []\nbody:\n - type: textarea\n attributes:\n label: Is your feature request related to a problem? Please describe.\n description: |\n A clear and concise description of what the problem is.\n placeholder: Ex. I'm always frustrated when [...]\n validations:\n required: true\n - type: textarea\n attributes:\n label: Describe the solution you'd like.\n description: |\n A clear and concise description of what you want to happen.\n validations:\n required: true\n - type: textarea\n attributes:\n label: Describe alternatives you've considered.\n description: |\n A clear and concise description of any alternative solutions or features you've considered.\n validations:\n required: true\n - type: textarea\n attributes:\n label: Additional context\n description: |\n Add any other context or screenshots about the feature request here.\n validations:\n required: false\n" }, { "path": ".github/pull_request_template.md", "content": "## Describe your changes. Use imperative present tense.\n\n## Checklist\n\n- Add documentation to docs/config.adoc\n - [ ] Yes or N/A\n- Add example and basic docs to cfg_samples/kanata.kbd\n - [ ] Yes or N/A\n- Update error messages\n - [ ] Yes or N/A\n- Added tests, or did manual testing\n - [ ] Yes\n" }, { "path": ".github/workflows/build-everything.yml", "content": "name: build-everything\n\non:\n workflow_dispatch:\n branches: [ \"main\" ]\n\nenv:\n CARGO_TERM_COLOR: always\n RUSTFLAGS: \"-Dwarnings\"\n\njobs:\n build-linux:\n uses: ./.github/workflows/linux-build.yml\n build-windows:\n uses: ./.github/workflows/windows-build.yml\n build-macos:\n uses: ./.github/workflows/macos-build.yml\n" }, { "path": ".github/workflows/linux-build.yml", "content": "name: linux-build\n\non:\n workflow_dispatch:\n branches: [ \"main\" ]\n workflow_call:\n\nenv:\n CARGO_TERM_COLOR: always\n\njobs:\n build-linux-x64:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v3\n - uses: Swatinem/rust-cache@v2\n with:\n shared-key: \"persist-cross-job-linux-x64\"\n - name: Do the stuff on x64 ubuntu linux\n shell: bash\n run: |\n mkdir -p artifacts-x64\n cargo build --release\n mv target/release/kanata artifacts-x64/kanata_linux_x64\n cargo build --release --features cmd\n mv target/release/kanata artifacts-x64/kanata_linux_cmd_allowed_x64\n - uses: actions/upload-artifact@v4\n with:\n name: linux-binaries-x64\n path: |\n artifacts-x64/kanata_linux_x64\n artifacts-x64/kanata_linux_cmd_allowed_x64\n" }, { "path": ".github/workflows/macos-build.yml", "content": "name: macos-build\n\non:\n workflow_dispatch:\n branches: [ \"main\" ]\n workflow_call:\n\nenv:\n CARGO_TERM_COLOR: always\n\njobs:\n build-macos-arm64:\n runs-on: macos-latest\n steps:\n - uses: actions/checkout@v3\n - uses: dtolnay/rust-toolchain@stable\n with:\n toolchain: stable\n target: aarch64-apple-darwin\n - uses: Swatinem/rust-cache@v2\n with:\n shared-key: \"persist-cross-job-macos-aarch64\"\n - name: Do the stuff on arm64\n shell: bash\n run: |\n mkdir -p artifacts-arm64\n cargo build --release --target aarch64-apple-darwin\n mv target/aarch64-apple-darwin/release/kanata artifacts-arm64/kanata_macos_arm64\n cargo build --release --features cmd --target aarch64-apple-darwin\n mv target/aarch64-apple-darwin/release/kanata artifacts-arm64/kanata_macos_cmd_allowed_arm64\n - uses: actions/upload-artifact@v4\n with:\n name: macos-binaries-arm64\n path: |\n artifacts-arm64/kanata_macos_arm64\n artifacts-arm64/kanata_macos_cmd_allowed_arm64\n\n build-macos-x64:\n runs-on: macos-15-intel\n\n steps:\n - uses: actions/checkout@v3\n - uses: Swatinem/rust-cache@v2\n with:\n shared-key: \"persist-cross-job-macos-x64\"\n - name: Do the stuff on x64\n shell: bash\n run: |\n mkdir -p artifacts\n cargo build --release\n mv target/release/kanata artifacts/kanata_macos_x64\n cargo build --release --features cmd\n mv target/release/kanata artifacts/kanata_macos_cmd_allowed_x64\n - uses: actions/upload-artifact@v4\n with:\n name: macos-binaries-x64\n path: |\n artifacts/kanata_macos_x64\n artifacts/kanata_macos_cmd_allowed_x64\n\n" }, { "path": ".github/workflows/rust.yml", "content": "name: cargo-checks\n\non:\n push:\n branches: [ \"main\" ]\n paths:\n - Cargo.*\n - src/**/*\n - keyberon/**/*\n - cfg_samples/**/*\n - parser/**/*\n - tcp_protocol/**/*\n - wasm/**/*\n - .github/workflows/rust.yml\n pull_request:\n branches: [ \"main\" ]\n paths:\n - Cargo.*\n - src/**/*\n - keyberon/**/*\n - parser/**/*\n - cfg_samples/**/*\n - tcp_protocol/**/*\n - wasm/**/*\n - .github/workflows/rust.yml\n\nenv:\n CARGO_TERM_COLOR: always\n RUSTFLAGS: \"-Dwarnings\"\n\njobs:\n\n fmt:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v3\n - name: Check fmt\n run: cargo fmt --all --check\n\n build-android:\n runs-on: ${{ matrix.os }}\n strategy:\n matrix:\n include:\n - build: linux\n os: ubuntu-latest\n target: aarch64-linux-android\n\n steps:\n - uses: actions/checkout@v3\n - uses: Swatinem/rust-cache@v2\n with:\n shared-key: \"persist-cross-job\"\n workspaces: ./\n - run: rustup target add aarch64-linux-android\n\n - name: Build for Android\n run: cargo check --target aarch64-linux-android\n\n build-test-clippy-linux:\n runs-on: ${{ matrix.os }}\n strategy:\n matrix:\n include:\n - build: linux\n os: ubuntu-latest\n target: x86_64-unknown-linux-musl\n\n steps:\n - uses: actions/checkout@v3\n - uses: Swatinem/rust-cache@v2\n with:\n shared-key: \"persist-cross-job\"\n workspaces: ./\n - run: rustup component add clippy\n\n - name: Run tests no features\n run: cargo test --all --no-default-features\n - name: Run clippy no features\n run: cargo clippy --all --no-default-features -- -D warnings\n\n - name: Run tests default features\n run: cargo test --all\n - name: Run clippy default features\n run: cargo clippy --all -- -D warnings\n\n - name: Run tests cmd\n run: cargo test --all --features=cmd\n - name: Run clippy cmd\n run: cargo clippy --all --features=cmd -- -D warnings\n\n - name: Run tests simulated output\n run: cargo test --features=simulated_output -- sim_tests\n - name: Run tests simulated output on_idle\n run: cargo test --features=simulated_output -- must_be_single_threaded --ignored --test-threads=1\n - name: Run clippy simulated output\n run: cargo clippy --all --features=simulated_output,cmd -- -D warnings\n\n - name: Run clippy for parser with lsp feature\n run: cargo clippy -p kanata-parser --features=lsp -- -D warnings\n\n build-test-clippy-windows:\n runs-on: ${{ matrix.os }}\n strategy:\n matrix:\n include:\n - build: windows\n os: windows-latest\n target: x86_64-pc-windows-msvc\n\n steps:\n - uses: actions/checkout@v3\n - uses: Swatinem/rust-cache@v2\n with:\n shared-key: \"persist-cross-job\"\n workspaces: ./\n - run: rustup component add clippy\n\n - name: Run tests no features\n run: cargo test --all --no-default-features\n - name: Run clippy no features\n run: cargo clippy --all --no-default-features -- -D warnings\n\n - name: Run tests default features\n run: cargo test --all\n - name: Run clippy default features\n run: cargo clippy --all -- -D warnings\n\n - name: Run tests winIOv2\n run: cargo test --all --features=cmd,win_llhook_read_scancodes,win_sendinput_send_scancodes\n - name: Run clippy all winIOv2\n run: cargo clippy --all --features=cmd,win_llhook_read_scancodes,win_sendinput_send_scancodes -- -D warnings\n\n - name: Run tests all features\n run: cargo test -p kanata -p kanata-parser -p kanata-keyberon -p kanata-tcp-protocol --features=cmd,interception_driver,win_sendinput_send_scancodes\n - name: Run clippy all features\n run: cargo clippy --all --features=cmd,interception_driver,win_sendinput_send_scancodes -- -D warnings\n\n - name: Run tests simulated output\n run: cargo test --features=simulated_output -- sim_tests\n - name: Run tests simulated output on_idle\n run: cargo test --features=simulated_output -- sim_tests::vkey_sim_tests::on_idle --ignored\n - name: Run clippy simulated output\n run: cargo clippy --all --features=simulated_output,cmd -- -D warnings\n\n - name: Run tests gui\n run: cargo test --all --features=gui\n - name: Run clippy gui\n run: cargo clippy --all --features=gui -- -D warnings\n\n - name: Check gui+cmd+interception\n run: cargo check --features gui,cmd,interception_driver\n\n build-test-clippy-macos:\n runs-on: ${{ matrix.os }}\n strategy:\n matrix:\n include:\n - build: macos\n os: macos-latest\n target: x86_64-apple-darwin\n\n steps:\n - uses: actions/checkout@v3\n - uses: Swatinem/rust-cache@v2\n with:\n shared-key: \"persist-cross-job\"\n workspaces: ./\n - run: rustup component add clippy\n\n - name: Run tests default features\n run: cargo test --all\n - name: Run clippy default features\n run: cargo clippy --all -- -D warnings\n\n - name: Run tests cmd\n run: cargo test --all --features=cmd\n - name: Run clippy all features\n run: cargo clippy --all --features=cmd -- -D warnings\n" }, { "path": ".github/workflows/windows-build.yml", "content": "name: windows-build\n\non:\n workflow_dispatch:\n branches: [ \"main\" ]\n workflow_call:\n\nenv:\n CARGO_TERM_COLOR: always\n\njobs:\n build-windows-x64:\n runs-on: windows-latest\n\n steps:\n - uses: actions/checkout@v3\n - uses: Swatinem/rust-cache@v2\n with:\n shared-key: \"persist-cross-job-win-x64\"\n - name: Build x64\n shell: powershell\n run: |\n md artifacts\n cargo build --release --features win_manifest,win_sendinput_send_scancodes,win_llhook_read_scancodes --target x86_64-pc-windows-msvc\n mv target/x86_64-pc-windows-msvc/release/kanata.exe artifacts/kanata_windows_tty_winIOv2_x64.exe\n cargo build --release --features win_manifest,win_sendinput_send_scancodes,win_llhook_read_scancodes,cmd --target x86_64-pc-windows-msvc\n mv target/x86_64-pc-windows-msvc/release/kanata.exe artifacts/kanata_windows_tty_winIOv2_cmd_allowed_x64.exe\n cargo build --release --features win_manifest,interception_driver --target x86_64-pc-windows-msvc\n mv target/x86_64-pc-windows-msvc/release/kanata.exe artifacts/kanata_windows_tty_wintercept_x64.exe\n cargo build --release --features win_manifest,cmd,interception_driver --target x86_64-pc-windows-msvc\n mv target/x86_64-pc-windows-msvc/release/kanata.exe artifacts/kanata_windows_tty_wintercept_cmd_allowed_x64.exe\n cargo build --release --features gui,win_manifest,win_sendinput_send_scancodes,win_llhook_read_scancodes --target x86_64-pc-windows-msvc\n mv target/x86_64-pc-windows-msvc/release/kanata.exe artifacts/kanata_windows_gui_winIOv2_x64.exe\n cargo build --release --features gui,win_manifest,win_sendinput_send_scancodes,win_llhook_read_scancodes,cmd --target x86_64-pc-windows-msvc\n mv target/x86_64-pc-windows-msvc/release/kanata.exe artifacts/kanata_windows_gui_winIOv2_cmd_allowed_x64.exe\n cargo build --release --features gui,win_manifest,interception_driver --target x86_64-pc-windows-msvc\n mv target/x86_64-pc-windows-msvc/release/kanata.exe artifacts/kanata_windows_gui_wintercept_x64.exe\n cargo build --release --features gui,win_manifest,cmd,interception_driver --target x86_64-pc-windows-msvc\n mv target/x86_64-pc-windows-msvc/release/kanata.exe artifacts/kanata_windows_gui_wintercept_cmd_allowed_x64.exe\n cargo build --release --features passthru_ahk --package=simulated_passthru --target x86_64-pc-windows-msvc\n mv target/x86_64-pc-windows-msvc/release/kanata_passthru.dll artifacts/kanata_passthru_x64.dll\n - uses: actions/upload-artifact@v4\n with:\n name: windows-binaries-x64\n path: |\n artifacts/kanata_windows_tty_winIOv2_x64.exe\n artifacts/kanata_windows_tty_winIOv2_cmd_allowed_x64.exe\n artifacts/kanata_windows_tty_wintercept_x64.exe\n artifacts/kanata_windows_tty_wintercept_cmd_allowed_x64.exe\n artifacts/kanata_windows_gui_winIOv2_x64.exe\n artifacts/kanata_windows_gui_winIOv2_cmd_allowed_x64.exe\n artifacts/kanata_windows_gui_wintercept_x64.exe\n artifacts/kanata_windows_gui_wintercept_cmd_allowed_x64.exe\n artifacts/kanata_passthru_x64.dll\n\n build-windows-arm64:\n runs-on: windows-11-arm\n\n steps:\n - uses: actions/checkout@v3\n - uses: Swatinem/rust-cache@v2\n with:\n shared-key: \"persist-cross-job-win-arm64\"\n - name: Build arm64\n shell: powershell\n run: |\n md artifacts\n cargo build --release --features win_manifest,win_sendinput_send_scancodes,win_llhook_read_scancodes --target aarch64-pc-windows-msvc\n mv target/aarch64-pc-windows-msvc/release/kanata.exe artifacts/kanata_windows_tty_winIOv2_arm64.exe\n cargo build --release --features win_manifest,win_sendinput_send_scancodes,win_llhook_read_scancodes,cmd --target aarch64-pc-windows-msvc\n mv target/aarch64-pc-windows-msvc/release/kanata.exe artifacts/kanata_windows_tty_winIOv2_cmd_allowed_arm64.exe\n cargo build --release --features gui,win_manifest,win_sendinput_send_scancodes,win_llhook_read_scancodes --target aarch64-pc-windows-msvc\n mv target/aarch64-pc-windows-msvc/release/kanata.exe artifacts/kanata_windows_gui_winIOv2_arm64.exe\n cargo build --release --features gui,win_manifest,win_sendinput_send_scancodes,win_llhook_read_scancodes,cmd --target aarch64-pc-windows-msvc\n mv target/aarch64-pc-windows-msvc/release/kanata.exe artifacts/kanata_windows_gui_winIOv2_cmd_allowed_arm64.exe\n - uses: actions/upload-artifact@v4\n with:\n name: windows-binaries-arm64\n path: |\n artifacts/kanata_windows_tty_winIOv2_arm64.exe\n artifacts/kanata_windows_tty_winIOv2_cmd_allowed_arm64.exe\n artifacts/kanata_windows_gui_winIOv2_arm64.exe\n artifacts/kanata_windows_gui_winIOv2_cmd_allowed_arm64.exe\n" }, { "path": ".gitignore", "content": "**/target\n.vscode/\nCLAUDE.md\n.DS_Store\nPLAN.md\n\n# Manual testing files\ntest_*.kbd\nmanual_test/\n*.test.kbd\n" }, { "path": "Cargo.toml", "content": "[workspace]\nmembers = [\n\t\"./\",\n\t\"parser\",\n\t\"keyberon\",\n\t\"example_tcp_client\",\n\t\"tcp_protocol\",\n\t\"windows_key_tester\",\n\t\"simulated_input\",\n\t\"simulated_passthru\",\n\t\"wasm\",\n]\nexclude = [\n\t\"interception\",\n\t\"key-sort-add\",\n]\nresolver = \"2\"\n\n[package]\nname = \"kanata\"\nversion = \"1.11.0\"\nauthors = [\"jtroo \"]\ndescription = \"Multi-layer keyboard customization\"\nkeywords = [\"keyboard\", \"layout\", \"remapping\"]\ncategories = [\"command-line-utilities\"]\nhomepage = \"https://github.com/jtroo/kanata\"\nrepository = \"https://github.com/jtroo/kanata\"\nreadme = \"README.md\"\nlicense = \"LGPL-3.0-only\"\nedition = \"2024\"\ndefault-run = \"kanata\"\n\n[lib]\nname = \"kanata_state_machine\"\npath = \"src/lib.rs\"\ncrate-type = [\"rlib\", \"staticlib\"]\n\n[[bin]]\nname = \"kanata\"\npath = \"src/main.rs\"\n\n[dependencies]\nanyhow = \"1\"\nclap = { version = \"4\", features = [ \"std\", \"derive\", \"help\", \"suggestions\" ], default-features = false }\ndirs = \"5.0.1\"\nindoc = { version = \"2.0.4\", optional = true }\nlog = { version = \"0.4.8\", default-features = false }\nmiette = { version = \"5.7.0\", features = [\"fancy\"] }\nonce_cell = \"1\"\nparking_lot = \"0.12\"\nradix_trie = \"0.2\"\nrustc-hash = \"1.1.0\"\nsimplelog = \"0.12.0\"\nserde_json = { version = \"1\", features = [\"std\"], default-features = false, optional = true }\ntime = \"0.3.47\"\nweb-time = \"1.1.0\"\n\nkanata-keyberon = { path = \"keyberon\", version = \"0.1110.0\" }\nkanata-parser = { path = \"parser\", version = \"0.1110.0\" }\nkanata-tcp-protocol = { path = \"tcp_protocol\", version = \"0.1110.0\" }\n\n[target.'cfg(not(any(target_arch = \"wasm32\", target_os = \"android\")))'.dependencies]\narboard = \"3.4\"\n\n[target.'cfg(target_os = \"macos\")'.dependencies]\nkarabiner-driverkit = \"0.2.1\"\nobjc = \"0.2.7\"\ncore-graphics = \"0.24.0\"\nopen = { version = \"5\", optional = true }\nlibc = \"0.2\"\nos_pipe = \"1.2.1\"\n\n[target.'cfg(any(target_os = \"linux\", target_os = \"android\"))'.dependencies]\nevdev = \"0.13.0\"\ninotify = { version = \"0.10.0\", default-features = false }\nmio = { version = \"0.8.11\", features = [\"os-poll\", \"os-ext\"] }\nnix = { version = \"0.26.1\", features = [\"ioctl\"] }\nopen = { version = \"5\", optional = true }\nsignal-hook = \"0.3.14\"\nsd-notify = \"0.4.1\"\n\n[target.'cfg(target_os = \"windows\")'.dependencies]\nencode_unicode = \"0.3.6\"\nwinapi = { version = \"0.3.9\", features = [\n \"wincon\",\n \"timeapi\",\n \"mmsystem\",\n \"winuser\",\n \"windef\",\n \"minwindef\",\n] }\nwindows-sys = { version = \"0.52.0\", features = [\n \"Win32_Devices_DeviceAndDriverInstallation\",\n \"Win32_Devices_Usb\",\n \"Win32_Foundation\",\n \"Win32_Graphics_Gdi\",\n \"Win32_Security\",\n \"Win32_System_Diagnostics_Debug\",\n \"Win32_System_Registry\",\n \"Win32_System_Threading\",\n \"Win32_UI_Controls\",\n \"Win32_UI_Shell\",\n \"Win32_UI_HiDpi\",\n \"Win32_UI_WindowsAndMessaging\",\n \"Win32_System_SystemInformation\",\n \"Wdk\",\n \"Wdk_System\",\n \"Wdk_System_SystemServices\",\n], optional=true }\nnative-windows-gui = { version = \"1.0.13\", default-features = false}\nregex = { version = \"1.10.4\", optional = true }\nkanata-interception = { version = \"0.3.0\", optional = true }\nmuldiv = { version = \"1.0.1\", optional = true }\nstrip-ansi-escapes = { version = \"0.2.0\", optional = true }\nopen = { version = \"5\", features = [\"shellexecute-on-windows\"], optional = true}\n# shellexecute fix allows opening files already opened for writing, needs _detached mode\n\n[build-dependencies]\nembed-resource = { version = \"2.4.2\", optional = true }\nindoc = { version = \"2.0.4\", optional = true }\nregex = { version = \"1.10.4\", optional = true }\n\n[features]\ndefault = [\"tcp_server\",\"win_sendinput_send_scancodes\", \"zippychord\"]\nperf_logging = []\ntcp_server = [\"dep:serde_json\", \"kanata-keyberon/tap_hold_tracker\"]\nwin_sendinput_send_scancodes = [\"kanata-parser/win_sendinput_send_scancodes\"]\nwin_llhook_read_scancodes = [\"kanata-parser/win_llhook_read_scancodes\"]\nwiniov2 = [\"win_llhook_read_scancodes\",\"win_sendinput_send_scancodes\"]\nwin_manifest = [\"dep:embed-resource\", \"dep:indoc\", \"dep:regex\"]\n# delete cargo-clippy when the objc crate is replaced\ncargo-clippy = []\ncmd = [\"kanata-parser/cmd\"]\ninterception_driver = [\"dep:kanata-interception\", \"kanata-parser/interception_driver\"]\nsimulated_output = [\"dep:indoc\"]\nsimulated_input = [\"dep:indoc\"]\npassthru_ahk = [\"simulated_input\",\"simulated_output\"]\ngui = [\"win_manifest\",\"kanata-parser/gui\",\n \"win_sendinput_send_scancodes\",\"win_llhook_read_scancodes\",\n \"dep:muldiv\",\"dep:strip-ansi-escapes\",\"dep:open\",\n \"dep:windows-sys\",\n \"winapi/processthreadsapi\",\n \"native-windows-gui/tray-notification\",\"native-windows-gui/message-window\",\"native-windows-gui/menu\",\"native-windows-gui/cursor\",\"native-windows-gui/high-dpi\",\"native-windows-gui/embed-resource\",\"native-windows-gui/image-decoder\",\"native-windows-gui/notice\",\"native-windows-gui/animation-timer\",\n]\nzippychord = [\"kanata-parser/zippychord\"]\n\n[profile.release]\nopt-level = \"z\"\nlto = \"fat\"\npanic = \"abort\"\ncodegen-units = 1\n" }, { "path": "EnableUIAccess/EnableUIAccess_launch.ahk", "content": "#requires AutoHotkey v2.0\n#SingleInstance Off ; Needed for elevation with *runas.\n/* v2 based on EnableUIAccess.ahk v1.01 by Lexikos USE AT YOUR OWN RISK\n Enables the uiAccess flag in an application's embedded manifest and signs the file with a self-signed digital certificate. If the file is in a trusted location (A_ProgramFiles or A_WinDir), this allows the application to bypass UIPI (User Interface Privilege Isolation, a part of User Account Control in Vista/7). It also enables the journal playback hook (SendPlay).\n Command line params (mutually exclusive):\n SkipWarning - don't display the initial warning\n \"\" \"\" - attempt to run silently using the given file(s)\n This script and the provided Lib files may be used, modified, copied, etc. without restriction.\n*/\n#include \n\nin_file := (A_Args.Has(1))?A_Args[1]:'' ; Command line args\nout_file := (A_Args.Has(2))?A_Args[2]:''\n\nif (in_file = \"\"){\n msgResult := MsgBox(\"Enable the selected EXE to bypass UAC-UIPI security restrictions imposed by modifying 'UIAccess' attribute in the file's embedded manifest and signing the file using a self-signed digital certificate, which is then installed in the local machine's Trusted Root Certification Authorities store.`n`nThe resulting EXE is unusable on a system without this certificate installed!`n`nContinue at your own risk\", \"\", 49)\n if (msgResult = \"Cancel\"){\n ExitApp()\n }\n}\n\nif !A_IsAdmin {\n if (in_file = \"\") {\n in_file := \"SkipWarning\"\n }\n cmd := \"`\"\" . A_ScriptFullPath . \"`\"\"\n if !A_IsCompiled { ; Use A_AhkPath in case the \"runas\" verb isn't registered for ahk files.\n cmd := \"`\"\" . A_AhkPath . \"`\" \" . cmd\n }\n Try Run(\"*RunAs \" cmd \" `\"\" in_file \"`\" `\"\" out_file \"`\"\", , \"\", )\n ExitApp()\n}\nglobal user_specified_files := false\nif (in_file = \"\" || in_file = \"SkipWarning\") { ; Find AutoHotkey installation.\n InstallDir := RegRead(\"HKEY_LOCAL_MACHINE\\SOFTWARE\\AutoHotkey\", \"InstallDir\")\n if A_LastError && A_PtrSize=8 {\n InstallDir := RegRead(\"HKLM\\SOFTWARE\\Wow6432Node\\AutoHotkey\", \"InstallDir\")\n }\n ; Let user confirm or select file(s).\n in_file := FileSelect(1, InstallDir \"\\AutoHotkey.exe\", \"Select Source File\", \"Executable Files (*.exe)\")\n if A_LastError {\n ExitApp()\n }\n out_file := FileSelect(\"S16\", in_file, \"Select Destination File\", \"Executable Files (*.exe)\")\n if A_LastError {\n ExitApp()\n }\n user_specified_files := true\n}\n\nLoop in_file { ; Convert short paths to long paths\n in_file := A_LoopFileFullPath\n}\nif (out_file = \"\") { ; i.e. only one file was given via command line\n out_file := in_file\n} else {\n Loop out_file {\n out_file := A_LoopFileFullPath\n }\n}\nif Crypt.IsSigned(in_file) {\n msgResult := MsgBox(\"Input file is already signed. The script will now exit\" in_file,\"\", 48)\n ExitApp()\n}\n\nif user_specified_files && !IsTrustedLocation(out_file) {\n msgResult := MsgBox(\"Target path is not a trusted location (Program Files or Windows\\System32), so 'uiAccess' will have no effect until the file is moved there\",\"\", 49)\n if (msgResult = \"Cancel\") {\n ExitApp()\n }\n}\n\nif (in_file = out_file) { ; The following should typically work even if the file is in use\n bak_file := in_file \"~\" A_Now \".bak\"\n FileMove(in_file, bak_file, 1)\n if A_LastError {\n Fail(\"Failed to rename selected file.\")\n }\n in_file := bak_file\n}\nTry {\n FileCopy(in_file, out_file, 1)\n} Catch as Err {\n throw OSError(Err)\n}\nif A_LastError {\n Fail(\"Failed to copy file to destination.\")\n}\n\nif !EnableUIAccess(out_file) { ; Set the uiAccess attribute in the file's manifest\n Fail(\"Failed to set uiAccess attribute in manifest\")\n}\n\n\nif (user_specified_files && in_file != out_file) { ; in interactive mode, if not overwriting the original file, offer to create an additional context menu item for AHK files\n uiAccessVerb := RegRead(\"HKCR\\AutoHotkeyScript\\Shell\\uiAccess\\Command\")\n if A_LastError {\n msgResult := MsgBox(\"Register `\"Run Script with UI Access`\" context menu item?\", \"\", 3)\n if (msgResult = \"Yes\") {\n RegWrite(\"Run with UI Access\", \"REG_SZ\", \"HKCR\\AutoHotkeyScript\\Shell\\uiAccess\")\n RegWrite(\"`\"\" out_file \"`\" `\"`%1`\" `%*\", \"REG_SZ\", \"HKCR\\AutoHotkeyScript\\Shell\\uiAccess\\Command\")\n }\n if (msgResult = \"Cancel\")\n ExitApp()\n }\n}\n\nIsTrustedLocation(path) { ; IsTrustedLocation →true if path is a valid location for uiAccess=\"true\"\n ; http://msdn.microsoft.com/en-us/library/bb756929 \"\\Program Files\\ and \\windows\\system32\\ are currently 2 allowable protected locations.\" However, \\Program Files (x86)\\ also appears to be allowed\n if InStr(path, A_ProgramFiles \"\\\") = 1 {\n return true\n }\n if InStr(path, A_WinDir \"\\System32\\\") = 1 {\n return true\n }\n other := EnvGet(A_PtrSize=8 ? \"ProgramFiles(x86)\" : \"ProgramW6432\") ; On 64-bit systems, if this script is 32-bit, A_ProgramFiles is %ProgramFiles(x86)%, otherwise it is %ProgramW6432%. So check the opposite \"Program Files\" folder:\n if (other != \"\" && InStr(path, other \"\\\") = 1) {\n return true\n }\n return false\n}\n\nFail(msg) {\n ; if (%True% != \"Silent\") { ;???\n MsgBox(msg \"`nA_LastError: \" A_LastError, \"\", 16)\n ; }\n ExitApp()\n}\n\nWarn(msg) {\n msg .= \" (Err \" A_LastError \")`n\"\n OutputDebug(msg)\n FileAppend(msg, \"*\")\n}\n" }, { "path": "EnableUIAccess/Lib/EnableUIAccess.ahk", "content": "#requires AutoHotkey v2.0\n\nEnableUIAccess(ExePath) {\n static CertName := \"AutoHotkey\"\n hStore := DllCall(\"Crypt32\\CertOpenStore\", \"ptr\",10 ; STORE_PROV_SYSTEM_W\n , \"uint\",0, \"ptr\",0, \"uint\",0x20000 ; SYSTEM_STORE_LOCAL_MACHINE\n , \"wstr\",\"Root\", \"ptr\")\n if !hStore {\n throw OSError()\n }\n store := CertStore(hStore)\n cert := CertContext() ; Find or create certificate for signing.\n while (cert.ptr := DllCall(\"Crypt32\\CertFindCertificateInStore\", \"ptr\",hStore\n , \"uint\",0x10001 ; X509_ASN_ENCODING|PKCS_7_ASN_ENCODING\n , \"uint\",0, \"uint\",0x80007 ; FIND_SUBJECT_STR\n , \"wstr\", CertName, \"ptr\",cert.ptr, \"ptr\"))\n && !(DllCall(\"Crypt32\\CryptAcquireCertificatePrivateKey\"\n , \"ptr\",cert, \"uint\",5 ; CRYPT_ACQUIRE_CACHE_FLAG|CRYPT_ACQUIRE_COMPARE_KEY_FLAG\n , \"ptr\",0, \"ptr*\", 0, \"uint*\", &keySpec:=0, \"ptr\",0)\n && (keySpec & 2)) { ; AT_SIGNATURE ; Keep looking for a certificate with a private key.\n }\n if !cert.ptr {\n cert := EnableUIAccess_CreateCert(CertName, hStore)\n }\n EnableUIAccess_SetManifest(ExePath) \t; Set uiAccess attribute in manifest\n EnableUIAccess_SignFile(ExePath, cert, CertName)\t; Sign the file (otherwise uiAccess attribute is ignored)\n return true\n}\n\nEnableUIAccess_SetManifest(ExePath) {\n xml := ComObject(\"Msxml2.DOMDocument\")\n xml.async := false\n xml.setProperty(\"SelectionLanguage\", \"XPath\")\n xml.setProperty(\"SelectionNamespaces\"\n , \"xmlns:v1='urn:schemas-microsoft-com:asm.v1' \"\n . \"xmlns:v3='urn:schemas-microsoft-com:asm.v3'\")\n try {\n if !xml.loadXML(EnableUIAccess_ReadManifest(ExePath)) {\n throw Error(\"Invalid manifest\")\n }\n } catch as e {\n throw Error(\"Error loading manifest from \" ExePath,, e.Message \"`n @ \" e.File \":\" e.Line)\n }\n\n\n node := xml.selectSingleNode(\"/v1:assembly/v3:trustInfo/v3:security\"\n . \"/v3:requestedPrivileges/v3:requestedExecutionLevel\")\n if !node ; Not AutoHotkey?\n throw Error(\"Manifest is missing required elements\")\n\n node.setAttribute(\"uiAccess\", \"true\")\n xml := RTrim(xml.xml, \"`r`n\")\n\n data := Buffer(StrPut(xml, \"utf-8\") - 1)\n StrPut(xml, data, \"utf-8\")\n\n if !(hupd := DllCall(\"BeginUpdateResource\", \"str\",ExePath, \"int\",false))\n throw OSError()\n r := DllCall(\"UpdateResource\", \"ptr\",hupd, \"ptr\",24, \"ptr\",1\n , \"ushort\", 1033, \"ptr\",data, \"uint\",data.size)\n\n ; Retry loop to work around file locks (especially by antivirus)\n for delay in [0, 100, 500, 1000, 3500] {\n Sleep delay\n if DllCall(\"EndUpdateResource\", \"ptr\",hupd, \"int\",!r) || !r\n return\n if !(A_LastError = 5 || A_LastError = 110) ; ERROR_ACCESS_DENIED || ERROR_OPEN_FAILED\n break\n }\n throw OSError(A_LastError, \"EndUpdateResource\")\n}\n\nEnableUIAccess_ReadManifest(ExePath) {\n if !(hmod := DllCall(\"LoadLibraryEx\", \"str\",ExePath, \"ptr\",0, \"uint\",2, \"ptr\"))\n throw OSError()\n try {\n if !(hres := DllCall(\"FindResource\", \"ptr\",hmod, \"ptr\",1, \"ptr\",24, \"ptr\")) {\n throw OSError()\n }\n size := DllCall(\"SizeofResource\", \"ptr\",hmod, \"ptr\",hres, \"uint\")\n if !(hglb := DllCall(\"LoadResource\", \"ptr\",hmod, \"ptr\",hres, \"ptr\")) {\n throw OSError()\n }\n if !(pres := DllCall(\"LockResource\", \"ptr\",hglb, \"ptr\")) {\n throw OSError()\n }\n return StrGet(pres, size, \"utf-8\")\n }\n finally {\n DllCall(\"FreeLibrary\", \"ptr\",hmod)\n }\n}\n\nEnableUIAccess_CreateCert(Name, hStore) {\n prov := CryptContext() ; Here Name is used as the key container name.\n if !DllCall(\"Advapi32\\CryptAcquireContext\", \"ptr*\", prov\n , \"str\",Name, \"ptr\",0, \"uint\",1, \"uint\",0) { ; PROV_RSA_FULL=1, open existing=0\n if !DllCall(\"Advapi32\\CryptAcquireContext\", \"ptr*\", prov\n , \"str\",Name, \"ptr\",0, \"uint\",1, \"uint\",8) { ; PROV_RSA_FULL=1, CRYPT_NEWKEYSET=8\n throw OSError()\n }\n if !DllCall(\"Advapi32\\CryptGenKey\", \"ptr\",prov\n , \"uint\",2, \"uint\",0x4000001, \"ptr*\", CryptKey()) { ; AT_SIGNATURE=2, EXPORTABLE=..01\n throw OSError()\n }\n }\n\n ; Here Name is used as the certificate subject and name.\n Loop 2 {\n if A_Index = 1 {\n pbName := cbName := 0\n } else {\n bName := Buffer(cbName), pbName := bName.ptr\n }\n if !DllCall(\"Crypt32\\CertStrToName\", \"uint\",1, \"str\",\"CN=\" Name\n , \"uint\",3, \"ptr\",0, \"ptr\",pbName, \"uint*\", &cbName, \"ptr\",0) ; X509_ASN_ENCODING=1, CERT_X500_NAME_STR=3\n throw OSError()\n }\n cnb := Buffer(2*A_PtrSize), NumPut(\"ptr\",cbName, \"ptr\",pbName, cnb)\n\n ; Set expiry to 9999-01-01 12pm +0.\n NumPut(\"short\", 9999, \"sort\", 1, \"short\", 5, \"short\", 1, \"short\", 12, endTime := Buffer(16, 0))\n\n StrPut(\"2.5.29.4\", szOID_KEY_USAGE_RESTRICTION := Buffer(9),, \"cp0\")\n StrPut(\"2.5.29.37\", szOID_ENHANCED_KEY_USAGE := Buffer(10),, \"cp0\")\n StrPut(\"1.3.6.1.5.5.7.3.3\", szOID_PKIX_KP_CODE_SIGNING := Buffer(18),, \"cp0\")\n\n ; CERT_KEY_USAGE_RESTRICTION_INFO key_usage;\n key_usage := Buffer(6*A_PtrSize, 0)\n NumPut('ptr', 0, 'ptr', 0, 'ptr', 1, 'ptr', key_usage.ptr + 5*A_PtrSize, 'ptr', 0\n , 'uchar', (CERT_DATA_ENCIPHERMENT_KEY_USAGE := 0x10)\n | (CERT_DIGITAL_SIGNATURE_KEY_USAGE := 0x80), key_usage)\n\n ; CERT_ENHKEY_USAGE enh_usage;\n enh_usage := Buffer(3*A_PtrSize)\n NumPut(\"ptr\",1, \"ptr\",enh_usage.ptr + 2*A_PtrSize, \"ptr\",szOID_PKIX_KP_CODE_SIGNING.ptr, enh_usage)\n\n key_usage_data := EncodeObject(szOID_KEY_USAGE_RESTRICTION, key_usage)\n enh_usage_data := EncodeObject(szOID_ENHANCED_KEY_USAGE, enh_usage)\n\n EncodeObject(structType, structInfo) {\n encoder := DllCall.Bind(\"Crypt32\\CryptEncodeObject\", \"uint\",X509_ASN_ENCODING := 1\n , \"ptr\",structType, \"ptr\",structInfo)\n if !encoder(\"ptr\",0, \"uint*\", &enc_size := 0)\n throw OSError()\n enc_data := Buffer(enc_size)\n if !encoder(\"ptr\",enc_data, \"uint*\", &enc_size)\n throw OSError()\n enc_data.Size := enc_size\n return enc_data\n }\n\n ; CERT_EXTENSION extension[2]; CERT_EXTENSIONS extensions;\n NumPut(\"ptr\",szOID_KEY_USAGE_RESTRICTION.ptr, \"ptr\",true, \"ptr\",key_usage_data.size, \"ptr\",key_usage_data.ptr\n , \"ptr\",szOID_ENHANCED_KEY_USAGE.ptr , \"ptr\",true, \"ptr\",enh_usage_data.size, \"ptr\",enh_usage_data.ptr\n , extension := Buffer(8*A_PtrSize))\n NumPut(\"ptr\",2, \"ptr\",extension.ptr, extensions := Buffer(2*A_PtrSize))\n\n if !hCert := DllCall(\"Crypt32\\CertCreateSelfSignCertificate\"\n , \"ptr\",prov, \"ptr\",cnb, \"uint\",0, \"ptr\",0\n , \"ptr\",0, \"ptr\",0, \"ptr\",endTime, \"ptr\",extensions, \"ptr\") {\n throw OSError()\n }\n cert := CertContext(hCert)\n\n if !DllCall(\"Crypt32\\CertAddCertificateContextToStore\", \"ptr\",hStore\n , \"ptr\",hCert, \"uint\",1, \"ptr\",0) { ; STORE_ADD_NEW=1\n throw OSError()\n }\n\n return cert\n}\n\nEnableUIAccess_DeleteCertAndKey(Name) {\n ; This first call \"acquires\" the key container but also deletes it.\n DllCall(\"Advapi32\\CryptAcquireContext\", \"ptr*\", 0, \"str\",Name\n , \"ptr\",0, \"uint\",1, \"uint\",16) ; PROV_RSA_FULL=1, CRYPT_DELETEKEYSET=16\n if !hStore := DllCall(\"Crypt32\\CertOpenStore\", \"ptr\",10 ; STORE_PROV_SYSTEM_W\n , \"uint\",0, \"ptr\",0, \"uint\",0x20000 ; SYSTEM_STORE_LOCAL_MACHINE\n , \"wstr\", \"Root\", \"ptr\")\n throw OSError()\n store := CertStore(hStore)\n deleted := 0\n ; Multiple certificates might be created over time as keys become inaccessible\n while p := DllCall(\"Crypt32\\CertFindCertificateInStore\", \"ptr\",hStore\n , \"uint\",0x10001 ; X509_ASN_ENCODING|PKCS_7_ASN_ENCODING\n , \"uint\",0, \"uint\",0x80007 ; FIND_SUBJECT_STR\n , \"wstr\", Name, \"ptr\",0, \"ptr\") {\n if !DllCall(\"Crypt32\\CertDeleteCertificateFromStore\", \"ptr\",p) {\n throw OSError()\n }\n deleted++\n }\n return deleted\n}\n\nclass Crypt {\n static IsSigned(FilePath) {\n return DllCall(\"Crypt32\\CryptQueryObject\"\n ,\"uint\" \t, CERT_QUERY_OBJECT_FILE := 1\n ,\"wstr\" \t, FilePath\n ,\"uint\" \t, CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED := 1<<10\n ,\"uint\" \t, CERT_QUERY_FORMAT_FLAG_BINARY := 2\n ,\"uint\" \t, 0\n ,\"uint*\"\t, &dwEncoding:=0\n ,\"uint*\"\t, &dwContentType:=0\n ,\"uint*\"\t, &dwFormatType:=0\n ,\"ptr\" \t, 0\n ,\"ptr\" \t, 0\n ,\"ptr\" \t, 0)\n }\n}\nclass CryptPtrBase {\n __new(p:=0) => this.ptr := p\n __delete() => this.ptr && this.Dispose()\n}\nclass CryptContext extends CryptPtrBase {\n Dispose() => DllCall(\"Advapi32\\CryptReleaseContext\", \"ptr\",this, \"uint\",0)\n}\nclass CertContext extends CryptPtrBase {\n Dispose() => DllCall(\"Crypt32\\CertFreeCertificateContext\", \"ptr\",this)\n}\nclass CertStore extends CryptPtrBase {\n Dispose() => DllCall(\"Crypt32\\CertCloseStore\", \"ptr\",this, \"uint\",0)\n}\nclass CryptKey extends CryptPtrBase {\n Dispose() => DllCall(\"Advapi32\\CryptDestroyKey\", \"ptr\",this)\n}\n\nEnableUIAccess_SignFile(ExePath, CertCtx, Name) {\n file_info := struct( ; SIGNER_FILE_INFO\n \"ptr\",A_PtrSize*3, \"ptr\",StrPtr(ExePath))\n dwIndex := Buffer(4, 0) ; DWORD\n subject_info := struct( ; SIGNER_SUBJECT_INFO\n \"ptr\",A_PtrSize*4, \"ptr\",dwIndex.ptr, \"ptr\",SIGNER_SUBJECT_FILE:=1,\n \"ptr\",file_info.ptr)\n cert_store_info := struct( ; SIGNER_CERT_STORE_INFO\n \"ptr\",A_PtrSize*4, \"ptr\",CertCtx.ptr, \"ptr\",SIGNER_CERT_POLICY_CHAIN:=2)\n cert_info := struct( ; SIGNER_CERT\n \"uint\",8+A_PtrSize*2, \"uint\",SIGNER_CERT_STORE:=2,\n \"ptr\",cert_store_info.ptr)\n authcode_attr := struct( ; SIGNER_ATTR_AUTHCODE\n \"uint\",8+A_PtrSize*3, \"int\",false, \"ptr\",true, \"ptr\",StrPtr(Name))\n sig_info := struct( ; SIGNER_SIGNATURE_INFO\n \"uint\",8+A_PtrSize*4, \"uint\",CALG_SHA1:=0x8004,\n \"ptr\",SIGNER_AUTHCODE_ATTR:=1, \"ptr\",authcode_attr.ptr)\n\n hr := DllCall(\"MSSign32\\SignerSign\"\n , \"ptr\",subject_info, \"ptr\",cert_info, \"ptr\",sig_info\n , \"ptr\",0, \"ptr\",0, \"ptr\",0, \"ptr\",0, \"hresult\") ; pProviderInfo pwszHttpTimeStamp psRequest pSipData\n\n struct(args*) => (\n args.Push(b := Buffer(args[2], 0)),\n NumPut(args*),\n b\n )\n}\n\nEnableUIAccess_Verify(ExePath) { ; Verifies a signed executable file. Returns 0 on success, or a standard OS error number.\n wfi := Buffer(4*A_PtrSize) ; WINTRUST_FILE_INFO\n NumPut('ptr', wfi.size, 'ptr', StrPtr(ExePath), 'ptr', 0, 'ptr', 0, wfi)\n NumPut('int64', 0x11d0cd4400aac56b, 'int64', 0xee95c24fc000c28c, actionID := Buffer(16)) ; WINTRUST_ACTION_GENERIC_VERIFY_V2\n\n wtd := Buffer(9*A_PtrSize+16) ; WINTRUST_DATA\n NumPut(\n 'ptr', wtd.Size, 'ptr', 0, 'ptr', 0, 'int', WTD_UI_NONE:=2, 'int', WTD_REVOKE_NONE:=0,\n 'ptr', WTD_CHOICE_FILE:=1, 'ptr', wfi.ptr, 'ptr', WTD_STATEACTION_VERIFY:=1,\n 'ptr', 0, 'ptr', 0, 'int', 0, 'int', 0, 'ptr', 0, wtd\n )\n return DllCall('wintrust\\WinVerifyTrust', 'ptr', 0, 'ptr', actionID, 'ptr', wtd, 'int')\n}\n" }, { "path": "EnableUIAccess/README.md", "content": "# EnableUIAccess\n\nSee [the guide documentation for context](https://github.com/jtroo/kanata/blob/main/docs/config.adoc#windows-only-work-elevated).\n" }, { "path": "LICENSE", "content": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007 Free Software Foundation, Inc. \n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n\n This version of the GNU Lesser General Public License incorporates\nthe terms and conditions of version 3 of the GNU General Public\nLicense, supplemented by the additional permissions listed below.\n\n 0. Additional Definitions.\n\n As used herein, \"this License\" refers to version 3 of the GNU Lesser\nGeneral Public License, and the \"GNU GPL\" refers to version 3 of the GNU\nGeneral Public License.\n\n \"The Library\" refers to a covered work governed by this License,\nother than an Application or a Combined Work as defined below.\n\n An \"Application\" is any work that makes use of an interface provided\nby the Library, but which is not otherwise based on the Library.\nDefining a subclass of a class defined by the Library is deemed a mode\nof using an interface provided by the Library.\n\n A \"Combined Work\" is a work produced by combining or linking an\nApplication with the Library. The particular version of the Library\nwith which the Combined Work was made is also called the \"Linked\nVersion\".\n\n The \"Minimal Corresponding Source\" for a Combined Work means the\nCorresponding Source for the Combined Work, excluding any source code\nfor portions of the Combined Work that, considered in isolation, are\nbased on the Application, and not on the Linked Version.\n\n The \"Corresponding Application Code\" for a Combined Work means the\nobject code and/or source code for the Application, including any data\nand utility programs needed for reproducing the Combined Work from the\nApplication, but excluding the System Libraries of the Combined Work.\n\n 1. Exception to Section 3 of the GNU GPL.\n\n You may convey a covered work under sections 3 and 4 of this License\nwithout being bound by section 3 of the GNU GPL.\n\n 2. Conveying Modified Versions.\n\n If you modify a copy of the Library, and, in your modifications, a\nfacility refers to a function or data to be supplied by an Application\nthat uses the facility (other than as an argument passed when the\nfacility is invoked), then you may convey a copy of the modified\nversion:\n\n a) under this License, provided that you make a good faith effort to\n ensure that, in the event an Application does not supply the\n function or data, the facility still operates, and performs\n whatever part of its purpose remains meaningful, or\n\n b) under the GNU GPL, with none of the additional permissions of\n this License applicable to that copy.\n\n 3. Object Code Incorporating Material from Library Header Files.\n\n The object code form of an Application may incorporate material from\na header file that is part of the Library. You may convey such object\ncode under terms of your choice, provided that, if the incorporated\nmaterial is not limited to numerical parameters, data structure\nlayouts and accessors, or small macros, inline functions and templates\n(ten or fewer lines in length), you do both of the following:\n\n a) Give prominent notice with each copy of the object code that the\n Library is used in it and that the Library and its use are\n covered by this License.\n\n b) Accompany the object code with a copy of the GNU GPL and this license\n document.\n\n 4. Combined Works.\n\n You may convey a Combined Work under terms of your choice that,\ntaken together, effectively do not restrict modification of the\nportions of the Library contained in the Combined Work and reverse\nengineering for debugging such modifications, if you also do each of\nthe following:\n\n a) Give prominent notice with each copy of the Combined Work that\n the Library is used in it and that the Library and its use are\n covered by this License.\n\n b) Accompany the Combined Work with a copy of the GNU GPL and this license\n document.\n\n c) For a Combined Work that displays copyright notices during\n execution, include the copyright notice for the Library among\n these notices, as well as a reference directing the user to the\n copies of the GNU GPL and this license document.\n\n d) Do one of the following:\n\n 0) Convey the Minimal Corresponding Source under the terms of this\n License, and the Corresponding Application Code in a form\n suitable for, and under terms that permit, the user to\n recombine or relink the Application with a modified version of\n the Linked Version to produce a modified Combined Work, in the\n manner specified by section 6 of the GNU GPL for conveying\n Corresponding Source.\n\n 1) Use a suitable shared library mechanism for linking with the\n Library. A suitable mechanism is one that (a) uses at run time\n a copy of the Library already present on the user's computer\n system, and (b) will operate properly with a modified version\n of the Library that is interface-compatible with the Linked\n Version.\n\n e) Provide Installation Information, but only if you would otherwise\n be required to provide such information under section 6 of the\n GNU GPL, and only to the extent that such information is\n necessary to install and execute a modified version of the\n Combined Work produced by recombining or relinking the\n Application with a modified version of the Linked Version. (If\n you use option 4d0, the Installation Information must accompany\n the Minimal Corresponding Source and Corresponding Application\n Code. If you use option 4d1, you must provide the Installation\n Information in the manner specified by section 6 of the GNU GPL\n for conveying Corresponding Source.)\n\n 5. Combined Libraries.\n\n You may place library facilities that are a work based on the\nLibrary side by side in a single library together with other library\nfacilities that are not Applications and are not covered by this\nLicense, and convey such a combined library under terms of your\nchoice, if you do both of the following:\n\n a) Accompany the combined library with a copy of the same work based\n on the Library, uncombined with any other library facilities,\n conveyed under the terms of this License.\n\n b) Give prominent notice with the combined library that part of it\n is a work based on the Library, and explaining where to find the\n accompanying uncombined form of the same work.\n\n 6. Revised Versions of the GNU Lesser General Public License.\n\n The Free Software Foundation may publish revised and/or new versions\nof the GNU Lesser General Public License from time to time. Such new\nversions will be similar in spirit to the present version, but may\ndiffer in detail to address new problems or concerns.\n\n Each version is given a distinguishing version number. If the\nLibrary as you received it specifies that a certain numbered version\nof the GNU Lesser General Public License \"or any later version\"\napplies to it, you have the option of following the terms and\nconditions either of that published version or of any later version\npublished by the Free Software Foundation. If the Library as you\nreceived it does not specify a version number of the GNU Lesser\nGeneral Public License, you may choose any version of the GNU Lesser\nGeneral Public License ever published by the Free Software Foundation.\n\n If the Library as you received it specifies that a proxy can decide\nwhether future versions of the GNU Lesser General Public License shall\napply, that proxy's public statement of acceptance of any version is\npermanent authorization for you to choose that version for the\nLibrary." }, { "path": "README.md", "content": "

Kanata

\n\n

\n \n

\n\n
\n Improve your keyboard comfort\n
\n\n## What does this do?\n\nThis is a cross-platform software keyboard remapper for Linux, macOS and Windows.\nA short summary of the features:\n\n- multiple layers of key functionality\n- advanced key behaviour customization (e.g. tap-hold, macros, unicode)\n\nTo see all of the features, see the [configuration guide](./docs/config.adoc).\n\nYou can find pre-built binaries in the [releases page](https://github.com/jtroo/kanata/releases)\nor read on for build instructions.\n\nYou can see a [list of known issues here](./docs/platform-known-issues.adoc).\n\n### Demo\n\n#### Demo video\n\n[Showcase of multi-layer functionality (30s, 1.7 MB)](https://user-images.githubusercontent.com/6634136/183001314-f64a7e26-4129-4f20-bf26-7165a6e02c38.mp4).\n\n#### Online simulator\n\nYou can check out the [online simulator](https://jtroo.github.io)\nto test configuration validity and test input simulation.\n\n## Why is this useful?\n\nImagine if, instead of pressing Shift to type uppercase letters, we had giant\nkeyboards with separate keys for lowercase and uppercase letters. I hope we can\nall agree: that would be a terrible user experience!\n\nA way to think of how Shift keys work is that they switch your input to another\nlayer of functionality where you now type uppercase letters and symbols\ninstead of lowercase letters and numbers.\n\nWhat kanata allows you to do is take this alternate layer concept that Shift\nkeys have and apply it to any key. You can then customize what those layers do\nto suit your exact needs and workflows.\n\n## Usage\n\nRunning kanata currently does not start it in a background process.\nYou will need to keep the window that starts kanata running to keep kanata active.\nSome tips for running kanata in the background:\n\n- Windows: https://github.com/jtroo/kanata/discussions/193\n- Linux: https://github.com/jtroo/kanata/discussions/130#discussioncomment-10227272\n- Run from tray icon: [kanata-tray](https://github.com/rszyma/kanata-tray)\n\n### Pre-built executables\n\nSee the\n[releases page](https://github.com/jtroo/kanata/releases)\nfor executables and instructions.\n\n### Build it yourself\n\nThis project uses the latest Rust stable toolchain. If you installed the\nRust toolchain using `rustup`, e.g. by using the instructions from the\n[official website](https://www.rust-lang.org/learn/get-started),\nyou can get the latest stable toolchain with `rustup update stable`.\n\n
\nInstructions\n\nUsing `cargo install`:\n\n cargo install kanata\n\n # On Linux and macOS, this may not work without `sudo`, see below\n kanata --cfg \n\nBuild and run yourself in Linux:\n\n git clone https://github.com/jtroo/kanata && cd kanata\n cargo build # --release optional, not really perf sensitive\n\n # sudo is used because kanata opens /dev/ files\n #\n # See below if you want to avoid needing sudo:\n # https://github.com/jtroo/kanata/wiki/Avoid-using-sudo-on-Linux\n sudo target/debug/kanata --cfg \n\nBuild and run yourself in Windows.\n\n git clone https://github.com/jtroo/kanata; cd kanata\n cargo build # --release optional, not really perf sensitive\n target\\debug\\kanata --cfg \n\nBuild and run yourself in macOS:\n\nFirst install the Karabiner driver by following the macOS documentation\nin the [releases page](https://github.com/jtroo/kanata/releases/).\n\nThen you can compile and run with the instructions below:\n\n git clone https://github.com/jtroo/kanata && cd kanata\n cargo build # --release optional, not really perf sensitive\n\n # sudo is needed to gain permission to intercept the keyboard\n\n sudo target/debug/kanata --cfg \n\nThe full configuration guide is [found here](./docs/config.adoc).\n\nSample configuration files are found in [cfg_samples](./cfg_samples). The\n[simple.kbd](./cfg_samples/simple.kbd) file contains a basic configuration file\nthat is hopefully easy to understand but does not contain all features. The\n`kanata.kbd` contains an example of all features with documentation. The\nrelease assets also have a `kanata.kbd` file that is tested to work with that\nrelease. All key names can be found in the [keys module](./parser/src/keys/mod.rs),\nand you can also define your own key names.\n\n
\n\n### Feature flags\n\nWhen either building yourself or using `cargo install`,\nyou can add feature flags that\nenable functionality that is turned off by default.\n\n
\nInstructions\n\nIf you want to enable the `cmd` actions,\nadd the flag `--features cmd`.\nFor example:\n\n```\ncargo build --release --features cmd\ncargo install --features cmd\n```\n\nOn Windows,\nif you want to compile a binary that uses the Interception driver,\nyou should add the flag `--features interception_driver`.\nFor example:\n\n```\ncargo build --release --features interception_driver\ncargo install --features interception_driver\n```\n\nTo combine multiple flags,\nuse a single `--features` flag\nand use a comma to separate the features.\nFor example:\n\n```\ncargo build --release --features cmd,interception_driver\ncargo install --features cmd,interception_driver\n```\n\n
\n\n## Other installation methods\n\n
\nRepositories for kanata\n\n[![Packaging status](https://repology.org/badge/vertical-allrepos/kanata.svg)](https://repology.org/project/kanata/versions)\n\n
\n\n## Notable features\n\n- Human-readable configuration file.\n - [Minimal example](./cfg_samples/minimal.kbd)\n - [Full guide](./docs/config.adoc)\n - [Simple example with explanations](./cfg_samples/simple.kbd)\n - [All features showcase](./cfg_samples/kanata.kbd)\n- Live reloading of the configuration for easy testing of your changes.\n- Multiple layers of key functionality\n- Advanced actions such as tap-hold, unicode output, dynamic and static macros\n- Vim-like leader sequences to execute other actions\n- Optionally run a TCP server to interact with other programs\n - Other programs can respond to [layer changes or trigger layer changes](https://github.com/jtroo/kanata/issues/47)\n- [Interception driver](https://web.archive.org/web/20240209172129/http://www.oblita.com/interception) support (use `kanata_wintercept.exe`)\n - Note that this issue exists, which is outside the control of this project:\n https://github.com/oblitum/Interception/issues/25\n\n## Contributing\n\nContributions are welcome!\n\nUnless explicitly stated otherwise, your contributions to kanata will be made\nunder the LGPL-3.0-only[*] license.\n\nSome directories are exceptions:\n\n- [keyberon](./keyberon): MIT License\n- [interception](./interception): MIT or Apache-2.0 Licenses\n\n[Here's a basic low-effort design doc of kanata](./docs/design.md)\n\n[*]: https://www.gnu.org/licenses/identify-licenses-clearly.html\n\n## How you can help\n\n- Try it out and let me know what you think. Feel free to file an issue or\n start a discussion.\n- Usability issues and unhelpful error messages are considered bugs that should\n be fixed. If you encounter any, I would be thankful if you file an issue.\n- Browse the open issues and help out if you are able and/or would like to. If\n you want to try contributing, feel free to ping jtroo for some pointers.\n- If you know anything about writing a keyboard driver for Windows, starting an\n open-source alternative to the Interception driver would be lovely.\n\n## Community projects related to kanata\n\n- [vscode-kanata](https://github.com/rszyma/vscode-kanata): Language support for kanata configuration files in VS Code\n- [komokana](https://github.com/LGUG2Z/komokana): Automatic application-aware layer switching for [`komorebi`](https://github.com/LGUG2Z/komorebi) (Windows)\n- [kanata-tray](https://github.com/rszyma/kanata-tray): Control kanata from a tray icon\n- [OverKeys](https://github.com/conventoangelo/overkeys): Visual layer display for kanata - see your active layers and keymaps in real-time (Windows)\n- Application-aware layer switching:\n - [qanata (Linux)](https://github.com/veyxov/qanata)\n - [kanawin (Windows)](https://github.com/Aqaao/kanawin)\n - [window_tools (Windows)](https://github.com/reidprichard/window_tools)\n - [nata (Linux)](https://github.com/mdSlash/nata)\n - [kanata-vk-agent (macOS)](https://github.com/devsunb/kanata-vk-agent)\n - [hyprkan (Linux)](https://github.com/mdSlash/hyprkan)\n - [kanata-switcher (Linux, all DEs)](https://github.com/7mind/kanata-switcher)\n - [kwanata (Linux-KDE)](https://github.com/jfsicilia/kwanata): A KDE Plasma companion for Kanata - Automatically activates Kanata's layers/virtualkeys and launches or raises apps.\n\n## What does the name mean?\n\nI wanted a \"k\" word since this relates to keyboards. According to Wikipedia,\nkanata is an indigenous Iroquoian word meaning \"village\" or \"settlement\" and is\nthe origin of Canada's name.\n\nThere's also PPT✧.\n\n## Motivation\n\nTLDR: QMK features but for any keyboard, not just fancy mechanical ones.\n\n
\n Long version\n\nI have a few keyboards that run [QMK](https://docs.qmk.fm/#/). QMK allows the\nuser to customize the functionality of their keyboard to their heart's content.\n\nOne great use case of QMK is its ability map keys so that they overlap with the\nhome row keys but are accessible on another layer. I won't comment on\nproductivity, but I find this greatly helps with my keyboard comfort.\n\nFor example, these keys are on the right side of the keyboard:\n\n 7 8 9\n u i o\n j k l\n m , .\n\nOn one layer I have arrow keys in the same position, and on another layer I\nhave a numpad.\n\n arrows: numpad:\n - - - 7 8 9\n - ↑ - 4 5 6\n ← ↓ → 1 2 3\n - - - 0 * .\n\nOne could add as many customizations as one likes to improve comfort, speed,\netc. Personally my main motivator is comfort due to a repetitive strain injury\nin the past.\n\nHowever, QMK doesn't run everywhere. In fact, it doesn't run on **most**\nhardware you can get. You can't get it to run on a laptop keyboard or any\nmainstream office keyboard. I believe that the comfort and empowerment QMK\nprovides should be available to anyone with a computer on their existing\nhardware, instead of having to purchase an enthusiast mechanical keyboard\n(which are admittedly very nice — I own a few — but can be costly).\n\nThe best alternative solution that I found for keyboards that don't run QMK was\n[kmonad](https://github.com/kmonad/kmonad). This is an excellent project\nand I recommend it if you want to try something similar.\n\nThe reason for this project's existence is that kmonad is written in Haskell\nand I have no idea how to begin contributing to a Haskell project. From an\noutsider's perspective I think Haskell is a great language but I really can't\nwrap my head around it. And there are a few [outstanding issues](./docs/kmonad_comparison.md)\nat the time of writing that make kmonad suboptimal for my personal workflows.\n\nThis project is written in Rust because Rust is my favourite programming\nlanguage and the prior work of the awesome [keyberon crate](https://github.com/TeXitoi/keyberon)\nexists.\n\n
\n\n## Similar Projects\n\nThe most similar project is [kmonad](https://github.com/kmonad/kmonad),\nwhich served as the inspiration for kanata. [Here's a comparison document](./docs/kmonad_comparison.md).\nOther similar projects:\n\n- [QMK](https://docs.qmk.fm/#/): Open source keyboard firmware\n- [keyberon](https://github.com/TeXitoi/keyberon): Rust `#[no_std]` library intended for keyboard firmware\n- [ktrl](https://github.com/ItayGarin/ktrl): Linux-only keyboard customizer with layers, a TCP server, and audio support\n- [kbremap](https://github.com/timokroeger/kbremap): Windows-only keyboard customizer with layers and unicode\n- [xcape](https://github.com/alols/xcape): Linux-only tap-hold modifiers\n- [karabiner-elements](https://karabiner-elements.pqrs.org/): Mac-only keyboard customizer\n- [capsicain](https://github.com/cajhin/capsicain): Windows-only key remapper with driver-level key interception\n- [keyd](https://github.com/rvaiya/keyd): Linux-only key remapper very similar to QMK, kmonad, and kanata\n- [xremap](https://github.com/k0kubun/xremap): Linux-only application-aware key remapper inspired more by Emacs key sequences vs. QMK layers/Vim modes\n- [keymapper](https://github.com/houmain/keymapper): Context-aware cross-platform key remapper with a different transformation model (Linux, Windows, Mac)\n- [mouseless](https://github.com/jbensmann/mouseless): Linux-only mouse-focused key remapper that also has layers, key combo and tap-hold capabilities\n\n### Why the list?\n\nWhile kanata is the best tool for some, it may not be the best tool for\nyou. I'm happy to introduce you to tools that may better suit your needs. This\nlist is also useful as reference/inspiration for functionality that could be\nadded to kanata.\n\n## Donations/Support?\n\nThe author (jtroo) will not accept monetary donations for work on kanata.\nPlease instead donate your time and/or money to charity.\n\nSome links are below. These links are provided for learning and as interesting\nreads. They are **not** an endorsement.\n\n- https://www.effectivealtruism.org/\n- https://www.givewell.org/\n" }, { "path": "build.rs", "content": "fn main() -> std::io::Result<()> {\n #[cfg(feature = \"win_manifest\")]\n {\n windows::build()?;\n }\n Ok(())\n}\n\n#[cfg(feature = \"win_manifest\")]\nmod windows {\n use indoc::formatdoc;\n use regex::Regex;\n use std::fs::File;\n use std::io::Write;\n extern crate embed_resource;\n\n // println! during build\n macro_rules! pb {\n ($($tokens:tt)*) => {println!(\"cargo:warning={}\", format!($($tokens)*))}}\n\n pub(super) fn build() -> std::io::Result<()> {\n let manifest_path: &str = \"./target/kanata.exe.manifest\";\n\n // Note about expected version format:\n // MS says \"Use the four-part version format: mmmmm.nnnnn.ooooo.ppppp\"\n // https://learn.microsoft.com/en-us/windows/win32/sbscs/application-manifests\n\n let re_ver_build = Regex::new(r\"^(?(\\d+\\.){2}\\d+)[-a-zA-Z]+(?\\d+)$\").unwrap();\n let re_ver_build2 = Regex::new(r\"^(?(\\d+\\.){2}\\d+)[-a-zA-Z]+$\").unwrap();\n let re_version3 = Regex::new(r\"^(\\d+\\.){2}\\d+$\").unwrap();\n let mut version: String = env!(\"CARGO_PKG_VERSION\").to_string();\n\n if re_version3.find(&version).is_some() {\n version = format!(\"{version}.0\");\n } else if re_ver_build.find(&version).is_some() {\n version = re_ver_build\n .replace_all(&version, r\"$vpre.$vpos\")\n .to_string();\n } else if re_ver_build2.find(&version).is_some() {\n version = re_ver_build2.replace_all(&version, r\"$vpre.0\").to_string();\n } else {\n pb!(\"unknown version format '{}', using '0.0.0.0'\", version);\n version = \"0.0.0.0\".to_string();\n }\n\n let manifest_str = formatdoc!(\n r#\"\n \n \n \n \n \n \n \n true\n PerMonitorV2\n \n \n \n \n \n \n \"#,\n version\n );\n let mut manifest_f = File::create(manifest_path)?;\n write!(manifest_f, \"{manifest_str}\")?;\n embed_resource::compile(\"./src/kanata.exe.manifest.rc\", embed_resource::NONE);\n Ok(())\n }\n}\n" }, { "path": "cfg_samples/artsey.kbd", "content": ";; ARTSEY MINI 0.2 https://github.com/artseyio/artsey/issues/7\n\n;; Exactly one defcfg entry is required. This is used for configuration key-pairs.\n(defcfg\n ;; Your keyboard device will likely differ from this.\n linux-dev /dev/input/event1\n\n ;; Windows doesn't need any input/output configuration entries; however, there\n ;; must still be a defcfg entry. You can keep the linux-dev entry or delete\n ;; it and leave it empty.\n)\n\n(defsrc\n q w e\n a s d\n)\n\n(deflayer base\n (chord base A) (chord base R) (chord base T)\n (chord base S) (chord base E) (chord base Y)\n)\n\n(deflayer meta\n (chord meta A) (chord meta R) (chord meta T)\n (chord meta S) (chord meta E) (chord meta Y)\n)\n\n(defchords base 5000\n (A R T S E Y) (layer-switch meta)\n (A R T ) (one-shot 2000 lsft)\n ( S E Y) spc\n (A ) a\n ( R T S ) b\n ( R S ) c\n (A E Y) d\n ( E ) e\n (A R ) f\n (A E ) g\n ( S Y) h\n ( R E ) i\n ( T S E ) j\n ( T E ) k\n ( S E ) l\n ( R T ) m\n ( E Y) n\n (A S ) o\n (A R Y) p\n ( T Y) q\n ( R ) r\n ( S ) s\n ( T ) t\n (A T ) u\n (A T E ) v\n ( T S ) w\n (A Y) x\n ( Y) y\n ( R S E ) z\n)\n\n(defchords meta 5000\n (A R T S E Y) (layer-switch base)\n ( S E Y) spc\n (A R T ) caps ;; should technically be shift lock, probably need to use fake keys for that \n (A R ) bspc\n ( R T ) del\n ( S E ) C-c\n ( E Y) C-v\n (A ) home\n ( R ) up\n ( T ) end\n ( S ) left\n ( E ) down\n ( Y) rght\n)\n" }, { "path": "cfg_samples/automousekeys-full-map.kbd", "content": "(defcfg\n ;; F* keys and arrow keys are left unmapped\n process-unmapped-keys yes\n\n ;; you may wish to only capture a trackpoint and keyboard\n ;; but not e.g. a trackpad or external mouse\n ;;linux-dev-names-include (\n ;; \"AT Translated Set 2 keyboard\"\n ;; \"TPPS/2 Elan TrackPoint\"\n ;;)\n ;; optional, but useful with the trackpoint\n ;;linux-use-trackpoint-property yes\n\n mouse-movement-key mvmt\n)\n\n;; ANSI layout for eg thinkpad internal or external keyboard\n(defsrc\n grv 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n caps a s d f g h j k l ; ' ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt menu rctl\n mvmt\n)\n\n(defvirtualkeys\n mouse (layer-while-held mouse-layer)\n)\n\n(defalias\n mhld (hold-for-duration 750 mouse)\n\n moff (on-press release-vkey mouse)\n\n _ (multi\n @moff\n _\n )\n\n ;; mouse click extended time out for double tap\n mdbt (hold-for-duration 500 mouse)\n mbl (multi\n mlft\n @mdbt\n )\n mbm (multi\n mmid\n @mdbt\n )\n mbr (multi\n mrgt\n @mdbt\n )\n)\n\n;; no mappings\n(deflayer qwerty\n grv 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n caps a s d f g h j k l ; ' ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt menu rctl\n @mhld\n)\n\n;; places mouse keys on the row above the home row.\n;; pressing any other keys exits the mouse layer until mouse movement stops and restarts again.\n(deflayer mouse-layer\n @_ @_ @_ @_ @_ @_ @_ @_ @_ @_ @_ @_ @_ @_\n @_ @_ mrgt mmid @mbl @_ @_ @mbl mmid mrgt @_ @_ @_ @_\n @_ @_ @_ @_ @_ @_ @_ @_ @_ @_ @_ @_ @_\n @_ @_ @_ @_ @_ @_ @_ @_ @_ @_ @_ @_\n @_ @_ @_ @_ @_ @_ @_\n @mhld\n)\n" }, { "path": "cfg_samples/automousekeys-only.kbd", "content": "(defcfg\n ;; we are only mapping the keys we want to use for mouse keys\n process-unmapped-keys yes\n\n ;; you may wish to only capture a trackpoint and keyboard\n ;; but not e.g. a trackpad or external mouse\n ;;linux-dev-names-include (\n ;; \"Lenovo TrackPoint Keyboard II\"\n ;;)\n ;; optional, but useful with the trackpoint\n ;;linux-use-trackpoint-property yes\n\n mouse-movement-key mvmt\n)\n\n(defsrc)\n\n(defvirtualkeys\n mouse (layer-while-held mouse-layer)\n)\n\n(defalias\n mhld (hold-for-duration 750 mouse)\n\n moff (on-press release-vkey mouse)\n\n _ (multi\n @moff\n _\n )\n\n ;; mouse click extended time out for double tap\n mdbt (hold-for-duration 500 mouse)\n mbl (multi\n mlft\n @mdbt\n )\n mbm (multi\n mmid\n @mdbt\n )\n mbr (multi\n mrgt\n @mdbt\n )\n)\n\n;; no key mappings\n(deflayermap (base)\n mvmt @mhld\n)\n\n;; places mouse keys on the row above the home row.\n;; pressing any other keys exits the mouse layer until mouse movement stops and restarts again.\n(deflayermap (mouse-layer)\n w mrgt\n e mmid\n r @mbl\n\n u @mbl\n i mmid\n o mrgt\n\n mvmt @mhld\n ___ @_\n)\n" }, { "path": "cfg_samples/chords.tsv", "content": "rus\trust\ncol\tcool\nnice\tnice\nyou\tyou\nth\tthe\n a\ta\n an\tan\nman\tman\nname\tname\nan\tand\nas\tas\nor\tor\nbu\tbut\nif\tif\nso\tso\ndn\tthen\nbc\tbecause\n\nto\tto\nof\tof\nin\tin\n f\tfor\n w\twith\non\ton\nat\tat\nfm\tfrom\nby\tby\nabt\tabout\nup\tup\nio\tinto\nov\tover\naf\tafter\nwo\twithout\n i\tI\n me\tme\n my\tmy\nou\tyou\nur\tyour\nhe\the\nhm\thim\nhis\this\nsh\tshe\nhr\ther\nit\tit\nts\tits\nwe\twe\nus\tus\nour\tour\ndz\tthey\ndr\ttheir\ndm\tthem\nwc\twhich\nwn\twhen\nwt\twhat\nwr\twhere\nho\twho\nhw\thow\nwz\twhy\nis\tis\nar\tare\nwa\twas\ner\twere\nbe\tbe\nhv\thave\nhs\thas\nhd\thad\nnt\tnot\ncn\tcan\ndo\tdo\nwl\twill\ncd\tcould\nwd\twould\nsd\tshould\nli\tlike\nbn\tbeen\nge\tget\nmaz\tmay\nmad\tmade\nmk\tmake\nai\tsaid\nwk\twork\nuz\tuse\nsz\tsay\n g\tgo\nkn\tknow\ntk\ttake\n se\tsee\nlk\tlook\ncm\tcome\nthk\tthink\nwnt\twant\ngi\tgive\nct\tcannot\nde\tdoes\ndi\tdid\nsem\tseem\ncl\tcall\ntha\tthank\n\n im\tI'm\n id\tI'd\ndt\tthat\ndis\tthis\ndes\tthese\ntes\ttest\nal\tall\n o\tone\nmo\tmore\nthe\tthere\nout\tout\nao\talso\ntm\ttime\nsm\tsome\njs\tjust\nne\tnew\nodr\tother\npl\tpeople\n n\tno\ndan\tthan\noz\tonly\n m\tmost\nay\tany\nmay\tmany\nel\twell\nfs\tfirst\nvy\tvery\nmuch\tmuch\nnow\tnow\nev\teven\ngo\tgood\ngrt\tgreat\nway\tway\n t\ttwo\nyr\tyear\nbk\tback\nday\tday\nqn\tquestion\nsc\tsecond\ndg\tthing\n y\tyes\ncn'\tcan't\ndif\tdifferent\ndgh\tthough\ntru\tthrough\nsr\tsorry\nmv\tmove\ndir\tdir\nstop\tstop\ntye\ttype\nnx\tnext\nsam\tsame\ntp\ttop\ncod\tcode\ngit\tgit\n to\tTODO\ncls\tclass\nclus\tcluster\nsure\tsure\nlets\tlet's\nsup\tsuper\nsuch\tsuch\nthig\tthing\nyet\tyet\ndon\tdone\nsem\tseem\nran\tran\njob\tjob\nbot\tbot\nfx\teffect\nnce\tonce\nrad\tread\nltr\tlater\nlot\tlot\nbrw\tbrew\nunst\tuninstall\nrmv\tremove\n ad\tadd\npoe\tproblem\nbuld\tbuild\n tol\ttool\ngot\tgot\nles\tless\n 0\tzero\n 1\tone\n 2\ttwo\n 3\tthree\n 4\tfour\n 5\tfive\n 6\tsix\n 7\tseven\n 8\teight\n 9\tnine\n" }, { "path": "cfg_samples/colemak.kbd", "content": ";;\n;; Learn Colemak, a few keys at a time.\n;;\n;; The \"j\" key moves around the keyboard each step,\n;; until you reach the full Colemak layout.\n;;\n;; To select the layout for your current step, press the\n;; letter \"m\" and the number of your current step, as a chord.\n;;\n;; Check out: https://dreymar.colemak.org/tarmak-intro.html\n;; and: https://colemak.com\n;;\n\n(defsrc\n q w e r t y u i o p\n a s d f g h j k l ;\n z x c v b n m\n)\n\n(deflayer colemak_j1\n _ _ j _ _ _ _ _ _ _\n _ _ _ _ _ _ n e _ _\n _ _ _ _ _ k _\n)\n\n(deflayer colemak_j2\n _ _ f _ g _ _ _ _ _\n _ _ _ t j _ n e _ _\n _ _ _ _ _ k _\n)\n\n(deflayer colemak_j3\n _ _ f j g _ _ _ _ _\n _ r s t d _ n e _ _\n _ _ _ _ _ k _\n)\n\n(deflayer colemak_j4\n _ _ f p g j _ _ y ;\n _ r s t d _ n e _ o\n _ _ _ _ _ k _\n)\n\n(deflayer colemak\n _ _ f p g j l u y ;\n _ r s t d _ n e i o\n _ _ _ _ _ k _\n)\n\n(defcfg\n process-unmapped-keys yes\n concurrent-tap-hold yes\n allow-hardware-repeat no\n)\n\n(defchordsv2\n (m 1) (layer-switch colemak_j1) 300 all-released ()\n (m 2) (layer-switch colemak_j2) 300 all-released ()\n (m 3) (layer-switch colemak_j3) 300 all-released ()\n (m 4) (layer-switch colemak_j4) 300 all-released ()\n (m 5) (layer-switch colemak) 300 all-released ()\n)\n\n" }, { "path": "cfg_samples/deflayermap.kbd", "content": ";; A configuration showcasing deflayermap.\n;;\n;; The process-unmapped-keys defcfg item is not used\n;; and the lctl and ralt keys are unmapped\n;; because mapping them can cause problems on Windows\n;; with non-US layouts.\n\n(defsrc\n grv 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n caps a s d f g h j k l ; ' ret\n lsft z x c v b n m , . / rsft\n lmet lalt spc rmet rctl\n)\n\n(deflayermap (base)\n caps (tap-hold 200 200 (caps-word 2000) lctl)\n spc (tap-hold 200 200 spc (layer-while-held nav))\n)\n\n(deflayermap (nav)\n i up\n j left\n k down\n l right\n)\n" }, { "path": "cfg_samples/f13_f24.kbd", "content": "(defcfg\n linux-dev /dev/input/by-path/platform-i8042-serio-0-event-kbd\n)\n\n(defsrc\n f13 f14 f15 f16 f17 f18 f19 f20 f21 f22 f23 f24\n)\n\n(deflayer test\n f13 f14 f15 f16 f17 f18 f19 f20 f21 f22 f23 f24\n)\n\n" }, { "path": "cfg_samples/fancy_symbols.kbd", "content": ";; Turns ⎇› RightAlt into a symbol key to insert valid kanata unicode symbols for the pressed key\n;; Turns ⇧›⎇› RightShift+RightAlt into a symbol key to insert extra symbols for the same keys\n;; e.g., ⎇›Delete will print ␡\n(defcfg)\n(defalias\n 🔣 (layer-while-held fancy-symbol)\n ⇧🔣 (layer-while-held ⇧fancy-symbol))\n(defsrc\n ‹🖰\t🖰›\t🖰3\t🖰4\t🖰5\n ▶⏸\t◀◀\t▶▶\t🔇 \t🔉\t🔊\t🔅\t🔆\t🎛\t⌨💡+\t⌨💡−\n ⎋\n ˋ \t \t1 \t2\t3\t4\t5\t6\t7\t8 \t9\t0\t- \t=\t␈\t⎀\t⇤\t⇞\t⇭ \t🔢⁄\t🔢∗\t🔢₋\n ⭾ \t \tq \tw\te\tr\tt\ty\tu\ti \to\tp\t[ \t]\t\\\t␡\t⇥\t⇟\t🔢₇\t🔢₈\t🔢₉\t🔢₊\n ⇪ \t \ta \ts\td\tf\tg\th\tj\tk \tl\t;\t' \t⏎\t \t \t \t \t🔢₄\t🔢₅\t🔢₆\n ‹⇧\t \tz \tx\tc\tv\tb\tn\tm\t, \t.\t/\t⇧›\t \t▲\t \t \t \t🔢₁\t🔢₂\t🔢₃\t🔢⏎\n ‹⎈\t‹◆\t‹⎇\t␠\t \t \t \t \t \t⎇›\t \t☰\t⎈›\t◀\t▼\t▶\t \t \t🔢₀\t🔢⸴ )\n(deflayer qwerty ;; =base with ⎇› as a fancy symbol key\n ‗\t‗\t‗\t‗\t‗\n ‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\n ‗\n ‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗ \t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\n ‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗ \t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\n ‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗ \t‗\t‗\t‗\t \t \t \t \t‗\t‗\t‗\n ‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗\t‗ \t‗\t‗\t \t‗\t \t \t \t‗\t‗\t‗\t‗\n ‗\t‗\t‗\t‗\t \t \t \t \t \t@🔣\t \t‗\t‗\t‗\t‗\t‗\t \t‗\t‗ )\n(deflayer fancy-symbol ;; •block all other keys\n 🔣‹🖰\t🔣🖰›\t🔣🖰3\t🔣🖰4\t🔣🖰5\n 🔣▶⏸\t🔣◀◀\t🔣▶▶\t🔣🔇 \t🔣🔉\t🔣🔊\t🔣🔅\t🔣🔆\t🔣🎛\t🔣⌨💡+\t🔣⌨💡−\n 🔣⎋\n 🔣ˋ\t \t• \t• \t•\t•\t•\t•\t•\t• \t• \t• \t🔣‐ \t🔣₌\t🔣␈\t🔣⎀\t🔣⇤\t🔣⇞\t🔣⇭ \t🔣🔢⁄\t🔣🔢∗\t🔣🔢₋\n 🔣⭾\t \t• \t• \t•\t•\t•\t•\t•\t• \t• \t• \t🔣【 \t🔣】\t🔣⧵\t🔣␡\t🔣⇥\t🔣⇟\t🔣🔢₇ \t🔣🔢₈\t🔣🔢₉\t🔣🔢₊\n 🔣⇪\t \t• \t• \t•\t•\t•\t•\t•\t• \t• \t🔣︔\t' \t🔣⏎\t \t \t \t \t 🔣🔢₄\t🔣🔢₅\t🔣🔢₆\n 🔣⇧\t \t• \t• \t•\t•\t•\t•\t•\t🔣⸴\t🔣．\t🔣⁄\t@⇧🔣\t \t🔣▲\t \t \t \t 🔣🔢₁\t🔣🔢₂\t🔣🔢₃\t🔣🔢⏎\n 🔣⎈\t🔣◆\t🔣⎇\t🔣␠\t \t \t \t \t \t• \t \t🔣☰\t• \t🔣◀\t🔣▼\t🔣▶\t \t \t 🔣🔢₀\t🔣🔢⸴ )\n(deflayer ⇧fancy-symbol ;; •block all other keys\n 🔣🖰1\t🔣🖰2\t•\t• \t•\n • \t• \t•\t🔣🔈⓪⓿₀\t•\t🔣🔈−➖₋⊖\t🔣🔈+➕₊⊕\t•\t•\t🔣⌨💡➕₊⊕\t🔣⌨💡➖₋⊖\n •\n 🔣˜\t \t• \t• \t•\t•\t•\t•\t•\t• \t•\t•\t- \t= \t🔣⌫\t• \t🔣⤒↖\t🔣🔢\t•\t•\t•\t•\n 🔣↹\t \t• \t• \t•\t•\t•\t•\t•\t• \t•\t•\t🔣「〔⎡\t🔣」〕⎣\t🔣＼\t🔣⌦\t🔣⤓↘\t• \t•\t•\t•\t•\n • \t \t• \t• \t•\t•\t•\t•\t•\t• \t•\t•\t• \t🔣↩⌤␤\t \t \t \t \t \t•\t•\t•\n • \t \t• \t• \t•\t•\t•\t•\t•\t• \t•\t/\t• \t \t• \t \t \t \t \t•\t•\t•\t🔣🔢↩⌤␤\n 🔣⌃\t🔣❖⌘\t🔣⌥\t🔣␣\t \t \t \t \t \t🔣▤𝌆\t \t•\t• \t• \t• \t• \t \t \t•\t• )\n" }, { "path": "cfg_samples/home-row-mod-advanced.kbd", "content": ";; Home row mods QWERTY example with more complexity.\n;; Some of the changes from the basic example:\n;; - when a home row mod activates tap, the home row mods are disabled\n;; while continuing to type rapidly\n;; - tap-hold-release helps make the hold action more responsive\n;; - pressing another key on the same half of the keyboard\n;; as the home row mod will activate an early tap action\n;;\n;; Suggested further reading:\n;;\n;; GitHub discussion on more advanced tap-hold improvements:\n;;\n;; https://github.com/jtroo/kanata/discussions/1455\n;;\n;; Configuration guide documentation on all tap-hold options:\n;;\n;; https://github.com/jtroo/kanata/blob/main/docs/config.adoc#tap-hold\n\n(defcfg\n process-unmapped-keys yes\n)\n(defsrc\n a s d f j k l ;\n)\n(defvar\n ;; Note: consider using different time values for your different fingers.\n ;; For example, your pinkies might be slower to release keys and index\n ;; fingers faster.\n tap-time 200\n hold-time 150\n\n left-hand-keys (\n q w e r t\n a s d f g\n z x c v b\n )\n right-hand-keys (\n y u i o p\n h j k l ;\n n m , . /\n )\n)\n(deflayer base\n @a @s @d @f @j @k @l @;\n)\n\n(deflayer nomods\n a s d f j k l ;\n)\n(deffakekeys\n to-base (layer-switch base)\n)\n(defalias\n tap (multi\n (layer-switch nomods)\n (on-idle-fakekey to-base tap 20)\n )\n\n a (tap-hold-release-keys $tap-time $hold-time (multi a @tap) lmet $left-hand-keys)\n s (tap-hold-release-keys $tap-time $hold-time (multi s @tap) lalt $left-hand-keys)\n d (tap-hold-release-keys $tap-time $hold-time (multi d @tap) lctl $left-hand-keys)\n f (tap-hold-release-keys $tap-time $hold-time (multi f @tap) lsft $left-hand-keys)\n j (tap-hold-release-keys $tap-time $hold-time (multi j @tap) rsft $right-hand-keys)\n k (tap-hold-release-keys $tap-time $hold-time (multi k @tap) rctl $right-hand-keys)\n l (tap-hold-release-keys $tap-time $hold-time (multi l @tap) ralt $right-hand-keys)\n ; (tap-hold-release-keys $tap-time $hold-time (multi ; @tap) rmet $right-hand-keys)\n)\n" }, { "path": "cfg_samples/home-row-mod-basic.kbd", "content": ";; Basic home row mods example using QWERTY\n;; For a more complex but perhaps usable configuration,\n;; see home-row-mod-advanced.kbd\n\n(defcfg\n process-unmapped-keys yes\n)\n(defsrc\n a s d f j k l ;\n)\n(defvar\n ;; Note: consider using different time values for your different fingers.\n ;; For example, your pinkies might be slower to release keys and index\n ;; fingers faster.\n tap-time 200\n hold-time 150\n)\n(defalias\n a (tap-hold $tap-time $hold-time a lmet)\n s (tap-hold $tap-time $hold-time s lalt)\n d (tap-hold $tap-time $hold-time d lctl)\n f (tap-hold $tap-time $hold-time f lsft)\n j (tap-hold $tap-time $hold-time j rsft)\n k (tap-hold $tap-time $hold-time k rctl)\n l (tap-hold $tap-time $hold-time l ralt)\n ; (tap-hold $tap-time $hold-time ; rmet)\n)\n(deflayer base\n @a @s @d @f @j @k @l @;\n)" }, { "path": "cfg_samples/home-row-mod-prior-idle.kbd", "content": ";; Home row mods with tap-hold-require-prior-idle.\n;;\n;; This replaces the layer-switching workaround in home-row-mod-advanced.kbd\n;; with two native features:\n;;\n;; tap-hold-require-prior-idle — during fast typing, tap-hold keys resolve as tap\n;; immediately (no waiting state, no accidental holds)\n;;\n;; tap-hold-opposite-hand — hold activates only when the next key is on\n;; the opposite hand; same-hand rolls always tap\n;;\n;; The result: no nomods layer, no fakekeys, no multi wrappers.\n;;\n;; Configuration guide:\n;; https://github.com/jtroo/kanata/blob/main/docs/config.adoc#tap-hold-require-prior-idle\n;; https://github.com/jtroo/kanata/blob/main/docs/config.adoc#tap-hold\n\n(defcfg\n process-unmapped-keys yes\n ;; If any key was pressed within 150ms, resolve tap-hold as tap immediately.\n ;; Prevents accidental modifier activation during fast typing.\n tap-hold-require-prior-idle 150\n)\n\n(defsrc\n a s d f j k l ;\n)\n\n;; Declare which keys belong to each hand.\n;; tap-hold-opposite-hand uses this to decide hold vs tap.\n(defhands\n (left q w e r t a s d f g z x c v b)\n (right y u i o p h j k l ; n m , . /)\n)\n\n(deflayer base\n @a @s @d @f @j @k @l @;\n)\n\n(defalias\n ;; Note: consider using different time values for your different fingers.\n ;; For example, your pinkies might be slower to release keys and index\n ;; fingers faster.\n a (tap-hold-opposite-hand 150 a lmet)\n s (tap-hold-opposite-hand 150 s lalt)\n d (tap-hold-opposite-hand 150 d lctl)\n f (tap-hold-opposite-hand 150 f lsft)\n j (tap-hold-opposite-hand 150 j rsft)\n k (tap-hold-opposite-hand 150 k rctl)\n l (tap-hold-opposite-hand 150 l ralt)\n ; (tap-hold-opposite-hand 150 ; rmet)\n)\n" }, { "path": "cfg_samples/included-file.kbd", "content": "(defalias\n included-alias (macro i spc a m spc i n c l u d e d)\n)\n" }, { "path": "cfg_samples/japanese_mac_eisu_kana.kbd", "content": "#|\n Using meta keys as japanese eisu and kana on Mac with US keyboard.\n\n | Source | Tap | Hold |\n | ------- | ------------ | ---- |\n | lmet | lang2 (eisu) | lmet |\n | rmet | lang1 (kana) | rmet |\n\n|#\n\n(defcfg\n process-unmapped-keys yes\n)\n\n(defsrc\n lmet rmet\n)\n\n(deflayer default\n @lmet @rmet\n)\n\n(defalias\n lmet (tap-hold-press 200 200 eisu lmet)\n rmet (tap-hold-press 200 200 kana rmet)\n)\n\n" }, { "path": "cfg_samples/jtroo.kbd", "content": "(defsrc\n grv 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n caps a s d f g h j k l ; ' ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n\n(defalias\n ;; toggle layer aliases\n num (layer-toggle numbers)\n chr (layer-toggle chords)\n arr (layer-toggle arrows)\n msc (layer-toggle misc)\n lay (layer-toggle layers)\n mse (layer-toggle mouse)\n\n ;; change the base layer between qwerty and dvorak\n dvk (layer-switch dvorak)\n qwr (layer-switch qwerty)\n\n ;; tap-hold keys with letters for tap and layer change for hold\n anm (tap-hold-release 200 200 a @num)\n oar (tap-hold-release 200 200 o @arr)\n ech (tap-hold-release 200 200 e @chr)\n umc (tap-hold-release 200 200 u @msc)\n grl (tap-hold-release 200 200 grv @lay)\n .ms (tap-hold-release 200 200 . @mse)\n\n ;; tap for capslk, hold for lctl\n cap (tap-hold-release 200 200 caps lctl)\n\n ;; chords\n csv C-S-v\n csc C-S-c\n)\n\n(deflocalkeys-linux\n pho 445\n)\n\n(defalias\n ;; shifted keys\n { S-[\n } S-]\n : S-;\n ral (tap-hold-release 200 200 sldr ralt)\n)\n\n(defalias\n alp (multi a b c d e f g h i j k l m n o p q r s t u v w x y z)\n ls (macro l s spc min a l ret)\n)\n\n(deflayer dvorak\n @grl 1 2 3 4 5 6 7 8 9 0 [ ] bspc\n tab ' , @.ms p y f g c r l / = \\\n @cap @anm @oar @ech @umc i d h t n s - ret\n lsft ; q j k x b m w v z rsft\n lctl lmet lalt spc @ral rmet rctl\n)\n\n(deflayer qwerty\n @grl 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n caps a s d f g h j k l ; ' ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n\n(deflayer layers\n _ @qwr @dvk lrld _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _\n)\n\n(deflayer numbers\n _ _ _ _ _ _ nlk kp7 kp8 kp9 _ _ _ _\n _ _ C-S-tab C-tab _ XX _ kp4 kp5 kp6 min _ _ _\n _ _ C-z C-y M-tab XX _ kp1 kp2 kp3 + _ _\n _ C-z C-x C-c C-v XX _ kp0 kp0 . / _\n _ _ _ _ _ _ _\n)\n\n(deflayer misc\n _ _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ ins @{ @} [ ] _ _ _\n _ _ _ _ C-u _ C-bspc bspc esc ret _ _ _\n _ C-z C-x C-c C-v _ _ del _ _ _ _\n _ _ _ _ _ _ _\n)\n\n(deflayer chords\n _ _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ @csc _ @ls _ _ _\n _ @alp _ _ C-u _ C-d _ S-; _ C-s _ _\n _ _ _ _ _ _ C-b _ _ @csv _ _\n _ _ _ _ _ _ _\n)\n\n(deflayer arrows\n _ f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12 _\n _ _ _ _ _ _ C-S-tab pgup up pgdn C-tab _ _ _\n _ _ _ _ _ _ home left down rght end _ _\n _ _ _ _ _ _ _ _ C-w _ _ _\n _ _ _ _ _ _ _\n)\n\n(defalias\n mwu (mwheel-up 50 120)\n mwd (mwheel-down 50 120)\n mwl (mwheel-left 50 120)\n mwr (mwheel-right 50 120)\n)\n\n(deflayer mouse\n _ _ _ _ _ _ _ _ _ _ _ _ _ _\n _ @mwu bck _ fwd _ _ _ _ _ _ _ _ _\n _ @mwd mlft _ mrgt mmid _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _\n)\n\n(defseq \"git status\" (g s t)\n \"git commit --amend --no-edit\" (g c a)\n \"git rebase -i HEAD~\" (g r e b)\n \"git log --pretty=oneline --abbrev-commit\" (g l s)\n \"git diff --ignore-space-change\" (g d f)\n \"git diff --cached --ignore-space-change\" (g d c)\n \"git push -f\" (g p f)\n \"git commit -m 'fix_this_commit_message'\" (g c m)\n)\n\n(deffakekeys\n \"git status\" (macro g i t spc s t a t u s)\n \"git commit --amend --no-edit\" (macro g i t spc c o m m i t spc min min a m e n d spc min min n o min e d i t)\n \"git rebase -i HEAD~\" (macro g i t spc r e b a s e spc min i spc S-h S-e S-a S-d S-grv)\n \"git log --pretty=oneline --abbrev-commit\" (macro\n g i t spc l o g spc\n min min p r e t t y = o n e l i n e spc\n min min a b b r e v min c o m m i t\n )\n \"git diff --ignore-space-change\" (macro\n g i t spc d i f f spc\n min min i g n o r e min s p a c e min c h a n g e\n )\n \"git diff --cached --ignore-space-change\" (macro\n g i t spc d i f f spc\n min min c a c h e d spc\n min min i g n o r e min s p a c e min c h a n g e\n )\n \"git push -f\" (macro g i t spc p u s h spc min f)\n \"git commit -m 'fix_this_commit_message'\" (macro\n g i t spc c o m m i t spc\n min m spc ' f i x S-min t h i s S-min c o m m i t S-min m e s s a g e '\n )\n)\n" }, { "path": "cfg_samples/kanata.kbd", "content": "#|\nThis is a sample configuration file that showcases every feature in kanata.\nA more detailed and less terse configuration guide is found here:\n\n https://github.com/jtroo/kanata/blob/main/docs/config.adoc\n\nOther configuration samples are found here:\n\n https://github.com/jtroo/kanata/tree/main/cfg_samples\n\nIf anything is confusing or hard to discover, please file an issue or\ncontribute a pull request to help improve the document.\n\nSince it may be important for you to know, pressing and holding all of the\nthree following keys together at the same time will cause kanata to exit:\n\n Left Control, Space, Escape\n\nThis is for the physical key input rather than after any remappings\nthat are done by kanata.\n\n|#\n\n;; Single-line comments are prefixed by double-semicolon. A single semicolon\n;; is parsed as the keyboard key. Comments are ignored for the configuration\n;; file.\n\n#|\nA multi-line comment block begin with an octothorphe followed by a pipe: `#|`.\nTo end the multi-line comment block, have a pipe followed by an octothorpe,\nlike the following sequence with the colon removed: `|:#`. The actual two\ncharacter sequence is not used because it would end this multi-line comment\nblock and cause a parsing error.\n\nThis configuration language is Lisp-like and uses S-Expression syntax.\nIf you're unfamiliar with Lisp, don't be alarmed. The maintainer jtroo is\nalso unfamiliar with Lisp. You don't need to know Lisp in-depth to\nbe able to configure kanata.\n\nIf you follow along with the examples, you should be fine. Kanata should\nalso hopefully have helpful error messages in case something goes wrong.\nIf you need help, please feel welcome to ask in the GitHub discussions.\n|#\n\n;; One defcfg entry may be added if desired. This is used for configuration\n;; key-value pairs that change kanata's behaviour at a global level.\n;; All defcfg options are optional.\n(defcfg\n ;; Your keyboard device will likely differ from this. I believe /dev/input/by-id/\n ;; is preferable; I recall reading that it's less likely to change names on you,\n ;; but I didn't find any keyboard device in there in my VM. If you are on Linux\n ;; and omit this entry, kanata will try to attach to every device found on your\n ;; system that seems like a keyboard.\n ;; linux-dev /dev/input/by-path/platform-i8042-serio-0-event-kbd\n\n ;; If you want to read from multiple devices, separate them by `:`.\n ;; linux-dev /dev/input/:/dev/input/\n ;;\n ;; If you have a colon in your device path, add a backslash before it so that\n ;; kanata does not parse it as multiple devices.\n ;; linux-dev /dev/input/path-to\\:device\n\n ;; Alternatively, you can use list syntax, where both backslashes and colons\n ;; are parsed literally. List items are separated by spaces or newlines.\n ;; Using quotation marks for each item is optional, and only required if an\n ;; item contains spaces.\n ;; linux-dev (\n ;; /dev/input/by-path/pci-0000:00:14.0-usb-0:1:1.0-event\n ;; /dev/input/by-id/usb-Dell_Dell_USB_Keyboard-event-kbd\n ;; )\n\n ;; The linux-dev-names-include entry is parsed identically to linux-dev. It\n ;; defines a list of device names that should be included. This is only\n ;; used if linux-dev is omitted.\n ;; linux-dev-names-include device-1-name:device\\:2\\:name\n\n ;; The linux-dev-names-exclude entry is parsed identically to linux-dev. It\n ;; defines a list of device names that should be excluded. This is only\n ;; used if linux-dev is omitted. This and linux-dev-names-include are not\n ;; mutually exclusive but in practice it probably makes sense to only use\n ;; one of them.\n ;; linux-dev-names-exclude device-1-name:device\\:2\\:name\n\n ;; By default, kanata will crash if no input devices are found. You can change\n ;; this behaviour by setting `linux-continue-if-no-devs-found`.\n ;;\n ;; linux-continue-if-no-devs-found yes\n\n ;; Kanata on Linux automatically detects and grabs input devices\n ;; when none of the explicit device configurations are in use.\n ;; In case kanata is undesirably grabbing mouse-like devices,\n ;; you can use a configuration item to change detection behaviour.\n ;;\n ;; linux-device-detect-mode keyboard-only\n\n ;; On Linux, you can ask kanata to run `xset r rate ` on startup\n ;; and on live reload via the config below. The first number is the delay in ms\n ;; and the second number is the repeat rate in repeats/second.\n ;;\n ;; linux-x11-repeat-delay-rate 400,50\n\n ;; On linux, you can ask kanata to label itself as a trackpoint. This has several\n ;; effects on libinput including enabling middle mouse button scrolling and using\n ;; a different acceleration curve. Otherwise, a trackpoint intercepted by kanata\n ;; may not behave as expected.\n ;;\n ;; If using this feature, it is recommended to filter out any non-trackpoint\n ;; pointing devices using linux-only-linux-dev-names-include,\n ;; linux-only-linux-dev-names-exclude or linux-only-linux-dev to avoid changing\n ;; their behavior as well.\n ;;\n ;; linux-use-trackpoint-property yes\n\n ;; Unicode on Linux works by pressing Ctrl+Shift+U, typing the unicode hex value,\n ;; then pressing Enter. However, if you do remapping in userspace, e.g. via\n ;; xmodmap/xkb, the keycode \"U\" that kanata outputs may not become a keysym \"u\"\n ;; after the userspace remapping. This will be likely if you use non-US,\n ;; non-European keyboards on top of kanata. For unicode to work, kanata needs to\n ;; use the keycode that outputs the keysym \"u\", which might not be the keycode\n ;; \"U\".\n ;;\n ;; You can use `evtest` or `kanata --debug`, set your userspace key remapping,\n ;; then press the key that outputs the keysym \"u\" to see which underlying keycode\n ;; is sent. Then you can use this configuration to change kanata's behaviour.\n ;;\n ;; Example:\n ;;\n ;; linux-unicode-u-code v\n\n ;; Unicode on Linux terminates with the Enter key by default. This may not work in\n ;; some applications. The termination is configurable with the following options:\n ;;\n ;; - `enter`\n ;; - `space`\n ;; - `enter-space`\n ;; - `space-enter`\n ;;\n ;; Example:\n ;;\n ;; linux-unicode-termination space\n\n ;; Kanata on Linux creates an evdev output device named \"kanata\".\n ;; This name can be changed with this linux-output-device-name.\n ;;\n ;; Examples:\n ;;\n ;; linux-output-device-name kanata_laptop\n ;; linux-output-device-name \"kanata output device\"\n\n ;; Kanata on Linux needs to declare a \"bus type\" for its evdev output device.\n ;; The options are USB and I8042. The default is I8042.\n ;; Using USB can break disable-touchpad-while-typing on Wayland.\n ;; But using I8042 appears to break some other scenarios. Thus it is configurable.\n ;;\n ;; Examples:\n ;;\n ;; linux-output-device-bus-type USB\n ;; linux-output-device-bus-type I8042\n\n ;; There is an optional configuration entry for Windows to help mitigate strange\n ;; behaviour of AltGr if your layout uses that. Uncomment one of the items below\n ;; to change what kanata does with the key.\n ;;\n ;; For more context, see: https://github.com/jtroo/kanata/issues/55.\n ;;\n ;; windows-altgr cancel-lctl-press ;; remove the lctl press that comes as a combo with ralt\n ;; windows-altgr add-lctl-release ;; add an lctl release when ralt is released\n ;;\n ;; NOTE: even with these workarounds, putting lctl+ralt in your defsrc may\n ;; not work too well with other applications that use WH_KEYBOARD_LL.\n ;; Known applications with issues: GWSL/VcXsrv\n\n ;; Enable kanata to execute commands.\n ;;\n ;; I consider this feature a hazard so it is conditionally compiled out of\n ;; the default binary.\n ;;\n ;; This is dangerous because it allows kanata to execute arbitrary commands.\n ;; Using a binary compiled with the cmd feature enabled, uncomment below to\n ;; enable command execution:\n ;;\n ;; danger-enable-cmd yes\n\n ;; Enable processing of keys that are not in defsrc.\n ;; This is useful if you are only mapping a few keys in defsrc instead of\n ;; most of the keys on your keyboard. Without this, the tap-hold-release and\n ;; tap-hold-press actions will not activate for keys that are not in defsrc.\n ;;\n ;; The reason this is not enabled by default is because some keys may not\n ;; work correctly if they are intercepted. E.g. rctl/altgr on Windows; see the\n ;; windows-altgr configuration item above for context.\n ;;\n ;; process-unmapped-keys yes\n\n ;; We need to set it to yes in this kanata.kbd example config to allow the use of __ and ___\n ;; in the deflayer-custom-map example below in the file\n\n ;; This also accepts a list parameter (all-except key1 ... keyN)\n ;; which behaves like \"yes\" but excludes the keys within the list.\n process-unmapped-keys (all-except f19)\n\n ;; Disable all keys not mapped in defsrc.\n ;; Only works if process-unmapped-keys is also yes.\n ;; block-unmapped-keys yes\n\n ;; Intercept mouse buttons for a specific mouse device.\n ;; The intended use case for this is for laptops such as a Thinkpad, which have\n ;; mouse buttons that may be useful to activate kanata actions with. This only\n ;; works with the Interception driver.\n ;;\n ;; To know what numbers to put into the string, you can run the\n ;; kanata-wintercept variant with this defcfg item defined with random numbers.\n ;; Then when a button is first pressed on the mouse device, kanata will print\n ;; its hwid in the log; you can then copy-paste that into this configuration\n ;; entry. If this defcfg item is not defined, the log will not print.\n ;;\n ;; windows-interception-mouse-hwid \"70, 0, 90, 0, 20\"\n\n ;; There is also a list version of windows-interception-mouse-hwid:\n ;;\n ;; windows-interception-mouse-hwids (\n ;; \"70, 0, 60, 0\"\n ;; \"71, 0, 62, 0\"\n ;; )\n\n ;; List configuration for kanata-wintercept variants\n ;; that allows intercepting only some connected keyboards.\n ;; Use similarly to mouse-hwid above.\n ;;\n ;; windows-interception-keyboard-hwids (\n ;; \"90, 80, 11, 34\"\n ;; \"99, 88, 77, 66\"\n ;; )\n\n ;; There are also exclude variants of the wintercept device configurations.\n ;; These cannot be defined at the same time as the non-exclude variants.\n ;;\n ;; windows-interception-keyboard-hwids-exclude (\n ;; \"90, 80, 11, 34\"\n ;; \"99, 88, 77, 66\"\n ;; )\n ;;\n ;; windows-interception-mouse-hwids-exclude (\n ;; \"70, 0, 60, 0\"\n ;; \"71, 0, 62, 0\"\n ;; )\n\n ;; Transparent keys on layers will delegate to the corresponding defsrc key\n ;; when found on a layer activated by `layer-switch`. This config entry\n ;; changes the behaviour to delegate to the action of the first layer,\n ;; which is the layer active upon startup, that is in the same position.\n ;;\n ;; delegate-to-first-layer yes\n\n ;; This config entry alters the behavior of movemouse-accel actions.\n ;; By default, this setting is disabled - vertical and horizontal\n ;; acceleration are independent. Enabling this setting will emulate QMK mouse\n ;; move acceleration behavior, i.e. the acceleration state of new mouse\n ;; movement actions are inherited if others are already being pressed.\n ;;\n ;; movemouse-inherit-accel-state yes\n\n ;; This config entry alters the behavior of movemouseaccel actions.\n ;; This makes diagonal movements simultaneous to mitigate choppiness in\n ;; drawing apps, if you're using kanata mouse movements to draw for\n ;; whatever reason.\n ;;\n ;; movemouse-smooth-diagonals yes\n\n ;; This configuration allows you to customize the length limit on dynamic macros.\n ;; The default limit is 128 keys.\n ;;\n ;; dynamic-macro-max-presses 1000\n\n ;; This configuration makes multiple tap-hold actions that are activated near\n ;; in time expire their timeout quicker. Without this, the timeout for the 2nd\n ;; tap-hold onwards will start from 0ms after the previous tap-hold expires.\n ;;\n concurrent-tap-hold yes\n\n ;; This configuration makes the release of one-shot-press and of the tap in a tap-hold\n ;; by the defined number of milliseconds (approximate).\n ;; The default value is 5.\n ;; While the release is delayed, further processing of inputs is also paused.\n ;; This means that there will be a minor input latency impact in the mentioned scenarios.\n ;; The reason for this configuration existing is that some environments\n ;; do not process the scenarios correctly due to the rapidity of the release.\n ;; Kanata does send the events in the correct order,\n ;; so the fault is more in the environment, but kanata provides a workaround anyway.\n rapid-event-delay 5\n\n ;; This setting defaults to yes but can be configured to no to save on\n ;; logging. However, if --log-layer-changes is passed as a command line\n ;; argument, a \"no\" in the configuration file will be overridden and layer\n ;; changes will be logged.\n ;;\n ;; log-layer-changes no\n\n ;; This configuration will press and then immediately release the non-modifier key\n ;; as soon as the override activates, meaning you are unlikely as a human to ever\n ;; release modifiers first, which can result in unintended behaviour.\n ;;\n ;; The downside of this configuration is that the non-modifier key\n ;; does not remain held which is important to consider for your use cases.\n override-release-on-activation yes\n\n ;; Accepts a single key name.\n ;; When configured, whenever a mouse cursor movement is received,\n ;; the configured key name will be \"tapped\" by Kanata, activating\n ;; the key's action.\n ;;\n ;; This enables reporting of every relative mouse movement, which\n ;; corresponds to standard mice, trackballs, trackpads and\n ;; trackpoints. Absolute movements, which can be generated by\n ;; touchscreens, drawing tablets and some mouse replacement or\n ;; accessibility software, are ignored. Scrolling events and mouse\n ;; buttons are also ignored.\n ;;\n ;; The intended use of these events is to provide a way to\n ;; automatically enable a mouse keys layer while mousing, which can\n ;; be disabled by a timeout or typing on other keys, rather than\n ;; explicit toggling. see cfg_examples/automousekeys-*.kbd for more.\n ;;\n ;; The `mvmt` key name is specially intended for this purpose. It\n ;; has no output key mapping and cannot be supplied as an action;\n ;; however, any key may be used.\n ;;\n ;; Supports live reload on Linux, but with Windows-interception,\n ;; this option must be present on startup to enable mouse movement\n ;; event collection, so restart is required to enable it. Changing\n ;; the key name is always supported, however.\n ;;\n ;; mouse-movement-key mvmt\n)\n\n;; deflocalkeys-* enables you to define and use key names that match your locale\n;; by defining OS code number mappings for that character.\n;;\n;; There are five variants of deflocalkeys-*:\n;; - deflocalkeys-win\n;; - deflocalkeys-winiov2\n;; - deflocalkeys-wintercept\n;; - deflocalkeys-linux\n;; - deflocalkeys-macos\n;;\n;; Only one of each deflocalkeys-* variant is allowed. The variants that are\n;; not applicable will be ignored, e.g. deflocalkeys-linux and deflocalkeys-wintercept\n;; are both ignored when using the default Windows kanata binary.\n;;\n;; The configuration item is parsed similarly to defcfg; it is composed of\n;; pairs of keys and values.\n;;\n;; You can check docs/locales.adoc for the mapping for your locale. If your\n;; locale is not there, please ask for help if needed, and add the mapping for\n;; your locale to the document.\n;;\n;; Web link for locales: https://github.com/jtroo/kanata/blob/main/docs/locales.adoc\n;;\n;; This example is for an Italian keyboard remapping in Linux. The numbers will\n;; unfortunately differ between Linux, Windows-hooks, and Windows-interception.\n;;\n;; To see how you can discover key mappings for yourself, see the \"Non-US keyboards\"\n;; section of docs/config.adoc.\n;;\n;; Web link or config: https://github.com/jtroo/kanata/blob/main/docs/config.adoc\n\n(deflocalkeys-win\n ì 187\n)\n\n(deflocalkeys-wintercept\n ì 187\n)\n\n(deflocalkeys-winiov2\n ì 187\n)\n\n(deflocalkeys-linux\n ì 13\n)\n\n(deflocalkeys-macos\n ì 13\n)\n\n;; Only one defsrc is allowed.\n;;\n;; defsrc defines the keys that will be intercepted by kanata. The order of the\n;; keys matches the deflayer declarations and all deflayer declarations must\n;; have the same number of keys as defsrc.\n;;\n;; The visual/spatial positioning is *not* mandatory; it is done by convention\n;; for visual ease. These items are parsed as a long list with newlines being\n;; ignored.\n;;\n;; If you are looking for other keys, the file src/keys/mod.rs should hopefully\n;; provide some insight.\n(defsrc\n grv 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n caps a s d f g h j k l ; ' ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n\n;; The first layer defined is the layer that will be active by default when\n;; kanata starts up. This layer is the standard QWERTY layout except for the\n;; backtick/grave key (@grl) which is an alias for a tap-hold key.\n(deflayer qwerty\n @grl 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n caps a s d f g h j k l ; ' ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n\n;; The dvorak layer remaps the keys to the dvorak layout. There are several\n;; tap-hold aliases configured on the left side.\n(deflayer dvorak\n @grl 1 2 3 4 5 6 7 8 9 0 [ ] bspc\n tab ' , @.ms p y f g c r l / = \\\n @cap @anm @oar @ech @umc @ifk d h t n s - ret\n lsft ; q j k x b m w v z rsft\n lctl lmet lalt spc @ralt rmet @rcl\n)\n\n;; This is an alternative to deflayer and does not rely on defsrc.\n;; It has the advantage of simpler config if only remapping a few keys.\n;; You might still prefer the standard deflayer for its visual printing in\n;; the log as you are learning a new configuration.\n(deflayermap (custom-map-example)\n caps esc\n esc caps\n\n ;; You can use _ , __ or ___ instead of specifying a key name to map all\n ;; keys that are not explicitly mapped in the layer.\n ;; E.g. esc and caps above will not be overwritten.\n ;;\n ;; _ maps only keys that are in defsrc.\n ;; __ excludes mapping keys that are in defsrc.\n ;; ___ maps both, keys that are in `defsrc`, and keys that are not.\n ;;\n ;; The two- and three-underscore variants require\n ;; \"process-unmapped-keys yes\" in defcfg to work.\n\n ;; ___ XX ;; maps all keys that are not mapped explicitly in the layer\n ;; ;; (i.e. esc and caps above) to \"no-op\" to disable the key.\n _ XX ;; maps all keys that are in defsrc and are not mapped in the layer\n __ XX ;; maps all keys that are NOT in defsrc and are not mapped in the layer\n)\n\n;; defvar can be used to declare commonly-used values\n(defvar\n tap-repress-timeout 100\n hold-timeout 200\n tt $tap-repress-timeout\n ht $hold-timeout\n\n ;; A list value in defvar that begins with concat behaves in a special manner\n ;; where strings will be joined together.\n ;;\n ;; Below results in 100200\n a \"hello\"\n b \"world\"\n ct (concat $a \" \" $b)\n)\n\n(defalias\n th1 (tap-hold $tt $ht caps lctl)\n th2 (tap-hold $tt $ht spc lsft)\n)\n\n;; defalias is used to declare a shortcut for a more complicated action to keep\n;; the deflayer declarations clean and aligned. The alignment in deflayers is not\n;; necessary, but is strongly recommended for ease of understanding visually.\n;;\n;; Aliases are referred to by `@`. Aliases can refer to each other,\n;; e.g. in the `anm` alias. However, an alias can only refer to another alias\n;; that has been defined before it in the file.\n(defalias\n ;; aliases to change the base layer to qwerty or dvorak\n dvk (layer-switch dvorak)\n qwr (layer-switch qwerty)\n\n ;; Aliases for layer \"toggling\". It's not quite toggling because the layer\n ;; will be active while the key is held and deactivated when the key is\n ;; released. An alternate action name you can use is layer-while-held.\n ;; However, the rest of this document will use The term \"toggle\" for brevity.\n num (layer-toggle numbers)\n chr (layer-toggle chords)\n arr (layer-toggle arrows)\n msc (layer-toggle misc)\n lay (layer-toggle layers)\n mse (layer-toggle mouse)\n fks (layer-while-held fakekeys)\n\n ;; tap-hold aliases with tap for dvorak key, and hold for toggle layers\n ;; WARNING(Linux only): key repeat with tap-hold can behave unexpectedly.\n ;; For full context, see https://github.com/jtroo/kanata/discussions/422\n ;;\n ;; tap-hold parameter order:\n ;; 1. tap repress timeout\n ;; 2. hold timeout\n ;; 3. tap action\n ;; 4. hold action\n ;;\n ;; The hold timeout is the number of milliseconds after which the hold action\n ;; will activate.\n ;;\n ;; The tap repress timeout is best explained in a roundabout way. When you press and\n ;; hold a standard key on your keyboard (e.g. 'a'), your operating system will\n ;; read that and keep sending 'a' to the active application. To be able to\n ;; replicate this behaviour with a tap-hold key, you must press-release-press\n ;; the key within the tap repress timeout window (number is milliseconds). Simply\n ;; holding the key results in the hold action activating, which is why you\n ;; need to double-press for the tap action to stay pressed.\n ;;\n ;; There are two additional versions of tap-hold available:\n ;; 1. tap-hold-press: if there is a key press, the hold action is activated\n ;; 2. tap-hold-release: if there is a press and release of another key, the\n ;; hold action is activated\n ;;\n ;; These versions are useful if you don't want to wait for the whole hold\n ;; timeout to activate, but want to activate the hold action immediately\n ;; based on the next key press or press and release of another key. These\n ;; versions might be great to implement home row mods.\n ;;\n ;; If you come from kmonad, tap-hold-press and tap-hold-release are similar\n ;; to tap-hold-next and tap-hold-next-release, respectively. If you know\n ;; the underlying keyberon crate, tap-hold-press is the HoldOnOtherKeyPress\n ;; and tap-hold-release is the PermissiveHold configuration.\n anm (tap-hold 200 200 a @num) ;; tap: a hold: numbers layer\n oar (tap-hold 200 200 o @arr) ;; tap: o hold: arrows layer\n ech (tap-hold 200 200 e @chr) ;; tap: e hold: chords layer\n umc (tap-hold 200 200 u @msc) ;; tap: u hold: misc layer\n grl (tap-hold 200 200 grv @lay) ;; tap: grave hold: layers layer\n .ms (tap-hold 200 200 . @mse) ;; tap: . hold: mouse layer\n ifk (tap-hold 200 200 i @fks) ;; tap: i hold: fake keys layer\n\n ;; There are additional variants of tap-hold-press and tap-hold-release that\n ;; activate the timeout action (the 5th parameter) when the action times out\n ;; as opposed to the hold action being activated by other keys.\n\n ;; tap: o hold: arrows layer timeout: backspace\n oat (tap-hold-press-timeout 200 200 o @arr bspc)\n ;; tap: e hold: chords layer timeout: esc\n ect (tap-hold-release-timeout 200 200 e @chr esc)\n ;; If you add reset-timeout-on-press to tap-hold-release-timeout,\n ;; the timeout will reset on a press to give you more time to release\n ;; a key to activate the hold.\n ect2 (tap-hold-release-timeout 200 200 e @chr esc reset-timeout-on-press)\n\n ;; There is another variant of `tap-hold-release` that takes a 5th parameter\n ;; that is a list of keys that will trigger an early tap when pressed.\n\n ;; tap: u hold: misc layer early tap if any of: (a o e) are pressed\n umk (tap-hold-release-keys 200 200 u @msc (a o e))\n\n ;; A variant of tap-hold-release-keys accepts another parameter,\n ;; which is a list of keys that activates the tap\n ;; on a press->release of a listed key.\n umk2 (tap-hold-release-tap-keys-release 200 200 u @msc (a o e) (' , .))\n\n ;; tap: u hold: misc layer always tap if any of: (a o e) are pressed\n uek (tap-hold-except-keys 200 200 u @msc (a o e))\n\n ;; tap: u hold: misc layer early tap if any of: (a o e) are pressed\n ;; Unlike tap-hold-release-keys, other keys do NOT trigger early hold.\n ;; This is useful for home row mods where fast typing should not trigger modifiers.\n utk (tap-hold-tap-keys 200 200 u @msc (a o e))\n\n ;; tap-hold-order resolves by release order instead of timeout.\n ;; tap: a hold: lctl buffer: 50ms (fast typing grace period)\n aor (tap-hold-order 200 50 a lctl)\n\n ;; tap for capslk, hold for lctl\n cap (tap-hold 200 200 caps lctl)\n\n ;; Below is an alias for the `multi` action which executes multiple actions\n ;; in order but at the same time.\n ;;\n ;; It may result in some incorrect/unexpected behaviour if combining complex\n ;; actions, so be reasonable with it. One reasonable use case is this alias:\n ;; press right-alt while also toggling to the `ralted` layer. The utility of\n ;; this is better revealed if you go see `ralted` and its aliases.\n ralt (multi ralt (layer-toggle ralted))\n)\n\n;; Wrapping a top-level configuration item in a list beginning with\n;; (environment (env-var-name env-var-value) ...configuration...)\n;; will make the configuration only active if the environment variable matches.\n(environment (LAPTOP lp1)\n (defalias met @lp1met)\n)\n\n(environment (LAPTOP lp2)\n (defalias met @lp2met)\n)\n\n;; NOTE: the configuration below is an older and less general variant\n;; of the environment configuration above.\n;;\n;; The defaliasenvcond variant of defalias is parsed similarly, but there must\n;; be a list parameter first. The list must contain two strings. In order,\n;; these strings are: an environment variable name, and the environment\n;; variable value. When the environment variable defined by name has the\n;; corresponding value when running kanata, the aliases within will be active.\n;; Otherwise, the aliases will be skipped.\n(defaliasenvcond (LAPTOP lp1)\n met @lp1met\n)\n\n(defaliasenvcond (LAPTOP lp2)\n met @lp2met\n)\n\n(defalias\n ;; shifted keys\n { S-[\n } S-]\n : S-;\n\n ;; alias numbers as themselves for use in macro\n 8 8\n 0 0\n)\n\n(defalias\n ;; For the multi action, all keys are pressed for the whole sequence\n ;; but still in the listed order which may be undesirable, particularly\n ;; for modifiers like shift. You probably want to use macro instead.\n ;;\n ;; Chording can be more succinctly described by the modifier prefixes\n ;; `C-`, `A-`, `S-`, and `M-` for lctrl, lalt, lshift, lmeta, but are possible\n ;; by using `multi` as well. The lmeta key is also known by some other\n ;; names: \"Windows\", \"GUI\", \"Command\", \"Super\".\n ;;\n ;; For ralt/altgr, you can use either of: `RA-` or `AG-`. They both work the\n ;; same and only one is allowed in a single chord. This chord can be useful for\n ;; international layouts.\n ;;\n ;; A special behaviour of output chords is that if another key is pressed,\n ;; all of the chord keys will be released. For the explanation about why\n ;; this is the case, see the configuration guide.\n ;;\n ;; This use case for multi is typing an all-caps string.\n alp (multi lsft a b c d e f g h i j k l m n o p q r s t u v w x y z)\n\n ;; Within multi you can also include reverse-release-order to release keys\n ;; from last-to-first order instead of first-to-last which is the default.\n S-a-reversed (multi lsft a reverse-release-order)\n\n ;; Chords using the shortcut syntax. These ones are used for copying/pasting\n ;; from some Linux terminals.\n csv C-S-v\n csc C-S-c\n\n ;; Windows shortcut for displaying all windows\n win M-tab\n\n ;; Accented e characters for France layout using altgr sequence. Showcases\n ;; both of the shortcuts. You can just use one version of shortcut at your\n ;; preference.\n é AG-2\n è RA-7\n testmacro (macro AG-2 RA-7)\n 🙃 (unicode 🙃)\n\n ;; macro accepts keys, chords, and numbers (a delay in ms). Note that numbers\n ;; will be parsed as delays, so they will need to be aliased to be used.\n lch (macro h t t p @: / / 100 l o c a l h o s t @: @8 @0 @8 @0)\n tbm (macro A-(tab 200 tab 200 tab) 200 S-A-(tab 200 tab 200 tab))\n hpy (macro S-i spc a m spc S-(h a p p y) spc m y S-f r S-i e S-n d @🙃)\n\n rls (macro-release-cancel Digit1 500 bspc S-1 500 bspc S-2)\n cop (macro-cancel-on-press Digit1 500 bspc S-1 500 bspc S-2)\n rlpr (macro-release-cancel-and-cancel-on-press Digit1 500 bspc S-1 500 bspc S-2)\n\n ;; repeat variants will repeat while held, once ALL macros have ended,\n ;; including the held macro.\n mr1 (macro-repeat mltp)\n mr2 (macro-repeat-release-cancel mltp)\n mr3 (macro-repeat-cancel-on-press mltp)\n mr4 (macro-repeat-release-cancel-and-cancel-on-press mltp)\n\n ;; Kanata also supports dynamic macros. Dynamic macros can be nested, but\n ;; cannot recurse.\n dms dynamic-macro-record-stop\n dst (dynamic-macro-record-stop-truncate 3)\n dr0 (dynamic-macro-record 0)\n dr1 (dynamic-macro-record 1)\n dr2 (dynamic-macro-record 2)\n dp0 (dynamic-macro-play 0)\n dp1 (dynamic-macro-play 1)\n dp2 (dynamic-macro-play 2)\n\n ;; unmod will release all modifiers temporarily and send the .\n ;; So for example holding shift and tapping a @um1 key will still output 1.\n um1 (unmod 1)\n ;; dead keys é (as opposed to using AltGr) that outputs É when shifted\n dké (macro (unmod ') e)\n\n ;; unshift is like unmod but only releases shifts\n ;; In ISO German QWERTZ, force unshifted symbols even if shift is held\n de{ (unshift ralt 7)\n de[ (unshift ralt 8)\n\n ;; unmod can optionally take a list as the first parameter,\n ;; and then will only temporarily remove\n ;; the listed modifiers instead of all modifiers.\n unalt-a (unmod (lalt ralt) a)\n\n ;; unicode accepts a single unicode character. The unicode character will\n ;; not be automatically repeated by holding the key down. The alias name\n ;; is the unicode character itself and is referenced by @🙁 in deflayer.\n 🙁 (unicode 🙁)\n\n ;; You may output parentheses or double quotes using unicode\n ;; by quotes as well as special quoting syntax.\n lp1 (unicode r#\"(\"#)\n rp1 (unicode r#\")\"#)\n dq (unicode r#\"\"\"#)\n lp2 (unicode \"(\")\n rp2 (unicode \")\")\n\n ;; fork accepts two actions and a key list. The first (left) action will\n ;; activate by default. The second (right) action will activate if any of\n ;; the keys in the third parameter (right-trigger-keys) are currently active.\n frk (fork @🙃 @🙁 (lsft rsft))\n\n ;; switch accepts triples of keys check, action, and fallthrough|break.\n ;; The default usage of keys check behaves similarly to fork.\n ;; However, it also accepts boolean operators and|or to allow more\n ;; complex use cases.\n ;;\n ;; The order of cases matters. If two different cases match the\n ;; currently pressed keys, the case listed earlier in the configuration\n ;; will activate first. If the early case uses break, the second case will\n ;; not activate at all. Otherwise if fallthrough is used, the second case\n ;; will also activate sequentially after the first case.\n swt (switch\n\n ;; translating this keys check to some other common languages\n ;; this might look like:\n ;;\n ;; (a && b && (c || d) && (e || f))\n ((and a b (or c d) (or e f))) a break\n\n ;; this case behaves like fork, i.e.\n ;;\n ;; (or a b c)\n ;;\n ;; or for some other common languages:\n ;;\n ;; a || b || c\n (a b c) b fallthrough\n\n ;; key-history evaluates to true if the n'th most recent typed key,\n ;; {n | n ∈ [1, 8]}, matches the given key.\n ((key-history a 1) (key-history b 8)) c break\n\n ;; key-timing evaluates to true if the n'th most recent typed key,\n ;; {n | n ∈ [1, 8]}, was typed at a time less-than/greater-than the\n ;; given number of milliseconds.\n ((key-timing 1 lt 3000) (key-timing 2 gt 30000) ) c break\n ((key-timing 7 less-than 200) (key-timing 8 greater-than 500)) c break\n\n ;; not means \"not any of the list constituents\".\n ;; The example below behaves like:\n ;;\n ;; !(a || b || c)\n ;;\n ;; and is equivalent to:\n ;;\n ;; ((not (or a b c)))\n ((not a b c)) c break\n\n ;; input logic\n ((input real lctl)) d break\n ((input virtual sft)) e break\n ((input-history real lsft 2)) f break\n ((input-history virtual ctl 2)) g break\n\n ;; layer evaluates to `true` if the active layer matches the given name\n ((layer dvorak)) x break\n ((layer qwerty)) y break\n\n ;; base-layer evaluates to `true` if the base layer matches the given name\n ;; The base layer is the most recent target of layer-switch.\n ;; The base layer is not always the active layer.\n ((base-layer dvorak)) x break\n ((base-layer qwerty)) y break\n\n ;; default case, empty list always evaluates to true.\n ;; break vs. fallthrough doesn't matter here\n () c break\n )\n\n ;; Having a cmd action in your configuration without explicitly enabling\n ;; `danger-enable-cmd` **and** using the cmd-enabled executable will make\n ;; kanata refuse to load your configuration. The aliases below are commented\n ;; out since commands aren't allowed by this configuration file.\n ;;\n ;; Note that the parameters to `cmd` are executed directly as opposed to\n ;; passed to a shell. So for example, `~` and `$HOME` would not refer\n ;; to your home directory on Linux.\n ;;\n ;; You can use:\n ;; `cmd bash -c \"your_stuff_here\"` to run your command inside of bash.\n ;;\n ;; cm1 (cmd bash -c \"echo hello world\")\n ;; cm2 (cmd rm -fr /tmp/testing)\n\n ;; One variant of `cmd` is `cmd-log`, which lets you control how\n ;; running command, stdout, stderr, and execution failure are logged.\n ;;\n ;; The command takes two extra arguments at the beginning ``,\n ;; and ``. `` controls where the name\n ;; of the command is logged, as well as the success message and command\n ;; stdout and stderr.\n ;;\n ;; `` is only used if there is a failure executing the initial\n ;; command. This can be if there is trouble spawning the command, or\n ;; the command is not found. This means if you use `bash -c \"thisisntacommand\"`, as\n ;; long as bash starts up correctly, nothing would be logged to this channel, but\n ;; something like `thisisntacommand` would be.\n ;;\n ;; The log level can be `debug`, `info`, `warn`, `error`, or `none`.\n ;;\n ;; cmd-log info error bash -c \"echo these are the default levels\"\n ;; cmd-log none none bash -c \"echo nothing back in kanata logs\"\n ;; cmd-log none error bash -c \"only if command fails\"\n ;; cmd-log debug debug bash -c \"echo log, but require changing verbosity levels\"\n ;; cmd-log warn warn bash -c \"echo this probably isn't helpful\"\n\n ;; Another variant of `cmd` is `cmd-output-keys`. This reads the output\n ;; of the command and treats it as an S-Expression, similarly to `macro`.\n ;; However, only delays, keys, chords, and chorded lists are supported.\n ;; Other actions are not.\n ;;\n ;; bash: type date-time as YYYY-MM-DD HH:MM\n ;; cmd-output-keys bash -c \"date +'%F %R' | sed 's/./& /g' | sed 's/:/S-;/g' | sed 's/\\(.\\{20\\}\\)\\(.*\\)/\\(\\1 spc \\2\\)/'\"\n)\n\n;; The underscore _ means transparent. The key on the base layer will be used\n;; instead. XX means no-op. The key will do nothing.\n;;\n;; A similar concept to transparent, use-defsrc means the key will always\n;; behave as the key as defined by defsrc.\n(defalias src use-defsrc)\n(deflayer numbers\n @src _ _ _ _ _ nlk kp7 kp8 kp9 _ _ _ _\n _ _ _ _ _ XX _ kp4 kp5 kp6 - _ _ _\n _ _ C-z _ _ XX _ kp1 kp2 kp3 + _ _\n _ C-z C-x C-c C-v XX _ kp0 kp0 . / _\n _ _ _ _ _ _ _\n)\n\n;; The `lrld` action stands for \"live reload\".\n;;\n;; NOTE: live reload does not read changes to device-related configurations,\n;; such as `linux-dev`, `macos-dev-names-include`,\n;; or `windows-only-windows-interception-keyboard-hwids`.\n;;\n;; The variants `lrpv` and `lrnx` will cycle between multiple configuration files\n;; if they are specified in the startup arguments.\n;; The list action variant `lrld-num` takes a number parameter and\n;; reloads the configuration file specified by the number, according to the\n;; order passed into the arguments on kanata startup.\n;;\n;; Upon a successful reload, the kanata state will begin on the default base layer\n;; in the configuration. E.g. in this example configuration, you would start on\n;; the qwerty layer.\n(deflayer layers\n _ @qwr @dvk lrld lrpv lrnx (lrld-num 1) _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _\n)\n\n(defalias\n\n ;; Alias for one-shot which will activate an action until either the timeout\n ;; expires or a different key is pressed. The timeout is the first parameter\n ;; and the action is the second parameter.\n ;;\n ;; The intended use cases are pressing a modifier for exactly one key or\n ;; switching to another layer for exactly one key.\n ;;\n ;; If a one-shot key is held then it will act as a regular key. E.g. for os1\n ;; below, holding an @os1 key will keep lsft held and holding an @os3 key\n ;; will keep the layer set to misc.\n os1 (one-shot 500 lsft)\n os2 (one-shot 500 C-S-lalt)\n os3 (one-shot 500 (layer-toggle misc))\n\n ;; Another name for one-shot is one-shot-press, since it ends on the first\n ;; press of another key.\n ;;\n ;; There is another variant one-shot-release which ends on the first release\n ;; of another key.\n ;;\n ;; There are further variants of both of these:\n ;; - one-shot-press-pcancel\n ;; - one-shot-release-pcancel\n ;;\n ;; These will cancel the one-shot action and all other active one-shot actions\n ;; if a one-shot key is repressed while already active.\n osp (one-shot-press 500 lsft)\n osr (one-shot-release 500 lsft)\n opp (one-shot-press-pcancel 500 lsft)\n orp (one-shot-release-pcancel 500 lsft)\n\n ;; one-shot-pause-processing can be useful in some cases\n ;; to preserve an activated one-shot state when it otherwise\n ;; would get deactivated by some action that isn't intended\n ;; to consume the one-shot.\n ;; The unit is number of milliseconds.\n ops (one-shot-pause-processing 5)\n\n ;; Alias for tap-dance which will activate one of the actions in the action\n ;; list depending on how many taps were done. Tapping once will output the\n ;; first action and tapping N times will output the N'th action.\n ;;\n ;; The first parameter is a timeout. Tapping the same tap-dance key again\n ;; within the timeout will reset the timeout and advance the tap-dance to the\n ;; next key.\n ;;\n ;; The action activates either when any of the following happens:\n ;; - the timeout expires\n ;; - the tap sequence reaches the end\n ;; - a different key is pressed\n td (tap-dance 200 (a b c d spc))\n\n ;; There is a variant of tap-dance — tap-dance-eager — that will activate\n ;; every action tapped in the sequence rather than a single one. The example\n ;; below is rather simple and behaves similarly to the original tap-dance.\n td2 (tap-dance-eager 500 (\n (macro a) ;; use macro to prevent auto-repeat of the key\n (macro bspc b b)\n (macro bspc bspc c c c)\n ))\n\n ;; arbitrary-code allows sending an arbitrary number as an OS code. This is\n ;; not cross platform! This can be useful for testing keys that are not yet\n ;; named or mapped in kanata. Please contribute findings with names and/order\n ;; mappings, either in a GitHub issue or as a pull request! This is currently\n ;; not supported with Windows using the interception driver.\n ab1 (arbitrary-code 700)\n)\n\n(defalias\n ;; caps-word will add an lsft to the active key list for all alphanumeric keys\n ;; a-z, and the US layout minus key; meaning it will be converted to an\n ;; underscore.\n ;;\n ;; The caps-word state will also be cleared if any key that doesn't get auto-\n ;; capitalized and also doesn't belong in this list is pressed:\n ;; - 0-9\n ;; - kp0-kp9\n ;; - bspc, del\n ;; - up, down, left, rght\n ;;\n ;; The single parameter is a timeout in milliseconds after which the caps-word\n ;; state will be cleared and lsft will not be added anymore. The timer is reset\n ;; any time a capitalizable or extra non-terminating key is active.\n cw (caps-word 2000)\n\n ;; Like caps-word, but you get to choose the key lists where lsft gets added.\n ;; This example is similar to the default caps-word behaviour but it moves the\n ;; 0-9 keys to capitalized key list from the extra non-terminating key list.\n cwc (caps-word-custom\n 2000\n (a b c d e f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9)\n (kp0 kp1 kp2 kp3 kp4 kp5 kp6 kp7 kp8 kp9 bspc del up down left rght)\n )\n)\n\n;; -toggle variants of caps-word will terminate caps-word on repress if it is\n;; currently active, otherwise caps-word will be activated.\n(defalias\n cwt (caps-word-toggle 2000)\n cct (caps-word-custom-toggle\n 2000\n (a b c d e f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9)\n (kp0 kp1 kp2 kp3 kp4 kp5 kp6 kp7 kp8 kp9 bspc del up down left rght)\n )\n)\n\n;; Can see a new action `rpt` in this layer. This repeats the most recently\n;; pressed key. Holding down the `rpt` key will not repeatedly send the key.\n;; The intended use case is to be able to use a different finger to repeat a\n;; double letter, as opposed to double-tapping a letter.\n;;\n;; The `rpt` action only repeats the last key output. For example, it won't\n;; output a chord like `ctrl+c` if the previous key pressed was `C-c` - it\n;; will only output `c`. There is a variant `rpt-any` which will repeat the\n;; previous action and would work for that use case.\n(deflayer misc\n _ _ _ _ _ _ _ _ _ @é @è _ ì #|random custom key for testing|# _\n _ _ @ab1 _ _ _ ins @{ @} [ ] _ _ +\n @cw _ _ _ C-u _ del bspc esc ret _ _ _\n @cwc C-z C-x C-c C-v _ _ _ @td @os1 @os2 @os3\n rpt rpt-any _ _ _ _ _\n)\n\n\n(deflayer chords ;; you can put list actions directly in deflayer but it's ugly, so prefer aliases.\n _ _ _ _ _ _ _ _ _ _ @🙁 (unicode 😀) _ _\n _ _ _ _ _ _ _ _ @csc @hpy @lch @tbm _ _\n _ @alp _ _ _ _ _ @ch1 @ch2 @ch4 @ch8 _ _\n _ _ _ _ _ _ _ _ _ @csv _ _\n _ _ _ _ _ _ _\n)\n\n(deflayer arrows\n _ f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12 _\n _ _ _ _ _ _ _ pgup up pgdn _ _ _ _\n _ _ _ _ _ _ home left down rght end _ _\n _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _\n)\n\n;; In Windows, using mouse buttons on the kanata window seems to cause it to hang.\n;; Using the mouse on other windows seems to be fine though.\n;;\n;; The mouse buttons can be clicked using mlft, mrgt, mmid, mfwd and mbck, representing the\n;; left, right, middle, forward and backward mouse buttons respectively. If the key is held, the\n;; button press will also be held.\n;;\n;; If there are multiple mouse click actions within a single multi action, e.g.\n;; (multi mrgt mlft), then all the buttons except the last will be clicked then\n;; unclicked. The last button will remain held until key release. In the example\n;; given, the button sequence will be:\n;; press key->click right->unclick right->click left->release key->release left\n;;\n;; There are variants of the standard mouse buttons which \"tap\" the button.\n;; These are mltp, mrtp, and mmtp. Rather than holding until key release, this\n;; action will click and unclick the button once the key is pressed. Nothing\n;; happens on key release. The action (multi lctl mltp) will result in the\n;; sequence below:\n;; press key->press lctl->click left->unclick left->release key->release lctl\n;;\n;; One can also see mouse movement actions at the lower right side, with the\n;; arrow unicode characters.\n(deflayer mouse\n _ @mwu @mwd @mwl @mwr _ _ _ _ _ @ma↑ _ _ _\n _ pgup bck _ fwd _ _ _ _ @ma← @ma↓ @ma→ _ _\n _ pgdn mlft _ mrgt mmid _ mbck mfwd _ @ms↑ _ _\n @fms _ mltp _ mrtp mmtp _ mbtp mftp @ms← @ms↓ @ms→\n _ _ _ _ _ _ _\n)\n\n(defalias\n ;; Mouse wheel actions. The first number is the interval in milliseconds\n ;; between scroll actions. The second number is the distance in some arbitrary\n ;; unit. Play with the parameters to see what feels correct. Both numbers\n ;; must be in the range 1-65535\n ;;\n ;; In both Windows and Linux, 120 distance units is equivalent to a single\n ;; notch movement on a physical wheel. In Linux, not all desktop environments\n ;; support the REL_WHEEL_HI_RES event so if you experience issues with `mwheel`\n ;; actions in Linux, using a distance value that is multiple of 120 may help.\n mwu (mwheel-up 50 120)\n mwd (mwheel-down 50 120)\n\n ;; Horizontal mouse wheel actions. Similar story to vertical mouse wheel.\n mwl (mwheel-left 50 120)\n mwr (mwheel-right 50 120)\n\n ;; There are similar wheel actions with `-accel` that have\n ;; accelerating/inertial scrolling.\n ;; The parameters are:\n ;; 1. initial velocity\n ;; 2. maximum velocity\n ;; 3. acceleration multiplier\n ;; 4. deceleration multiplier\n ;; The units are arbitrary.\n ;; The author finds the values in the example below\n ;; to be a decent-feeling starting paint.\n ;; Experiment to find your preference.\n mau (mwheel-accel-up 3 1200 1.15 0.93)\n mad (mwheel-accel-down 3 1200 1.15 0.93)\n\n ;; Mouse movement actions.The first number is the interval in milliseconds\n ;; between mouse actions. The second number is the distance traveled per interval\n ;; in pixels.\n\n ms↑ (movemouse-up 1 1)\n ms← (movemouse-left 1 1)\n ms↓ (movemouse-down 1 1)\n ms→ (movemouse-right 1 1)\n\n ;; Mouse movement actions with linear acceleration. The first number is the\n ;; interval in milliseconds between mouse actions. The second number is the time\n ;; in milliseconds for the distance to linearly ramp up from the minimum distance\n ;; to the maximum distance. The third number is the minimum distance traveled\n ;; per interval in pixels. The fourth number is the maximum distance traveled\n ;; per interval in pixels.\n\n ma↑ (movemouse-accel-up 1 1000 1 5)\n ma← (movemouse-accel-left 1 1000 1 5)\n ma↓ (movemouse-accel-down 1 1000 1 5)\n ma→ (movemouse-accel-right 1 1000 1 5)\n\n ;; setmouse places the cursor at a specific pixel x-y position. This\n ;; example puts it in the middle of the screen. The coordinates go from 0,0\n ;; which is the upper-left corner of the screen to 65535,65535 which is the\n ;; lower-right corner of the screen. If you have multiple monitors, they are\n ;; treated as one giant screen, which may make it a bit confusing for how to\n ;; set up the pixels. You will need to experiment.\n sm (setmouse 32228 32228)\n\n ;; movemouse-speed takes a percentage by which it then scales all of the\n ;; mouse movements while held. You can have as many of these active at a\n ;; given time as you would like, but be warned that some values, such as 33\n ;; may not have correct pixel distance representations.\n fms (movemouse-speed 200)\n)\n\n(defalias\n lft (multi (release-key ralt) left) ;; release ralt if held and also press left\n rgt (multi (release-key ralt) rght) ;; release ralt if held and also press rght\n rlr (release-layer ralted) ;; release layer-toggle of ralted\n)\n\n;; It's not clear what the practical use case is for the @rlr alias, but the\n;; combination of @ralt on the dvorak layer and this layer with @lft and @rgt\n;; results in the physical ralt key behaving mostly as ralt, **except** for\n;; holding it **then** pressing specific keys. These specific keys release the\n;; ralt because it would cause them to have undesired behaviour without the\n;; release.\n;;\n;; E.g. ralt+@lft will result in only left being pressed instead of ralt+left,\n;; while ralt(hold)+tab+tab+tab still works as intended.\n(deflayer ralted\n _ _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ @lft @rlr @rgt _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _\n)\n\n;; Virtual key actions\n\n(defvirtualkeys\n ;; Define some virtual keys that perform modifier actions\n vkctl lctl\n vksft lsft\n vkmet lmet\n vkalt lalt\n\n ;; A virtual key that toggles all modifier virtual keys above\n vktal (multi\n (on-press toggle-virtualkey vkctl)\n (on-press toggle-virtualkey vksft)\n (on-press toggle-virtualkey vkmet)\n (on-press toggle-virtualkey vkalt)\n )\n\n ;; Virtual key that activates a macro\n vkmacro (macro h e l l o spc w o r l d)\n)\n\n(defalias\n psfvk (on-press press-virtualkey vksft)\n rsfvk (on-press release-virtualkey vksft)\n\n palvk (on-press tap-vkey vktal)\n macvk (on-press tap-vkey vkmacro)\n\n isfvk (on-idle 1000 tap-vkey vksft)\n pisfvk (on-physical-idle 1000 tap-vkey vksft)\n)\n\n;; Press and release fake keys.\n;;\n;; Fake keys can't be pressed by any physical keyboard buttons and can only be\n;; acted upon by the actions:\n;; - on-press-fakekey\n;; - on-release-fakekey\n;; - on-idle-fakekey\n;;\n;; One use case of fake keys is for holding modifier keys\n;; for any number of keypresses and then releasing the modifiers when desired.\n;;\n;; The actions associated with fake keys in deffakekeys are parsed before\n;; aliases, so you can't use aliases within deffakekeys. Other than the lack\n;; of alias support, fake keys can do any action that a normal key can,\n;; including doing operations on previously defined fake keys.\n;;\n;; Operations on fake keys can occur either on press (on-press-fakekey),\n;; on release (on-release-fakekey), or on idle for a specified time\n;; (on-idle-fakekey).\n;;\n;; Fake keys are flexible in usage but can be obscure to discover how they\n;; can be useful to you.\n(deflayer fakekeys\n _ @fcp @fsp @fmp @pal _ _ _ _ _ _ _ _ _\n _ @fcr @fsr @fap @ral _ _ _ _ _ _ _ _ _\n _ @fct @fst @rma _ _ _ _ _ _ _ _ _\n _ @t1 _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _\n)\n\n(deffakekeys\n ctl lctl\n sft lsft\n lsft lsft\n met lmet\n alt lalt\n mmid mmid\n pal (multi\n (on-press-fakekey ctl press)\n (on-press-fakekey sft press)\n (on-press-fakekey met press)\n (on-press-fakekey alt press)\n )\n ral (multi\n (on-press-fakekey ctl release)\n (on-press-fakekey sft release)\n (on-press-fakekey met release)\n (on-press-fakekey alt release)\n )\n)\n\n(defalias\n fcp (on-press-fakekey ctl press)\n fcr (on-press-fakekey ctl release)\n fct (on-press-fakekey ctl tap)\n fsp (on-release-fakekey sft press)\n fsr (on-release-fakekey sft release)\n fst (on-release-fakekey sft tap)\n fsg (on-release-fakekey sft toggle)\n fmp (on-press-fakekey met press)\n fap (on-press-fakekey alt press)\n rma (multi\n (on-press-fakekey met release)\n (on-press-fakekey alt release)\n )\n pal (on-press-fakekey pal tap)\n ral (on-press-fakekey ral tap)\n rdl (on-idle-fakekey ral tap 1000)\n hfd (hold-for-duration 1000 met)\n\n ;; Test of on-press-fakekey and on-release-fakekey in a macro\n t1 (macro-release-cancel @fsp 5 a b c @fsr 5 c b a)\n\n ;; If you find that an application isn't registering keypresses correctly\n ;; with multi, you can try out:\n ;; - on-press-fakekey-delay\n ;; - on-release-fakekey-delay\n ;;\n ;; Do note that processing a fakekey-delay and even a sequence of delays will\n ;; delay any other inputs from being processed until the fakekey-delays are\n ;; all complete, so use with care.\n stm (multi ;; Shift -> middle mouse with a delay\n (on-press-fakekey lsft press)\n (on-press-fakekey-delay 200)\n (on-press-fakekey mmid press)\n (on-release-fakekey mmid release)\n (on-release-fakekey-delay 200)\n (on-release-fakekey lsft release)\n )\n)\n\n;; Vim-style leader-key sequences. Activate a fakekey-tap by pressing a \"leader\"\n;; key and then a sequence of characters.\n;; See: https://github.com/jtroo/kanata/issues/97\n;;\n;; You can add an entry to defcfg to change the sequence timeout (default is 1000):\n;; sequence-timeout \n;;\n;; If you want multiple timeouts with different leaders, you can also activate the\n;; sequence action:\n;; (sequence )\n;; This acts like `sldr` but uses a different timeout.\n;;\n;; There is also an option to customize the key sequence input mode. Its default\n;; value when not configured is `hidden-suppressed`.\n;;\n;; The options are:\n;;\n;; - `visible-backspaced`: types sequence characters as they are inputted. The\n;; typed characters will be erased with backspaces for a valid sequence termination.\n;; - `hidden-suppressed`: hides sequence characters as they are typed. Does not\n;; output the hidden characters for an invalid sequence termination.\n;; - `hidden-delay-type`: hides sequence characters as they are typed. Outputs the\n;; hidden characters for an invalid sequence termination either after either a\n;; timeout or after a non-sequence key is typed.\n;;\n;; For `visible-backspaced` and `hidden-delay-type`, a sequence leader input will\n;; be ignored if a sequence is already active. For historical reasons, and in case\n;; it is desired behaviour, a sequence leader input using `hidden-suppressed` will\n;; reset the key sequence.\n;;\n;; Example:\n;; sequence-input-mode visible-backspaced\n(defseq git-status (g s t))\n(deffakekeys git-status (macro g i t spc s t a t u s))\n(defalias rcl (tap-hold-release 200 200 sldr rctl))\n\n(defseq\n dotcom (. S-3)\n dotorg (. S-4)\n)\n(deffakekeys\n dotcom (macro . c o m)\n dotorg (macro . o r g)\n)\n;; Enter sequence mode and input .\n(defalias dot-sequence (macro (sequence 250) 10 .))\n(defalias dot-sequence-inputmode (macro (sequence 250 hidden-delay-type) 10 .))\n\n;; There are special keys that you can assign in your actions which will\n;; never output events to your operating system, but which you can use\n;; in sequences. They are named: nop0-nop9.\n(defseq\n dotcom (nop0 nop1)\n dotorg (nop8 nop9)\n)\n\n;; A key list within O-(...) signifies simultaneous presses.\n(defseq\n dotcom (O-(. c m))\n dotorg (O-(. r g))\n)\n\n;; sequence-noerase\n;;\n;; When you have a keyboard locale that uses dead keys,\n;; you may be pressing two keys that only actually output one symbol.\n;; By default, when visible-backspaced does the backtracking backspace,\n;; it backspaces according to input count.\n;; With dead keys, this may result in too many backspaces.\n;;\n;; The sequence-noerase action is a no-output action\n;; that tells the sequences action to have one fewer backspace\n;; when backtracking with visible-backspaced.\n\n(deflayermap (base)\n 0 sldr\n u (t! maybe-noerase u)\n)\n(deftemplate maybe-noerase (char)\n (multi\n (switch\n ((key-history ' 1)) (sequence-noerase 1) fallthrough\n () $char break\n ))\n)\n(defvirtualkeys seq-output-1 (macro a b c d e f g))\n(defseq seq-output-1 (' u))\n\n;; Input chording.\n;;\n;; Not to be confused with output chords (like C-S-a or the chords layer\n;; defined above), these allow you to perform actions when a combination of\n;; input keys (a \"chord\") are pressed all at once (order does not matter).\n;; Each combination/chord can perform a different action, allowing you to bind\n;; up to `2^n - 1` different actions to just `n` keys.\n;;\n;; Each `defchords` defines a named group of such chord-action pairs.\n;; The 500 is a timeout after which a chord triggers if it isn't triggered by a\n;; key release or press of a non-chord key before the timeout expires.\n;; If a chord is not defined, no action will occur when it is triggered but the\n;; keys used to input it will be consumed regardless.\n;;\n;; Each pair consists of the keys that make up a given chord in the parenthesis\n;; followed by the action that should be executed when the given chord is\n;; pressed.\n;; Note that these keys do not directly correspond to real keys and are merely\n;; arbitrary labels that make sense within the context of the chord.\n;; They are mapped to real keys in layers by configuring the key in the layer to\n;; map to a `(chord name key)` action (like those in the `defalias` below) where\n;; `name` is the name of the chords group (here `binary`) and `key` is one of the\n;; arbitrary labels of the keys in a chord (here `1`, `2`, `4` and `8`).\n;;\n;; Note that it is perfectly valid to nest these `chord` actions that enter\n;; \"chording mode\" within other actions like `tap-dance` and that will work as\n;; one would expect.\n;; However, this only applies to the first key used to enter \"chording mode\".\n;; Once \"chording mode\" is active, all other keys will be directly handled by\n;; \"chording mode\" with no regard for wrapper actions; e.g. if a key is pressed\n;; and it maps to a tap-hold with a chord as the hold action within, that chord\n;; key will immediately activate instead of the key needing to be held for the\n;; timeout period.\n;;\n;; The action executed by a chord (the right side of the chord-action pairs) may\n;; be any regular or advanced action, including aliases. They currently cannot\n;; however contain a `chord` action.\n(defchords binary 500\n (1 ) 1\n ( 2 ) 2\n (1 2 ) 3\n ( 4 ) 4\n (1 4 ) 5\n ( 2 4 ) 6\n (1 2 4 ) 7\n ( 8) 8\n (1 8) 9\n ( 2 8) (multi 1 0)\n (1 2 8) (multi 1 1)\n ( 4 8) (multi 1 2)\n (1 4 8) (multi 1 3)\n ( 2 4 8) (multi 1 4)\n (1 2 4 8) (multi 1 5)\n)\n\n(defalias\n ch1 (chord binary 1)\n ch2 (chord binary 2)\n ch4 (chord binary 4)\n ch8 (chord binary 8)\n)\n\n;; The top-level action `include` will read a configuration from a new file.\n;; At the time of writing, includes can only be placed at the top level. The\n;; included files also cannot contain includes themselves.\n;;\n;; (include included-file.kbd)\n\n\n;; The top-level item `deftemplate` declares a template\n;; which can be expanded multiple times to reduce repetition.\n;;\n;; Expansion of a template is done via `expand-template`.\n\n;; This template defines a chord group and aliases that use the chord group.\n;; The purpose is to easily define the same chord position behaviour\n;; for multiple layers that have different underlying keys.\n(deftemplate left-hand-chords (chordgroupname k1 k2 k3 k4 alias1 alias2 alias3 alias4)\n (defalias\n $alias1 (chord $chordgroupname $k1)\n $alias2 (chord $chordgroupname $k2)\n $alias3 (chord $chordgroupname $k3)\n $alias4 (chord $chordgroupname $k4)\n )\n (defchords $chordgroupname $chord-timeout\n ($k1) $k1\n ($k2) $k2\n ($k3) $k3\n ($k4) $k4\n ($k1 $k2) lctl\n ($k3 $k4) lsft\n )\n)\n\n(defvar chord-timeout 200)\n\n(template-expand left-hand-chords qwerty a s d f qwa qws qwd qwf)\n;; You can use t! as a short form of template-expand\n(t! left-hand-chords dvorak a o e u dva dvo dve dvu)\n\n(deflayer template-example\n _ _ _ _ _ _ _ _ _ _ _ _ _ _\n _ @qwa @qws @qwd @qwf _ _ _ _ _ _ _ _ _\n _ @dva @dvo @dve @dvu _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _\n)\n\n;; Within a deftemplate you can use if-equal to conditionally insert content\n;; into the template.\n\n(deftemplate home-row (version)\n a s d f g h\n (if-equal $version v1 j)\n (if-equal $version v2 (tap-hold 200 200 j lctl))\n k l ; '\n)\n\n(deftemplate common-overrides ()\n (lctl 7) (lctl lsft tab)\n (lctl 9) (lctl tab)\n (lalt 7) (lalt lsft tab)\n (lalt 9) (lalt tab)\n)\n\n;; Wrapping a top-level configuration item in a list beginning with\n;; (platform (applicable-platforms...) ...configuration...)\n;; will make the configuration only active on a specific platform.\n(platform (macos)\n ;; Only on macos, use command arrows to jump/delete words\n ;; because command is used for so many other things\n ;; and it's weird that these cases use alt.\n (defoverrides\n (lmet bspc) (lalt bspc)\n (lmet left) (lalt left)\n (lmet right) (lalt right)\n (template-expand common-overrides)\n )\n)\n(platform (win winiov2 wintercept linux)\n (defoverrides\n (template-expand common-overrides)\n )\n)\n\n#|\nThere is a more recent version of defoverrides that offers more customizability.\nInstead of 2 list items per override entry,\n`defoverridesv2` mandates 4, though the extra 2 can be empty.\n\nYou cannot have both a v1 and v2 of `defoverrides` at the same time.\n\nThe 3rd item is an \"exclude modifiers list\" which is composed of modifier key names\n(such as `lctl`, `lalt`) that, if held, will disable the override from activating.\n\nThe 4th item is an \"exclude layers\" list which is composed of layer names\nthat while active as the most recent `layer-switch` or `layer-while-held`,\nwill disable the override from activating.\n\n(defoverridesv2\n ;; lctl+a will become lalt+9\n ;; except when lsft is held or other-layer is active.\n (lctl a) (lalt 9) (lsft) (other-layer))\n\n ;; lctl+b will always become lalt+0\n (lctl b) (lalt 0) () ()\n)\n|#\n\n#|\n\nGlobal input chords.\n\nSyntax (5-tuples):\n\n (defchordsv2\n (participating-keys1) action1 timeout1 release-behaviour1 (disabled-layers1)\n ...\n (participating-keysN) actionN timeoutN release-behaviourN (disabled-layersN)\n )\n\n|#\n\n(defchordsv2\n (a b c) (macro a l p h a b e t) 200 all-released (qwerty arrows)\n (h l o) (macro h e l l o) 250 first-release (qwerty arrows)\n (g b y e) (macro g o o d b y e) 400 first-release (qwerty arrows)\n)\n\n#|\n\nYet another chording implementation - zippychord:\n\n\n;; This is a sample for US international layout.\n(defzippy\n zippy.txt\n on-first-press-chord-deadline 500\n idle-reactivate-time 500\n smart-space-punctuation (? ! . , ; :)\n output-character-mappings (\n ! S-1\n ? S-/\n % S-5\n \"(\" S-9\n \")\" S-0\n : S-;\n < S-,\n > S-.\n r#\"\"\"# S-'\n | S-\\\n _ S--\n ® AG-r\n ;; In case you use dead keys or compose keys\n ;; where multiple keys are pressed\n ;; to produce a single backspaceable symbol,\n ;; use no-erase or single-output\n ’ (no-erase `)\n é (single-output ' e)\n )\n)\n\nExample file content of zippy.txt:\n---\ndy\tday\ndy 1\tMonday\n abc\tAlphabet\nr df\trecipient\n w a\tWashington\nrq\trequest\nrqa\trequest assistance\n---\n\nYou can read about zippychord in more detail in the configuration guide.\n\n|#\n\n#|\n\nClipboard actions allow you to manipulate the clipboard.\nTo paste, you should manually output C-v,\nor whatever key output is necessary to paste.\nE.g. S-ins might also work.\n\n|#\n\n(deflayermap (clip)\n a (clipboard-set clip)\n b (clipboard-save 0)\n c (clipboard-restore 0)\n d (clipboard-save-swap 0 65535)\n #| actions with cmd only works with the compilation flags and defcfg enablement.\n e (clipboard-cmd-set powershell.exe -c \"echo 'hello world'\")\n f (clipboard-save-cmd-set 0 bash -c \"echo 'goodbye'\")\n |#\n)\n" }, { "path": "cfg_samples/key-toggle_press-only_release-only.kbd", "content": "#|\n\nThis configuration showcases all of:\n\t- key toggle\n\t- press-only\n\t- release-only\n\n|#\n\n(deftemplate toggle-key (vkey-name output-key alias)\n\t(defvirtualkeys $vkey-name $output-key)\n\t(defalias $alias (on-press toggle-vkey $vkey-name))\n)\n\n(deftemplate press-only-release-only-pair\n\t\t(vkey-name output-key press-alias release-alias)\n\t(defvirtualkeys $vkey-name $output-key)\n\t(defalias $press-alias (on-press press-vkey $vkey-name))\n\t(defalias $release-alias (on-press release-vkey $vkey-name))\n)\n\n(template-expand toggle-key v-lctl lctl lcl)\n(template-expand toggle-key v-rctl rctl rcl)\n\n;; t! is a short form of template-expand\n(t! press-only-release-only-pair v-lalt lalt p-a r-a)\n\n(defsrc\n\tlctl rctl lalt ralt\n)\n\n(deflayer base\n\t@lcl @rcl @p-a @r-a\n)\n" }, { "path": "cfg_samples/minimal.kbd", "content": "#|\nThis minimal config changes Caps Lock to act as Caps Lock on quick tap, but\nif held, it will act as Left Ctrl. It also changes the backtick/grave key to\nact as backtick/grave on quick tap, but change ijkl keys to arrow keys on hold.\n\nThis text between the two pipe+octothorpe sequences is a multi-line comment.\n|#\n\n;; Text after double-semicolons are single-line comments.\n\n#|\nOne defcfg entry may be added, which is used for configuration key-pairs. These\nconfigurations change kanata's behaviour at a more global level than the other\nconfiguration entries.\n|#\n\n(defcfg\n #|\n This configuration will process all keys pressed inside of kanata, even if\n they are not mapped in defsrc. This is so that certain actions can activate\n at the right time for certain input sequences. By default, unmapped keys are\n not processed through kanata due to a Windows issue related to AltGr. If you\n use AltGr in your keyboard, you will likely want to follow the simple.kbd\n file while unmapping lctl and ralt from defsrc.\n |#\n process-unmapped-keys yes\n)\n\n(defsrc\n caps grv i\n j k l\n lsft rsft\n)\n\n(deflayer default\n @cap @grv _\n _ _ _\n _ _\n)\n\n(deflayer arrows\n _ _ up\n left down rght\n _ _\n)\n\n(defalias\n cap (tap-hold-press 200 200 caps lctl)\n grv (tap-hold-press 200 200 grv (layer-toggle arrows))\n)\n" }, { "path": "cfg_samples/opposite-hand-hrm.kbd", "content": ";; Home row mods using tap-hold-opposite-hand\n;;\n;; Hold activates only when the next key is on the opposite hand,\n;; which substantially reduces misfires during fast same-hand rolls.\n;; Same-hand keys resolve as tap by default.\n;;\n;; Compare with home-row-mod-basic.kbd which uses plain tap-hold.\n\n(defcfg\n process-unmapped-keys yes\n)\n\n;; Assign physical keys to hands. Keys not listed have no hand\n;; assignment and are governed by (unknown-hand ) (default: ignore).\n(defhands\n (left q w e r t a s d f g z x c v b)\n (right y u i o p h j k l ; n m , . /))\n\n(defsrc\n q w e r t y u i o p\n a s d f g h j k l ;\n z x c v b n m , . /\n spc\n)\n\n(defvar\n tap-time 200\n hold-time 180\n)\n\n(defalias\n a (tap-hold-opposite-hand $hold-time a lmet)\n s (tap-hold-opposite-hand $hold-time s lalt)\n d (tap-hold-opposite-hand $hold-time d lctl)\n f (tap-hold-opposite-hand $hold-time f lsft)\n j (tap-hold-opposite-hand $hold-time j rsft)\n k (tap-hold-opposite-hand $hold-time k rctl)\n l (tap-hold-opposite-hand $hold-time l ralt)\n ; (tap-hold-opposite-hand $hold-time ; rmet)\n)\n\n(deflayer base\n q w e r t y u i o p\n @a @s @d @f g h @j @k @l @;\n z x c v b n m , . /\n spc\n)\n" }, { "path": "cfg_samples/push-msg.kbd", "content": ";; push-msg Sample Configuration\n;;\n;; This configuration demonstrates the push-msg action for sending\n;; messages to external tools via Kanata's TCP server.\n;;\n;; To use this config:\n;; kanata -p 7070 -c push-msg.kbd\n;;\n;; Then connect a TCP client to localhost:7070 to receive messages.\n\n(defcfg\n process-unmapped-keys yes\n)\n\n(defsrc\n caps a s d f g h j k l ; '\n z x c v b n m , . /\n)\n\n;; ==========================================================================\n;; Layer Definitions\n;; ==========================================================================\n\n(deflayer base\n @caps a s d f g h j k l ; '\n z x c v b n m , . /\n)\n\n(deflayer nav\n @caps left down up right g h j k l ; '\n z x c v b n m , . /\n)\n\n;; ==========================================================================\n;; Aliases with push-msg\n;; ==========================================================================\n\n(defalias\n ;; Caps Lock: tap for Esc (with notification), hold for nav layer (with notification)\n caps (tap-hold 200 200\n (multi esc (push-msg \"layer:base\"))\n (multi (layer-toggle nav) (push-msg \"layer:nav:hold\"))\n )\n)\n\n;; ==========================================================================\n;; Virtual Keys - Triggerable via TCP ActOnFakeKey\n;; ==========================================================================\n;;\n;; External tools can trigger these using TCP commands:\n;; {\"ActOnFakeKey\":{\"name\":\"email-sig\",\"action\":\"Tap\"}}\n;; {\"ActOnFakeKey\":{\"name\":\"switch-nav\",\"action\":\"Tap\"}}\n\n(defvirtualkeys\n ;; Text expansion macro (S-x for shift+x to get capitals)\n email-sig (macro\n S-b e s t spc r e g a r d s , ret ret\n S-j o h n spc S-d o e\n )\n\n ;; Layer switches that also push messages\n switch-nav (multi\n (layer-switch nav)\n (push-msg \"layer:nav:activated\")\n )\n\n switch-base (multi\n (layer-switch base)\n (push-msg \"layer:base:activated\")\n )\n\n ;; Notify external tools (no keyboard action)\n notify-ready (push-msg \"status:ready\")\n notify-busy (push-msg \"status:busy\")\n)\n\n;; ==========================================================================\n;; Usage Examples for External Tools\n;; ==========================================================================\n;;\n;; Python TCP client example:\n;;\n;; import socket\n;; import json\n;;\n;; sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n;; sock.connect(('127.0.0.1', 7070))\n;; buffer = \"\"\n;;\n;; while True:\n;; data = sock.recv(4096).decode()\n;; buffer += data\n;; while '\\n' in buffer:\n;; line, buffer = buffer.split('\\n', 1)\n;; if line:\n;; msg = json.loads(line)\n;; if 'MessagePush' in msg:\n;; print(f\"Received: {msg['MessagePush']['message']}\")\n;; elif 'LayerChange' in msg:\n;; print(f\"Layer: {msg['LayerChange']['new']}\")\n;;\n;; Triggering virtual keys from external tools:\n;;\n;; # Send this JSON to trigger the email-sig virtual key:\n;; echo '{\"ActOnFakeKey\":{\"name\":\"email-sig\",\"action\":\"Tap\"}}' | nc localhost 7070\n;;\n;; # Or trigger layer switch:\n;; echo '{\"ActOnFakeKey\":{\"name\":\"switch-nav\",\"action\":\"Tap\"}}' | nc localhost 7070\n;;\n;; ==========================================================================\n" }, { "path": "cfg_samples/simple.kbd", "content": ";; Comments are prefixed by double-semicolon. A single semicolon is parsed as the\n;; keyboard key. Comments are ignored for the configuration file.\n;;\n;; This configuration language is Lisp-like. If you're unfamiliar with Lisp,\n;; don't be alarmed. The maintainer jtroo is also unfamiliar with Lisp. You\n;; don't need to know Lisp in-depth to be able to configure kanata.\n;;\n;; If you follow along with the examples, you should be fine. Kanata should\n;; also hopefully have helpful error messages in case something goes wrong.\n;; If you need help, you are welcome to ask.\n\n;; Only one defsrc is allowed.\n;;\n;; defsrc defines the keys that will be intercepted by kanata. The order of the\n;; keys matches with deflayer declarations and all deflayer declarations must\n;; have the same number of keys as defsrc. Any keys not listed in defsrc will\n;; be passed straight to the operating system.\n(defsrc\n grv 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n caps a s d f g h j k l ; ' ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n\n;; The first layer defined is the layer that will be active by default when\n;; kanata starts up. This layer is the standard QWERTY layout except for the\n;; backtick/grave key (@grl) which is an alias for a tap-hold key.\n(deflayer qwerty\n @grl 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n caps a s d f g h j k l ; ' ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n\n;; The dvorak layer remaps the keys to the dvorak layout. In addition there is\n;; another tap-hold key: @cap. This key retains caps lock functionality when\n;; quickly tapped but is read as left-control when held.\n(deflayer dvorak\n @grl 1 2 3 4 5 6 7 8 9 0 [ ] bspc\n tab ' , . p y f g c r l / = \\\n @cap a o e u i d h t n s - ret\n lsft ; q j k x b m w v z rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n\n;; defalias is used to declare a shortcut for a more complicated action to keep\n;; the deflayer declarations clean and aligned. The alignment in deflayers is not\n;; necessary, but is strongly recommended for ease of understanding visually.\n;;\n;; Aliases are referred to by `@`.\n(defalias\n ;; tap: backtick (grave), hold: toggle layer-switching layer while held\n grl (tap-hold 200 200 grv (layer-toggle layers))\n\n ;; layer-switch changes the base layer.\n dvk (layer-switch dvorak)\n qwr (layer-switch qwerty)\n\n ;; tap for capslk, hold for lctl\n cap (tap-hold 200 200 caps lctl)\n)\n\n;; The `lrld` action stands for \"live reload\". This will re-parse everything\n;; except for linux-dev, meaning you cannot live reload and switch keyboard\n;; devices.\n;;\n;; The keys 1 and 2 switch the base layer to qwerty and dvorak respectively.\n;;\n;; Apart from the layer switching and live reload, all other keys are the\n;; underscore _ which means \"transparent\". Transparent means the base layer\n;; behaviour is used when pressing that key.\n(deflayer layers\n _ @qwr @dvk lrld _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _\n)\n" }, { "path": "cfg_samples/tray-icon/license_icons.txt", "content": "BSD 2-Clause License\n\nCopyright (c) 2024, Fred Vatin\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" }, { "path": "cfg_samples/tray-icon/tray-icon.kbd", "content": "(defcfg\n process-unmapped-keys\t\tyes\t;;|no| enable processing of keys that are not in defsrc, useful if mapping a few keys in defsrc instead of most of the keys on your keyboard. Without this, the tap-hold-release and tap-hold-press actions will not activate for keys that are not in defsrc. Disabled because some keys may not work correctly if they are intercepted. E.g. rctl/altgr on Windows; see the windows-altgr configuration item above for context.\n log-layer-changes \t\tyes\t;;|no| overhead\n tray-icon \"./_custom-icons/s.png\" ;; should activate for layers without icons like '5no-icn'\n ;;opt \tval \t |≝|\n icon-match-layer-name \tyes \t;;|yes| match layer name to icon files even without an explicit (icon name.ico) config\n tooltip-layer-changes \tyes \t;;|false|\n tooltip-show-blank \tyes \t;;|no|\n tooltip-duration \t500 \t;;|500|\n tooltip-size \t24,24\t;;|24 24|\n notify-cfg-reload \tyes \t;;|yes|\n notify-cfg-reload-silent\tno \t;;|no|\n notify-error \tyes \t;;|yes|\n)\n(defalias l1 (layer-while-held 1emoji))\n(defalias l2 (layer-while-held 2icon-quote))\n(defalias l3 (layer-while-held 3emoji_alt))\n(defalias l4 (layer-while-held 4my-lmap))\n(defalias l5 (layer-while-held 5no-icn))\n(defalias l6 (layer-while-held 6name-match))\n\n(defsrc \t \t \t1 \t2 \t3 \t4 \t5 \t6)\n(deflayer \t(⌂ \ticon base.png) \t@l1\t@l2\t@l3\t@l4\t@l5\t@l6)\t;; find in the 'icon' subfolder\n(deflayer \t(1emoji \t🖻 1symbols.png) \tq \tq \tq \tq \tq \tq) \t;; find in the 'icons' subfolder\n(deflayer \t(2icon-quote\t🖻 \"2Nav Num.png\") \tw \tw \tw \tw \tw \tw) \t;; find in the 'img' subfolder\n(deflayer \t(3emoji_alt \t🖼 3trans.parent) \te \te \te \te \te \te) \t;; find '.png'\n(deflayermap\t(4my-lmap \t🖻 \"..\\..\\assets\\kanata.ico\")\t1 r\t2 r\t3 r\t4 r\t5 r\t6 r) ;; find in relative path\n(deflayer \t5no-icn \t \tt \tt \tt \tt \tt \tt) ;; match file name from 'tray-icon' config, whithout which would fall back to 'tray-icon.png' as it's the only valid icon matching 'tray-icon.kbd' name\n(deflayer \t6name-match \t \ty \ty \ty \ty \ty \ty) ;; uses '6name-match' with any valid extension since 'icon-match-layer-name' is set to 'yes'\n" }, { "path": "docs/README.md", "content": "\n### Converting \".adoc\" to html\n\nTo generate html from the these documentation files, use [\"asciidoctor\"](https://asciidoctor.org)\n(they are not fully compatible with the separate \"asciidoc\" project)\n\n" }, { "path": "docs/config-stylesheet.css", "content": "html{font-family:sans-serif;-webkit-text-size-adjust:100%}\na{background:none}\na:focus{outline:thin dotted}\na:active,a:hover{outline:0}\nh1{font-size:2em;margin:.67em 0}\nb,strong{font-weight:bold}\nabbr{font-size:.9em}\nabbr[title]{cursor:help;border-bottom:1px dotted #dddddf;text-decoration:none}\ndfn{font-style:italic}\nhr{height:0}\nmark{background:#ff0;color:#000}\ncode,kbd,pre,samp{font-family:monospace;font-size:1em}\npre{white-space:pre-wrap}\nq{quotes:\"\\201C\" \"\\201D\" \"\\2018\" \"\\2019\"}\nsmall{font-size:80%}\nsub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}\nsup{top:-.5em}\nsub{bottom:-.25em}\nimg{border:0}\nsvg:not(:root){overflow:hidden}\nfigure{margin:0}\naudio,video{display:inline-block}\naudio:not([controls]){display:none;height:0}\nfieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .75em}\nlegend{border:0;padding:0}\nbutton,input,select,textarea{font-family:inherit;font-size:100%;margin:0}\nbutton,input{line-height:normal}\nbutton,select{text-transform:none}\nbutton,html input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer}\nbutton[disabled],html input[disabled]{cursor:default}\ninput[type=checkbox],input[type=radio]{padding:0}\nbutton::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}\ntextarea{overflow:auto;vertical-align:top}\ntable{border-collapse:collapse;border-spacing:0}\n*,::before,::after{box-sizing:border-box}\nhtml,body{font-size:100%}\nbody{background:#fff;color:rgba(0,0,0,.8);padding:0;margin:0;font-family:\"Noto Serif\",\"DejaVu Serif\",serif;line-height:1;position:relative;cursor:auto;-moz-tab-size:4;-o-tab-size:4;tab-size:4;word-wrap:anywhere;-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased}\na:hover{cursor:pointer}\nimg,object,embed{max-width:100%;height:auto}\nobject,embed{height:100%}\nimg{-ms-interpolation-mode:bicubic}\n.left{float:left!important}\n.right{float:right!important}\n.text-left{text-align:left!important}\n.text-right{text-align:right!important}\n.text-center{text-align:center!important}\n.text-justify{text-align:justify!important}\n.hide{display:none}\nimg,object,svg{display:inline-block;vertical-align:middle}\ntextarea{height:auto;min-height:50px}\nselect{width:100%}\n.subheader,.admonitionblock td.content>.title,.audioblock>.title,.exampleblock>.title,.imageblock>.title,.listingblock>.title,.literalblock>.title,.stemblock>.title,.openblock>.title,.paragraph>.title,.quoteblock>.title,table.tableblock>.title,.verseblock>.title,.videoblock>.title,.dlist>.title,.olist>.title,.ulist>.title,.qlist>.title,.hdlist>.title{line-height:1.45;color:#7a2518;font-weight:400;margin-top:0;margin-bottom:.25em}\ndiv,dl,dt,dd,ul,ol,li,h1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6,pre,form,p,blockquote,th,td{margin:0;padding:0}\na{color:#2156a5;text-decoration:underline;line-height:inherit}\na:hover,a:focus{color:#1d4b8f}\na img{border:0}\np{line-height:1.6;margin-bottom:1.25em;text-rendering:optimizeLegibility}\np aside{font-size:.875em;line-height:1.35;font-style:italic}\nh1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6{font-family:\"Open Sans\",\"DejaVu Sans\",sans-serif;font-weight:300;font-style:normal;color:#ba3925;text-rendering:optimizeLegibility;margin-top:1em;margin-bottom:.5em;line-height:1.0125em}\nh1 small,h2 small,h3 small,#toctitle small,.sidebarblock>.content>.title small,h4 small,h5 small,h6 small{font-size:60%;color:#e99b8f;line-height:0}\nh1{font-size:2.125em}\nh2{font-size:1.6875em}\nh3,#toctitle,.sidebarblock>.content>.title{font-size:1.375em}\nh4,h5{font-size:1.125em}\nh6{font-size:1em}\nhr{border:solid #dddddf;border-width:1px 0 0;clear:both;margin:1.25em 0 1.1875em}\nem,i{font-style:italic;line-height:inherit}\nstrong,b{font-weight:bold;line-height:inherit}\nsmall{font-size:60%;line-height:inherit}\ncode{font-family:\"Droid Sans Mono\",\"DejaVu Sans Mono\",monospace;font-weight:400;color:rgba(0,0,0,.9)}\nul,ol,dl{line-height:1.6;margin-bottom:1.25em;list-style-position:outside;font-family:inherit}\nul,ol{margin-left:1.5em}\nul li ul,ul li ol{margin-left:1.25em;margin-bottom:0}\nul.circle{list-style-type:circle}\nul.disc{list-style-type:disc}\nul.square{list-style-type:square}\nul.circle ul:not([class]),ul.disc ul:not([class]),ul.square ul:not([class]){list-style:inherit}\nol li ul,ol li ol{margin-left:1.25em;margin-bottom:0}\ndl dt{margin-bottom:.3125em;font-weight:bold}\ndl dd{margin-bottom:1.25em}\nblockquote{margin:0 0 1.25em;padding:.5625em 1.25em 0 1.1875em;border-left:1px solid #ddd}\nblockquote,blockquote p{line-height:1.6;color:rgba(0,0,0,.85)}\n@media screen and (min-width:768px){h1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6{line-height:1.2}\nh1{font-size:2.75em}\nh2{font-size:2.3125em}\nh3,#toctitle,.sidebarblock>.content>.title{font-size:1.6875em}\nh4{font-size:1.4375em}}\ntable{background:#fff;margin-bottom:1.25em;border:1px solid #dedede;word-wrap:normal}\ntable thead,table tfoot{background:#f7f8f7}\ntable thead tr th,table thead tr td,table tfoot tr th,table tfoot tr td{padding:.5em .625em .625em;font-size:inherit;color:rgba(0,0,0,.8);text-align:left}\ntable tr th,table tr td{padding:.5625em .625em;font-size:inherit;color:rgba(0,0,0,.8)}\ntable tr.even,table tr.alt{background:#f8f8f7}\ntable thead tr th,table tfoot tr th,table tbody tr td,table tr td,table tfoot tr td{line-height:1.6}\nh1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6{line-height:1.2;word-spacing:-.05em}\nh1 strong,h2 strong,h3 strong,#toctitle strong,.sidebarblock>.content>.title strong,h4 strong,h5 strong,h6 strong{font-weight:400}\n.center{margin-left:auto;margin-right:auto}\n.stretch{width:100%}\n.clearfix::before,.clearfix::after,.float-group::before,.float-group::after{content:\" \";display:table}\n.clearfix::after,.float-group::after{clear:both}\n:not(pre).nobreak{word-wrap:normal}\n:not(pre).nowrap{white-space:nowrap}\n:not(pre).pre-wrap{white-space:pre-wrap}\n:not(pre):not([class^=L])>code{font-size:.9375em;font-style:normal!important;letter-spacing:0;padding:.1em .5ex;word-spacing:-.15em;background:#f7f7f8;border-radius:4px;line-height:1.45;text-rendering:optimizeSpeed}\npre{color:rgba(0,0,0,.9);font-family:\"Droid Sans Mono\",\"DejaVu Sans Mono\",monospace;line-height:1.45;text-rendering:optimizeSpeed}\npre code,pre pre{color:inherit;font-size:inherit;line-height:inherit}\npre>code{display:block}\npre.nowrap,pre.nowrap pre{white-space:pre;word-wrap:normal}\nem em{font-style:normal}\nstrong strong{font-weight:400}\n.keyseq{color:rgba(51,51,51,.8)}\nkbd{font-family:\"Droid Sans Mono\",\"DejaVu Sans Mono\",monospace;display:inline-block;color:rgba(0,0,0,.8);font-size:.65em;line-height:1.45;background:#f7f7f7;border:1px solid #ccc;border-radius:3px;box-shadow:0 1px 0 rgba(0,0,0,.2),inset 0 0 0 .1em #fff;margin:0 .15em;padding:.2em .5em;vertical-align:middle;position:relative;top:-.1em;white-space:nowrap}\n.keyseq kbd:first-child{margin-left:0}\n.keyseq kbd:last-child{margin-right:0}\n.menuseq,.menuref{color:#000}\n.menuseq b:not(.caret),.menuref{font-weight:inherit}\n.menuseq{word-spacing:-.02em}\n.menuseq b.caret{font-size:1.25em;line-height:.8}\n.menuseq i.caret{font-weight:bold;text-align:center;width:.45em}\nb.button::before,b.button::after{position:relative;top:-1px;font-weight:400}\nb.button::before{content:\"[\";padding:0 3px 0 2px}\nb.button::after{content:\"]\";padding:0 2px 0 3px}\np a>code:hover{color:rgba(0,0,0,.9)}\n#header,#content,#footnotes,#footer{width:100%;margin:0 auto;max-width:62.5em;*zoom:1;position:relative;padding-left:.9375em;padding-right:.9375em}\n#header::before,#header::after,#content::before,#content::after,#footnotes::before,#footnotes::after,#footer::before,#footer::after{content:\" \";display:table}\n#header::after,#content::after,#footnotes::after,#footer::after{clear:both}\n#content{margin-top:1.25em}\n#content::before{content:none}\n#header>h1:first-child{color:rgba(0,0,0,.85);margin-top:2.25rem;margin-bottom:0}\n#header>h1:first-child+#toc{margin-top:8px;border-top:1px solid #dddddf}\n#header>h1:only-child{border-bottom:1px solid #dddddf;padding-bottom:8px}\n#header .details{border-bottom:1px solid #dddddf;line-height:1.45;padding-top:.25em;padding-bottom:.25em;padding-left:.25em;color:rgba(0,0,0,.6);display:flex;flex-flow:row wrap}\n#header .details span:first-child{margin-left:-.125em}\n#header .details span.email a{color:rgba(0,0,0,.85)}\n#header .details br{display:none}\n#header .details br+span::before{content:\"\\00a0\\2013\\00a0\"}\n#header .details br+span.author::before{content:\"\\00a0\\22c5\\00a0\";color:rgba(0,0,0,.85)}\n#header .details br+span#revremark::before{content:\"\\00a0|\\00a0\"}\n#header #revnumber{text-transform:capitalize}\n#header #revnumber::after{content:\"\\00a0\"}\n#content>h1:first-child:not([class]){color:rgba(0,0,0,.85);border-bottom:1px solid #dddddf;padding-bottom:8px;margin-top:0;padding-top:1rem;margin-bottom:1.25rem}\n#toc{border-bottom:1px solid #e7e7e9;padding-bottom:.5em}\n#toc>ul{margin-left:.125em}\n#toc ul.sectlevel0>li>a{font-style:italic}\n#toc ul.sectlevel0 ul.sectlevel1{margin:.5em 0}\n#toc ul{font-family:\"Open Sans\",\"DejaVu Sans\",sans-serif;list-style-type:none}\n#toc li{line-height:1.3334;margin-top:.3334em}\n#toc a{text-decoration:none}\n#toc a:active{text-decoration:underline}\n#toctitle{color:#7a2518;font-size:1.2em}\n@media screen and (min-width:768px){#toctitle{font-size:1.375em}\nbody.toc2{padding-left:15em;padding-right:0}\nbody.toc2 #header>h1:nth-last-child(2){border-bottom:1px solid #dddddf;padding-bottom:8px}\n#toc.toc2{margin-top:0!important;background:#f8f8f7;position:fixed;width:15em;left:0;top:0;border-right:1px solid #e7e7e9;border-top-width:0!important;border-bottom-width:0!important;z-index:1000;padding:1.25em 1em;height:100%;overflow:auto}\n#toc.toc2 #toctitle{margin-top:0;margin-bottom:.8rem;font-size:1.2em}\n#toc.toc2>ul{font-size:.9em;margin-bottom:0}\n#toc.toc2 ul ul{margin-left:0;padding-left:1em}\n#toc.toc2 ul.sectlevel0 ul.sectlevel1{padding-left:0;margin-top:.5em;margin-bottom:.5em}\nbody.toc2.toc-right{padding-left:0;padding-right:15em}\nbody.toc2.toc-right #toc.toc2{border-right-width:0;border-left:1px solid #e7e7e9;left:auto;right:0}}\n@media screen and (min-width:1280px){body.toc2{padding-left:20em;padding-right:0}\n#toc.toc2{width:20em}\n#toc.toc2 #toctitle{font-size:1.375em}\n#toc.toc2>ul{font-size:.95em}\n#toc.toc2 ul ul{padding-left:1.25em}\nbody.toc2.toc-right{padding-left:0;padding-right:20em}}\n#content #toc{border:1px solid #e0e0dc;margin-bottom:1.25em;padding:1.25em;background:#f8f8f7;border-radius:4px}\n#content #toc>:first-child{margin-top:0}\n#content #toc>:last-child{margin-bottom:0}\n#footer{max-width:none;background:rgba(0,0,0,.8);padding:1.25em}\n#footer-text{color:hsla(0,0%,100%,.8);line-height:1.44}\n#content{margin-bottom:.625em}\n.sect1{padding-bottom:.625em}\n@media screen and (min-width:768px){#content{margin-bottom:1.25em}\n.sect1{padding-bottom:1.25em}}\n.sect1:last-child{padding-bottom:0}\n.sect1+.sect1{border-top:1px solid #e7e7e9}\n#content h1>a.anchor,h2>a.anchor,h3>a.anchor,#toctitle>a.anchor,.sidebarblock>.content>.title>a.anchor,h4>a.anchor,h5>a.anchor,h6>a.anchor{position:absolute;z-index:1001;width:1.5ex;margin-left:-1.5ex;display:block;text-decoration:none!important;visibility:hidden;text-align:center;font-weight:400}\n#content h1>a.anchor::before,h2>a.anchor::before,h3>a.anchor::before,#toctitle>a.anchor::before,.sidebarblock>.content>.title>a.anchor::before,h4>a.anchor::before,h5>a.anchor::before,h6>a.anchor::before{content:\"\\00A7\";font-size:.85em;display:block;padding-top:.1em}\n#content h1:hover>a.anchor,#content h1>a.anchor:hover,h2:hover>a.anchor,h2>a.anchor:hover,h3:hover>a.anchor,#toctitle:hover>a.anchor,.sidebarblock>.content>.title:hover>a.anchor,h3>a.anchor:hover,#toctitle>a.anchor:hover,.sidebarblock>.content>.title>a.anchor:hover,h4:hover>a.anchor,h4>a.anchor:hover,h5:hover>a.anchor,h5>a.anchor:hover,h6:hover>a.anchor,h6>a.anchor:hover{visibility:visible}\n#content h1>a.link,h2>a.link,h3>a.link,#toctitle>a.link,.sidebarblock>.content>.title>a.link,h4>a.link,h5>a.link,h6>a.link{color:#ba3925;text-decoration:none}\n#content h1>a.link:hover,h2>a.link:hover,h3>a.link:hover,#toctitle>a.link:hover,.sidebarblock>.content>.title>a.link:hover,h4>a.link:hover,h5>a.link:hover,h6>a.link:hover{color:#a53221}\ndetails,.audioblock,.imageblock,.literalblock,.listingblock,.stemblock,.videoblock{margin-bottom:1.25em}\ndetails{margin-left:1.25rem}\ndetails>summary{cursor:pointer;display:block;position:relative;line-height:1.6;margin-bottom:.625rem;outline:none;-webkit-tap-highlight-color:transparent}\ndetails>summary::-webkit-details-marker{display:none}\ndetails>summary::before{content:\"\";border:solid transparent;border-left:solid;border-width:.3em 0 .3em .5em;position:absolute;top:.5em;left:-1.25rem;transform:translateX(15%)}\ndetails[open]>summary::before{border:solid transparent;border-top:solid;border-width:.5em .3em 0;transform:translateY(15%)}\ndetails>summary::after{content:\"\";width:1.25rem;height:1em;position:absolute;top:.3em;left:-1.25rem}\n.admonitionblock td.content>.title,.audioblock>.title,.exampleblock>.title,.imageblock>.title,.listingblock>.title,.literalblock>.title,.stemblock>.title,.openblock>.title,.paragraph>.title,.quoteblock>.title,table.tableblock>.title,.verseblock>.title,.videoblock>.title,.dlist>.title,.olist>.title,.ulist>.title,.qlist>.title,.hdlist>.title{text-rendering:optimizeLegibility;text-align:left;font-family:\"Noto Serif\",\"DejaVu Serif\",serif;font-size:1rem;font-style:italic}\ntable.tableblock.fit-content>caption.title{white-space:nowrap;width:0}\n.paragraph.lead>p,#preamble>.sectionbody>[class=paragraph]:first-of-type p{font-size:1.21875em;line-height:1.6;color:rgba(0,0,0,.85)}\n.admonitionblock>table{border-collapse:separate;border:0;background:none;width:100%}\n.admonitionblock>table td.icon{text-align:center;width:80px}\n.admonitionblock>table td.icon img{max-width:none}\n.admonitionblock>table td.icon .title{font-weight:bold;font-family:\"Open Sans\",\"DejaVu Sans\",sans-serif;text-transform:uppercase}\n.admonitionblock>table td.content{padding-left:1.125em;padding-right:1.25em;border-left:1px solid #dddddf;color:rgba(0,0,0,.6);word-wrap:anywhere}\n.admonitionblock>table td.content>:last-child>:last-child{margin-bottom:0}\n.exampleblock>.content{border:1px solid #e6e6e6;margin-bottom:1.25em;padding:1.25em;background:#fff;border-radius:4px}\n.sidebarblock{border:1px solid #dbdbd6;margin-bottom:1.25em;padding:1.25em;background:#f3f3f2;border-radius:4px}\n.sidebarblock>.content>.title{color:#7a2518;margin-top:0;text-align:center}\n.exampleblock>.content>:first-child,.sidebarblock>.content>:first-child{margin-top:0}\n.exampleblock>.content>:last-child,.exampleblock>.content>:last-child>:last-child,.exampleblock>.content .olist>ol>li:last-child>:last-child,.exampleblock>.content .ulist>ul>li:last-child>:last-child,.exampleblock>.content .qlist>ol>li:last-child>:last-child,.sidebarblock>.content>:last-child,.sidebarblock>.content>:last-child>:last-child,.sidebarblock>.content .olist>ol>li:last-child>:last-child,.sidebarblock>.content .ulist>ul>li:last-child>:last-child,.sidebarblock>.content .qlist>ol>li:last-child>:last-child{margin-bottom:0}\n.literalblock pre,.listingblock>.content>pre{border-radius:4px;overflow-x:auto;padding:1em;font-size:.8125em}\n@media screen and (min-width:768px){.literalblock pre,.listingblock>.content>pre{font-size:.90625em}}\n@media screen and (min-width:1280px){.literalblock pre,.listingblock>.content>pre{font-size:1em}}\n.literalblock pre,.listingblock>.content>pre:not(.highlight),.listingblock>.content>pre[class=highlight],.listingblock>.content>pre[class^=\"highlight \"]{background:#f7f7f8}\n.literalblock.output pre{color:#f7f7f8;background:rgba(0,0,0,.9)}\n.listingblock>.content{position:relative}\n.listingblock code[data-lang]::before{display:none;content:attr(data-lang);position:absolute;font-size:.75em;top:.425rem;right:.5rem;line-height:1;text-transform:uppercase;color:inherit;opacity:.5}\n.listingblock:hover code[data-lang]::before{display:block}\n.listingblock.terminal pre .command::before{content:attr(data-prompt);padding-right:.5em;color:inherit;opacity:.5}\n.listingblock.terminal pre .command:not([data-prompt])::before{content:\"$\"}\n.listingblock pre.highlightjs{padding:0}\n.listingblock pre.highlightjs>code{padding:1em;border-radius:4px}\n.listingblock pre.prettyprint{border-width:0}\n.prettyprint{background:#f7f7f8}\npre.prettyprint .linenums{line-height:1.45;margin-left:2em}\npre.prettyprint li{background:none;list-style-type:inherit;padding-left:0}\npre.prettyprint li code[data-lang]::before{opacity:1}\npre.prettyprint li:not(:first-child) code[data-lang]::before{display:none}\ntable.linenotable{border-collapse:separate;border:0;margin-bottom:0;background:none}\ntable.linenotable td[class]{color:inherit;vertical-align:top;padding:0;line-height:inherit;white-space:normal}\ntable.linenotable td.code{padding-left:.75em}\ntable.linenotable td.linenos,pre.pygments .linenos{border-right:1px solid;opacity:.35;padding-right:.5em;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}\npre.pygments span.linenos{display:inline-block;margin-right:.75em}\n.quoteblock{margin:0 1em 1.25em 1.5em;display:table}\n.quoteblock:not(.excerpt)>.title{margin-left:-1.5em;margin-bottom:.75em}\n.quoteblock blockquote,.quoteblock p{color:rgba(0,0,0,.85);font-size:1.15rem;line-height:1.75;word-spacing:.1em;letter-spacing:0;font-style:italic;text-align:justify}\n.quoteblock blockquote{margin:0;padding:0;border:0}\n.quoteblock blockquote::before{content:\"\\201c\";float:left;font-size:2.75em;font-weight:bold;line-height:.6em;margin-left:-.6em;color:#7a2518;text-shadow:0 1px 2px rgba(0,0,0,.1)}\n.quoteblock blockquote>.paragraph:last-child p{margin-bottom:0}\n.quoteblock .attribution{margin-top:.75em;margin-right:.5ex;text-align:right}\n.verseblock{margin:0 1em 1.25em}\n.verseblock pre{font-family:\"Open Sans\",\"DejaVu Sans\",sans-serif;font-size:1.15rem;color:rgba(0,0,0,.85);font-weight:300;text-rendering:optimizeLegibility}\n.verseblock pre strong{font-weight:400}\n.verseblock .attribution{margin-top:1.25rem;margin-left:.5ex}\n.quoteblock .attribution,.verseblock .attribution{font-size:.9375em;line-height:1.45;font-style:italic}\n.quoteblock .attribution br,.verseblock .attribution br{display:none}\n.quoteblock .attribution cite,.verseblock .attribution cite{display:block;letter-spacing:-.025em;color:rgba(0,0,0,.6)}\n.quoteblock.abstract blockquote::before,.quoteblock.excerpt blockquote::before,.quoteblock .quoteblock blockquote::before{display:none}\n.quoteblock.abstract blockquote,.quoteblock.abstract p,.quoteblock.excerpt blockquote,.quoteblock.excerpt p,.quoteblock .quoteblock blockquote,.quoteblock .quoteblock p{line-height:1.6;word-spacing:0}\n.quoteblock.abstract{margin:0 1em 1.25em;display:block}\n.quoteblock.abstract>.title{margin:0 0 .375em;font-size:1.15em;text-align:center}\n.quoteblock.excerpt>blockquote,.quoteblock .quoteblock{padding:0 0 .25em 1em;border-left:.25em solid #dddddf}\n.quoteblock.excerpt,.quoteblock .quoteblock{margin-left:0}\n.quoteblock.excerpt blockquote,.quoteblock.excerpt p,.quoteblock .quoteblock blockquote,.quoteblock .quoteblock p{color:inherit;font-size:1.0625rem}\n.quoteblock.excerpt .attribution,.quoteblock .quoteblock .attribution{color:inherit;font-size:.85rem;text-align:left;margin-right:0}\np.tableblock:last-child{margin-bottom:0}\ntd.tableblock>.content{margin-bottom:1.25em;word-wrap:anywhere}\ntd.tableblock>.content>:last-child{margin-bottom:-1.25em}\ntable.tableblock,th.tableblock,td.tableblock{border:0 solid #dedede}\ntable.grid-all>*>tr>*{border-width:1px}\ntable.grid-cols>*>tr>*{border-width:0 1px}\ntable.grid-rows>*>tr>*{border-width:1px 0}\ntable.frame-all{border-width:1px}\ntable.frame-ends{border-width:1px 0}\ntable.frame-sides{border-width:0 1px}\ntable.frame-none>colgroup+*>:first-child>*,table.frame-sides>colgroup+*>:first-child>*{border-top-width:0}\ntable.frame-none>:last-child>:last-child>*,table.frame-sides>:last-child>:last-child>*{border-bottom-width:0}\ntable.frame-none>*>tr>:first-child,table.frame-ends>*>tr>:first-child{border-left-width:0}\ntable.frame-none>*>tr>:last-child,table.frame-ends>*>tr>:last-child{border-right-width:0}\ntable.stripes-all>*>tr,table.stripes-odd>*>tr:nth-of-type(odd),table.stripes-even>*>tr:nth-of-type(even),table.stripes-hover>*>tr:hover{background:#f8f8f7}\nth.halign-left,td.halign-left{text-align:left}\nth.halign-right,td.halign-right{text-align:right}\nth.halign-center,td.halign-center{text-align:center}\nth.valign-top,td.valign-top{vertical-align:top}\nth.valign-bottom,td.valign-bottom{vertical-align:bottom}\nth.valign-middle,td.valign-middle{vertical-align:middle}\ntable thead th,table tfoot th{font-weight:bold}\ntbody tr th{background:#f7f8f7}\ntbody tr th,tbody tr th p,tfoot tr th,tfoot tr th p{color:rgba(0,0,0,.8);font-weight:bold}\np.tableblock>code:only-child{background:none;padding:0}\np.tableblock{font-size:1em}\nol{margin-left:1.75em}\nul li ol{margin-left:1.5em}\ndl dd{margin-left:1.125em}\ndl dd:last-child,dl dd:last-child>:last-child{margin-bottom:0}\nli p,ul dd,ol dd,.olist .olist,.ulist .ulist,.ulist .olist,.olist .ulist{margin-bottom:.625em}\nul.checklist,ul.none,ol.none,ul.no-bullet,ol.no-bullet,ol.unnumbered,ul.unstyled,ol.unstyled{list-style-type:none}\nul.no-bullet,ol.no-bullet,ol.unnumbered{margin-left:.625em}\nul.unstyled,ol.unstyled{margin-left:0}\nli>p:empty:only-child::before{content:\"\";display:inline-block}\nul.checklist>li>p:first-child{margin-left:-1em}\nul.checklist>li>p:first-child>.fa-square-o:first-child,ul.checklist>li>p:first-child>.fa-check-square-o:first-child{width:1.25em;font-size:.8em;position:relative;bottom:.125em}\nul.checklist>li>p:first-child>input[type=checkbox]:first-child{margin-right:.25em}\nul.inline{display:flex;flex-flow:row wrap;list-style:none;margin:0 0 .625em -1.25em}\nul.inline>li{margin-left:1.25em}\n.unstyled dl dt{font-weight:400;font-style:normal}\nol.arabic{list-style-type:decimal}\nol.decimal{list-style-type:decimal-leading-zero}\nol.loweralpha{list-style-type:lower-alpha}\nol.upperalpha{list-style-type:upper-alpha}\nol.lowerroman{list-style-type:lower-roman}\nol.upperroman{list-style-type:upper-roman}\nol.lowergreek{list-style-type:lower-greek}\n.hdlist>table,.colist>table{border:0;background:none}\n.hdlist>table>tbody>tr,.colist>table>tbody>tr{background:none}\ntd.hdlist1,td.hdlist2{vertical-align:top;padding:0 .625em}\ntd.hdlist1{font-weight:bold;padding-bottom:1.25em}\ntd.hdlist2{word-wrap:anywhere}\n.literalblock+.colist,.listingblock+.colist{margin-top:-.5em}\n.colist td:not([class]):first-child{padding:.4em .75em 0;line-height:1;vertical-align:top}\n.colist td:not([class]):first-child img{max-width:none}\n.colist td:not([class]):last-child{padding:.25em 0}\n.thumb,.th{line-height:0;display:inline-block;border:4px solid #fff;box-shadow:0 0 0 1px #ddd}\n.imageblock.left{margin:.25em .625em 1.25em 0}\n.imageblock.right{margin:.25em 0 1.25em .625em}\n.imageblock>.title{margin-bottom:0}\n.imageblock.thumb,.imageblock.th{border-width:6px}\n.imageblock.thumb>.title,.imageblock.th>.title{padding:0 .125em}\n.image.left,.image.right{margin-top:.25em;margin-bottom:.25em;display:inline-block;line-height:0}\n.image.left{margin-right:.625em}\n.image.right{margin-left:.625em}\na.image{text-decoration:none;display:inline-block}\na.image object{pointer-events:none}\nsup.footnote,sup.footnoteref{font-size:.875em;position:static;vertical-align:super}\nsup.footnote a,sup.footnoteref a{text-decoration:none}\nsup.footnote a:active,sup.footnoteref a:active,#footnotes .footnote a:first-of-type:active{text-decoration:underline}\n#footnotes{padding-top:.75em;padding-bottom:.75em;margin-bottom:.625em}\n#footnotes hr{width:20%;min-width:6.25em;margin:-.25em 0 .75em;border-width:1px 0 0}\n#footnotes .footnote{padding:0 .375em 0 .225em;line-height:1.3334;font-size:.875em;margin-left:1.2em;margin-bottom:.2em}\n#footnotes .footnote a:first-of-type{font-weight:bold;text-decoration:none;margin-left:-1.05em}\n#footnotes .footnote:last-of-type{margin-bottom:0}\n#content #footnotes{margin-top:-.625em;margin-bottom:0;padding:.75em 0}\ndiv.unbreakable{page-break-inside:avoid}\n.big{font-size:larger}\n.small{font-size:smaller}\n.underline{text-decoration:underline}\n.overline{text-decoration:overline}\n.line-through{text-decoration:line-through}\n.aqua{color:#00bfbf}\n.aqua-background{background:#00fafa}\n.black{color:#000}\n.black-background{background:#000}\n.blue{color:#0000bf}\n.blue-background{background:#0000fa}\n.fuchsia{color:#bf00bf}\n.fuchsia-background{background:#fa00fa}\n.gray{color:#606060}\n.gray-background{background:#7d7d7d}\n.green{color:#006000}\n.green-background{background:#007d00}\n.lime{color:#00bf00}\n.lime-background{background:#00fa00}\n.maroon{color:#600000}\n.maroon-background{background:#7d0000}\n.navy{color:#000060}\n.navy-background{background:#00007d}\n.olive{color:#606000}\n.olive-background{background:#7d7d00}\n.purple{color:#600060}\n.purple-background{background:#7d007d}\n.red{color:#bf0000}\n.red-background{background:#fa0000}\n.silver{color:#909090}\n.silver-background{background:#bcbcbc}\n.teal{color:#006060}\n.teal-background{background:#007d7d}\n.white{color:#bfbfbf}\n.white-background{background:#fafafa}\n.yellow{color:#bfbf00}\n.yellow-background{background:#fafa00}\nspan.icon>.fa{cursor:default}\na span.icon>.fa{cursor:inherit}\n.admonitionblock td.icon [class^=\"fa icon-\"]{font-size:2.5em;text-shadow:1px 1px 2px rgba(0,0,0,.5);cursor:default}\n.admonitionblock td.icon .icon-note::before{content:\"\\f05a\";color:#19407c}\n.admonitionblock td.icon .icon-tip::before{content:\"\\f0eb\";text-shadow:1px 1px 2px rgba(155,155,0,.8);color:#111}\n.admonitionblock td.icon .icon-warning::before{content:\"\\f071\";color:#bf6900}\n.admonitionblock td.icon .icon-caution::before{content:\"\\f06d\";color:#bf3400}\n.admonitionblock td.icon .icon-important::before{content:\"\\f06a\";color:#bf0000}\n.conum[data-value]{display:inline-block;color:#fff!important;background:rgba(0,0,0,.8);border-radius:50%;text-align:center;font-size:.75em;width:1.67em;height:1.67em;line-height:1.67em;font-family:\"Open Sans\",\"DejaVu Sans\",sans-serif;font-style:normal;font-weight:bold}\n.conum[data-value] *{color:#fff!important}\n.conum[data-value]+b{display:none}\n.conum[data-value]::after{content:attr(data-value)}\npre .conum[data-value]{position:relative;top:-.125em}\nb.conum *{color:inherit!important}\n.conum:not([data-value]):empty{display:none}\ndt,th.tableblock,td.content,div.footnote{text-rendering:optimizeLegibility}\nh1,h2,p,td.content,span.alt,summary{letter-spacing:-.01em}\np strong,td.content strong,div.footnote strong{letter-spacing:-.005em}\np,blockquote,dt,td.content,td.hdlist1,span.alt,summary{font-size:1.0625rem}\np{margin-bottom:1.25rem}\n.sidebarblock p,.sidebarblock dt,.sidebarblock td.content,p.tableblock{font-size:1em}\n.exampleblock>.content{background:#fffef7;border-color:#e0e0dc;box-shadow:0 1px 4px #e0e0dc}\n.print-only{display:none!important}\n@page{margin:1.25cm .75cm}\n@media print{*{box-shadow:none!important;text-shadow:none!important}\nhtml{font-size:80%}\na{color:inherit!important;text-decoration:underline!important}\na.bare,a[href^=\"#\"],a[href^=\"mailto:\"]{text-decoration:none!important}\na[href^=\"http:\"]:not(.bare)::after,a[href^=\"https:\"]:not(.bare)::after{content:\"(\" attr(href) \")\";display:inline-block;font-size:.875em;padding-left:.25em}\nabbr[title]{border-bottom:1px dotted}\nabbr[title]::after{content:\" (\" attr(title) \")\"}\npre,blockquote,tr,img,object,svg{page-break-inside:avoid}\nthead{display:table-header-group}\nsvg{max-width:100%}\np,blockquote,dt,td.content{font-size:1em;orphans:3;widows:3}\nh2,h3,#toctitle,.sidebarblock>.content>.title{page-break-after:avoid}\n#header,#content,#footnotes,#footer{max-width:none}\n#toc,.sidebarblock,.exampleblock>.content{background:none!important}\n#toc{border-bottom:1px solid #dddddf!important;padding-bottom:0!important}\nbody.book #header{text-align:center}\nbody.book #header>h1:first-child{border:0!important;margin:2.5em 0 1em}\nbody.book #header .details{border:0!important;display:block;padding:0!important}\nbody.book #header .details span:first-child{margin-left:0!important}\nbody.book #header .details br{display:block}\nbody.book #header .details br+span::before{content:none!important}\nbody.book #toc{border:0!important;text-align:left!important;padding:0!important;margin:0!important}\nbody.book #toc,body.book #preamble,body.book h1.sect0,body.book .sect1>h2{page-break-before:always}\n.listingblock code[data-lang]::before{display:block}\n#footer{padding:0 .9375em}\n.hide-on-print{display:none!important}\n.print-only{display:block!important}\n.hide-for-print{display:none!important}\n.show-for-print{display:inherit!important}}\n@media amzn-kf8,print{#header>h1:first-child{margin-top:1.25rem}\n.sect1{padding:0!important}\n.sect1+.sect1{border:0}\n#footer{background:none}\n#footer-text{color:rgba(0,0,0,.6);font-size:.9em}}\n@media amzn-kf8{#header,#content,#footnotes,#footer{padding:0}}\n\n/* DARK MODE */\n\n@media (prefers-color-scheme: dark) {\nbody,\nbody .btn,\nbody table,\nbody th {\n\tbackground-color: #222; !important\n\tcolor: #e0e0e0; !important\n}\n\nbody .btn {\n\tbox-shadow: 0 0 5px #616161; !important\n\tborder: 1px solid #222; !important\n}\n\nbody .btn:focus {\n\tbox-shadow: 0 0 5px #9e9e9e; !important\n}\n\nbody .theme-switcher {\n\tbackground: url(\"../img/sun.svg\") no-repeat center; !important\n}\n\n.subheader,.admonitionblock td.content>.title,.audioblock>.title,.exampleblock>.title,.imageblock>.title,.listingblock>.title,.literalblock>.title,.stemblock>.title,.openblock>.title,.paragraph>.title,.quoteblock>.title,table.tableblock>.title,.verseblock>.title,.videoblock>.title,.dlist>.title,.olist>.title,.ulist>.title,.qlist>.title,.hdlist>.title{\ncolor:#ff8a80;!important\n}\n.quoteblock blockquote::before{\ncolor:#ff8a80;!important\n}\n\nbody h1,\nbody h2,\nbody h3,\nbody h4,\nbody h5,\nbody h6,\nbody #toctitle,\nbody .sidebarblock .title,\nbody .imageblock .title {\n\tcolor: #ff8a80 !important;\n}\n\nbody blockquote::before {\n\tcolor: #d32f2f !important;\n}\n\nbody code,\nbody pre {\n\tbackground-color: #2f2f2f !important;\n\tcolor: #e0e0e0; !important\n}\n\nbody .sectlevel1 li a {\n\tcolor: #ff8a80 !important;\n}\n\nbody a,\nbody a code,\nbody .sectlevel2 li a {\n\tcolor: #90caf9 !important;\n}\n\nbody a:hover,\nbody a:hover code,\nbody a code:hover,\nbody .sectlevel2 li a:hover {\n\tcolor: #42a5f5 !important;\n}\n\nbody #toc,\nbody .pwa-install-div {\n\tbackground-color: #222 !important;\n}\n\nbody #toc {\n\tborder-left-color: #212121; !important\n\tborder-right-color: #212121; !important\n}\n\nbody .pwa-install-div {\n\tbox-shadow: 0 0 5px #2f2f2f; !important\n}\n\nbody #pwa-install-btn {\n\tbox-shadow: 0 0 5px #2f2f2f; !important\n\tbackground-color: #e0e0e0; !important\n\tborder: 1px solid #e0e0e0; !important\n\tcolor: #222; !important\n}\n\nbody li,\nbody p,\nbody .details,\nbody details,\nbody details summary,\nbody td,\nbody blockquote,\nbody .attribution cite {\n\tcolor: #e0e0e0 !important;\n}\n\nbody .sidebarblock {\n\tbackground-color: #222 !important;\n}\n\n* {\n\tscrollbar-color: #818181 #333; !important\n}\n*::-webkit-scrollbar-track:hover {\n\tscrollbar-color: #a1a181 #333; !important\n}\n\n\n/* code style */\n:not(pre):not([class^=L])>code{background:#2f2f2f;!important}\nkbd{background:#2f2f2f;!important}\n.literalblock pre,.listingblock>.content>pre:not(.highlight),.listingblock>.content>pre[class=highlight],.listingblock>.content>pre[class^=\"highlight \"]{background:#2f2f2f;!important}\n.literalblock.output pre{color:#2f2f2f;!important}\n.prettyprint{background:#2f2f2f;!important}\n}\n" }, { "path": "docs/config.adoc", "content": "= Kanata Configuration Guide\n:last-update-label!:\nifndef::env-github[]\n:toc: left\nendif::[]\n:stylesheet: config-stylesheet.css\n\nThis document describes how to create a kanata configuration file.\nThe kanata configuration file will determine your keyboard behaviour upon running kanata.\n\n== How to read the guide\n\nifdef::env-github[]\nSee the triple bullet-lines at the upper right\nto open or close a Table of Contents sidebar.\n\nYou may want to view the guide rendered to HTML.\nhttps://jtroo.github.io/config.html[Link to guide].\nendif::[]\n\nThe **Reference** sections are shorter\nand are intended for reviewing how precisely to configure different sections.\nThe **Description** sections are longer\nand contain more details such as advice, motivation, and examples.\n\nThe configuration guide you are reading\nmay have content not applicable to the version you are using.\nSee below for links to specific guide versions.\n\nifdef::env-github[]\n* https://github.com/jtroo/kanata/blob/v1.11.0/docs/config.adoc[v1.11.0]\n* https://github.com/jtroo/kanata/blob/v1.10.1/docs/config.adoc[v1.10.1]\n* https://github.com/jtroo/kanata/blob/v1.10.0/docs/config.adoc[v1.10.0]\n* https://github.com/jtroo/kanata/blob/v1.9.0/docs/config.adoc[v1.9.0]\n* https://github.com/jtroo/kanata/blob/v1.8.1/docs/config.adoc[v1.8.1]\n* https://github.com/jtroo/kanata/blob/v1.8.0/docs/config.adoc[v1.8.0]\nendif::[]\nifndef::env-github[]\n* link:/config-1.11.0.html[v1.11.0]\n* link:/config-1.10.1.html[v1.10.1]\n* link:/config-1.10.0.html[v1.10.0]\n* link:/config-1.9.0.html[v1.9.0]\n* link:/config-1.8.1.html[v1.8.1]\n* link:/config-1.8.0.html[v1.8.0]\nendif::[]\n\n== Preamble\n\nThe configuration file uses S-expression syntax from Lisps. If you are not\nfamiliar with any Lisp-like programming language, do not be too worried. This\ndocument will hopefully be a sufficient guide to help you customize your\nkeyboard behaviour to your exact liking.\n\nUseful terminology to learn early:\n[cols=\"1,5\"]\n|===\n| string\n| A sequence of characters.\nOptionally surrounded by quotes.\nExamples: `backspace`, `\"string with spaces and 1 number\"`.\n\n| list\n| A sequence of strings or nested lists within round brackets.\nList items are separated by any amount of whitespace characters,\nor by round brackets.\nExamples: `(lrld-num 1)`, `(tap-dance 200 (f1(unicode 😀)f2(unicode 🙂)))`.\n|===\n\nIf you have any questions, confusions, suggestions, etc., feel free to\nhttps://github.com/jtroo/kanata/discussions/new/choose[start a discussion]\nor https://github.com/jtroo/kanata/issues/new/choose[file an issue].\nIf you have ideas for how to improve this document or any other part of the project,\nplease be welcome to make a pull request or file an issue.\n\n== Forcefully exit kanata [[force-exit]]\n\nThough this isn't configuration-related,\nit may be important for you to know that pressing and holding all of the\nthree following keys together at the same time will cause kanata to exit:\n\n- Left Control\n- Space\n- Escape\n\nThis mechanism works on the key input **before** any remappings done by kanata.\n\n[[comments]]\n== Comments\n\nYou can add comments to your configuration file. Comments are prefixed with two\nsemicolons. E.g:\n\n[source]\n----\n;; This is a comment in a kanata configuration file.\n;; Comments will be ignored and are intended for you to help understand your\n;; own configuration when reading it later.\n----\n\nYou can begin a multi-line comment block with `+#|+` and end it with `+|#+`:\n\n[source]\n----\n#|\nThis is\na multi-line comment block\n|#\n----\n\n[[required-configuration-entries]]\n== Required configuration entries\n\n[[defsrc]]\n=== defsrc\n\n**Reference**\n\nYour configuration file must have exactly one `defsrc` list.\nThis defines the order of keys that the `+deflayer+` entries will operate on.\n\n.Syntax:\n[source]\n----\n(defsrc $key1 $key2 ... $keyN)\n----\n\n[cols=\"1,6\"]\n|===\n| `$key`\n| The name of a key. This can be a default key name or one defined in <>.\nWhen physically pressing this input key, the action defined\nat the same order position on the active layer will activate.\n|===\n\n**Description**\n\nThe `defsrc` configuration entry defines which of your key inputs\nwill be processed by kanata and how the keys map to defined layers.\nKeys excluded from `defsrc` will not be processed by Kanata\nunless you have `process-unmapped-keys yes` in <>.\n\nKeys not processed by Kanata has implications on various actions.\nFor example:\n\n- Pressing an excluded key will type a letter\nwhile a prior `tap-hold` decision is still pending,\nresulting in potentially incorrect results.\n- Excluded keys do not trigger early activation\nin actions such as `tap-hold-press` or `tap-dance`\n- Excluded keys cannot be read by `fork` or `switch` logic.\n\nThe `defsrc` entry is treated as a long sequence.\nThe amount of whitespace (spaces, tabs, newlines) are not relevant.\nYou may use spaces, tabs, or newlines however you like\nto visually format `defsrc` to your liking.\n\nThe primary source of all key names are the\n`str_to_oscode` and `default_mappings` functions in\nhttps://github.com/jtroo/kanata/blob/main/parser/src/keys/mod.rs[the source].\nPlease feel welcome to file an issue\nif you're unable to find the key you're looking for.\n\nAn example `defsrc` containing the US QWERTY keyboard keys as an\napproximately 60% keyboard layout:\n\n.Example:\n[source]\n----\n(defsrc\n grv 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n caps a s d f g h j k l ; ' ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n----\n\nNote that some keyboards have a Menu key instead of a right Meta key.\nIn this case you can use `menu` instead of `rmet`.\n\nFor non-US keyboards, see <>.\n\n[[deflayer]]\n=== deflayer\n\n**Reference**\n\nYour configuration file must have at least one `+deflayer+` entry. This defines\nhow each physical key mapped in `+defsrc+` behaves when kanata runs.\n\n.Syntax:\n[source]\n----\n(deflayer $layer-name $action1 $action2 ... $actionN)\n----\n\n[cols=\"1,5\"]\n|===\n| `$layer-name`\n| A string representing the layer name.\nThis name is used to reference this layer in other actions.\n\n| `$action`\n| The action that activates while this layer is active\nwhen the corresponding `defsrc` input key is pressed.\n|===\n\n**Description**\n\nA `+deflayer+` configuration entry is followed by the layer name then a list of\nkeys or actions. The usable key names are the same as in defsrc. Actions are\nexplained further on in this document. The whitespace story is the same as with\n`+defsrc+`. The order of keys/actions in `+deflayer+` corresponds to the\nphysical key in the same sequence position defined in `+defsrc+`.\n\nThe first layer defined in your configuration file will be the starting layer\nwhen kanata runs. Other layers can be temporarily activated or switched to\nusing actions.\n\nAn example `defsrc` and `deflayer` that remaps QWERTY to the Dvorak layout\nwould be:\n\n.Example:\n[source]\n----\n(defsrc\n grv 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n caps a s d f g h j k l ; ' ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n\n(deflayer dvorak\n grv 1 2 3 4 5 6 7 8 9 0 [ ] bspc\n tab ' , . p y f g c r l / = \\\n caps a o e u i d h t n s - ret\n lsft ; q j k x b m w v z rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n----\n\nA <> also allows specifying\nlayer icons in `+deflayer+` and `+deflayermap+` to show in the tray menu on layer activation,\nsee https://github.com/jtroo/kanata/blob/main/cfg_samples/tray-icon/tray-icon.kbd[example config]\n\n==== deflayermap\n\n**Reference**\n\nAn alternative method for defining a layer exists: `deflayermap`.\nThis method maps inputs to actions by defining input-output pairs,\nignoring `defsrc` entirely.\n\nYou will likely want to either enable <>\nor define most of your keyboard keys within <> when using `deflayermap`.\nOtherwise many actions do not behave as intended.\nSee one of the links for more context.\n\n.Syntax:\n[source]\n----\n(deflayermap ($layer-name)\n $input1 $action1\n $input2 $action2\n ...\n $inputN $actionN)\n----\n\n[cols=\"1,5\"]\n|===\n| `$layer-name`\n| A string representing the layer name.\nThis name is used to reference this layer in other actions.\n\n| `$input`\n| The input key mapped to the corresponding output.\n\n| `$action`\n| The action that activates while this layer is active\nwhen the corresponding input key is pressed.\n|===\n\n**Description**\n\n\nThe `deflayermap` variant has the advantage of terser configuration\nwhen only a few keys on a layer need to be mapped.\nWhen practicing a new configuration, the standard `deflayer` has an advantage\nof looking more like a physical keyboard layout,\nwhich may be helpful to some.\n\nWithin `deflayermap`, the very first item must be the layer name.\nThe layer name must be in parentheses unlike with `deflayer`.\nAfter the layer name, the layer is configured via pairs of items:\n\n* input key\n* output action\n\nAn example complete configuration that maps Caps Lock to Escape is:\n\n[source]\n----\n;; defsrc is still necessary\n(defsrc)\n(deflayermap (base-layer)\n caps esc)\n----\n\nThe input key takes the same role as `defsrc` keys.\nThe output action takes the role that items in the normal `deflayer` have.\n\nAs special input names,\nyou can use one of `_`, `__`, or `___` to map all\nthe keys that are not explicitly mapped in the layer,\ne.g. in the example above, these affect keys other than `caps`.\n\n[cols=\"1,6\"]\n|===\n| `_`\n| Map all unmapped keys in this layer that are defined in `defsrc`.\n\n| `__`\n| Map all unmapped keys in this layer that are not defined in `defsrc`.\n\n| `___`\n| Map all unmapped keys in this layer.\n|===\n\nIf a key is not mapped explicitly or through these wildcards, it will be implicitly mapped to a <>.\n\n[[review-of-required-configuration-entries]]\n=== Review of required configuration entries\n\nIf you're reading in order, you have now seen all of the required entries:\n\n* `+defsrc+`\n* `+deflayer+`\n\n[[minimal-config]]\nAn example minimal configuration is:\n\n[source]\n----\n(defsrc a b c)\n\n(deflayer start 1 2 3)\n----\n\nThis will make kanata remap your `a b c` keys to `1 2 3`. This is almost\ncertainly undesirable but is a valid configuration.\n\nNOTE: Please have a read through link:https://github.com/jtroo/kanata/blob/main/docs/platform-known-issues.adoc[the known platform issues]\nbecause they may have implications on what you should include/exclude in `defsrc`.\nThe Windows LLHOOK I/O mechanism has the most issues by far.\n\n[[key-names]]\n== Key names for defsrc and deflayermap\n\nThe source of truth for all default key names are the functions\n`str_to_oscode` and `add_default_str_osc_mappings`\nin the link:https://github.com/jtroo/kanata/blob/main/parser/src/keys/mod.rs[keys/mod.rs file].\n\nhttps://www.toptal.com/developers/keycode[This online tool]\nwill also work for most keys to tell you the key name.\nIt will be shown as the `event.code` field in the web page\nafter you press the key.\n\n[[non-us-keyboards]]\n== Non-US keyboards\n\nFor non-US keyboard users, you may have some keys on your keyboard with characters\nthat are not allowed in `defsrc` by default, at least according to the symbol shown\non the physical keys.\nThe two sections below can help you understand how to remap all your keys.\n\n=== Browser event.code\n\nEnsure kanata and other key remapping programs are **not** running.\nThen you can use https://www.toptal.com/developers/keycode[this online tool]\nand press the key.\nThe `event.code` field tells you the key name to use in Kanata.\nAlternatively, you can read through\nhttps://www.w3.org/TR/uievents-code/[this reference].\nDue to the lengthy key names,\nyou may want to use `deflayermap` if remapping using these key names.\n\nIMPORTANT: On Windows, you should use either `kanata_winIOv2.exe`\nor Interception when using key names according to the browser `event.code`.\nThe default `kanata.exe` does not do mappings according to the browser `event.code`\nkey names.\n\n[[deflocalkeys]]\n=== deflocalkeys\n\n**Reference**\n\nYou can use `deflocalkeys` to define additional key names that can be\nused in `defsrc`, `deflayer`, and anywhere else in the configuration.\n\n.Syntax:\n[source]\n----\n(deflocalkeys-$variant\n $key-name1 $key-number1\n $key-name2 $key-number2\n ...\n $key-nameN $key-numberN)\n----\n\n[cols=\"1,5\"]\n|===\n| `$variant`\n| One of: `win winiov2 wintercept linux macos`\n\n| `$key-name`\n| A key name of your choice that can be used in the rest of the configuration.\n\n| `$key-number`\n| A key number that varies based on the kanata variant you are using.\n|===\n\nOnly one of each deflocalkeys-* variant is allowed. The variants that are not\napplicable will be ignored, e.g. `deflocalkeys-linux` and `deflocalkeys-wintercept`\nare both ignored when using the default Windows `kanata.exe` binary.\n\n**Description**\n\nThe `deflocalkeys` configurations are not strictly necessary.\nTheir purpose is to help you match your physical keyboard's appearance\nto your kanata configuration,\nin the hopes it will be more readable and less confusing.\nIn the underlying hardware, all keyboard positions send the same scan codes\naccording to their position, regardless of what is printed on the key cap.\nThe scan code names are typically referred to by the corresponding US layout name.\nIt is the job of the operating system to translate the same scan code\nto the correct outputs according to the configured locale and layout.\n\nYou can find configurations that others have made in\nhttps://github.com/jtroo/kanata/blob/main/docs/locales.adoc[this document].\nIf you do not see your keyboard there and are not confident in using\nthe available tools,\nplease feel welcome to ask for help in a discussion or issue.\nPlease contribute to the document if you are able!\n\nThere are five variants of deflocalkeys:\n\n- `deflocalkeys-win`\n- `deflocalkeys-winiov2`\n- `deflocalkeys-wintercept`\n- `deflocalkeys-linux`\n- `deflocalkeys-macos`\n\n.Example:\n[source]\n----\n(deflocalkeys-win\n ì 187\n)\n\n(deflocalkeys-winiov2\n ì 187\n)\n\n(deflocalkeys-wintercept\n ì 187\n)\n\n(deflocalkeys-linux\n ì 13\n)\n\n(deflocalkeys-macos\n ì 13\n)\n\n(defsrc\n grv 1 2 3 4 5 6 7 8 9 0 - ì bspc\n)\n----\n\nThe number used for a custom key represents the converted value for an OsCode in\nbase 10. This differs between Windows-hooks, Windows-interception, and Linux.\n\nRunning kanata with the `--debug` flag lets you read the correct number,\nshown in parenthesis of `code` in the `KeyEvent` log lines.\n\nIt also possible to use native tools, as described below.\n\nIn Linux, `evtest` will give the correct number for the physical key you press.\n\nIn Windows using the default hook mechanism, the non-interception version of the\nkeyboard tester in the kanata repository will give the correct number\nin the `code: ` section.\n(https://github.com/jtroo/kanata/releases/tag/win-keycode-tester-v0.3.0[prebuilt binary])\n\nIn Windows uning `winIOv2`, the winIOv2 executable variant\nwill give the correct number in the `code: ` section.\n\nIn Windows using Interception, the interception version of the keyboard tester\nwill give the correct number i the `num: ` section.\nBetween the hook and interception versions, some\nkeys may agree but others may not; do be aware that they are **not** compatible!\n\nHowever, Interception and winIOv2 should generally agree with each other.\n\nIdeas for improving the user-friendliness of this system are welcome! As\nmentioned before, please ask for help in an issue or discussion if needed, and\nhelp with https://github.com/jtroo/kanata/blob/main/docs/locales.adoc[this document]\nis very welcome so that future users can have an easier time 🙂.\n\n[[introduction-defcfg]]\n== Introduction to defcfg\n\nYour configuration file may include a single `defcfg` entry.\nThe `defcfg` can be empty or omitted.\nThere are options that change kanata's behaviour,\nbut this introduction will introduce\nonly the most prevalent entry: `process-unmapped-keys`.\nAll other options can be found later in the <> section.\n\n.Example of an empty defcfg:\n[source]\n----\n(defcfg)\n----\n\n[[process-unmapped-keys]]\n=== process-unmapped-keys\n\nThe `process-unmapped-keys` option in `defcfg` is probably the most\ngenerally impactful option.\nEnabling this configuration makes kanata process keys\nthat are not defined in `defsrc`.\nThis might be useful\nif you are only mapping a few keys in defsrc\ninstead of most of the keys on your keyboard.\n\nBy default, keys excluded from `defsrc` will not work in various scenarios.\nSome examples:\n\n- The early hold for prior `+tap-hold-press+` actions will not\n- Prior `+one-shot+` actions will not be released\n- `fork` and `switch` logic will not see the key\n\nThis option is disabled by default.\nThe reason this is not enabled by default\nis because some keys may not work correctly if they are intercepted.\nA known issue being AltGr/ralt/Right Alt; see <>.\n\n.Example:\n[source]\n----\n(defcfg process-unmapped-keys yes)\n(defcfg process-unmapped-keys (all-except lctl ralt))\n----\n\n== Aliases and variables[[aliases-and-vars]]\n\nBefore learning about actions,\nit will be useful to first learn about aliases and variables.\n\n[[aliases]]\n=== Aliases\n\n**Reference**\n\nUsing the `defalias` configuration entry, you can introduce a shortcut label\nfor an action.\n\n.Syntax:\n[source]\n----\n(defalias\n $alias-name1 $action1\n $alias-name2 $action2\n ...\n $alias-nameN $actionN)\n----\n\n[cols=\"1,5\"]\n|===\n| `$alias-name`\n| The chosen shortcut label for the action.\nThis shortcut label can be used in the rest of\nthe configuration by prefixing it with the `@`\ncharacter.\n\n| `$action`\n| The ouput action used wherever the alias name is referenced.\n|===\n\n**Description**\n\nThe `defalias` entry reads pairs of items in a sequence\nwhere the first item in the pair is the alias name and the second item is the\naction it can be substituted for.\n\nA list is a sequence of strings\nor nested lists separated by whitespace,\nsurrounded by parentheses.\nAll of the configuration entries we've looked at so far are lists;\n`defalias` is where we'll first see nested lists in this guide.\n\n.Example:\n[source]\n----\n(defalias\n ;; tap for caps lock, hold for left control\n cap (tap-hold 200 200 caps lctl)\n)\n----\n\nThis alias can be used in `deflayer` as a substitute for the long action. The\nalias name is prefixed with `@` to signify that it's an alias as opposed to a\nnormal key.\n\n[source]\n----\n(deflayer example\n @cap a s d f\n)\n----\n\nYou may have multiple `defalias` entries and multiple aliases within a single\n`defalias`. Aliases may also refer to other aliases that were defined earlier\nin the configuration file.\n\n.Example:\n[source]\n----\n(defalias one (tap-hold 200 200 caps lctl))\n(defalias two (tap-hold 200 200 esc lctl))\n(defalias\n three C-A-del ;; Ctrl+Alt+Del\n four (tap-hold 200 200 @three ralt)\n)\n----\n\nYou can choose to put actions without aliasing them right into `deflayer`.\nHowever, for long actions it is recommended not to do so to keep a nice visual\nalignment. Visually aligning your `deflayer` entries will hopefully make your\nconfiguration file easier to read.\n\n.Example:\n[source]\n----\n(deflayer example\n ;; this is equivalent to the previous deflayer example\n (tap-hold 200 200 caps lctl) a s d f\n)\n----\n\n[[variables]]\n=== Variables\n\n**Reference**\n\nUsing the `defvar` configuration entry,\nyou can introduce a shortcut label for an arbitrary string or list.\n\n.Syntax:\n[source]\n----\n(defvar\n $var-name1 $var-value1\n $var-name2 $var-value2\n ...\n $var-nameN $var-valueN)\n----\n\n[cols=\"1,5\"]\n|===\n| `$var-name`\n| The chosen shortcut label for the string or list.\nThis shortcut label can be used in the rest of the\nconfiguration by prefixing it with `$`.\n\n| `$var-value`\n| An arbitrary string or list that will be substituted\nwherever the variable is used.\n\n|===\n\n**Description**\n\nUnlike an alias, a variable does not need to be a valid standalone action.\nIn other words,\na variable can be used as components of actions.\n\nThe most common use case is to define common number strings\nfor actions such as `tap-hold`, `tap-dance`, and `one-shot`.\n\nSimilar to how `defalias` works,\n`defvar` reads pairs of items in a sequence\nwhere the first item in the pair is the variable name\nand the second item is a string or list.\nVariables are allowed to refer to previously defined variables.\n\nVariables can be used to substitute most values.\nSome notable exceptions are:\n\n- variables cannot be used in `defcfg`, `defsrc`, or `deflocalkeys`\n- variables cannot be used to substitute an action name\n\nVariables are referred to by prefixing their name with `$`.\n\n.Example:\n[source]\n----\n(defvar\n tap-repress-timeout 100\n hold-timeout 200\n tt $tap-repress-timeout\n ht $hold-timeout\n)\n\n(defalias\n th1 (tap-hold $tt $ht caps lctl)\n th2 (tap-hold $tt $ht spc lsft)\n)\n----\n\n[[concat-in-defvar]]\n==== concat in defvar\n\nWithin the second item of `defvar`,\na list that begins with the special keyword `concat` will concatenate all\nsubsequent items in the list together into a single string value.\nWithout using `concat`, lists are saved as-is.\n\n.Example:\n[source]\n----\n(defvar\n rootpath \"/home/myuser/mysubdir\"\n ;; $otherpath will be the string: /home/myuser/mysubdir/helloworld\n otherpath (concat $rootpath \"/helloworld\")\n)\n----\n\n[[actions]]\n== Actions\n\nThe actions kanata provides are what make it truly customizable.\nThis section explains the available actions.\n\n[[live-reload]]\n=== Live reload\n\n**Reference**\n\nLive reload variants:\n\n[cols=\"1,5\"]\n|===\n| `lrld`\n| String action that live-reloads the currently-used configuration file.\n\n| `lrld-next`\n| String action that live-reloads the configuration file specified\nconsecutively later in the command line order.\nCycles to the first-specified file\nif currently using the last file specified.\n\n| `lrld-prev`\n| String action that live-reloads the configuration file specified\nconsecutively earlier in the command line order.\nCycles to the last-specified file\nif currently using the first file specified.\n\n| `(lrld-num $n)`\n| List action that live-reloads the n'th file\nas specified in the command line order.\nThe first file specified is `n=1`.\n|===\n\nLive reload does not read or apply changes to device-related configurations.\nExamples of device-related configurations:\n`linux-dev`, `macos-dev-names-include`, `linux-use-trackpoint-property`,\n`windows-only-windows-interception-keyboard-hwids`.\n\n**Description**\n\nYou can put the `+lrld+` action onto a key to live reload your configuration file.\nIf kanata can't parse the file,\nthe previous configuration will continue to be used.\nWhen live reload is activated,\nthe active kanata layer will be the first `deflayer` defined in the configuration.\n\n.Example:\n[source]\n----\n(deflayer has-live-reload\n lrld a s d f\n)\n----\n\nThere are variants of `lrld`: `lrld-prev` and `lrld-next`. These will cycle\nthrough different configuration files that you specify on kanata's startup.\nThe first configuration file specified will be the one loaded on startup.\nThe prev/next variants can be used with shortened names of `lrpv` and `lrnx` as\nwell.\n\nAnother variant is the list action `lrld-num`.\nThis reloads the configuration file specified by the number,\naccording to the order that the configuration file arguments\nare passed into kanata's startup command.\n\n.Example:\n[source]\n----\n(deflayer has-live-reloads\n lrld lrpv lrnx (lrld-num 3)\n)\n----\n\nExample specifying multiple config files in the command line:\n\n[source]\n----\nkanata -c startup.cfg -c 2nd.cfg -c 3rd.cfg\n----\n\nGiven the above startup command,\nactivating `(lrld-num 2)` would reload the `2nd.cfg` file.\n\n\n[[layer-switch]]\n=== layer-switch\n\n**Reference**\n\nA list action that changes the active base layer.\n\n.Syntax:\n[source]\n----\n(layer-switch $layer-name)\n----\n\n[cols=\"1,5\"]\n|===\n| `$layer-name`\n| Layer name to switch to.\n|===\n\n\n**Description**\n\nThis action allows you to switch to another \"base\" layer.\nThis is permanent until a `layer-switch` to another layer is activated.\nThe concept of a base layer makes more sense\nwhen looking at the next action: `layer-while-held`.\n\nThis action accepts a single subsequent string which must be a layer name\ndefined in a `deflayer` entry.\n\n.Example:\n[source]\n----\n(defalias dvk (layer-switch dvorak))\n----\n\n[[layer-while-held]]\n=== layer-while-held\n\n**Reference**\n\nA list action that changes the active layer while the key is held.\n\n.Syntax:\n[source]\n----\n(layer-while-held $layer-name)\n----\n\n[cols=\"1,5\"]\n|===\n| `$layer-name`\n| Layer name to activate while key is held.\n|===\n\n**Description**\n\nThis action allows you to temporarily change to another layer while the key\nremains held. When the key is released, you go back to the currently active\n\"base\" layer.\n\nThis action accepts a single subsequent string which must be a layer name\ndefined in a `deflayer` entry.\n\n.Example:\n[source]\n----\n(defalias nav (layer-while-held navigation))\n----\n\nYou may also use `layer-toggle` in place of `layer-while-held`; they behave\nexactly the same. The `layer-toggle` name is slightly shorter but is a bit\ninaccurate with regards to its meaning.\n\n[[transparent-key]]\n=== Transparent key\n\n**Reference**\n\n[cols=\"1,5\"]\n|===\n| `+_+`\n| String action that activates the action of the layer \"underneath\" the active one.\n|===\n\n**Description**\n\nKanata maintains a layer stack consisting in order of:\n\n* a stack of temporary layers, where each `layer-while-held` adds one layer on top\n* the base layer, manipulated by `layer-switch`\n* if `delegate-to-first-layer` is enabled: the first layer defined by `deflayer` or `deflayermap`\n* `defsrc`\n\nA single underscore `+_+` acts as a \"transparent\" key in the current layer.\nIt will invoke the action assigned to the same key position on the next layer in the stack.\n\nNOTE: If `delegate-to-first-layer` is enabled and the base layer is currently set to the first defined layer, a transparent key on the base layer will fall through directly to `defsrc`.\n\n[[use-defsrc]]\n=== use-defsrc\n\n**Reference**\n\n[cols=\"1,6\"]\n|===\n| `use-defsrc`\n| String action that outputs the corresponding `defsrc` input key.\n|===\n\n**Description**\n\nA similar concept to transparent key is the `+use-defsrc+` action.\nWhen activated, the underlying `defsrc` key will be the output action.\n\n.Example:\n[source]\n----\n(defsrc a b c d)\n(defalias src use-defsrc)\n(deflayer remap-only-c-to-d\n _ _ d @src)\n----\n\n[[no-op]]\n=== No-op\n\n**Reference**\n\n[cols=\"1,6\"]\n|===\n| `XX`\n| String action that will output nothing.\n|===\n\n**Description**\n\nYou may use the action `+XX+` as a \"no operation\" key, meaning pressing the key\nwill do nothing. This might be desirable in place of a transparent key on a\nlayer that is not fully mapped so that a key that is intentionally not mapped\nwill do nothing as opposed to typing a letter.\n\nAlternatively you can use `+✗+` `+∅+` `+•+` to mean no-op.\n\n.Example:\n[source]\n----\n(deflayer contains-no-ops\n XX ✗ ∅ •)\n----\n\n[[unicode]]\n=== Unicode\n\n**Reference**\n\nList action that outputs a single unicode codepoint.\nThe unicode codepoint will not be repeatedly typed if you hold the key down.\n\n.Syntax:\n[source]\n----\n(unicode $unicode-codepoint)\n----\n\n[cols=\"1,4\"]\n|===\n| `$unicode-codepoint`\n| One unicode codepoint.\nBe warned that many emojis/glyphs/graphemes\nare composed of multiple codepoints.\n|===\n\n**Description**\n\nNOTE: The <> may output unicode characters more consistently.\n\nThe `+unicode+` (or `+🔣+`) action accepts a single unicode character (but not\na composed character, so 🤲, but not 🤲🏿),\nor a single unicode number prefixed with `U+`.\nFor example, both of these actions are the same:\n- `(unicode 🚆)`\n- `(unicode U+1F686)`\n\nIf you want to output a glyph that is composed of multiple codepoints,\nyou can use <> with multiple `unicode` actions.\n\nYou may use a unicode character as an alias if desired or in its simplified form `+🔣😀+`\n(vs the usual `+(🔣 😀)+`).\n\nNOTE: The unicode action may not be correctly accepted by the active\napplication.\n\nNOTE: If using Linux, make sure to look at the\n<> in defcfg.\nFurthermore, on Wayland the unicode mechanism may be broken entirely.\nOn Wayland you can install then use the `wtype` program,\nusing <> to execute it.\nFor example: `(cmd wtype á)`\n\n.Example:\n[source]\n----\n(defalias\n sml (unicode 😀)\n 😀 (🔣 😀)\n 🙁 (unicode 🙁)\n)\n(deflayer has-happy-sad\n @sml @🙁 @😀 🔣😀 d f\n)\n----\n\nIf you want output parentheses `+( )+` via unicode you can quote them.\n\n.Example with parentheses\n[source]\n----\n(defalias\n lp (unicode \"(\")\n rp (unicode \")\")\n)\n----\n\nIf you want to output double quotes via unicode\nyou need a special quoting syntax.\n\n.Example use of double-quote within a string\n[source]\n----\n(defalias\n dq (unicode r#\"\"\"#)\n)\n----\n\n[[output-chordscombos]]\n=== Output chords/combos\n\n**Reference**\n\nPrefixing a known key name with the following strings\nwill output the key alongside the specified modifier.\nMultiple prefixes can be combined to add more modifiers\nto the same key output.\nDuplicate prefixes are not allowed.\n\n[cols=\"1,6\"]\n|===\n| `+C-+`\n| Left Control\n\n| `+RC-+`\n| Right Control\n\n| `+A-+`\n| Left Alt\n\n| `+RA-+`\n| Right Alt, also known as AltGr\n\n| `+AG-+`\n| Also means Right Alt/AltGr\n\n| `+S-+`\n| Left Shift\n\n| `+RS-+`\n| Right Shift\n\n| `+M-+`\n| Left Meta\n\n| `+RM-+`\n| Right Meta\n|===\n\nA special behaviour of output chords is that if another key is pressed,\nall of the chord keys will be released\nbefore the newly pressed key action activates.\nThe modifier keys are often not desired for subsequent actions\nand without this behaviour,\nrapid typing can result in undesired modified key presses.\nIf you want keys to remain pressed, use <> instead.\n\n**Description**\n\nYou may want to remap a key to automatically be pressed in combination with\nmodifiers such as Control or Shift.\nOutput chords are a way for you to achieve this.\n\nOutput chords are typically used do one-off actions such as:\n\n- type a symbol, e.g. `S-1` to output `!` for the US layout.\n- type an accented character,\ne.g. `RA-a` to output `á` for the US international layout.\n- do a special action like `C-c` to send `SIGTERM` in the terminal\n\nIt should be noted that output chords are not usable in all configuration items.\nIf you get an unknown key error where you expected an output chord to be usable,\nyou must split the output chord into its component keys.\nFor example, `+(unmod C-l)+` is an error;\ninstead you should use `+(unmod lctl l)+`.\n\nThe output chord prefix strings are:\n\n* `+C-+`: Left Control (also `+‹⎈+` `+‹⌃+` or without the `+‹+` side indicator)\n* `+RC-+`: Right Control (also `+⎈›+` `+⌃›+`)\n* `+A-+`: Left Alt (also `+‹⎇+` `+‹⌥+` or without the `+‹+` side indicator))\n* `+RA-+`: Right Alt, a.k.a. AltGr (also `+AG+` `+⎇›+` `+⌥›+`)\n* `+S-+`: Left Shift (also `+‹⇧+` or without the `+‹+` side indicator))\n* `+RS-+`: Right Shift (also `+⇧›+`)\n* `+M-+`: Left Meta, a.k.a. Windows, GUI, Command, Super (also `+‹⌘+` `+‹❖+` `+‹◆+` or without the `+‹+` side indicator))\n* `+RM-+`: Right Meta (also `+⌘›+` `+❖›+` `+◆›+`)\n\n.Example:\n[source]\n----\n(defalias\n ;; Type exclamation mark (US layout)\n ex! S-1\n ;; Ctrl+C: send SIGINT to a Linux terminal program\n int C-c\n ;; Win+Tab: open Windows' Task View\n tsk M-tab\n ;; Ctrl+Shift+(C|V): copy or paste from certain terminal programs\n cpy C-S-c\n pst C-S-v\n)\n----\n\n[[repeat-key]]\n=== Repeat key\n\n**Reference**\n\n[cols=\"1,5\"]\n|===\n| `rpt`\n| String action that outputs the single most-recently typed key.\n\n| `rpt-any`\n| String action that outputs the most-recently outputted action.\n|===\n\n**Description**\n\nThe action `+rpt+` repeats the most recently typed key. Holding down this key\nwill not repeatedly send the key. The intended use case is to be able to use a\ndifferent finger or even thumb key to repeat a typed key, as opposed to\ndouble-tapping a key.\n\n.Example:\n[source]\n----\n(deflayer has-repeat\n rpt a s d f\n)\n----\n\nThe `rpt` action only repeats the last key output.\nFor example, it won't output a chord like `ctrl+c`\nif the previous key pressed was `C-c`.\nThe `rpt` action will only output `c` in this case.\n\nThere is a variant `rpt-any`\nwhich will repeat any previous action\nand would output `ctrl+c` in the example case.\n\n----\n(deflayer has-repeat-any\n rpt-any a s d f\n)\n----\n\n[[release-a-key-or-layer]]\n=== Release a key or layer\n\n**Reference**\n\n[cols=\"1,2\"]\n|===\n| `(release-key $key)`\n| List action that releases the defined key from output actions.\nNotably this does not act on key inputs.\n\n| `(release-layer $layer-name)`\n| List action that releases `layer-while-held` activations\nfor the given layer name.\n|===\n\n**Description**\n\nYou can release a held key or layer via these actions:\n\n* `release-key` or `key↑`: release a key, accepts `defsrc` compatible names\n* `release-layer` or `layer↑`: release a while-held layer\n\nA lower-level detail of these actions is that they operate on output states\nas opposed to virtually releasing an input key.\nThis does have some practical significance.\nFor example, if the action `(macro-repeat a 50)` were on the `a` key,\nactivating `(release-key a)` will not stop the repeating macro.\n\nAn example practical use case for `release-key` is seen in the `multi` section\ndirectly below.\n\nThere is currently no known practical use case for\n`release-layer`, but it exists nonetheless.\n\n[[multi]]\n=== multi\n\n**Reference**\n\nActivate multiple actions in sequence.\n\n.Syntax:\n[source]\n----\n(multi $action1 $action2 ... $actionN)\n----\n\n[cols=\"1,3\"]\n|===\n| `$action`\n| An output action.\n|===\n\n**Description**\n\nThe `+multi+` action executes multiple keys or actions in order but also\nsimultaneously. It accepts one or more actions.\n\nAn example use case is to press the \"Alt\" key while also activating another\nlayer.\n\nIn the example below, holding the physical \"Alt\" key will result in a held\nlayer being activated while also holding \"Alt\" itself. The held layer operates\nnearly the same as the standard keyboard, so for example the sequence (hold\nAlt)+(Tab+Tab+Tab) will work as expected. This is in contrast to having a layer\nwhere `tab` is mapped to `A-tab`, which results in repeated press+release of\nthe two keys and has different behaviour than expected. Some special keys will\nrelease the \"Alt\" key and do some other action that requires \"Alt\" to be\nreleased. In other words, the \"Alt\" key serves a dual purpose of still\nfulfilling the \"Alt\" key role for some button presses (e.g. Tab), but also as a\nnew layer for keys that aren't typically used with \"Alt\" to have added useful\nfunctionality.\n\n[source]\n----\n(defalias\n atl (multi alt (layer-while-held alted-with-exceptions))\n lft (multi (release-key alt) left) ;; release alt if held and also press left\n rgt (multi (release-key alt) rght) ;; release alt if held and also press rght\n)\n\n(defsrc\n alt a s d f\n)\n\n(deflayer base\n @atl _ _ _ _\n)\n\n(deflayer alted-with-exceptions\n _ _ _ @lft @rgt\n)\n----\n\nWARNING: This action can sometimes behave in surprising ways\nwith regards to simultaneity and order of actions.\nFor example, an action like `(multi sldr ')` will not behave as expected.\nDue to implementation details, `sldr` will activate after the `'`\neven though it is listed before.\nThis example could instead be written as `(macro sldr 10 ')`,\nand that would work as intended.\nIt is recommended to avoid `multi` if it can be replaced\nwith a different action like `macro` or an output chord.\n\n==== reverse-release-order\n\n**Reference**\n\nString item that can be used inside of `(multi ...)`\nto reverse the release order of any keys that were pressed\nas part of `multi`.\n\n.Syntax:\n[source]\n----\n(multi ... reverse-release-order)\n----\n\n**Description**\n\nWithin `multi` you can use include `reverse-release-order`\nto do what the action states: reverse the typical release order from\nif you have multiple keys in multi.\n\nFor example, pressing then releasing a key with the action:\n`(multi a b c)` would press a b c in the stated order\nand then release a b c in the stated order.\nChanging it to `(multi a b c reverse-release-order)`\nwould press a b c in the stated order\nand then release c b a in the stated order.\n\n.Example:\n[source]\n----\n(defalias\n S-a-reversed (multi lsft a reverse-release-order)\n)\n----\n\n[[mouse-actions]]\n=== Mouse actions\n\nYou can click the left, middle, and right buttons using kanata actions, do\nvertical/horizontal scrolling, and move the mouse.\n\n[[mouse-buttons]]\n==== Mouse buttons\n\n**Reference**\n\nYou can activate mouse actions with the string actions below.\n\n[cols=\"1,5\"]\n|===\n| `mlft`\n| Hold left mouse button.\n\n| `mmid`\n| Hold middle mouse button.\n\n| `mrgt`\n| Hold right mouse button.\n\n| `mfwd`\n| Hold forward mouse button.\n\n| `mbck`\n| Hold backward mouse button.\n\n| `mltp`\n| Tap left mouse button.\n\n| `mmtp`\n| Tap middle mouse button.\n\n| `mrtp`\n| Tap right mouse button.\n\n| `mftp`\n| Tap forward mouse button.\n\n| `mbtp`\n| Tap backward mouse button.\n|===\n\nIn Linux and Windows,\nthe hold actions can be used within `defsrc` and `deflayermap`\nto remap mouse buttons like keyboard keys.\n\nNOTE:\nOn Windows, the Kanata process must be restarted\nfor it to begin or to stop handling mouse events;\nchanging defsrc then live-reloading will not\nbegin handling mouse events\nif defsrc previously did not have any mouse events in defsrc.\n\n**Description**\n\nThe mouse button actions are:\n\n* `mlft`: left mouse button\n* `mmid`: middle mouse button\n* `mrgt`: right mouse button\n* `mfwd`: forward mouse button\n* `mbck`: backward mouse button\n\nThe mouse button will be held while the key mapped to it is held.\nOnly on Linux and Windows,\nthe above actions are also usable in `defsrc`\nto enable remapping specified mouse actions in your layers,\nlike you would with keyboard keys.\n\nIf there are multiple mouse click actions within a single multi action, e.g.\n\n`+(multi mrgt mlft)+`\n\nthen all the buttons except the last will be clicked then unclicked. The last\nbutton will remain held until key release. In the example above, pressing then\nreleasing the key mapped to this action will result in the following event\nsequence:\n\n. press key mapped to `+multi+`\n. click right mouse button\n. unclick right mouse button\n. click left mouse button\n. release key mapped to `+multi+`\n. release left mouse button\n\nThere are variants of the standard mouse buttons which \"tap\" the button. Rather\nthan holding the button while the key is held, a mouse click will be\nimmediately followed by the release. Nothing happens when the key is released.\nThe actions are as follows:\n\n* `mltp`: tap left mouse button\n* `mmtp`: tap middle mouse button\n* `mrtp`: tap right mouse button\n* `mftp`: tap forward mouse button\n* `mbtp`: tap bacward mouse button\n\n[[mouse-wheel]]\n==== Mouse wheel\n\n**Reference**\n\nThe `mwheel-*` actions allow you to emulate a mouse wheel.\nHolding the action will repeatedly scroll\naccording to the action configuration.\n\n.Syntax:\n[source]\n----\n(mwheel-$variant $interval $distance)\n----\n\n[cols=\"1,4\"]\n|===\n| `$variant`\n| One of `up down left right` representing the scroll direction to use.\n\n| `$interval`\n| Number of milliseconds between scroll actions.\n\n| `$distance`\n| Distance to travel per activation.\nThe number `120` represents a complete notch on\nstandard resolution mice and in some environments,\n120 or a multiple of it should be what is used.\n|===\n\nYou may use these key names within `defsrc`\nto remap scroll events as if they were keys,\ncorresponding to up, down, left, right respectively:\n`mwu`, `mwd`, `mwl`, `mwr`.\n\nThe remapping of mouse events is only effective on Linux and Windows.\n\nNOTE:\nOn Windows, the Kanata process must be restarted\nfor it to begin or to stop handling mouse events;\nchanging defsrc then live-reloading will not\nbegin handling mouse events\nif defsrc previously did not have any mouse events in defsrc.\n\n**Description**\n\nThe mouse wheel actions are:\n\n* `mwheel-up` or `🖱☸↑`: vertical scroll up\n* `mwheel-down` or `🖱☸↓`: vertical scroll down\n* `mwheel-left` or `🖱☸←`: horizontal scroll left\n* `mwheel-right` or `🖱☸→`: horizontal scroll right\n\nAll of these actions accept two number strings. The first is the interval\n(unit: ms) between scroll actions. The second number is the distance\n(unit: arbitrary). In both Linux and Windows, 120 distance units is equivalent\nto a notch movement on a physical wheel. You can play with the parameters to\nsee what feels correct to you. Both numbers must be in the range [1,65535].\n\nNOTE: In Linux, not all desktop environments support the `REL_WHEEL_HI_RES` event.\nIf this is the case for yours,\nit will likely be a better experience to use a distance value that is a multiple of 120.\n\nOn Linux and Windows, you can also choose to read from a mouse device.\nWhen doing so, using the `mwu`, `mwd`, `mwl`, `mwr` key names in `defsrc`\nallow you to remap the mouse scroll up/down/left/right actions like you would\nwith keyboard keys.\n\nNOTE: If you are using a high-resolution mouse in Linux,\nonly a full \"notch\" of the scroll wheel will activate the action.\n\nNOTE: If you are using a high-resolution mouse with Interception,\nyou will probably get way more events than you intended.\n\n[[mouse-wheel-inertial]]\n===== Mouse wheel: inertial variants\n\n**Reference**\n\nThe `mwheel-accel-*` actions allow you to emulate a mouse wheel,\nwith \"inertial\" properties,\nmeaning scroll speed accelerates while active and decelerates when not.\nYou can adjust factors of acceleration and deceleration.\n\n.Syntax:\n[source]\n----\n(mwheel-accel-$variant $initial-velocity $maximum-velocity $acceleration-multiplier $deceleration-multiplier)\n----\n\n[cols=\"2,3\"]\n|===\n| `$variant`\n| One of `up down left right` representing the scroll direction to use.\n\n| `$initial-velocity`\n| Starting scroll speed, in arbitrary units.\nSuggested starting point: `3`.\n\n| `$maximum-velocity`\n| Starting scroll speed, in arbitrary units.\nSuggested starting point: `1200`.\n\n| `$acceleration-multiplier`\n| Determines acceleration rate of scroll speed.\nSuggested starting point: `1.15`.\n\n| `deceleration-multiplier`\n| Determines deceleration rate of scroll speed.\nSuggested starting point: `0.93`.\nSetting to 0 will make scroll stop abruptly.\n|===\n\n**Description**\n\nAn alternative scrolling action can be used via `mwheel-accel-*`.\nThis action has \"inertial\" behaviour which you may prefer.\n\nThe recommended starting point for the parameters are as below:\n\n.Example configuration:\n[source]\n----\n(defvar\n mw-initial-v 3\n mw-maximum-v 1200\n mw-accel 1.15\n mw-decel 0.93)\n(defalias\n mwu (mwheel-accel-up $mw-initial-v $mw-maximum-v $mw-accel $mw-decel)\n mwd (mwheel-accel-down $mw-initial-v $mw-maximum-v $mw-accel $mw-decel))\n----\n\n[[mouse-movement]]\n==== Mouse movement\n\n**Reference**\n\nThe `movemouse-*` actions allow you to move the mouse cursor.\nHolding the action will repeatedly move the cursor\naccording to the configuration.\n\n.Syntax:\n[source]\n----\n(movemouse-$variant $interval $distance)\n----\n\n[cols=\"1,4\"]\n|===\n| `$variant`\n| One of `up down left right` representing the direction to move.\n\n| `$interval`\n| Number of milliseconds between move activations.\n\n| `$distance`\n| Distance to travel per activation in unit of pixels.\n|===\n\nThere is a move mouse variant that increases distance per activation\nat a constant rate until a maximum is reached.\n\n.Syntax:\n[source]\n----\n(movemouse-accel-$variant $interval $acceleration-time $min $max)\n----\n\n[cols=\"1,4\"]\n|===\n| `$variant`\n| One of `up down left right` representing the direction to move.\n\n| `$interval`\n| Number of milliseconds between move activations.\n\n| `$acceleration-time`\n| Number of milliseconds until max distance per activation is reached.\n\n| `$min`\n| Initial distance to travel per activation in unit of pixels.\n\n| `$max`\n| Maximum distance to travel per activation in unit of pixels.\n|===\n\n**Description**\n\nThe mouse movement actions are:\n\n* `movemouse-up` or `🖱↑`\n* `movemouse-down` or `🖱↓`\n* `movemouse-left` or `🖱←`\n* `movemouse-right` or `🖱→`\n\nSimilar to the mouse wheel actions, all of these actions accept two number strings.\nThe first is the interval (unit: ms) between movement actions and the second number\nis the distance (unit: pixels) of each movement.\n\nThe following are variants of the above mouse movements that apply linear mouse\nacceleration from the minimum distance to the maximum distance as the mapped key is held.\n\n* `movemouse-accel-up` or `🖱accel↑`\n* `movemouse-accel-down` or `🖱accel↓`\n* `movemouse-accel-left` or `🖱accel←`\n* `movemouse-accel-right` or `🖱accel→`\n\nAll these actions accept four number strings. The first number is the\ninterval (unit: ms) between movement actions. The second number is the time it\ntakes (unit: ms) to linearly ramp up from the minimum distance to the maximum\ndistance. The third and fourth numbers are the minimum and maximum distances\n(unit: pixels) of each movement.\n\nThere is a toggable defcfg option related to `movemouse-accel` - <>. You might want to enable it, especially if you're coming from QMK.\n\n[[set-mouse]]\n==== Set absolute mouse position\n\nThe action `setmouse` or `set🖱` sets the absolute mouse position.\n\nWARNING: This is not supported on Linux.\nFor an interesting keyboard-centric mouse solution in Linux,\ntry looking at\nhttps://github.com/rvaiya/warpd[warpd].\n\nThis list action takes two parameters which are `x` and `y` positions\nof the absolute movement.\n\nThe coordinate system is platform-specific:\n\n* **macOS**: Pixel coordinates. `0,0` is the top-left of the main display,\n maximum values are your screen resolution (e.g., `1920,1080`).\n* **Windows**: Normalized coordinates from `0,0` (top-left)\n to `65535,65535` (bottom-right). Multiple monitors are treated as one virtual desktop.\n\nExperimentation will be needed to find the correct values for your setup.\n\n[[mouse-speed]]\n==== Modify the speed of mouse movements\n\nThe action `movemouse-speed` or `🖱speed` modifies the speed at which `movemouse` and\n`movemouse-accel` function at runtime. It does this by expanding or shrinking\n`min_distance` and `max_distance` while the action key is pressed.\n\nThis action accepts one number (unit: percentage) by which the\nmouse movements will be accelerated.\n\nWARNING: Due to the nature of pixels being whole numbers, some values such as\n33 may not result in an exact third of the distance.\n\n.Example:\n[source]\n----\n(defalias\n fst (movemouse-speed 200)\n slw (movemouse-speed 50)\n)\n----\n\n[[mouse-all-actions-example]]\n==== Mouse all actions example\n\n[source]\n----\n(defalias\n mwu (mwheel-up 50 120)\n mwd (mwheel-down 50 120)\n mwl (mwheel-left 50 120)\n mwr (mwheel-right 50 120)\n\n ms↑ (movemouse-up 1 1)\n ms← (movemouse-left 1 1)\n ms↓ (movemouse-down 1 1)\n ms→ (movemouse-right 1 1)\n\n ma↑ (movemouse-accel-up 1 1000 1 5)\n ma← (movemouse-accel-left 1 1000 1 5)\n ma↓ (movemouse-accel-down 1 1000 1 5)\n ma→ (movemouse-accel-right 1 1000 1 5)\n\n sm (setmouse 32228 32228)\n\n fst (movemouse-speed 200)\n)\n\n(deflayer mouse\n _ @mwu @mwd @mwl @mwr _ _ _ _ _ @ma↑ _ _ _\n _ pgup bck _ fwd _ _ _ _ @ma← @ma↓ @ma→ _ _\n _ pgdn mlft _ mrgt mmid _ mbck mfwd _ @ms↑ _ _\n @fst _ mltp _ mrtp mmtp _ mbtp mftp @ms← @ms↓ @ms→\n _ _ _ _ _ _ _\n)\n----\n\n[[tap-dance]]\n=== tap-dance\n\n**Reference**\n\nThe `tap-dance` action allows performing different actions\nbased on number of consecutive taps of the same key.\n\n.Syntax:\n[source]\n----\n(tap-dance $timeout $action-list)\n----\n\n[cols=\"1,4\"]\n|===\n| `$timeout`\n| Number of milliseconds after which the tap-dance ends.\n\n| `$action-list`\n| A list of actions that can be selected, ordered by number of taps.\n|===\n\nThe `tap-dance-eager` variant will eagerly perform actions.\nUse of `macro` and `bspc` can help to backtrack for the 2nd tap onwards.\n\n.Syntax:\n[source]\n----\n(tap-dance-eager $timeout $action-list)\n----\n\n**Description**\n\nThe `+tap-dance+` action allows repeated tapping of a key to result in\ndifferent actions. It is followed by a timeout (unit: ms) and a list\nof keys or actions. Each time the key is pressed, its timeout will reset. The\naction will be chosen if one of the following events occur:\n\n* the timeout expires\n* a different key is pressed\n* the key is repeated up to the final action\n\nYou may put normal keys or other actions in `+tap-dance+`.\n\n.Example:\n[source]\n----\n(defalias\n ;; 1 tap : \"A\" key\n ;; 2 taps: Control+C\n ;; 3 taps: Switch to another layer\n ;; 4 taps: Escape key\n td (tap-dance 200 (a C-c (layer-switch l2) esc))\n)\n----\n\nThere is a variant of `tap-dance` with the name `tap-dance-eager`. The variant\nis parsed identically but the difference is that it will activate every\naction in the sequence as the taps progress.\n\nIn the example below, repeated taps will, in order:\n\n1. type `a`\n2. erase the `a` and type `bb`\n3. erase the `bb` and type `ccc`\n\n[source]\n----\n(defalias\n td2 (tap-dance-eager 500 (\n (macro a) ;; use macro to prevent auto-repeat of the key\n (macro bspc b b)\n (macro bspc bspc c c c)\n ))\n)\n----\n\n[[one-shot]]\n=== one-shot\n\n**Reference**\n\nActivate keys or layers for a time without keeping the input key held,\nfor one subsequent key.\nActivating other one-shot actions,\nwhile one or more are already active,\nwill reset the timeout,\nand overlap the one-shot actions.\n\n\n.Syntax:\n[source]\n----\n($one-shot-variant $timeout $action)\n----\n\nValues for `$variant`:\n[cols=\"1,3\"]\n|===\n| `one-shot-press`\n| End on the first press of another key.\nThis is also the variant selected by the name `one-shot`.\n\n| `+one-shot-release+`\n| End on the first release of a newly pressed key.\n\n| `+one-shot-press-pcancel+`\n| End on the first press of another key\n or on re-press of this key, or of another active one-shot key\n\n| `+one-shot-release-pcancel+`\n| End on the first release of a newly pressed key\n or on re-press of this key, or of another active one-shot key.\n|===\n\nOther items:\n[cols=\"1,3\"]\n|===\n| `$timeout`\n| Number of milliseconds after which\nif not deactivated due to user input,\none-shot will deactivate on its own.\n\n| `$action`\n| Layer action, key, or output chord.\n|===\n\n**Description**\n\nThe `+one-shot+` action is similar to \"sticky keys\", if you know what that is.\nThis activates an action or key until either the timeout expires or a different\nkey is used. The `+one-shot+` action must be followed by a timeout (unit:\nms) and another key or action.\n\nSome of the intended use cases are:\n\n* press a modifier for exactly one following key press\n* switch to another layer for exactly one following key press\n\nIf a `+one-shot+` key is held then it will act as the regular key. E.g. holding\na key assigned with `+@os2+` in the example below will keep Left Shift held for\nevery key, not just one, as long as it's still physically pressed.\n\nPressing multiple `+one-shot+` keys in a row within the timeout will combine\nthe actions of those keys and reset the timeout to the value of the most\nrecently pressed `+one-shot+` key.\n\nThere are four variants of the `+one-shot+` action:\n\n- `+one-shot-press+` or `+one-shot↓+`:\n end on the first press of another key\n- `+one-shot-release+` or `+one-shot↑+`:\n end on the first release of another key\n- `+one-shot-press-pcancel+` or `+one-shot↓⤫+`:\n end on the first press of another key\n or on re-press of another active one-shot key\n- `+one-shot-release-pcancel+` or `+one-shot↑⤫+`:\n end on the first release of another key\n or on re-press of another active one-shot key\n\nIt is important to note that the first activation of a one-shot key\ndetermines the behaviour with regards to the 4 variants\nfor all subsequent one-shot key activations,\neven if a following one-shot key has a different configuration\nthan the initial key pressed.\n\nThe default name `+one-shot+` corresponds to `+one-shot-press+`.\n\nNOTE: When using one-shot with keys that will trigger defoverrides,\nyou will likely want to adjust <> to yes in `defcfg`.\n\n.Example:\n[source]\n----\n(defalias\n os1 (one-shot 500 (layer-while-held another-layer))\n os2 (one-shot-press 2000 lsft)\n os3 (one-shot-release 2000 lctl)\n os4 (one-shot-press-pcancel 2000 lalt)\n os5 (one-shot-release-pcancel 2000 lmet)\n)\n----\n\n[[one-shot-pause-processing]]\n==== one-shot-pause-processing\n\n**Reference**\n\nPause `one-shot` processing of new input keypresses for a time,\nto allow actions that are not intended to consume `one-shot`\nto take place.\n\n.Syntax:\n[source]\n----\n(one-shot-pause-processing $time)\n----\n\n[cols=\"1,5\"]\n|===\n| `time`\n| Number of milliseconds to ignore processing.\nSomething notable is that one virtual key press or releas\n(tap is a separate press and subsequent release)\nwill take 1ms to process.\nIf using virtual keys this number must be larger\nthan the number of virtual key events that are taking place.\n|===\n\n**Description**\n\nThe `one-shot-pause-processing` list action allows you to pause the\nkey press processing of one-shot activations.\nAn example of when this is useful the following sequence:\n\n- Activate a layer-while-held\n- Activate a one-shot action on that layer\n- Release the layer-while-held key, which has an `(on-release ...)` action\n associated with it.\n- The on-release action is not intended to consume one-shot activations\n\nIn the scenario above, by default the on-release activation\nwould trigger deactivation of one-shot;\nthus the pause processing action must be used to stop this from happening.\n\n[[tap-hold]]\n=== tap-hold\n\nWARNING: The `tap-hold` action and all variants can behave unexpectedly on Linux\nwith respect to repeat of antecedent key presses.\nThe full context is in https://github.com/jtroo/kanata/discussions/422[discussion #422].\nIn brief, the workaround is to use `tap-hold` inside of <>,\ncombined with another key action that behaves as a no-op like `f24`. +\nExample: `(multi f24 (tap-hold ...))`.\nIf multiple `tap-hold` actions may be pressed subsequently,\nall using the `f24` workaround,\nyou may need to release the `f24` within the same `multi`\nto avoid repeats from one double-tapped `tap-hold` action\nfollowed by another, different `tap-hold` action.\nExample:\n`(defvirtualkeys relf24 (release-key f24)) ... (multi f24 (tap-hold ...) (macro 5 (on-press tap-vkey relf24)))`\n\n**Reference**\n\nThe `tap-hold` action lets you activate different actions\ndepending it a key is tapped or held.\n\n.Syntax:\n[source]\n----\n(tap-hold $tap-repress-timeout $hold-timeout $tap-action $hold-action)\n----\n\n[cols=\"1,4\"]\n|===\n| `$tap-repress-timeout`\n| Number of milliseconds for the window that a tap into re-press with hold\nresults in the `$tap-action` being held.\n\n| `$hold-timeout`\n| Number of milliseconds after which the `$hold-action` activates.\nReleasing the key before this elapses\nresults in `$tap-action` activating.\n\n| `$tap-action`\n| Action to activate when the input is determined to be a \"tap\".\n\n| `$hold-action`\n| Action to activate when the input is determined to be a \"hold\".\n|===\n\n.Variants:\n----\n(tap-hold-press $tap-repress-timeout $hold-timeout $tap-action $hold-action)\n(tap-hold-release $tap-repress-timeout $hold-timeout $tap-action $hold-action)\n(tap-hold-press-timeout $tap-repress-timeout $hold-timeout $tap-action $hold-action $timeout-action)\n(tap-hold-release-timeout $tap-repress-timeout $hold-timeout $tap-action $hold-action $timeout-action [?reset-timeout-on-press])\n(tap-hold-release-keys $tap-repress-timeout $hold-timeout $tap-action $hold-action $tap-keys)\n(tap-hold-release-tap-keys-release $tap-repress-timeout $hold-timeout $tap-action $hold-action $tap-trigger-keys-on-press $tap-trigger-keys-on-press-then-release)\n(tap-hold-except-keys $tap-repress-timeout $hold-timeout $tap-action $hold-action $tap-keys)\n(tap-hold-tap-keys $tap-repress-timeout $hold-timeout $tap-action $hold-action $tap-keys)\n(tap-hold-opposite-hand $timeout $tap-action $hold-action [options...])\n(tap-hold-order $tap-repress-timeout $buffer-ms $tap-action $hold-action [options...])\n----\n\n[cols=\"1,2\"]\n|===\n| `tap-hold-press`\n| Activate `$hold-action` early if held and another input key is pressed.\n\n| `tap-hold-release`\n| Activate `$hold-action` early if held and another input key is pressed and released.\n\n| `tap-hold-press-timeout`\n| Activate `$hold-action` if held and another input key is pressed.\nIf the defined timeout elapses, `$timeout-action` will activate.\n\n| `tap-hold-release-timeout`\n| Activate `$hold-action` early if held and another input key is pressed and released.\nIf the defined timeout elapses, `$timeout-action` will activate.\nOptionally include `reset-timeout-on-press` to reset timeout duration on a new press,\ngiving more time for a subsequent release to activate hold instead of timeout.\n\n| `tap-hold-release-keys`\n| Activate `$hold-action` early if held and another input key is pressed and released.\nThe `$tap-keys` parameter is a list of key names.\nActivates `$tap-action` early if a key within `$tap-keys` is pressed before hold activates.\n\n| `tap-hold-release-tap-keys-release`\n| Activate `$hold-action` early if held and another input key is pressed and released.\nThe `$tap-keys-...` parameters are lists of key names.\nActivate `$tap-action` early\nif a key within `$tap-trigger-keys-on-press`\nis pressed before hold activates\nActivate `$tap-action` early\nif a key within `$tap-trigger-keys-on-press-then-release`\nis pressed then released before hold activates.\n\n| `tap-hold-except-keys`\n| The `$tap-keys` parameter is a list of key names.\nActivates `$tap-action` if a key within `$tap-keys` is pressed\nor if the action key is released before hold timeout.\nNo key is ever output until the action key is released\nor another key is pressed,\nwhich differs from the default `tap-hold` behaviour.\n\n| `tap-hold-tap-keys`\n| The `$tap-keys` parameter is a list of key names.\nActivates `$tap-action` early if a key within `$tap-keys` is pressed before hold activates.\nUnlike `tap-hold-release-keys`, does NOT activate `$hold-action` early\nwhen other keys are pressed and released.\nWaits for full `$hold-timeout` before activating `$hold-action`.\nThis is useful for home row mods where fast typing should not trigger modifiers.\n\n| `tap-hold-opposite-hand`\n| Resolves to `$hold-action` when a key from the opposite hand (per `defhands`) is pressed.\nRequires a `defhands` directive. Supports list-form options for fine-grained control.\nSee <> below.\n\n| `tap-hold-order`\n| Resolves purely by key release order, with no timeout.\nIf the tap-hold key is released before the other key, activates `$tap-action`;\nif the other key is released first (while the tap-hold key is still held), activates `$hold-action`.\n`$buffer-ms` is a grace period after the tap-hold key is pressed during which\nrelease-order logic is ignored so that fast typing resolves as tap.\nOptionally, `(require-prior-idle )` can short-circuit to tap when a different key\nwas pressed within that many milliseconds before the tap-hold key;\n`require-prior-idle` checks prior typing activity before release-order logic begins,\nwhereas `buffer-ms` creates an unconditional tap-only window after the key is pressed.\nThis option is available on all tap-hold variants; see <>.\n|===\n\nAll `tap-hold` variants support an optional trailing `(require-prior-idle )` option\nto override the global <> setting for that specific action.\nUse `(require-prior-idle 0)` to disable idle detection for a specific key.\n\n**Description**\n\nThe `+tap-hold+` action allows you to have one action/key for a \"tap\" and a\ndifferent action/key for a \"hold\". A tap is a rapid press then release of the\nkey whereas a hold is a long press.\n\nNOTE: for more discussion on tap-hold,\nyou may want to have a look at this GitHub discussion:\nhttps://github.com/jtroo/kanata/discussions/1455[link to discussion].\n\nThe action takes 4 parameters in the listed order:\n\n. tap repress timeout (unit: ms)\n. hold timeout (unit: ms)\n. tap action\n. hold action\n\nThe tap repress timeout is the number of milliseconds within which a rapid\npress+release+press of a key will result in the tap action being held instead\nof the hold action activating.\n\n.Tap repress timeout in more detail\n[%collapsible,indent=4]\n====\nThe way a `tap-hold` action works with respect to the tap repress timeout\nis often unclear to newcomers.\nTo make it concrete, the output event sequence of the `tap-hold` action\n`(tap-hold $tap-repress-timeout 200 a lctl)`\nfor varying values of `$tap-repress-timeout`\nwith a fixed input event sequence will be described.\n\nThe input event sequence is:\n\n- press\n- 50 ms elapses\n- release\n- 50 ms elapses\n- press\n- 300 ms elapses\n- release\n\nWith `(defvar $tap-repress-timeout 0)`, the output event sequence is:\n\n- 50 ms elapses\n- press `a`\n- release `a`\n- 250 ms elapses\n- press `lctl`\n- 100 ms elapses\n- release `lctl`\n\nThe above output sequence is the same for all `$tap-repress-timeout` values\nbetween and including `0` and `99`.\n\nFor a value of `100` or greater for `$tap-repress-timeout`,\nthe output event sequence is instead:\n\n- 50 ms elapses\n- press `a`\n- release `a`\n- 50 ms elapses\n- press `a`\n- 300 ms elapses\n- release `a`\n====\n\nThe hold timeout is the number of milliseconds after which the hold action will\nactivate.\n\nThere are two additional variants of `+tap-hold+`:\n\n* `+tap-hold-press+` or `+tap⬓↓+`\n** If there is a press of a different key, the hold action is activated even if\nthe hold timeout hasn't expired yet\n* `+tap-hold-release+` or `+tap⬓↑+`\n** If there is a press+release of a different key, the hold action is activated\neven if the hold timeout hasn't expired yet\n\nThese variants may be useful if you want more responsive tap-hold keys,\nbut you should be wary of activating the hold action unintentionally.\n\n.Example:\n[source]\n----\n(defalias\n anm (tap-hold 200 200 a @num) ;; tap: a hold: numbers layer\n oar (tap-hold-press 200 200 o @arr) ;; tap: o hold: arrows layer\n ech (tap-hold-release 200 200 e @chr) ;; tap: e hold: chords layer\n)\n----\n\nThere are further additional variants of `tap-hold-press` and `tap-hold-release`:\n\n- `tap-hold-press-timeout` or `tap⬓↓timeout`\n- `tap-hold-release-timeout` or `tap⬓↑timeout`\n\nThese variants take a 5th parameter, in addition to the same 4 as the other\nvariants. The 5th parameter is another action, which will activate if the hold\ntimeout expires as opposed to being triggered by other key actions, whereas the\nnon `-timeout` variants will activate the hold action in both cases.\n\nThe `release` variant also accepts an optional 6th argument,\n`reset-timeout-on-press` which if included changes the timeout behaviour.\nThis flag will make the timeout duration reset if a new key is pressed.\nThis may result in longer timeouts,\nbut can help with more consistent hold activations;\nbecause it may be challenging to release a key in time\nto activate the hold action instead of the timeout action.\n\n- `tap-hold-release-keys` or `tap⬓↑keys`\n\nThis variant takes a 5th parameter which is a list of keys\nthat trigger an early tap\nwhen they are pressed while the `tap-hold-release-keys` action is waiting.\nOtherwise this behaves as `tap-hold-release`.\n\nThe keys in the 5th parameter correspond to the physical input keys,\nor in other words the key that corresponds to `defsrc`.\nThis is in contrast to the `fork` and `switch` actions\nwhich operates on outputted keys, or in other words the outputs\nthat are in `deflayer`, `defalias`, etc. for the corresponding `defsrc` key.\n\n.Example:\n[source]\n----\n(defalias\n ;; tap: u hold: misc layer early tap if any of: (a o e) are pressed\n umk (tap-hold-release-keys 200 200 u @msc (a o e))\n)\n----\n\n- `tap-hold-release-tap-keys-release`\n\nThis variant behaves nearly the same as `tap-hold-release-keys`,\nbut has another condition with respect to the eager tap.\nIt accepts a second list that activates the eager tap\nif the any key listed within is pressed then released;\nas opposed to only on a press.\n\nThe keys in the 5th and 6th parameters correspond to the physical input keys,\nor in other words the key that corresponds to `defsrc`.\nThis is in contrast to the `fork` and `switch` actions\nwhich operates on outputted keys, or in other words the outputs\nthat are in `deflayer`, `defalias`, etc. for the corresponding `defsrc` key.\n\n.Example:\n[source]\n----\n(defalias\n ;; tap: u hold: misc layer early tap if any of:\n ;; (z x c v) are pressed, OR\n ;; (a s d f) are pressed THEN released\n umk2 (tap-hold-release-tap-keys-release 200 200 u @msc (z x c v) (a s d f))\n)\n----\n\n- `tap-hold-except-keys` or `tap-hold⤫keys`\n\nThis variant takes a 5th parameter which is a list of keys\nthat always trigger a tap\nwhen they are pressed while the `tap-hold-except-keys` action is waiting.\nNo key is ever output until there is either a release of the key or any other\nkey is pressed. This differs from `tap-hold` behaviour.\n\nThe keys in the 5th parameter correspond to the physical input keys,\nor in other words the key that corresponds to `defsrc`.\nThis is in contrast to the `fork` and `switch` actions\nwhich operates on outputted keys, or in other words the outputs\nthat are in `deflayer`, `defalias`, etc. for the corresponding `defsrc` key.\n\n.Example:\n[source]\n----\n(defalias\n ;; tap: u hold: misc layer always tap if any of: (a o e) are pressed\n umk (tap-hold-except-keys 200 200 u @msc (a o e))\n)\n----\n\n- `tap-hold-tap-keys` or `tap⬓tapkeys`\n\nThis variant takes a 5th parameter which is a list of keys\nthat trigger an early tap when they are pressed.\nUnlike `tap-hold-release-keys`, pressing and releasing other keys\ndoes NOT activate hold early - the full hold timeout is always waited.\nThis is useful for home row mods where fast typing should not trigger modifiers.\n\nThe keys in the 5th parameter correspond to the physical input keys,\nor in other words the key that corresponds to `defsrc`.\n\n.Example:\n[source]\n----\n(defalias\n ;; tap: a hold: lsft early tap if any of: (s d f) are pressed\n ;; other keys do NOT trigger early hold\n ath (tap-hold-tap-keys 200 200 a lsft (s d f))\n)\n----\n\n==== defhands and tap-hold-opposite-hand\n\n`defhands` assigns physical keys to `left` / `right` hand groups.\n`tap-hold-opposite-hand` uses this to resolve hold when the next key\nis on the opposite hand — reducing misfires compared to manual key lists.\n\n[source]\n----\n(defhands\n (left q w e r t a s d f g z x c v b)\n (right y u i o p h j k l ; n m , . /))\n\n(defalias\n fctl (tap-hold-opposite-hand 180 f lctl))\n----\n\n`defhands` rules: at most one block; each group (`(left ...)`/`(right ...)`) at most once;\na key cannot appear in both groups; partial definitions (only one hand) are allowed;\nunlisted keys have no hand assignment.\n\n`tap-hold-opposite-hand` takes `$timeout $tap-action $hold-action` followed by\noptional option lists. Most use `(name value)`, while `neutral-keys` uses\nfollowup key atoms: `(neutral-keys spc tab ...)`.\nIt requires `defhands` to be defined.\nInternally it uses the same `HoldTapConfig::Custom` machinery as `tap-hold-release-keys`.\n\n[cols=\"1,1,1,2\"]\n|===\n| Option | Values | Default | Description\n\n| `(timeout )` | `tap`, `hold` | `tap` | Action when hold timeout elapses (optimized for home-row-mod behavior).\n| `(same-hand )` | `tap`, `hold`, `ignore` | `tap` | Action when a same-hand key is pressed.\n| `(neutral-keys key ...)` | one or more key names | (empty) | Keys treated as neutral, overriding their `defhands` assignment.\n| `(neutral )` | `tap`, `hold`, `ignore` | `ignore` | Action when a `neutral-keys` key is pressed.\n| `(unknown-hand )` | `tap`, `hold`, `ignore` | `ignore` | Action when a key not in `defhands` is pressed.\n|===\n\nWhen a value is `ignore`, that key press is skipped and the action\nwaits for the next key or timeout.\n\nExample with options:\n[source]\n----\n(defalias\n fctl (tap-hold-opposite-hand 180 f lctl\n (same-hand ignore)\n (timeout hold)\n (neutral-keys spc tab)\n (neutral tap)))\n----\n\nSee `cfg_samples/opposite-hand-hrm.kbd` for a full working example.\n\n[[macro]]\n=== macro\n\n**Reference**\n\nThe macro action taps the configured sequence of keys or actions.\nNumbers can be used to delay the sequence by the defined number of milliseconds.\n\n.Syntax:\n[source]\n----\n(macro $macro-action1 $macro-action2 ... $macro-actionN)\n----\n\n[cols=\"1,4\"]\n|===\n| `$macro-action`\n| A delay, key, action within the subset allowed within macros,\nor an output-chord-prefixed list of more macro-actions.\n|===\n\n.Variants:\n----\n(macro-release-cancel ...)\n(macro-cancel-on-press ...)\n(macro-release-cancel-and-cancel-on-press ...)\n(macro-repeat ...)\n(macro-repeat-$cancel-variant ...)\n----\n[cols=\"1,2\"]\n|===\n| `macro-release-cancel`\n| Cancel all active macros if the key is released.\n\n| `macro-cancel-on-press`\n| Cancel all active macros if a different key is pressed.\n\n| `macro-release-cancel-and-cancel-on-press`\n| Cancel all active macros if either the key is released or a different key is pressed.\n\n| `macro-repeat`\n| Repeat the macro while held.\n\n| `macro-repeat-$cancel-variant`\n| Repeat the macro while held.\nCancels the final repeat according the behaviour of one of the variants:\n`release-cancel`, `cancel-on-press`, `release-cancel-and-cancel-on-press`.\n|===\n\n**Description**\n\nThe `+macro+` action will tap a sequence of keys with optional\ndelays. This is different from `+multi+` because in the `+multi+` action,\nall keys are held, whereas in `+macro+`, keys are pressed then released.\n\nThis means that with `+macro+` you can have some letters capitalized and others\nnot. This is not possible with `+multi+`.\n\nThe `+macro+` action accepts one or more keys, some actions, chords, and delays\n(unit: ms). It also accepts a list prefixed with <>\nmodifiers where the list is subject to the aforementioned restrictions.\n\nIMPORTANT: The number keys `0-9` will be parsed as millisecond delays\nwhereas in other contexts they would be parsed as key names.\nTo use the numbered keys they must be aliased\nor otherwise use the key names `Digit0-Digit9`.\n\nUp to 4 macros can be active at the same time.\n\nThe actions supported in `+macro+` are:\n\n* <>\n* <>\n* <>\n* <>\n* <>\n* <>\n* <>\n* <>\n* <>\n* <>\n\nNOTE: Some of these actions may need short delays between.\nFor example, `(macro a (unmod b) 5 (unmod c) d))`\nneeds the delay of `5` to work correctly.\n\n.Example:\n[source]\n----\n(defalias\n : S-;\n 8 8\n 0 0\n 🙃 (unicode 🙃)\n\n ;; Type \"http://localhost:8080\"\n lch (macro h t t p @: / / 100 l o c a l h o s t @: @8 @0 @8 @0)\n\n ;; Type \"I am HAPPY my FrIeNd 🙃\"\n hpy (macro S-i spc a m spc S-(h a p p y) spc m y S-f r S-i e S-n d spc @🙃)\n\n ;; alt-tab(x3) and alt-shift-tab(x3) with macro\n tfd (macro A-(tab 200 tab 200 tab))\n tbk (macro A-S-(tab 200 tab 200 tab))\n)\n----\n\n[[macro-release-cancel]]\n==== macro-release-cancel\n\nThe `macro-release-cancel` variant of the `+macro+` action\nwill cancel all active macros\nupon releasing the key.\nShorter unicode variant: `+macro↑⤫+`.\nThis variant is parsed identically to the non-cancelling version.\nAn example use case for this action is holding down\na key to get different outputs,\nsimilar to tap-dance but one can see which keys are being outputted.\n\nE.g. in the example below, when holding the key, first `1` is typed, then\nreplaced by `!` after 500ms, and finally that is replaced by `@` after another\n500ms. However, if the key is released, the last character typed will remain\nand the rest of the macro does not run.\n\n[source]\n----\n(defalias\n 1 1\n\n ;; macro-release-cancel to output different characters with visual feedback\n ;; after holding for different amounts of time.\n 1!@ (macro-release-cancel @1 500 bspc S-1 500 bspc S-2)\n)\n----\n\n[[macro-cancel-on-press]]\n==== macro-cancel-on-press\n\nThe `macro-cancel-on-press` variant of the `macro action`\nenables a cancellation trigger for all active macros including itself,\nwhich is activated when a physical press of any other key happens.\nThe trigger is enabled while the macro is in progress.\n\n[source]\n----\n(defalias\n 1 1\n 1!@ (macro-cancel-on-press @1 500 bspc S-1 500 bspc S-2)\n)\n----\n\n[[macro-release-cancel-and-cancel-on-press]]\n==== macro-release-cancel-and-cancel-on-press\n\nThe `macro-release-cancel-and-cancel-on-press` variant\ncombines the cancel behaviours\nof both the release-cancel and cancel-on-press.\n\n[source]\n----\n(defalias\n 1 1\n 1!@ (macro-release-cancel-and-cancel-on-press @1 500 bspc S-1 500 bspc S-2)\n)\n----\n\n\n[[macro-repeat]]\n==== macro-repeat\n\nThere are further `macro-repeat` variants of the three `macro` actions described previously.\nThese variants repeat while held.\nThe repeat will only occur once all macros have completed,\nincluding the held macro key.\nIf multiple repeating macros are being held simulaneously,\nonly the most recently pressed macro will be repeated.\n\n[source]\n----\n(defalias\n mr1 (macro-repeat mltp)\n mr2 (macro-repeat-release-cancel mltp)\n mr3 (macro-repeat-cancel-on-press mltp)\n mr4 (macro-repeat-release-cancel-and-cancel-on-press mltp)\n)\n----\n\n[[dynamic-macro]]\n=== dynamic-macro\n\n**Reference**\n\nRecord and replay key inputs.\n\n.Syntax:\n[source]\n----\n(dynamic-macro-record $id)\n(dynamic-macro-play $id)\n(dynamic-macro-record-stop)\n(dynamic-macro-record-stop-truncate $count)\n----\n\n[cols=\"1,3\"]\n|===\n| `dynamic-macro-record`\n| Record a dynamicro macro which will be saved with the defined `$id`.\n\n| `dynamic-macro-play`\n| Play back a macro saved with the defined `$id`.\n\n| `dynamic-macro-record-stop`\n| Stop and save a macro recording.\nThis can also be achieved by recording a new macro\nor re-pressing record with the same `$id`.\n\n| `dynamic-macro-record-stop-truncate`\n| Stop and save a macro recording while truncating `$count` events\nfrom the end of the recording.\nThis can be useful if the record/stop button is on a different layer.\n|===\n\n**Description**\n\nThe dynamic-macro actions allow for recording and playing key presses. The\ndynamic macro records physical key presses, as opposed to kanata's outputs.\nThis allows the dynamic macro to replicate any action, but it means that if\nthe macro starts and ends on different layers, then the macro might not be\nproperly repeatable.\n\nThe action `dynamic-macro-record` accepts one number (0-65535), which represents\nthe macro ID. Activating this action will begin recording physical key inputs.\nIf `dynamic-macro-record` with the same ID is pressed again, the recording will\nend and be saved. If `dynamic-macro-record` with a different ID is pressed then\nthe current recording will end and be saved, then a new recording with the new\nID will begin.\n\nThe action `dynamic-macro-record-stop` will stop and save any active recording.\nThere is a variant of this:\n`dynamic-macro-record-stop-truncate`\nThis is a list action that takes a single parameter:\nthe number of key actions to remove at the end of a dynamic macro.\nThis variant is useful if the macro stop button is on a different layer.\n\nThe action `dynamic-macro-play` accepts one number (0-65535), which represents\nthe macro ID. Activating this action will play the saved recording of physical\nkeys from a previous `dynamic-macro-record` with the same macro ID, if it exists.\n\nOne can nest dynamic macros within each other, e.g. activate\n`(dynamic-macro-play 1)` while recording with `(dynamic-macro-record 0)`.\nHowever, dynamic macros cannot recurse; e.g. activating `(dynamic-macro-play 0)`\nwhile recording with `(dynamic-macro-record 0)` will be ignored.\n\n.Example:\n[source]\n----\n(defalias\n dr0 (dynamic-macro-record 0)\n dr1 (dynamic-macro-record 1)\n dr2 (dynamic-macro-record 2)\n dp0 (dynamic-macro-play 0)\n dp1 (dynamic-macro-play 1)\n dp2 (dynamic-macro-play 2)\n dms dynamic-macro-record-stop\n dst (dynamic-macro-record-stop-truncate 1)\n)\n----\n\n[[caps-word]]\n=== caps-word\n\n**Reference**\n\nThe `caps-word` action puts Kanata into a state where\ntyped keys are automatically shifted by `lsft`.\nThe state persists until terminated by timeout\nor by typing a key that ends the state.\nTyping a non-terminating key refreshes the timeout duration.\n\nThe `-toggle` variants will end the caps-word state\nif pressed while caps-word is active,\nwhereas the re-pressing the standard variants\nwill keep the state active and refresh the timeout duration.\n\n.Syntax:\n[source]\n----\n(caps-word $timeout)\n(caps-word-toggle $timeout)\n(caps-word-custom $timeout $shifted-list $non-terminal-list)\n(caps-word-custom-toggle $timeout $shifted-list $non-terminal-list)\n----\n\n[cols=\"1,4\"]\n|===\n| `$timeout`\n| Number of milliseconds after which the caps-word state ends.\nThe duration is refreshed upon typing a non-terminating character.\n\n| `$shifted-list`\n| List of keys that will be automatically shifted.\n\n| `$non-terminal-list`\n| List of keys that are not shifted\nbut which do not terminate the caps-word state.\n|===\n\n**Description**\n\nThe `caps-word` or `word⇪` action triggers a state where the `lsft` key\nwill be added to the active key list\nwhen a set of specific keys are active.\nThe keys are: `a-z` and `-`, which will be outputted as `A-Z` and `_`\nrespectively when using the US layout.\n\nExamples where this is helpful\nis capitalizing a single important word\nlike in `IMPORTANT!`\nor defining a constant in code\nlike `const P99_99_VALUE: ...`.\nThis has an advantage over the regular caps lock\nbecause it automatically ends\nso it doesn't need to be toggled off manually,\nand it also shifts `-` to `_`\nwhich caps lock does not do.\n\nThe `caps-word` state ends when the keyboard is idle\nfor the duration of the defined timeout (1st parameter),\nor a terminating key is pressed.\nEvery key is a terminating key\nexcept the keys which get capitalized\nand the extra keys in this list:\n\n- `0-9`\n- `kp0-kp9`\n- `bspc del`\n- `up down left rght`\n\nYou can use `caps-word-custom` or `word⇪-custom` instead of `caps-word`\nif you want to manually define which keys are capitalized (2nd parameter)\nand what the extra non-terminal+non-capitalized keys should be (3rd parameter).\n\n.Example:\n[source]\n----\n(defalias\n cw (caps-word 2000)\n\n ;; This example is similar to the default caps-word behaviour but it moves the\n ;; 0-9 keys to the capitalized key list from the extra non-terminating key list.\n cwc (caps-word-custom\n 2000\n (a b c d e f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9)\n (kp0 kp1 kp2 kp3 kp4 kp5 kp6 kp7 kp8 kp9 bspc del up down left rght)\n )\n)\n----\n\n==== caps-word-toggle[[caps-word-toggle]]\n\nThere are `-toggle` variants of the `caps-word` actions.\nBy default re-pressing `caps-word` will keep `caps-word` active.\nThe `-toggle` variants will end `caps-word` if it is currently active,\notherwise `caps-word` will be activate as normal.\n\n.Example:\n[source]\n----\n(defalias\n cwt (caps-word-toggle 2000)\n cct (caps-word-custom-toggle\n 2000\n (a b c d e f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9)\n (kp0 kp1 kp2 kp3 kp4 kp5 kp6 kp7 kp8 kp9 bspc del up down left rght)\n )\n)\n----\n\n=== unmod[[unmod]]\n\n**Reference**\n\nThe `unmod` action will deactivate modifier keys while outputting\none or more defined keys.\n\n.Syntax:\n[source]\n----\n(unmod $key1 $key2 ... $keyN)\n(unmod ($mod1 $mod2 ... $modN) $key1 $key2 ... $keyN)\n----\n\n[cols=\"1,5\"]\n|===\n| `$key`\n| A key name to output while unmodded.\n\n| `$mod`\n| By default `unmod` will deactivate all modifier keys.\nAn optional list as the first parameter\nallows specfying a subset of modifiers to deactivate during the action.\n|===\n\n**Description**\n\nThe `unmod` action will release all modifiers temporarily\nand send one or more keys.\nAfter the `unmod` key is released, the released modifiers are pressed again.\nThe affected modifiers are: `lsft,rsft,lctl,rctl,lmet,rmet,lalt,ralt`.\n\nA variant of `unmod` is `unshift` or `un⇧`.\nThis action only releases the `lsft,rsft` keys.\nThis can be useful for forcing unshifted keys while AltGr is still held.\n\nNOTE: In case the modifiers to be undone are not part of `defsrc`,\n<> needs to be enabled in `defcfg` in order for their\nstates to be tracked correctly.\n\n.Example:\n[source]\n----\n(defalias\n ;; holding shift and tapping a @um1 key will still output 1.\n um1 (unmod 1)\n ;; dead keys é (as opposed to using AltGr) that outputs É when shifted\n dké (macro (unmod ') e)\n\n ;; In ISO German QWERTZ, force unshifted symbols even if shift is held\n { (unshift ralt 7)\n [ (unshift ralt 8)\n)\n----\n\nA list may optionally be used as the first parameter of `unmod`.\nThe list must be non-empty and must contain only modifier keys,\nwhich are the keys in the affected modifiers list from earlier in this document section.\n\nWhen this list exists, the action will temporarily release only the keys listed\nrather than all modifiers.\n\n.Example:\n[source]\n----\n(defalias\n\t;; only unshift the alt keys\n\tunalt-a (unmod (lalt ralt) a)\n)\n----\n\n[[fork]]\n=== fork\n\n**Reference**\n\nThe `fork` action allows choosing between a default and an alternate action\nbased on whether specific keys are active. `fork` is the equivalent of the\nbasic key checks in `switch`, using none of the list logic items, i.e. virtual\nkeys are not supported.\n\n.Syntax:\n[source]\n----\n(fork $left-action $right-action $right-trigger-keys)\n----\n\n[cols=\"1,3\"]\n|===\n| `$left-action`\n| Action to activate by default.\n\n| `$right-action`\n| Action to activate if any of `$right-trigger-keys` are active.\n\n| `$right-trigger-keys`\n| List of keys that, if active when fork activates,\ncauses `$right-action` to happen in place of `$left-action`.\n|===\n\nTIP: The keys `nop0-nop9` can be used as no-op outputs that\ncan still be checked within `fork`, unlike what `XX` does.\n\n[[switch]]\n=== switch\n\n**Reference**\n\nThe `switch` action allows conditionally activating 0 or more actions,\ndepending on conditional checks.\n\n.Syntax:\n[source]\n----\n(switch\n $logic-check1 $action1 $post-activate1\n $logic-check2 $action2 $post-activate2\n ...\n $logic-checkN $actionN $post-activateN)\n----\n\n[cols=\"1,4\"]\n|===\n| `$logic-check`\n| The condition, which if it evaluates to true,\nwill trigger the corresponding action.\n\n| `$action`\n| Action to activate when logic evaluates to true.\n\n| `$post-activate`\n| Valid values are `fallthrough` and `break`.\nWith `fallthrough`, when an action activates\nswitch will continue evaluating further logic checks\nand potentially trigger more actions.\nWith `break`, further actions will not activate.\n|===\n\nThe logic check is a list.\nThe items within the list can either be key names or a special list check.\nA key name item evaluates to true if that key name\nis a currently active key output of Kanata upon activating `switch`.\nThe outer-most list evaluates to true\nif any of the items evaluates to true.\n\n.Syntax of logic check:\n[source]\n----\n($item1 $item2 ... $itemN)\n----\n\n.Syntax of special checks:\n[source]\n----\n(or $item1 $item2 ... $itemN)\n(and $item1 $item2 ... $itemN)\n(not $item1 $item2 ... $itemN)\n(key-history $key-name $key-recency)\n(key-timing $key-recency $comparator $time)\n(input $input-type $key-name)\n(input-history $input-type $key-name $input-recency)\n(layer $layer-name)\n(base-layer $layer-name)\n----\n\n[cols=\"1,4\"]\n|===\n| `or`\n| Evaluates to true if any `$item` is true.\n\n| `and`\n| Evaluates to true if all of `$item` are true.\n\n| `not`\n| Evaluates to true if all of `$item` are false.\n\n| `key-history`\n| Evaluates to true if the key in the recency slot matches `$key-name`.\nA `$key-recency` of 1 is the most recent key pressed according to Kanata processing.\nThe max recency is 8.\n\n| `key-timing`\n| The valid values for `$comparator` are `less-than` and `greater-than`,\nwith `lt` and `gt` as shorthand if desired.\nThis item evaluates to true if the key with the corresponding recency\nwas pressed — for `lt` more recently than, or for `gt` later than —\nthe defined `$time` with unit milliseconds.\n\n| `input`\n| Evaluates to true if the `$key-name` is currently pressed.\nThe `$input-type` must be either `real` or `virtual`.\nIf using `real`, this will check against the defsrc inputs.\nIf using `virtual`, this will check against virtual key activations.\n\n| `input-history`\n| Evaluates to true if the input in the `$input-recency` slot matches `$key-name`.\nTwo input types use the same history with respect to recency slots.\nA recency of 1 is the most recent input i.e. the input activating `switch` itself.\nThe max recency is 8.\n\n| `layer`\n| Evaluates to true if the active layer matches `$layer-name`.\n\n| `base-layer`\n| Evaluates to true if the most-recently-switched-to layer\nfrom a `layer-switch` action matches `$layer-name`.\n|===\n\n**Description**\n\nConceptually, the `switch` action is similar to <>\nbut has more capabilities as well as more complexity.\nThe `switch` action accepts multiple cases.\nOne case is a triple of:\n\n- logic check\n- action: to activate if logic check evaluates to true\n- `fallthrough|break`: choose to continue vs. stop evaluating cases\n\nThe default use of the logic check behaves similarly to fork.\n\nFor example, the logic check `(a b c)` will activate the corresponding action\nif any of a, b, or c are currently pressed.\n\nTIP: the keys `nop0-nop9` can be used as no-op outputs that\ncan still be checked within `switch`, unlike what `XX` does.\n\nThe logic check also accepts the boolean operators `and|or|not` to allow more\ncomplex use cases.\n\nThe order of cases matters.\nFor example, if two different cases match the currently pressed keys,\nthe case listed earlier in the configuration will activate first.\nIf the early case uses break, the second case will not activate.\nOtherwise if fallthrough is used,\nthe second case will activate sequentially after the first case.\nThis idea generalizes to more than two cases,\nbut the two case example is hopefully simple and effective enough.\n\n.Example:\n[source]\n----\n(defalias\n swt (switch\n ;; case 1\n ((and a b (or c d) (or e f))) @ac1 break\n ;; case 2\n (a b c) @ac2 fallthrough\n ;; case 3\n () @ac3 break\n )\n)\n----\n\nBelow is a description of how this example behaves.\n\n==== Case 1\n\n----\n((and a b (or c d) (or e f))) a break\n----\n\nTranslating case 1's logic check to some other common languages\nmight look like:\n\n----\n(a && b && (c || d) && (e || f))\n----\n\nIf the logic check passes, the action `@ac1` will activate.\nNo other action will activate since `break` is used.\n\n==== Cases 2 and 3\n\n----\n(a b c) c fallthrough\n() b break\n----\n\nCase 2's key check behaves like that of `fork`, i.e.\n\n (or a b c)\n\nor for some other common languages:\n\n a || b || c\n\nIf this logic check passes and the case 1 does not pass,\nthe action `@ac2` will activate first.\nSince the logic check of case 3 always passes, `@ac3` will activate next.\n\nIf neither case 1 or case 2 pass their logic checks,\ncase 3 will always activate with `@ac3`.\n\n[[key-history-and-key-timing]]\n==== key-history and key-timing\n\nIn addition to simple keys there are two list items\nthat can be used within the case logic check\nthat compare against your typed key history:\n\n* `key-history`\n* `key-timing`\n\nThe `key-history` item compares the order that keys were typed.\nIt accepts, in order:\n\n* a key\n* the key recency\n\nThe key recency must be in the range 1-8,\nwhere 1 is the most recent key that was pressed\nand 8 is 8th most recent key pressed.\n\n.Example:\n[source]\n----\n(defalias\n swh (switch\n ((key-history a 1)) S-a break\n ((key-history b 1)) S-b break\n ((key-history c 1)) S-c break\n ((key-history d 8)) (macro d d d) break\n () XX break\n )\n)\n----\n\nThe `key-timing` compares how long ago recent key typing events occurred.\nIt accepts, in order,\n\n* the key recency\n* a comparison string, which is one of: `less-than|greater-than|lt|gt`\n* number of milliseconds to compare against\n\nThe key recency must be in the range 1-8,\nwhere 1 is the most recent key that was pressed\nand 8 is 8th most recent key pressed.\nMost use cases are expected to use a value of 1 for this parameter,\nbut perhaps you can find a creative use for the other values.\n\nThe comparison string determines how the actual key event timing\nwill be compared to the provided timing.\n\nThe number of milliseconds must be 0-65535.\n\nWARNING: The maximum milliseconds value of this configuration item\nacross your whole configuration\nwill be a lower bound of how long it takes for kanata to become idle\nand stop processing its state machine every approximately 1ms.\n\n.Example:\n[source]\n----\n(defalias\n swh (switch\n ((key-timing 1 less-than 200)) S-a break\n ((key-timing 1 greater-than 500)) S-b break\n ((key-timing 2 lt 1000)) S-c break\n ((key-timing 8 gt 2000)) (macro d d d) break\n () XX break\n )\n)\n----\n\n==== not\n\nThe examples presented so far have not included the `not` boolean operator.\nThis operator will now be discussed.\nSyntactically, the `not` operator is used similarly to `or|and`.\nFunctionally, it means \"not **any** of\" the list elements.\n\n.Example:\n[source]\n----\n(defalias\n swn (switch\n ((not x y z)) S-a break\n ;; the above and below cases are equivalent in logic\n ((not (or x y z))) S-a break\n )\n)\n----\n\nIn potentially more familiar notation, both cases have the logic:\n\n !(x || y || z)\n\n==== input\n\nUntil now, all `switch` logic has been associated to key code outputs.\nIt is also possible to operate on inputs.\nInputs can be either real keys or \"virtual\" (fake) keys.\n\n.Example:\n[source]\n----\n(defalias switch-input-example\n (switch\n ((input real lctl)) $ac1 break\n ((input virtual vk1)) $ac2 break\n () $ac3 break\n )\n)\n----\n\nSimilar to `key-history` for regular active keys, `input-history` also exists.\nA perhaps surprising, but hopefully logical, behaviour of input-history\nwhen compared to key-history is that, at the time of switch activation,\nthe history of `input-history` for recency `1` will be the just-pressed input.\nIn other words recency `1` is the input activating the `switch` action itself.\nWhereas with `key-history` for example, the key that will be next outputted\nmay be determined by the switch logic itself, so is not in the history.\nThe consequence of this is that you should use a recency of `2`\nwhen referring to the previously pressed input\nbecause the current input is in the recency `1` slot.\n\n.Example:\n[source]\n----\n(defalias switch-input-history-example\n (switch\n ((input-history real lsft 2)) $var1 break\n ((input-history virtual vk2 2)) $var1 break\n () $ac3 break\n )\n)\n----\n\n==== layer\n\nThe `layer` list item can be used in `switch` logic to operate on the active layer.\nIt accepts a single layer name\nand evaluates to true if the configured layer name is the active layer,\notherwise it evaluates to false.\n\n.Example:\n[source]\n----\n(defalias switch-layer-example\n (switch\n ((layer base)) x break\n ((layer other)) y break\n () z break\n )\n)\n----\n\n==== base-layer\n\nThe `base-layer` list item evaluates to true\nif the configured layer name is the base layer.\nThe base layer is the most recently switched-to layer\nfrom a `layer-switch` action,\nor the first layer defined in your configuration\nif `layer-switch` has never been activated.\n\n.Example:\n[source]\n----\n(defalias switch-layer-example\n (switch\n ((base-layer base)) x break\n ((base-layer other)) y break\n () z break\n )\n)\n----\n\n\n[[cmd]]\n=== cmd\n\nWARNING: This action does not work unless you use the appropriate binary\nor - if compiling yourself - the appropriate feature flag.\nAdditionally you must add the <> `defcfg` option.\n\n**Reference**\n\nThe `cmd` action allows you to execute arbitrary binaries with arbitrary arguments.\nThe `cmd-log` variant behaves similarly but allows customization\nof the stdout and stderr log levels within Kanata's output logging.\nThe `cmd-output-keys` is like `cmd`, but stdout of the command\nwill be parsed as a list of keys, output chords, and delays similar to <>\nand be typed as kanata outputs.\n\n.Syntax:\n[source]\n----\n(cmd $binary $arg1 $arg2 ... $argN)\n(cmd-log $stdout-log-level $stderr-log-level)\n(cmd-output-keys $binary $arg1 $arg2 ... $argN)\n----\n\n[cols=\"1,3\"]\n|===\n| `$binary`\n| Executable binary to run.\n\n| `$arg`\n| Argument passed into the binary.\n\n| `$stdout-log-level`\n| Log level for stdout of the command. Must be `+debug+`, `+info+`, `+warn+`, `+error+`, or `+none+`.\n\n| `$stderr-log-level`\n| Log level for stderr of the command. Must be `+debug+`, `+info+`, `+warn+`, `+error+`, or `+none+`.\n|===\n\n**Description**\n\nThe `+cmd+` action executes a program with arguments. It accepts one or more\nstrings. The first string is the program that will be run and the following\nstrings are arguments to that program. The arguments are provided to the\nprogram in the order written in the config file.\nLists may also be used within `cmd`\nwhich you may desire to do for reuse via `defvar`.\nLists will be flattened such that arguments are provided to the program\nin the order written in the config file, regardless of list nesting.\nTo be technical, it would be a depth-first flattening (similar to DFS).\n\nCommands are executed directly and not via a shell, so you cannot make\nuse of environment variables or symbols with special meaning.\nFor example `+~+` or `+$HOME+` in Linux will not be\nsubstituted with your home directory.\nIf you want to execute with a shell program\nuse the shell as the first parameter, e.g. `bash` or `powershell.exe`.\n\nThe user executing the command\nis the user that kanata was started with.\nFor example, if kanata was started by root,\nthe command will be run by the root user.\nIf you need to execute as a different user,\non Unix platforms you can use `sudo -u USER`\nbefore the rest of your command to achieve this.\n\n.Example:\n[source]\n----\n(defalias\n cm1 (cmd rm -fr /tmp/testing)\n\n ;; You can use bash -c and then a quoted string to execute arbitrary text in\n ;; bash. All text within double-quotes is treated as a single string.\n cm2 (cmd bash -c \"echo hello world\")\n\n ;; You can prefix commands with sudo -u USER\n ;; to execute commands as a different user.\n cm3 (cmd sudo -u other_user bash -c \"echo goodbye\")\n)\n----\n\nBy default, `+cmd+` logs start of command, completion of command, stdout, and stderr.\nUsing the variant `+cmd-log+`, these log levels can be changed, and even disabled.\nIt takes two arguments, `++` and `++`. `++`\nwill be the level where the command to run, stdout, and stderr are logged.\nThe error channel is logged only if there is a failure with running the\ncommand (typically if the command can't be found, or there is trouble spawning it).\n\nThe valid levels are `+debug+`, `+info+`, `+warn+`, `+error+`, and `+none+`.\n\n.Example:\n[source]\n----\n(defalias\n ;; The first two arguments are the log levels, then just the normal command\n ;; This will only error if `bash` is not found or something else goes\n ;; wrong with the initial execution. Any logs produced by bash will not\n ;; be shown.\n noisy-cmd (cmd-log none error bash -c \"echo hello this produces a log\")\n\n ;; This will only log the output of the command, but it won't start\n ;; because the command doesn't exist.\n ignore-failure-cmd (cmd-log info none thiscmddoesnotexist)\n\n verbose-only-log (cmd-log verbose verbose bash -c \"echo yo\")\n)\n----\n\nThere is a variant of `cmd`: `cmd-output-keys`. This variant reads the output\nof the executed program and reads it as an S-expression, similarly to the\n<>. However — unlike macro — only delays, keys, chords, and\nchorded lists are supported. Other actions are not supported.\n\n[source]\n----\n(defalias\n ;; bash: type date-time as YYYY-MM-DD HH:MM\n pdb (cmd-output-keys bash -c \"date +'%F %R' | sed 's/./& /g' | sed 's/:/S-;/g' | sed 's/\\(.\\{20\\}\\)\\(.*\\)/\\(\\1 spc \\2\\)/'\")\n\n ;; powershell: type date-time as YYYY-MM-DD HH:MM\n pdp (cmd-output-keys powershell.exe \"echo '(' (((Get-Date -Format 'yyyy-MM-dd HH:mm').toCharArray() -join ' ').insert(20, ' spc ') -replace ':','S-;') ')'\")\n)\n----\n\n[[push-msg]]\n=== push-msg\n\nNOTE: This action requires the TCP server to be enabled via the\n<> command line argument.\nIf used without the TCP server enabled, a warning will be logged\nand the action will have no effect.\n\n**Reference**\n\nThe `push-msg` action sends an arbitrary message to all connected TCP clients.\nThis enables communication between your keyboard configuration and external tools\nwithout the security risks or performance overhead of executing shell commands.\n\n.Syntax:\n[source]\n----\n(push-msg $message)\n----\n\n[cols=\"1,3\"]\n|===\n| `$message`\n| A string or S-expression to send to TCP clients.\n Strings are sent as-is; S-expressions are converted to JSON arrays.\n|===\n\n**Description**\n\nThe `push-msg` action broadcasts a message to all TCP clients connected to Kanata's\nTCP server. This is useful for:\n\n- Triggering external tool actions from keyboard shortcuts\n- Layer change notifications to status bars or tray applications\n- Integration with automation tools like Raycast, Alfred, or Hammerspoon\n- Controlling other applications without spawning shell processes\n\nMessages are sent as newline-terminated JSON in the format:\n\n[source,json]\n----\n{\"MessagePush\":{\"message\":\"your-message-here\"}}\n----\n\nCompared to the <> action, `push-msg` offers:\n\n- **Better security**: No shell execution, no privilege escalation risks\n- **Better performance**: Sub-millisecond latency vs ~100ms for command execution\n- **No special flags**: Does not require `danger-enable-cmd` in defcfg\n\n.Example - Basic messages:\n[source]\n----\n(defalias\n ;; Send a simple string message\n notify (push-msg \"key-pressed\")\n\n ;; Send layer change notification\n nav-on (push-msg \"layer:nav:activated\")\n nav-off (push-msg \"layer:nav:deactivated\")\n)\n----\n\n.Example - Integration with external tools:\n[source]\n----\n(defalias\n ;; Trigger a Raycast extension\n raycast-clip (push-msg \"raycast:clipboard-history\")\n\n ;; Control media playback via external script\n play-pause (push-msg \"media:toggle\")\n next-track (push-msg \"media:next\")\n\n ;; Switch keyboard layouts via external tool\n layout-next (push-msg \"xkb:next-layout\")\n)\n----\n\n.Example - Using with defvirtualkeys for external triggering:\n[source]\n----\n;; Define virtual keys that can be triggered via TCP's ActOnFakeKey command\n;; External tools can trigger these using: {\"ActOnFakeKey\":{\"name\":\"email-sig\",\"action\":\"Tap\"}}\n(defvirtualkeys\n email-sig (macro S-b e s t spc r e g a r d s , ret ret S-j o h n)\n nav-mode (layer-switch nav)\n)\n\n;; Combine push-msg with other actions\n(defalias\n launch-term (multi\n (push-msg \"app:launch:terminal\")\n (layer-switch base)\n )\n)\n----\n\nTo receive these messages, connect a TCP client to Kanata's server port.\nSee the https://github.com/jtroo/kanata/blob/main/example_tcp_client/src/main.rs[example TCP client]\nfor implementation guidance.\n\n[[clipboard-actions]]\n=== clipboard actions\n\n**Reference**\n\nClipboard actions can manipulate the operating system clipboard\nalongside \"save ids\".\nTo paste, you would use an action such as `C-v`;\nKanata has no builtin paste action.\n\n.Syntax:\n[source]\n----\n(clipboard-set $clipboard-string)\n(clipboard-save $save-id)\n(clipboard-restore $save-id)\n(clipboard-save-swap $save-id $save-id)\n(clipboard-cmd-set $binary $arg1 $arg2 ... $argN)\n(clipboard-save-cmd-set $save-id $binary $arg1 $arg2 ... $argN)\n----\n\n[cols=\"1,3\"]\n|===\n| `clipboard-set`\n| Sets the clipboard to the specified string.\n\n| `clipboard-save`\n| Saves the current clipboard content with the specified ID.\n\n| `clipboard-restore`\n| Sets the clipboard to content saved with the specified ID.\nIf the save ID content is blank, this will do nothing.\n\n| `clipboard-save-swap`\n| Swaps the content of two save IDs.\n\n| `clipboard-cmd-set`\n| Sets the clipboard to the output of the command.\nThe current content of the clipboard is passed to stdin of the command\nif the current content is text.\nIf the content is an image, nothing is passed to stdin.\n\n| `clipboard-save-cmd-set`\n| Sets the save ID content to the output of the command.\nThe current content of the save ID is passed to stdin of the command\nif the current content is text.\nIf the content is an image, nothing is passed to stdin.\n\n| `$clipboard-string`\n| Fixed string to set the operating system clipboard to.\n\n| `$save-id`\n| A number `0-65535` representing an ID of saved clipboard content.\n\n| `$binary`\n| Executable binary to run.\n\n| `$arg`\n| Argument passed into the binary.\n|===\n\n**Description**\n\nYou can use clipboard actions to save clipboard content,\npaste arbitrary content,\nand then restore the original clipboard content.\nThis functionality is similar to what some text expanders do.\nYou can additionally use shell commands to manipulate\nclipboard content in arbitrary ways.\nThis can all be done in a single command via <>.\n\nNote that you will likely want to add delays in between components,\nbecause clipboard systems take some time to propagate updates.\n\nThe example below is a macro that pastes the content of the clipboard\ntwice with a space in between,\nwhile restoring the original clipboard content at the end.\nNotable is that the example uses `C-v` but this may not work for you.\nIf you have OS-level remapping, the `v` may be different\nto effectively paste.\nSomething that may also work is `S-ins`\n\n.Example:\n[source]\n----\n(macro\n (clipboard-save 0)\n 20\n (clipboard-cmd-set powershell.exe -c r#\"$v = ($Input | Select-Object -First 1); Write-Host -NoNewLine \"$v $v\"\"#)\n 300\n C-v\n (clipboard-restore 0)\n)\n----\n\nAs another example you can use templates\nwith clipboard actions to have a convenient clipboard-based\ntext output while preserving the old clipboard content.\nThis can fit the use case of \"text expansion\".\n\n.Example:\n[source]\n----\n(deftemplate text-paste (text)\n (macro\n (clipboard-save 0)\n 20\n (clipboard-set $text)\n 300\n C-v\n (clipboard-restore 0)\n ))\n\n(defalias\n myalias1 (t! text-paste \"Hello world\")\n myalias2 (t! text-paste \"Goodbye my old friend\")\n)\n----\n\n[[arbitrary-code]]\n=== arbitrary-code\n\nThe `arbitrary-code` action allows sending an arbitrary number to kanata's\noutput mechanism. The press is sent when pressed, and the release sent when\nreleased. This action can be useful for testing keys that are not yet named or\nmapped in kanata. Please contribute findings with names and mappings, either in\na GitHub issue or as a pull request!\n\nWARNING: This is not cross platform!\n\nWARNING: When using the Interception driver, this action is still sent over\nSendInput.\n\n[source]\n----\n(defalias ab1 (arbitrary-code 700))\n----\n\n[[global-overrides]]\n== Global overrides\n\nThe `defoverrides` optional configuration item allows you to create global\nkey overrides, irrespective of what actions are used to generate those keys.\nIt accepts pairs of lists:\n\n1. the input key list that gets replaced\n2. the output key list to replace the input keys with\n\nBoth input and output lists accept 0 or more modifier keys (e.g. lctl, rsft)\nand exactly 1 non-modifier key (e.g. 1, bspc).\n\nOnly zero or one `defoverrides` is allowed in a configuration file.\n\nNOTE: Depending on your use case\nyou may want to adjust <> in `defcfg`.\n\n.Example:\n[source]\n----\n;; Swap numbers and their symbols with respect to shift\n(defoverrides\n (1) (lsft 1)\n (2) (lsft 2)\n ;; repeat for all remaining numbers\n\n (lsft 1) (1)\n (lsft 2) (2)\n ;; repeat for all remaining numbers\n)\n----\n\n[[defoverridesv2]]\n=== defoverridesv2\n\nThere is a more recent version of defoverrides that offers more customizability.\nInstead of 2 list items per override entry,\n`defoverridesv2` mandates 4, though the extra 2 can be empty.\n\nYou cannot have both a v1 and v2 of `defoverrides` at the same time.\n\nThe 3rd item is an \"exclude modifiers list\" which is composed of modifier key names\n(such as `lctl`, `lalt`) that, if held, will disable the override from activating.\n\nNOTE: if all excluded list modifiers are released while the\noverride input is still active, the override will activate.\nYou can avoid this by ensuring to always release the non-modifier key\nbefore releasing any modifiers.\n\nThe 4th item is an \"exclude layers\" list which is composed of layer names\nthat while active as the most recent `layer-switch` or `layer-while-held`,\nwill disable the override from activating.\n\nNOTE: if the layer changes while the override input is still active,\nthe override will activate.\n\n.Example:\n[source]\n----\n(defoverridesv2\n ;; lctl+a will become lalt+9\n ;; except when lsft is held or other-layer is active.\n (lctl a) (lalt 9) (lsft) (other-layer))\n\n ;; lctl+b will always become lalt+0\n (lctl b) (lalt 0) () ()\n)\n----\n\n[[templates]]\n== Templates\n\nThe top-level configuration item `deftemplate`\ndeclares a template that can be expanded multiple times\nvia the list item `template-expand`.\nThe short form of `template-expand` is `t!`.\n\nThe parameters to `deftemplate` in order are:\n\n* Template name\n* List of template variables\n* Template content (any combination of lists / strings)\n\nWithin the template content, variable names prefixed with `$`\nwill be substituted with the expression passed into `template-expand`.\n\nThe list item `template-expand` can be placed as a top-level list\nor within another list.\nIts parameters in order are:\n\n* template name\n* parameters to substitute into the template\n\nNOTE: Template expansion happens after file includes and before any other parsing.\nOne consequence of this early parsing is that variables defined in `defvar`\nare **not** substituted when used inside of `template-expand`.\nThis has consequences for condtional content, e.g. with `if-equal`.\nThis is discussed further in Example 5.\n\nExample 1:\n\nIn a simple example, let's say you wanted to set a large group of keys\nto do something different when you're holding alt. Yes, this could also\nbe handled with remapping alt to a layer shift, but there are cases where\nyou wouldn't want this. Rather than retyping the code with `fork` and\n`unmod` (to release alt) a bunch of times, you could template it like so:\n[source]\n----\n(deftemplate alt-fork (original-action new-action)\n (fork $original-action (multi (unmod (ralt lalt) nop0) $new-action) (lalt ralt))\n)\n(defsrc 1 2 3)\n(defalias fn1 (template-expand alt-fork 1 f1))\n;; Templates are a simple text substitution, so the above is exactly equivalent to:\n;; (defalias fn1 (fork 1 (multi (unmod (ralt lalt) nop0) f1) (lalt ralt)))\n(defalias fn2 (template-expand alt-fork 2 f2))\n;; You can use t! as a short form of template-expand\n(defalias fn3 (t! alt-fork 3 f3))\n(deflayer default @fn1 @fn2 @fn3)\n----\n\n.Example 2:\n[source]\n----\n(defvar chord-timeout 200)\n(defcfg process-unmapped-keys yes)\n\n;; This template defines a chord group and aliases that use the chord group.\n;; The purpose is to easily define the same chord position behaviour\n;; for multiple layers that have different underlying keys.\n(deftemplate left-hand-chords (chordgroupname k1 k2 k3 k4 alias1 alias2 alias3 alias4)\n (defalias\n $alias1 (chord $chordgroupname $k1)\n $alias2 (chord $chordgroupname $k2)\n $alias3 (chord $chordgroupname $k3)\n $alias4 (chord $chordgroupname $k4)\n )\n (defchords $chordgroupname $chord-timeout\n ($k1) $k1\n ($k2) $k2\n ($k3) $k3\n ($k4) $k4\n ($k1 $k2) lctl\n ($k3 $k4) lsft\n )\n)\n\n(template-expand left-hand-chords qwerty a s d f qwa qws qwd qwf)\n;; t! is short for template-expand\n(t! left-hand-chords dvorak a o e u dva dvo dve dvu)\n\n(defsrc a s d f)\n(deflayer dvorak @dva @dvo @dve @dvu)\n(deflayer qwerty @qwa @qws @qwd @qwf)\n----\n\n.Example 3:\n[source]\n----\n;; This template defines a home row that customizes a single key's behaviour\n(deftemplate home-row (j-behaviour)\n a s d f g h $j-behaviour k l ; '\n)\n\n(defsrc\n grv 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n ;; usable even inside defsrc\n caps (t! home-row j) ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n\n(deflayer base\n grv 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n ;; lists can be passed in too!\n caps (t! home-row (tap-hold 200 200 j lctl)) ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n----\n\n=== if-equal\n\nWithin a template you can use the list item `if-equal`\nto have condiditionally-used items within a template.\n\nIt accepts a minimum of 2 parameters.\nThe first two parameters must be strings and are compared\nagainst each other.\nIf they match, the following parameters are inserted into\nthe template in place of the `if-equal` list.\nOtherwise if the strings do not match\nthen the whole `if-equal` list is removed from the template.\n\n.Example 4:\n----\n(deftemplate home-row (version)\n a s d f g h\n (if-equal $version v1 j)\n (if-equal $version v2 (tap-hold 200 200 j lctl))\n k l ; '\n)\n\n(defsrc\n grv 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n caps (template-expand home-row v1) ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n\n(deflayer base\n grv 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p [ ] \\\n caps (template-expand home-row v2) ret\n lsft z x c v b n m , . / rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n----\n\nSimilar to `if-equal` are three more conditional operators for templates:\n\n* `if-not-equal`\n** the content is used if the first two string parameters are not equal\n* `if-in-list`\n** the content is used if the first string parameter exists in\nthe second list-of-strings parameter\n* `if-not-in-list`\n** the content is used if the first string parameter does not exist in\nthe second list-of-strings parameter\n\n.Example 5:\n----\n;; defvar is parsed AFTER template expansion occurs.\n(defvar a hello)\n\n(deftemplate template1 (var1)\n a (if-equal hello $var1 b) c\n)\n\n;; Below will expand to: `a c` because the string\n;; $a itself is compared against the string hello\n;; and they are not equal.\n(template-expand template1 $a)\n\n(deftemplate template2 (var1)\n a (if-equal $a $var1 b) c\n)\n\n;; Below will expand to: `a b c` because the string\n;; $a is compared against the string $a and they are equal.\n;; But note that the variable $a is still not substituted\n;; with its defvar value of: hello.\n(template-expand template2 $a)\n----\n\n[[concat-in-deftemplate]]\n=== concat in deftemplate\n\nLike <>,\na list beginning with `concat` within the content of `deftemplate`\nwill be replaced with a single string that consists of\nall the subsequent items in the list concatenated to each other.\n\n== Include other files[[include]]\n\nThe `include` optional configuration item\nallows you to include other files into the configuration.\nThis configuration accepts a single string which is a file path.\nThe file path can be an absolute path or a relative path.\nThe path will be relative to the defined configuration file.\n\nAt the time of writing, includes can only be placed at the top level.\nThe included files also cannot contain includes themselves.\n\nNon-existing files will be ignored.\n\n.Example:\n----\n;; This is in the file initially read by kanata, e.g. kanata.kbd\n(include other-file.kbd)\n\n;; This is in the other file\n(defalias\n included-alias XX\n ;; ...\n)\n\n;; This is in the other file\n(deflayer included-layer\n ;; ...\n)\n----\n\n[[platform]]\n== Platform-specific configuration\n\nIf you put any top-level configuration item\nwithin a list beginning with `platform`,\nit will become a platform-specific configuration\nthat is only active for the specified platforms.\n\n.Syntax:\n[source]\n----\n(platform (applicable-platforms) ...)\n----\n\nThe valid values for applicable platforms are:\n\n- `win`\n- `winiov2`\n- `wintercept`\n- `linux`\n- `macos`\n\n.Example:\n[source]\n----\n(platform (macos)\n ;; Only on macos, use command arrows to jump/delete words\n ;; because command is used for so many other things\n ;; and it's weird that these cases use alt.\n (defoverrides\n (lmet bspc) (lalt bspc)\n (lmet left) (lalt left)\n (lmet right) (lalt right)\n )\n)\n\n(platform (win winiov2 wintercept)\n (defalias run-my-script (cmd #| something involving powershell |#))\n)\n\n(platform (macos linux)\n (defalias run-my-script (cmd #| something involving bash |#))\n)\n----\n\n[[environment]]\n== Environment-conditional configuration\n\n.Syntax:\n[source]\n----\n(environment (env-var-name env-var-value) ...)\n----\n\nThe items `env-var-name` and `env-var-value` can be arbitrary strings.\nThe name is the environment variable that is read\nfor determining if the configuration is used or not.\nIf the value of the environment variable (set only on kanata startup)\nmatches `env-var-value`, the configuration is used; otherwise it is ignored.\nAn empty string for `env-var-value` — `\"\"` — will use the configuration\nif the environment variable is an empty string\nand also if the environment variable is not defined.\n\n.Example:\n[source]\n----\n(environment (LAPTOP lp1)\n (defalias met @lp1met)\n)\n\n(environment (LAPTOP lp2)\n (defalias met @lp2met)\n)\n----\n\n.Set environment variables in the current terminal process:\n[source]\n----\n# powershell\n$env:VAR_NAME = \"var_value\"\n\n# bash\nVAR_NAME=var_value\n----\n\n\n[[input-chords-v2]]\n== Input chords / combos (v2)\n\nYou may define a single `+defchordsv2+` configuration item.\nThis enables you to define global input chord behaviour.\nOne might also find this functionality called another name of \"combos\"\nin other projects.\n\nInput chords enables you to press two or more keys in quick succession\nto activate a different action\nthan would normally be associated with those keys.\nWhen activating a chord, the order of presses is not important;\nwhen all keys belonging to a chord are pressed,\nthe action activates regardless of press order.\n\nThe `+defchordsv2+` feature is configured as shown below:\n\n.Syntax example\n[source]\n----\n(defchordsv2\n (participating-keys1) action1 timeout1 release-behaviour1 (disabled-layers1)\n ...\n (participating-keysN) actionN timeoutN release-behaviourN (disabled-layersN)\n)\n----\n\nThe configuration is made up of 5-tuples of:\n\n[cols=\"1,3\"]\n|===\n| `$participating-keys`\n| These are key names you would use in `defsrc`.\nA minimum of two keys must be defined per chord.\nThe list must be unique per chord.\n\n| `$action`\n| These are actions as you would configure in `deflayer` or `defalias`.\nThe action activates if all participating keys are activated\nwithin the timeout.\n\n| `$timeout`\n| The time (unit: milliseconds) within which,\nif all participating keys are pressed,\nthe chord action will activate;\notherwise the key presses are handled by the active layer.\nThe time begins when the first participant is pressed.\n\n| `$release-behaviour`\n| This must be either `first-release` or `all-released`;\n`first-release` means the chord action will be released\nwhen the first participant is released,\nwhile `all-released` means the chord action will be released\nonly when all of the participants have been released.\n\n| `$disabled-layers`\n| A list of layer names on which this chord is disabled.\n|===\n\nInput chords have a related `defcfg` item: <>.\nWhen any non-chord activation happens,\na timeout begins with duration configured by\n`chords-v2-min-idle` (unit: milliseconds).\nUntil this timeout expires, all inputs will immediately skip\nchords processing and be processed by the active layer.\n\nIMPORTANT: When opting into input chords v2,\nyou must enable `concurrent-tap-hold`.\nThis is enforced for a more responsive `tap-hold` experience when\nactivated by a chord.\n\n.Example:\n[source]\n----\n(defcfg concurrent-tap-hold yes)\n(defchordsv2\n (a s) c 200 all-released (non-chord-layer)\n (a s d) (macro h e l l o) 250 first-release (non-chord-layer)\n (s d f) (macro b y e) 400 first-release (non-chord-layer)\n)\n----\n\nNOTE: Also see <>,\nwhich are configured differently and can be defined per-layer.\n\n[[chordsv2-processing-order]]\n=== Action processing order\n\nThe chordsv2 system handles keys before any layer action handling.\nThis has a consequence of not entering the delay and interruption flow\nof actions such as `tap-hold-release`.\n\nIf you want a chordsv2 action activation to be processed\nby the aforementioned category of actions\nyou can move the action into a virtual key\n(see <>) and have the chordsv2 action\npress and release the virtual key.\n\nSee a sample below that showcases a reusable template.\n\n.Example:\n[source]\n----\n(defcfg concurrent-tap-hold yes)\n(defsrc)\n(deflayermap (base)\n caps (tap-hold-release 0 200 esc lctl))\n\n;; defines a vkey named v-$key, example v-bspc\n;; and an alias @v-bspc that press and and releases the v-key\n;; within on-press and on-release respectively.\n(deftemplate v- (key)\n (defvirtualkeys (concat v- $key) $key)\n (defalias (concat v- $key)\n (multi (on-press press-vkey (concat v- $key)) (on-release release-vkey (concat v- $key))))\n)\n\n(t! v- bspc)\n(t! v- del)\n(defchordsv2\n (j k) @v-bspc 75 first-release ()\n (s d) @v-del 75 first-release ()\n)\n----\n\n[[optional-defcfg-options]]\n== defcfg options\n\n[[danger-enable-cmd]]\n=== danger-enable-cmd\n\nThis option can be used to enable the `cmd` action in your configuration. The\n`+cmd+` action allows kanata to execute programs with arguments passed to them.\n\nThis requires using a kanata program that is compiled with the `cmd` action\nenabled. The reason for this is so that if you choose to, there is no way for\nkanata to execute arbitrary programs even if you download some random\nconfiguration from the internet.\n\nThis configuration is disabled by default and can be enabled by giving it the\nvalue `yes`.\n\n.Example:\n[source]\n----\n(defcfg\n danger-enable-cmd yes\n)\n----\n\n[[sequence-timeout]]\n=== sequence-timeout\n\nThis option customizes the key sequence timeout (unit: ms). Its default value\nis 1000. The purpose of this item is explained in <>.\n\n.Example:\n[source]\n----\n(defcfg\n sequence-timeout 2000\n)\n----\n\n[[sequence-input-mode]]\n=== sequence-input-mode\n\nThis option customizes the key sequence input mode. Its default value when not\nconfigured is `hidden-suppressed`.\n\nThe options are:\n\n- `visible-backspaced`: types sequence characters as they are inputted. The\n typed characters will be erased with backspaces for a valid sequence termination.\n- `hidden-suppressed`: hides sequence characters as they are typed. Does not\n output the hidden characters for an invalid sequence termination.\n- `hidden-delay-type`: hides sequence characters as they are typed. Outputs the\n hidden characters for an invalid sequence termination either after a\n timeout or after a non-sequence key is typed.\n\nFor `visible-backspaced` and `hidden-delay-type`, a sequence leader input will\nbe ignored if a sequence is already active. For historical reasons, and in case\nit is desired behaviour, a sequence leader input using `hidden-suppressed` will\nreset the key sequence.\n\nSee <> for more about sequences.\n\n.Example:\n[source]\n----\n(defcfg\n sequence-input-mode visible-backspaced\n)\n----\n\n\n[[sequence-backtrack-modcancel]]\n=== sequence-backtrack-modcancel\n\nThis option customizes the behaviour of key sequences\nwhen modifiers are used.\nThe default is `yes` and can be overridden to `no` if desired.\n\nSetting it to `yes` allows both `fk1` and `fk2` to be activated\nin the following configuration, but with `no`,\n`fk1` will be impossible to activate\n\n----\n(defseq\n fk1 (lsft a b)\n fk2 (S-(c d))\n)\n----\n\nSee <> for more about sequences and\nhttps://github.com/jtroo/kanata/blob/main/docs/sequence-adding-chords-ideas.md[this document]\nfor more context about this specific configuration.\n\n.Example:\n[source]\n----\n(defcfg\n sequence-backtrack-modcancel no\n)\n----\n\n[[log-layer-changes]]\n=== log-layer-changes\n\nBy default, kanata will log layer changes. However, logging has some processing\noverhead. If you do not care for the logging, you can choose to disable it.\n\n.Example:\n[source]\n----\n(defcfg\n log-layer-changes no\n)\n----\n\nIf `+--log-layer-changes+` is passed as a command line argument,\na `no` in the configuration file will be overridden\nand layer changes will again be logged.\nThis flag can be helpful when testing new configuration changes\nwhile keeping the default behaviour as \"no logging\" to save on processing,\nso that the `defcfg` item does not need to be adjusted back and forth\nwhen experimenting vs. stable usage.\n\n[[delegate-to-first-layer]]\n=== delegate-to-first-layer\n\n\nBy default, transparent keys on layers\nwill delegate to the corresponding defsrc key\nwhen found on a layer activated by `layer-switch`.\n\nThis config entry changes the behaviour\nto delegate to the action in the same position on the first layer defined\nin the configuration, which is the active layer on startup.\n\nFor more context, see https://github.com/jtroo/kanata/issues/435.\n\n.Example:\n[source]\n----\n(defcfg\n delegate-to-first-layer yes\n)\n----\n\n\n[[movemouse-inherit-accel-state]]\n=== movemouse-inherit-accel-state\n\nBy default `movemouse-accel` actions will track the acceleration\nstate for vertical and horizontal axes separately.\n\nWhen this setting is enabled, `movemouse-accel` will behave exactly like mouse movements in https://qmk.fm[QMK],\ni.e. the acceleration state of new mouse\nmovement actions will be inherited if others are already being pressed.\n\n.Example:\n[source]\n----\n(defcfg\n movemouse-inherit-accel-state yes\n)\n----\n\n[[movemouse-smooth-diagonals]]\n=== movemouse-smooth-diagonals\n\nBy default, mouse movements move one direction at a time\nand vertical/horizontal movements are on independent timers.\n\nThis can result in non-smooth diagonals when drawing a line in some app.\nThis option adds a small imperceptible amount of latency to\nsynchronize the mouse movements.\n\n.Example:\n[source]\n----\n(defcfg\n movemouse-smooth-diagonals yes\n)\n----\n\n=== dynamic-macro-max-presses [[dynamic-macro-max-presses]]\n\nThis configuration allows you to customize the length limit on dynamic macros.\nThe default length limit is 128 keys.\n\n.Example:\n[source]\n----\n(defcfg\n dynamic-macro-max-presses 1000\n)\n----\n\n=== concurrent-tap-hold [[concurrent-tap-hold]]\nThis configuration makes multiple tap-hold actions\nthat are activated near in time expire their timeout quicker.\nBy default this is disabled.\nWhen disabled, the timeout for a following tap-hold\nwill start from 0ms **after** the previous tap-hold expires.\nWhen enabled, the timeout will start\nas soon as the tap-hold action is pressed\neven if a previous tap-hold action is still held and has not expired.\n\n.Example:\n[source]\n----\n(defcfg\n concurrent-tap-hold yes\n)\n----\n\n[[block-unmapped-keys]]\n=== block-unmapped-keys\n\nIf you desire to use only a subset of your keyboard\nyou can use `block-unmapped-keys` to make every key\nother than those that exist in `defsrc` a no-op.\n\nNOTE: this only functions correctly if you also set\n<> to yes.\n\n.Example:\n[source]\n----\n(defcfg\n block-unmapped-keys yes\n)\n----\n\n[[rapid-event-delay]]\n=== rapid-event-delay\n\nThis configuration applies to the following events:\n\n* the release of one-shot-press activation\n* the release of the tapped key in a tap-hold activation\n* a non-eager tap-dance activation from interruption by another key\n* input chord activations, both v1 and v2\n\nKey event processing is paused the defined number of milliseconds (approximate).\nThe default value is 5.\n\nThere will be a minor input latency impact in the mentioned scenarios.\nSince 5ms is 1 frame at 200 Hz refresh rate,\nin most scenarios this will not be perceptible.\n\nThe reason for this configuration existing is that some environments\ndo not process the scenarios correctly due to the rapidity of key events.\nKanata does send the events in the correct order,\nso the fault is more in the environment,\nbut kanata provides a workaround anyway.\n\nIf you are negatively impacted by the latency increase of these events\nand your environment is not impacted by increased rapidity,\nyou can reduce the value to a number between 0 and 4.\n\n.Example:\n[source]\n----\n(defcfg\n ;; If your environment is particularly buggy, might need to delay even more\n rapid-event-delay 20\n)\n----\n\n[[chords-v2-min-idle]]\n=== chords-v2-min-idle\n\nThis configuration affects the timer during which chords processing is disabled.\nNOTE: For more info, see <>.\n\nThe default (and minimum) value is `5` and the unit is milliseconds.\n\n.Example:\n[source]\n----\n(defcfg\n chords-v2-min-idle 200\n)\n----\n\n[[tap-hold-require-prior-idle]]\n=== tap-hold-require-prior-idle\n\nThis configuration applies to all `tap-hold` variants.\nWhen a different physical key was pressed within the configured number of\nmilliseconds before a `tap-hold` key is pressed, the `tap-hold` key will\nimmediately resolve as its tap action without entering the waiting state.\nThis prevents accidental modifier activations during fast typing.\nThe concept is equivalent to ZMK's `require-prior-idle-ms`.\n\nNOTE: For more info, see <>.\n\nThe default value is `0` (disabled) and the unit is milliseconds.\n\n.Example:\n[source]\n----\n(defcfg\n tap-hold-require-prior-idle 150\n)\n----\n\n- If you type a normal key and then press a `tap-hold` key within the threshold,\n the `tap-hold` key immediately outputs its tap action.\n- If the keyboard is idle for longer than the threshold before pressing a `tap-hold` key,\n normal `tap-hold` behavior applies (waiting state, hold on timeout, etc.).\n- When `tap-hold-require-prior-idle` triggers, the tap action is chosen before any other\n `tap-hold` configuration (e.g., `tap-hold-opposite-hand`, `concurrent-tap-hold`)\n is consulted.\n\n==== Per-action override\n\nThe global `tap-hold-require-prior-idle` value can be overridden on individual\n`tap-hold` actions using the `(require-prior-idle )` option.\nThis is useful when most keys benefit from idle detection (e.g., home-row mods)\nbut specific keys (e.g., a layer-tap key) need immediate activation even during\nfast typing.\n\nThe option can be appended to any `tap-hold` variant as a trailing\n`(keyword value)` list:\n\n.Example: disable for a specific key\n[source]\n----\n(defcfg tap-hold-require-prior-idle 150)\n(defalias\n ;; HRMs use the global 150ms threshold\n a (tap-hold 200 200 a lmet)\n s (tap-hold 200 200 s lalt)\n ;; Layer key disables idle detection for immediate activation\n nav (tap-hold 200 200 tab (layer-toggle nav) (require-prior-idle 0))\n)\n----\n\n.Example: enable for a specific key without a global setting\n[source]\n----\n(defalias\n a (tap-hold 200 200 a lmet (require-prior-idle 150))\n)\n----\n\n- `(require-prior-idle 0)` disables the feature for that action,\n even when a global threshold is set.\n- A non-zero value enables or changes the threshold for that action only.\n- When no per-action override is specified, the global `defcfg` value is used.\n- Works with all `tap-hold` variants: `tap-hold`, `tap-hold-press`,\n `tap-hold-release`, `tap-hold-press-timeout`, `tap-hold-release-timeout`,\n `tap-hold-release-keys`, `tap-hold-except-keys`, `tap-hold-tap-keys`,\n and `tap-hold-opposite-hand`.\n\n[[override-release-on-activation]]\n=== override-release-on-activation\n\nThis configuration item changes activation behaviour from `defoverrides`.\n\nTake this example override:\n\n[source]\n----\n(defoverrides (lsft a) (lsft 9))\n----\n\nThe default behaviour is that if `lsft` is released **before** releasing `a`,\nkanata's behaviour would be to send `a`.\n\nA future improvement could be to make the `9` continue to be the key held,\nbut that is not implemented today.\n\nThe workaround in case the above behaviour negatively impacts your workflow\nis to enable this configuration.\nThis configuration will press and then immediately release the `9` output\nas soon as the override activates, meaning you are unlikely as a human to ever\nrelease `lsft` first.\n\nThe effect of this configuration is that the `9` key cannot remain held\nwhen activated by the override which is important to consider for your use cases.\n\n.Example:\n[source]\n----\n(defcfg\n override-release-on-activation yes\n)\n----\n\n[[allow-hardware-repeat]]\n=== allow-hardware-repeat\n\nBy default, any repeat-key events generated by the physical keyboard (or operating system)\nwill be passed through to the application. On Linux, under Wayland, this is wasted effort\nsince the DE handles key-repeat on its own. Such events can also be distracting when\ndebugging your configuration with evtest, etc.\n\nSetting this option to \"false\" will cause such events to be dropped, and not passed through.\nThis is primarily meant for Linux, but may find some use on Mac. It is not implemented on\nWindows, and will be silently ignored.\n\n.Example:\n[source]\n----\n(defcfg\n allow-hardware-repeat false\n)\n----\n\n[[alias-to-trigger-on-load]]\n=== alias-to-trigger-on-load\n\nSelect an alias to execute when first starting, and after each\nlive-reload of the config. You can use this to run external\ncommands, or to stack layers (with layer-while-held).\n\nThe name of an alias, without a leading \"@\", is expected as a\nparameter. The example below will beep at startup (assuming\nyour system has a beep command), and will already be blocking\nthe swapped \"i\" and \"o\" keys.\n\n.Example:\n[source]\n----\n(defcfg\n alias-to-trigger-on-load S\n danger-enable-cmd yes\n)\n\n(deffakekeys B (layer-while-held block))\n\n(defalias\n P (on-press toggle-vkey B)\n S (macro @P (cmd beep))\n)\n\n(defsrc i o p )\n(deflayer base o i @P )\n(deflayer block • • _ )\n----\n\n[[mouse-movement-key]]\n=== Linux or Windows-interception only: mouse-movement-key\n\nAccepts a single key name.\nWhen configured, whenever a mouse cursor movement is received,\nthe configured key name will be \"tapped\" by Kanata,\nactivating the key's action.\n\nThis enables reporting of every relative mouse movement, which\ncorresponds to standard mice, trackballs, trackpads and\ntrackpoints. Absolute movements, which can be generated by\ntouchscreens, drawing tablets and some mouse replacement or\naccessibility software, are ignored. Scrolling events and mouse\nbuttons are also ignored.\n\nThe intended use of these events is to provide a way to automatically\nenable a mouse keys layer while mousing, which can be disabled by a\ntimeout or typing on other keys, rather than explicit toggling. see\ncfg_examples/automousekeys-*.kbd for more.\n\nThe `mvmt` key name is specially intended for this purpose. It has no\noutput key mapping and cannot be supplied as an action; however, any\nkey may be used.\n\nSupports live reload on Linux, but with Windows-interception, this\noption must be present on startup to enable mouse movement event\ncollection, so restart is required to enable it. Changing the key name\nis always supported, however.\n\n.Example:\n[source]\n----\n(defcfg\n process-unmapped-keys yes\n mouse-movement-key mvmt\n)\n\n(defsrc\n k l ;\n mvmt\n)\n\n(defvirtualkeys\n mouse (layer-while-held mouse-layer)\n)\n\n(defalias\n mhld (hold-for-duration 750 mouse)\n)\n\n(deflayer qwerty\n k l ;\n @mhld\n)\n\n(deflayer mouse-layer\n mlft mmid mrgt\n @mhld\n)\n----\n\n[[linux-only-linux-dev]]\n=== Linux only: linux-dev\n\nBy default, kanata will try to detect which input devices are keyboards and try\nto intercept them all. However, you may specify exact keyboard devices from the\n`/dev/input` directories using the `linux-dev` configuration.\n\n.Example:\n[source]\n----\n(defcfg\n linux-dev /dev/input/by-path/platform-i8042-serio-0-event-kbd\n)\n----\n\nIf you want to specify multiple keyboards, you can separate the paths with a\ncolon `+:+`.\n\n.Example:\n[source]\n----\n(defcfg\n linux-dev /dev/input/dev1:/dev/input/dev2\n)\n----\n\nDue to using the colon to separate devices, if you have a device with colons in\nits file name, you must escape those colons with backslashes:\n\n[source]\n----\n(defcfg\n linux-dev /dev/input/path-to\\:device\n)\n----\n\nAlternatively, you can use list syntax, where both backslashes and colons\nare parsed literally. List items are separated by spaces or newlines.\nUsing quotation marks for each item is optional, and only required if an\nitem contains spaces.\n\n[source]\n----\n(defcfg\n linux-dev (\n /dev/input/path:to:device\n \"/dev/input/path to device\"\n )\n)\n----\n\nFor devices that do not have an easily identifiable device path like Bluetooth\nkeyboards using the `linux-dev-names-include` option below is recommended.\n\n[[linux-only-linux-dev-names-include]]\n=== Linux only: linux-dev-names-include\n\nIn the case that `linux-dev` is omitted,\nthis option defines a list of device names that should be included.\nDevice names that do not exist in the list will be ignored.\n\nDevice paths are not supported by this option; instead use the device names\nas output by Kanata during startup. Launch Kanata with a\n<> (any use of a `linux-dev*`\noption may hide devices) and look for lines beginning with \"registering\":\n\n----\nregistering /dev/input/eventX: \"Device name 1\"\nregistering /dev/input/eventY: \"Device name 2\"\n----\n\nThe entire name within quotes must be used, partial matches and regex's are not supported.\n\n.Example:\n[source]\n----\n(defcfg\n linux-dev-names-include (\n \"Device name 1\"\n \"Device name 2\"\n )\n)\n----\n\n[[linux-only-linux-dev-names-exclude]]\n=== Linux only: linux-dev-names-exclude\n\nIn the case that `linux-dev` is omitted,\nthis option defines a list of device names that should be excluded.\nThis option is parsed identically to `linux-dev-names-include`.\n\nThe `linux-dev-names-include` and `linux-dev-names-exclude` options\nare not mutually exclusive\nbut in practice it probably only makes sense to use one and not both.\n\n.Example:\n[source]\n----\n(defcfg\n linux-dev-names-exclude (\n \"Device Name 1\"\n \"Device Name 2\"\n )\n)\n----\n\n[[linux-only-linux-continue-if-no-devs-found]]\n=== Linux only: linux-continue-if-no-devs-found\n\nBy default, kanata will crash if no input devices are found. You can change\nthis behaviour by setting `linux-continue-if-no-devs-found`.\n\n.Example:\n[source]\n----\n(defcfg\n linux-continue-if-no-devs-found yes\n)\n----\n\n[[linux-only-linux-device-detect-mode]]\n=== Linux only: linux-device-detect-mode\n\nKanata on Linux automatically detects and grabs input devices\nwhen none of the explicit device configurations are in use.\nIn case kanata is undesirably grabbing mouse-like devices,\nyou can use a configuration item to change detection behaviour.\n\nThe configuration is `linux-device-detect-mode` and it has the options:\n\n[cols=\"1,4\"]\n|===\n| `keyboard-only`\n| Grab devices that seem to be a keyboard only.\n\n| `keyboard-mice`\n| Grab devices that seem to be a keyboard only\nand devices that declare **both** keyboard and mouse functionality.\n\n| `any`\n| Grab all keyboard-like and mouse-like devices.\n|===\n\nThe default behaviour is:\n\n[cols=\"1,4\"]\n|===\n| `keyboard-mice`\n| When no mouse events are in `defsrc`.\n\n| `any`\n| When any mouse buttons or mouse scroll events are in `defsrc`.\n|===\n\n[[linux-only-linux-unicode-u-code]]\n=== Linux only: linux-unicode-u-code\n\nUnicode on Linux works by pressing Ctrl+Shift+U, typing the unicode hex value,\nthen pressing Enter. However, if you do remapping in userspace, e.g. via\nxmodmap/xkb, the keycode \"U\" that kanata outputs may not become a keysym \"u\"\nafter the userspace remapping. This will be likely if you use non-US,\nnon-European keyboards on top of kanata. For unicode to work, kanata needs to\nuse the keycode that outputs the keysym \"u\", which might not be the keycode\n\"U\".\n\nYou can use `evtest` or `kanata --debug`, set your userspace key remapping,\nthen press the key that outputs the keysym \"u\" to see which underlying keycode\nis sent. Then you can use this configuration to change kanata's behaviour.\n\n.Example:\n[source]\n----\n(defcfg\n linux-unicode-u-code v\n)\n----\n\n[[linux-only-linux-unicode-termination]]\n=== Linux only: linux-unicode-termination\n\nUnicode on Linux terminates with the Enter key by default. This may not work in\nsome applications. The termination is configurable with the following options:\n\n- `enter`\n- `space`\n- `enter-space`\n- `space-enter`\n\n.Example:\n[source]\n----\n(defcfg\n linux-unicode-termination space\n)\n----\n\n=== Linux only: linux-x11-repeat-delay-rate[[linux-only-x11-repeat-rate]]\n\nOn Linux, you can tell kanata to run `xset r rate `\non startup and on live reload\nvia the configuration item `linux-only-x11-repeat-rate`.\nThis takes two numbers separated by a comma.\nThe first number is the delay in ms\nand the second number is the repeat rate in repeats/second.\n\nThis configuration item does not affect Wayland or no-desktop environments.\n\n.Example:\n[source]\n----\n(defcfg\n linux-x11-repeat-delay-rate 400,50\n)\n----\n\n[[linux-only-linux-use-trackpoint-property]]\n=== Linux only: linux-use-trackpoint-property\n\nOn linux, you can ask kanata to label itself as a trackpoint. This has several\neffects on libinput including enabling middle mouse button scrolling and using a\ndifferent acceleration curve. Otherwise, a trackpoint intercepted by kanata may\nnot behave as expected.\n\nIf using this feature, it is recommended to filter out any non-trackpoint\npointing devices using <>,\n<> or <> to avoid\nchanging their behavior as well.\n\n.Example:\n[source]\n----\n(defcfg\n linux-use-trackpoint-property yes\n)\n----\n\n[[linux-only-linux-output-device-name]]\n=== Linux only: linux-output-device-name\n\nThis option defines the name of the evdev output device.\nThe default value is kanata.\n\n.Example:\n[source]\n----\n(defcfg\n linux-output-device-name \"kanata output\"\n)\n----\n\n[[linux-only-linux-output-device-bus-type]]\n=== Linux only: linux-output-device-bus-type\n\nKanata on Linux needs to declare a \"bus type\" for its evdev output device.\nThe options are `USB`, `I8042`, and `virtual`, with the default as `I8042`.\nUsing USB can https://github.com/jtroo/kanata/pull/661[break disable-touchpad-while-typing on Wayland].\nBut using I8042 appears to break https://github.com/jtroo/kanata/issues/1131[some other scenarios].\nThus the output bus type is configurable.\n\n.Example:\n[source]\n----\n(defcfg\n linux-output-device-bus-type USB\n)\n----\n\n[[macos-only-macos-dev-names-include]]\n=== macOS only: macos-dev-names-include\n\nThis option defines a list of device names that should be included.\nBy default, kanata will try to detect which input devices are keyboards and try\nto intercept them all. However, you may specify exact keyboard devices to intercept\nusing the `macos-dev-names-include` configuration.\nDevice names that do not exist in the list will be ignored.\nThis option is parsed identically to `linux-dev`.\n\nUse `kanata -l` or `kanata --list` to list the available keyboards.\n\n.Example:\n[source]\n----\n(defcfg\n macos-dev-names-include (\n \"Device name 1\"\n \"Device name 2\"\n )\n)\n----\n\n[[macos-only-macos-dev-names-exclude]]\n=== macOS only: macos-dev-names-exclude\n\nThis option defines a list of device names that should be excluded.\nBy default, kanata will try to detect which input devices are keyboards and try\nto intercept them all. However, you may specify certain keyboard devices to be ignored\nusing the `macos-dev-names-exclude` configuration.\nDevice names that do not exist in the list will be included.\nThis option is parsed identically to `linux-dev`.\n\nUse `kanata -l` or `kanata --list` to list the available keyboards.\n\n.Example:\n[source]\n----\n(defcfg\n macos-dev-names-exclude (\n \"Device name 1\"\n \"Device name 2\"\n )\n)\n----\n[[windows-only-windows-altgr]]\n=== Windows only: windows-altgr\n\nThere is an option for Windows to mitigate the strange behaviour of AltGr (ralt)\nif you're using `process-unmapped-keys yes` or have the key in your defsrc.\nThis is applicable for many non-US layouts.\nYou can use one of the listed values to change what kanata does with the key:\n\n* `cancel-lctl-press`\n** This will remove the `lctl` press that is generated alonside `ralt`\n* `add-lctl-release`\n** This adds an `lctl` release when `ralt` is released\n\nWithout these workarounds,\nyou should use `process-unmapped-keys (all-except lctl ralt))`,\nor use `process-unmapped-keys no`\n**and** also omit both `ralt` and `lctl` from `defsrc`.\n\n.Example:\n[source]\n----\n(defcfg\n windows-altgr add-lctl-release\n)\n----\n\nFor more context, see: https://github.com/jtroo/kanata/issues/55.\n\nNOTE: Even with these workarounds, putting `+lctl+` and `+ralt+` in your defsrc may not\nwork properly with other applications that also use keyboard interception.\nKnown application with issues: GWSL/VcXsrv\n\n=== Windows only: windows-interception-mouse-hwid[[windows-only-windows-interception-mouse-hwid]]\n\nThis defcfg item allows you to intercept mouse buttons for a specific mouse device.\nThis only works with the Interception driver\n(the -wintercept variants of the release binaries).\n\nThe original use case for this is for laptops such as a Thinkpad,\nwhich have mouse buttons that may be desirable to activate kanata actions with.\n\nTo know what numbers to put into the string, you can run the variant with this\ndefcfg item defined with any numbers. Then when a button is first pressed on\nthe mouse device, kanata will print its hwid in the log; you can then\ncopy-paste that into this configuration entry. If this defcfg item is not\ndefined, the log will not print.\n\nHwids in Kanata are byte array representations of a concatenation of the\nASCII hardware ids, which can be seen in Device Manager on Windows. As such,\nthey are an arbitrary length and can be very long.\n\nhttps://github.com/jtroo/kanata/issues/108[Relevant issue].\n\n.Example:\n[source]\n----\n(defcfg\n windows-interception-mouse-hwid \"70, 0, 60, 0\"\n)\n----\n\n=== Windows only: windows-interception-mouse-hwids[[windows-only-windows-interception-mouse-hwids]]\n\nThis item has a similar purpose as the singular version documented above,\nbut is instead a list of strings that allows multiple mice to be intercepted.\n\nIf both the singular and list items are used,\nthe singular version will behave as if added to the list.\n\n.Example:\n[source]\n----\n(defcfg\n windows-interception-mouse-hwids (\n \"70, 0, 60, 0\"\n \"71, 0, 62, 0\"\n )\n)\n----\n\n=== Windows only: windows-interception-keyboard-hwids[[windows-only-windows-interception-keyboard-hwids]]\n\nThis defcfg item allows you to intercept only specific keyboards.\nIts value must be a list of strings\nwith each string representing one hardware ID.\n\nTo know what numbers to put into the string,\nyou can run the variant with this defcfg item empty.\nThen when a button is first pressed on the keyboard,\nkanata will print its hwid in the log.\nYou can then copy-paste that into this configuration entry.\nIf this defcfg item is not defined, the log will not print.\n\nHwids in Kanata are byte array representations of a concatenation of the\nASCII hardware ids, which can be seen in Device Manager on Windows. As such,\nthey are an arbitrary length and can be very long.\n\n.Example:\n[source]\n----\n(defcfg\n windows-interception-keyboard-hwids (\n \"70, 0, 60, 0\"\n \"71, 72, 73, 74\"\n )\n)\n----\n\n=== Windows only: windows-interception-keyboard-hwids-exclude[[windows-only-windows-interception-keyboard-hwids-exclude]]\n\nThis defcfg item allows you to exclude certain keyboards from being intercepted.\nYou cannot define this alongside the inclusive keyboard configuration.\n\nIt is parsed identically to the inclusive configuration.\n\n.Example:\n[source]\n----\n(defcfg\n windows-interception-keyboard-hwids-exclude (\n \"70, 0, 60, 0\"\n \"71, 72, 73, 74\"\n )\n)\n----\n\n=== Windows only: windows-interception-mouse-hwids-exclude[[windows-only-windows-interception-mouse-hwids-exclude]]\n\nThis defcfg item allows you to exclude certain mice from being intercepted.\nYou cannot define this alongside the inclusive mouse configuration.\n\nIt is parsed identically to the inclusive configuration.\n\n.Example:\n[source]\n----\n(defcfg\n windows-interception-mouse-hwids-exclude (\n \"70, 0, 60, 0\"\n \"71, 0, 62, 0\"\n )\n)\n----\n\n[[windows-only-tray-icon]]\n=== Windows only: tray-icon\n\nShow a custom tray icon file for a <> gui-enabled build of kanata on Windows.\nAccepts either the full path (including the file name with an extension) to the icon file\nor just the file name, which is then searched in the following locations:\n\n* Default parent folders:\n** config file's, executable's\n** env vars: `XDG_CONFIG_HOME`, `APPDATA` (`C:\\Users\\\\AppData\\Roaming`), `USERPROFILE` `/.config` (`C:\\Users\\\\.config`)\n* Default config subfolders: `kanata` `kanata-tray`\n* Default image subfolders (optional): `icon` `img` `icons`\n* Supported image file formats: `ico` `jpg` `jpeg` `png` `bmp` `dds` `tiff`\n\nIf not specified, tries to load any icon file from the same locations with the name matching\nconfig name with extension replaced by one of the supported ones.\nSee https://github.com/jtroo/kanata/blob/main/cfg_samples/tray-icon/tray-icon.kbd[example config] for more details.\n\n.Example:\n[source]\n----\n;; in a config file C:\\Users\\\\AppData\\Roaming\\kanata\\kanata.kbd\n(defcfg\n tray-icon base.png ;; will load C:\\Users\\\\AppData\\Roaming\\kanata\\base.png\n)\n----\n\n[[windows-only-icon-match-layer-name]]\n=== Windows only: icon-match-layer-name\n\nWhen enabled, attempt to switch to a custom tray icon that matches the name of the active layer\nif the layer doesn't specify an explicit icon. If no icon file is found, the default icon will be used (see <>).\nFile search rules are the same as in <>. Defaults to true.\nSee https://github.com/jtroo/kanata/blob/main/cfg_samples/tray-icon/tray-icon.kbd[example config] for more details.\n\n[[windows-only-tooltip-layer-changes]]\n=== Windows only: tooltip-layer-changes\n\nShow a custom layer icon near the mouse pointer position. Defaults to false. Requires <> gui-enabled build.\n\n[[windows-only-tooltip-show-blank]]\n=== Windows only: tooltip-show-blank\n\nShow a blank square when instead of an icon if a layer isn't configured to have one. Defaults to false. Requires <> gui-enabled build.\n\n[[windows-only-tooltip-no-base]]\n=== Windows only: tooltip-no-base\n\nDon't show a tooltip layer icon for the base layer (1st deflayer). Defaults to true. Requires <> gui-enabled build.\n\n[[windows-only-tooltip-duration]]\n=== Windows only: tooltip-duration\n\nSet duration (in ms) for showing a custom layer icon near the mouse pointer position. 0 to never hide. Defaults to 500. Requires <> gui-enabled build.\n\n[[windows-only-tooltip-size]]\n=== Windows only: tooltip-size\n\nSet the size (comma-separated Width,Height without spaces) for a custom layer icon near the mouse pointer position. Defaults to 24,24. Requires <> gui-enabled build.\n\n[[windows-only-notify-cfg-reload]]\n=== Windows only: notify-cfg-reload\n\nShow system notification message on config reload. Defaults to true. Requires <> gui-enabled build.\n\n[[windows-only-notify-cfg-reload-silent]]\n=== Windows only: notify-cfg-reload-silent\n\nDisable sound for the system notification message on config reload. Defaults to false. Requires <> gui-enabled build.\n\n[[windows-only-notify-error]]\n=== Windows only: notify-error\n\nShow system notification message on kanata errors. Defaults to true. Requires <> gui-enabled build.\n\n[[using-multiple-defcfg-options]]\n=== Using multiple defcfg options\n\nThe `defcfg` entry is treated as a list with pairs of strings. For example:\n\n[source]\n----\n(defcfg a 1 b 2)\n----\n\nThis will be treated as configuration `a` having value `1` and configuration\n`b` having value `2`.\n\nAn example defcfg containing many of the options is shown below. It should be\nnoted options that are Linux-only, Windows-only, or macOS-only will be ignored when used on\na non-applicable operating system.\n\n[source]\n----\n;; Don't actually use this exact configuration,\n;; it's almost certainly not what you want.\n(defcfg\n process-unmapped-keys yes\n danger-enable-cmd yes\n sequence-timeout 2000\n sequence-input-mode visible-backspaced\n sequence-backtrack-modcancel no\n log-layer-changes no\n delegate-to-first-layer yes\n movemouse-inherit-accel-state yes\n movemouse-smooth-diagonals yes\n dynamic-macro-max-presses 1000\n linux-dev (/dev/input/dev1 /dev/input/dev2)\n linux-dev-names-include (\"Name 1\" \"Name 2\")\n linux-dev-names-exclude (\"Name 3\" \"Name 4\")\n linux-continue-if-no-devs-found yes\n linux-unicode-u-code v\n linux-unicode-termination space\n linux-x11-repeat-delay-rate 400,50\n windows-altgr add-lctl-release\n windows-interception-mouse-hwid \"70, 0, 60, 0\"\n)\n----\n\n== Command line arguments[[cli-args]]\n\nWhen executing Kanata, you can pass a variety of arguments to the program\nto change Kanata's behaviour.\nThis section describes the purpose and usage of these arguments.\n\n[[args-help]]\n=== Show help text: `-h`, `--help`\n\nOnly show help text that describes these arguments,\nthen exit the program.\n\n[[args-config-file]]\n=== Configuration file(s): `-c`, `--cfg`\n\nConfiguration file(s) to use with Kanata.\nWhen not specified, default file locations are checked.\nThe default files checked depend on your operating system\nand are described by `--help`.\n\nThis argument can be used more than once;\nsee <> to understand the behaviour of this.\nThe startup configuration will be the first file listed.\n\n[[args-tcp]]\n=== TCP server address: `-p`, `--port`\n\nEnable the TCP server capability and listen on either:\n- a specified port, on all IP addresses\n- a specific `IP:PORT`\n\nThis enables use cases such as\nhttps://github.com/jtroo/kanata?tab=readme-ov-file#community-projects-related-to-kanata[application aware switching].\n\nThe protocol is plaintext newline-terminated JSON.\nThe source of truth is the\nhttps://github.com/jtroo/kanata/blob/main/tcp_protocol/src/lib.rs[TCP protocol code].\n\nYou may also be interested in the\nhttps://github.com/jtroo/kanata/blob/main/example_tcp_client/src/main.rs[example client].\n\n==== TCP Protocol Overview\n\nThe TCP server uses a simple request/response model with JSON messages.\nEach message is a single line of JSON terminated by a newline (`\\n`).\n\n- **Client → Server**: Commands to control Kanata (reload config, switch layers, etc.)\n- **Server → Client**: Responses to commands and event notifications (layer changes, config reloads, etc.)\n\n==== Client Commands\n\nThese JSON messages can be sent from a TCP client to control Kanata:\n\n===== Layer Control\n\n[cols=\"1,2\"]\n|===\n| Command | Description\n\n| `{\"ChangeLayer\":{\"new\":\"layer-name\"}}`\n| Switch to the specified layer. Equivalent to the `layer-switch` keyboard action.\n\n| `{\"RequestLayerNames\":{}}`\n| Request a list of all defined layer names. Server responds with `LayerNames`.\n\n| `{\"RequestCurrentLayerName\":{}}`\n| Request the name of the currently active layer. Server responds with `CurrentLayerName`.\n\n| `{\"RequestCurrentLayerInfo\":{}}`\n| Request the current layer's name and full configuration text. Server responds with `CurrentLayerInfo`.\n|===\n\n.Example - Query and switch layers:\n[source,bash]\n----\n# Get all layer names\necho '{\"RequestLayerNames\":{}}' | nc localhost 7070\n\n# Get current layer\necho '{\"RequestCurrentLayerName\":{}}' | nc localhost 7070\n\n# Switch to nav layer\necho '{\"ChangeLayer\":{\"new\":\"nav\"}}' | nc localhost 7070\n----\n\n===== Virtual Key Actions\n\n[cols=\"1,2\"]\n|===\n| Command | Description\n\n| `{\"RequestFakeKeyNames\":{}}`\n| Request a list of all defined virtual key names. Server responds with `FakeKeyNames`.\n\n| `{\"ActOnFakeKey\":{\"name\":\"key-name\",\"action\":\"Tap\"}}`\n| Trigger a virtual key defined in `defvirtualkeys`. Actions: `Press`, `Release`, `Tap`, `Toggle`.\n|===\n\nVirtual keys must be defined in your configuration using `defvirtualkeys`.\nSee the <> section for details.\n\n.Example - Trigger a text expansion macro:\n[source]\n----\n;; In your config:\n(defvirtualkeys\n email-sig (macro S-b e s t spc r e g a r d s)\n)\n\n;; From TCP client:\necho '{\"ActOnFakeKey\":{\"name\":\"email-sig\",\"action\":\"Tap\"}}' | nc localhost 7070\n----\n\n===== Mouse Control\n\n[cols=\"1,2\"]\n|===\n| Command | Description\n\n| `{\"SetMouse\":{\"x\":100,\"y\":200}}`\n| Set the mouse cursor position to absolute screen coordinates.\n|===\n\nThis is the TCP equivalent of the <> keyboard action.\n\n===== Configuration Reload\n\n[cols=\"1,2\"]\n|===\n| Command | Description\n\n| `{\"Reload\":{}}`\n| Reload the current configuration file. Equivalent to `lrld` keyboard action.\n\n| `{\"ReloadNext\":{}}`\n| Load the next configuration file in the list. Equivalent to `lrnx` keyboard action.\n\n| `{\"ReloadPrev\":{}}`\n| Load the previous configuration file in the list. Equivalent to `lrpv` keyboard action.\n\n| `{\"ReloadNum\":{\"index\":0}}`\n| Load configuration file at the specified index (0-based).\n\n| `{\"ReloadFile\":{\"path\":\"/path/to/config.kbd\"}}`\n| Load a specific configuration file by path.\n|===\n\nAll reload commands support optional `wait` and `timeout_ms` fields for synchronous confirmation:\n\n[source,json]\n----\n{\"Reload\":{\"wait\":true,\"timeout_ms\":5000}}\n----\n\nWhen `wait` is `true`, the server blocks until the reload completes or times out, then sends a `ReloadResult` message. The `timeout_ms` field specifies the maximum wait time in milliseconds (default: 5000).\n\n===== Server Information\n\n[cols=\"1,2\"]\n|===\n| Command | Description\n\n| `{\"Hello\":{}}`\n| Request server version and capabilities. Server responds with `HelloOk`.\n|===\n\n==== Server Messages\n\nThese JSON messages are sent from Kanata to connected TCP clients:\n\n===== Event Notifications\n\nThese are sent automatically when events occur:\n\n[cols=\"1,2\"]\n|===\n| Message | Description\n\n| `{\"LayerChange\":{\"new\":\"layer-name\"}}`\n| Sent when the active layer changes.\n\n| `{\"ConfigFileReload\":{\"new\":\"/path/to/config.kbd\"}}`\n| Sent when a configuration file is reloaded.\n\n| `{\"MessagePush\":{\"message\":\"your-message\"}}`\n| Sent when a `push-msg` action is triggered from the keyboard configuration.\n\n| `{\"Error\":{\"msg\":\"error description\"}}`\n| Sent when an error occurs processing a command.\n\n| `{\"HoldActivated\":{\"key\":\"caps\"}}`\n| Sent when a tap-hold key transitions to hold state. The `key` field is the physical key name.\n\n| `{\"TapActivated\":{\"key\":\"a\"}}`\n| Sent when a tap-hold key triggers its tap action. The `key` field is the physical key name.\n|===\n\n===== Query Responses\n\nThese are sent in response to client queries:\n\n[cols=\"1,2\"]\n|===\n| Message | Description\n\n| `{\"LayerNames\":{\"names\":[\"base\",\"nav\",\"num\"]}}`\n| Response to `RequestLayerNames`. Contains all defined layer names.\n\n| `{\"FakeKeyNames\":{\"names\":[\"email-sig\",\"nav-mode\"]}}`\n| Response to `RequestFakeKeyNames`. Contains all defined virtual key names.\n\n| `{\"CurrentLayerName\":{\"name\":\"base\"}}`\n| Response to `RequestCurrentLayerName`. Contains the active layer name.\n\n| `{\"CurrentLayerInfo\":{\"name\":\"base\",\"cfg_text\":\"...\"}}`\n| Response to `RequestCurrentLayerInfo`. Contains the layer name and its full configuration text.\n\n| `{\"HelloOk\":{\"version\":\"1.11.0\",\"protocol\":1,\"capabilities\":[...]}}`\n| Response to `Hello`. Contains server version, protocol version, and supported capabilities. Includes `hold-activated` and `tap-activated`.\n\n| `{\"ReloadResult\":{\"ok\":true}}`\n| Response to reload commands when `wait` was `true`. Indicates whether the config reload succeeded. If timed out, includes `timeout_ms`.\n|===\n\nFor a complete implementation example, see the\nhttps://github.com/jtroo/kanata/blob/main/example_tcp_client/src/main.rs[example TCP client].\n\n[[args-quiet]]\n=== Disable logs other than errors: `-q`, `--quiet`\n\nSilence info and warning logs so that only errors are logged.\nThis might be desirable when running in the background as a system service.\n\n[[args-debug]]\n=== Enable debug logs: `-d`, `--debug`\n\nAdd extra debug logging.\nThis is helpful when diagnosing an issue\nor discovering key names.\n\n[[args-trace]]\n=== Enable trace logs: `-t`, `--trace`\n\nAdd extra trace logging.\nAlso includes debug logging.\nThis is sometimes helpful when diagnosing an issue,\nbut is very verbose.\n\n[[args-nodelay]]\n=== Remove startup delay: `-n`, `--nodelay`\n\nBy default, Kanata adds a delay before reading keyboard inputs.\nThis helps protect against stale states\nwhen started from a terminal.\n\nHowever, this may be undesirable\nwhen running as a background service.\n\n[[args-check]]\n=== Only check configuration: `--check`\n\nCheck the configuration file validity and then exit.\n\n[[args-log-layer-changes]]\n=== Force log changes: `--log-layer-changes`\n\nYour final desired `defcfg` could be to have logging of layer changes as false.\nHowever, for testing purposes you may want to temporarily log the layers.\nThis configuration forces logging to happen for this use case.\n\n[[args-no-wait]]\n=== Skip exit prompt: `--no-wait`\n\nBy default, kanata displays \"Press enter to exit\" and waits for user input\nbefore exiting. This flag skips that prompt and exits immediately.\n\nThis is useful when running kanata as a background service (e.g., systemd)\nwhere you want automatic restart on failure. Without this flag,\nthe service would hang waiting for stdin input that never comes.\n\n[[args-linux-dev-symlink]]\n=== Linux only - Device symlink path: `-s`, `--symlink-path`\n\nIf you want another program to consume the Kanata device output,\nyou can use this flag to have a consistent device filesystem path.\n\n[[args-wait-device]]\n=== Linux only - Wait before device grab attempt: `-w`, `--wait-device-ms`\n\nSome devices take a while to become ready and can fail to be grabbed.\nThis configuration adds a delay before trying to grab devices\nin case this is an issue impacting you.\n\n[[args-macos-list-devices]]\n=== macOS only - Only list keyboards: `-l`, `--list`\n\nList keyboard names that can be used\nwithin defcfg and then exit.\n\n== Advanced features[[advanced-features]]\n[[virtual-keys]]\n=== Virtual keys\n\nYou can define up to 767 virtual keys.\nThese keys are not directly mapped to any physical key presses or releases.\nVirtual keys can be activated via special actions:\n\n* `(on-press )` or `on↓`:\nActivate a virtual key action when pressing the associated input key.\n* `(on-release )` or `on↑`:\nActivate a virtual key action when releasing the associated input key.\n* `(on-idle )`:\nActivate a virtual key action when kanata has been idle\nfor at least `idle time` milliseconds.\n* `(on-physical-idle )`:\nActivate a virtual key action when the physical keyboard has\nhad all keys released\nfor at least `idle time` milliseconds.\n* `(hold-for-duration `):\nPress a virtual key for `hold time` milliseconds.\nIf `hold-for-duration` retriggered on a virtual key before release,\nthe time will be reset with no additional press/release events.\n\nThe `` parameter can be one of:\n\n* `tap-virtualkey | tap-vkey`:\nPress and release the virtual key. If the key is already pressed, this only releases it.\n* `press-virtualkey | press-vkey`:\nPress the virtual key. It will not be released until another action triggers a release or tap.\nIf the key is already pressed, this does nothing.\n* `release-virtualkey | release-vkey`:\nRelease the virtual key. If it is not already pressed, this does nothing.\n* `toggle-virtualkey | toggle-vkey`:\nPress the virtual key if it is not already pressed, otherwise release it.\n\nA virtual key can be defined in a `defvirtualkeys` configuration entry.\nConfiguring this entry is similar to `+defalias+`,\nbut you cannot make use of aliases inside to shorten an action.\nYou can refer to previously defined virtual keys.\n\nExpanding on the `on-idle` action some more,\nthe wording that \"kanata\" has been idle is important.\nEven if the keyboard is idle, kanata may not yet be idle.\nFor example, if a long-running macro is playing,\nor kanata is waiting for the timeout of actions such as `caps-word` or `tap-dance`,\nkanata is not yet idle, and the tick count for the `` parameter\nwill not yet be counting even if you no longer have any keyboard keys pressed.\nThe variant `on-physical-idle` may be more desirable if you want the timer\nto only start based on having all keyboard keys be released.\n\n.Example:\n[source]\n----\n(defvirtualkeys\n ;; Define some virtual keys that perform modifier actions\n ctl lctl\n sft lsft\n met lmet\n alt lalt\n\n ;; A virtual key that toggles all modifier virtual keys above\n tal (multi\n (on-press toggle-virtualkey ctl)\n (on-press toggle-virtualkey sft)\n (on-press toggle-virtualkey met)\n (on-press toggle-virtualkey alt)\n )\n\n ;; Virtual key that activates a macro\n vkmacro (macro h e l l o spc w o r l d)\n)\n\n(defalias\n psf (on-press press-virtualkey sft)\n rsf (on-press release-virtualkey sft)\n\n tal (on-press tap-vkey tal)\n mac (on-press tap-vkey vkmacro)\n\n isf (on-idle 1000 tap-vkey sft)\n hfd (hold-for-duration 1000 met)\n)\n\n(deflayer use-virtual-keys\n @psf @rsf @tal @mac a s d f @isf @hfd\n)\n----\n\n.Older fake keys documentation\n[%collapsible]\n====\nThe older configuration style of fake keys are still supported\nbut the new style is preferred due to (hopefully) clearer naming.\n\nFake keys can be defined inside of `deffakekeys`.\n\nThe actions are:\n\n* `+(on-press-fakekey )+` or `on↓fakekey`: Activate a fake key\n action when pressing the key mapped to this action.\n* `+(on-release-fakekey )+` or `on↑fakekey`: Activate a fake key\n action when releasing the key mapped to this action.\n* `+(on-idle-fakekey )+`:\n Activate a fake key action when kanata has been idle\n for at least `idle time` milliseconds.\n\nThe aforementioned `++` can be one of four values:\n\n* `+press+`: Press the fake key. It will not be released until another action\n triggers a release or tap.\n* `+release+`: Release the fake key. If it's not already pressed, this does nothing.\n* `+tap+`: Press and release the fake key. If it's already pressed, this only releases it.\n* `+toggle+`: Press the fake key if not already pressed, otherwise release it.\n\n.Example:\n[source]\n----\n(deffakekeys\n ctl lctl\n sft lsft\n met lmet\n alt lalt\n\n ;; Press all modifiers\n pal (multi\n (on-press fakekey ctl press)\n (on-press-fakekey sft press)\n (on-press-fakekey met press)\n (on-press-fakekey alt press)\n )\n\n ;; Release all modifiers\n ral (multi\n (on-press-fakekey ctl release)\n (on-press-fakekey sft release)\n (on-press-fakekey met release)\n (on-press-fakekey alt release)\n )\n)\n\n(defalias\n psf (on-press-fakekey sft press)\n rsf (on-press-fakekey sft release)\n\n pal (on-press-fakekey pal tap)\n ral (on-press-fakekey ral tap)\n\n isf (on-idle-fakekey sft tap 1000)\n)\n\n(deflayer use-virtual-keys\n @psf @rsf @pal @ral a s d f @isf\n)\n----\n\n====\n\nFor more context, you can read the\nhttps://github.com/jtroo/kanata/issues/80[issue that sparked the creation of virtual keys].\n\nSomething notable about virtual keys is that they don't always interrupt the state\nof an active `+tap-dance-eager+`. If a `macro` action is assigned to a virtual\nkey, this won't interrupt a tap dance. However, most other action types,\nnotably a \"normal\" key action like `+rsft+` will still interrupt a tap dance.\n\n[[sequences]]\n=== Sequences\n\nThe `+sldr+` action makes kanata go into \"sequence\" mode. The action name is\nshort for \"sequence leader\". This comes from Vim which has the concept of a configurable\nsequence leader key. When in sequence mode, keys are not typed\n(<>)\nbut are saved until one of the following happens:\n\n* A key is typed that does not match any sequence\n* `+sequence-timeout+` milliseconds elapses since the most recent key press\n\nSequences are configured similarly to `+defvirtualkeys+`. The first parameter of a\npair must be a defined virtual key name. The second parameter is a list of keys\nthat will activate a virtual key tap when typed in the defined order. More\nprecisely, the action triggered is:\n\n`+(on-press tap-vkey )+`\n\n.Example:\n[source]\n----\n(defseq git-status (g s t))\n(defvirtualkeys git-status (macro g i t spc s t a t u s))\n(defalias rcl (tap-hold-release 200 200 sldr rctl))\n\n(defseq\n dotcom (. S-3)\n dotorg (. S-4)\n\n ;; The shifted letters in parentheses means a single press of lsft\n ;; must remain held while both h and then s are pressed.\n ;; This is not the same as S-h S-s, which means that the lsft key\n ;; must be released and repressed between the h and s presses.\n https (S-(h s))\n)\n(defvirtualkeys\n dotcom (macro . c o m)\n dotorg (macro . o r g)\n https (macro h t t p s S-; / /)\n)\n----\n\nThere are 10 special keys with names `nop0-nop9` which kanata treats specially.\nKanata will never send OS events for these keys\nbut they can still participate in sequences.\n\nSee an example of using the nop keys\nalongside templates to define sequences below.\n\n.Example:\n[source]\n----\n(defsrc f7 f8 f9 f10)\n(deflayer base\n sldr nop0 nop1 nop2)\n(deftemplate seq (vk-name input-keys output-action)\n (defvirtualkeys $vk-name $output-action)\n (defseq $vk-name $input-keys)\n)\n;; template-expand has a shortened form: t!\n(t! seq dotcom (nop0 nop1) (macro . c o m))\n(t! seq dotorg (nop0 nop2) (macro . o r g))\n----\n\nIf 10 special nop keys do not seem sufficient,\nyou can get creative with your sequences and treat some as a prefix modifier.\nFor example, you can get 24 \"keys\" by treating `nop0-nop5` as normal\nwhile treating `nop6-nop9` as prefixes that are always followed by a second nop key.\n\n.Example:\n[source]\n----\n(defalias\n nop0 nop0\n ;; ...\n nop5 nop5\n nop6 (macro nop6 nop0)\n ;; ...\n nop11 (macro nop6 nop5)\n ;; ...\n nop18 (macro nop9 nop0)\n ;; ...\n nop23 (macro nop9 nop5)\n)\n----\n\n==== Overlapping keys in any order\n\nWithin the key list of `defseq` configuration items,\nthe special `O-` list prefix can be used to denote a set of keys that must\nall be pressed before any are released in order to match the sequence.\n\nFor an example, `O-(a b c)` is equivalent to `O-(c b a)`.\n\n.Example:\n[source]\n----\n(defvirtualkey hello (macro h (unshift e l) 5 (unshift l o)))\n(defseq hello (O-(h l o)))\n----\n\nWARNING: The way that sequences implements this functionality behind the scenes\nis by generating a sequence for every permutation of the overlapping keys.\nThis can make kanata use up a lot of memory.\nDue to this, the maximum keys allowed in a given `O-(...)` list is 6,\nbut you are still permitted to add more to the sequence,\nincluding more `O-(...)` lists.\nDoing the above can balloon kanata's memory consumption.\n\n.Sample of more advanced usage\n[%collapsible]\n====\n\nThe configuration below showcases context-dependent chording\nwith auto-space and auto-deleted spaces from typing punctuation.\n\nFor example, chording `(d a y)` and then `(t u e)` will output\n`Tuesday`, while chording `(t u e)` by itself does nothing.\n\n.Example configuration:\n[source]\n----\n(defsrc f1)\n(deflayer base lrld)\n(defcfg process-unmapped-keys yes\n\tsequence-input-mode visible-backspaced\n\tconcurrent-tap-hold true)\n(deftemplate seq (vk-name in out)\n\t(defvirtualkeys $vk-name $out)\n\t(defseq $vk-name $in))\n\n(defvirtualkeys rls-sft (multi (release-key lsft)(release-key rsft)))\n(defvar rls-sft (on-press tap-vkey rls-sft))\n(deftemplate rls-sft () $rls-sft 5)\n\n(defchordsv2\n\t(d a y) (macro sldr d (t! rls-sft) a y spc nop0) 200 first-release ()\n\t(h l o) (macro h (t! rls-sft) e l l o sldr spc nop0) 200 first-release ()\n)\n(t! seq Monday (d a y spc nop0 O-(m o n)) (macro S-m $rls-sft o n d a y nop9 sldr spc nop0))\n(t! seq Tuesday (d a y spc nop0 O-(t u e)) (macro S-t $rls-sft u e s d a y nop9 sldr spc nop0))\n(t! seq DelSpace_. (spc nop0 .) (macro .))\n(t! seq DelSpace_; (spc nop0 ;) (macro ;))\n----\n\n.Try using the above configuration to type the text:\n[source]\n----\nday;\nDay;\nTuesday.\nday hello\nhello day\nHello day.\nhello Tuesday\nHello Monday;\n----\n\n====\n\n==== Override the global timeout and input mode\n\nAn alternative to using `sldr` is the `sequence` action.\nThe syntax is `(sequence )`.\nThis enters sequence mode with a sequence timeout\ndifferent from the globally configured one.\n\nThe `sequence` action can also be called with a second parameter.\nThe second parameter is an override for `sequence-input-mode`:\n\n----\n(sequence )\n----\n\n\n.Example:\n[source]\n----\n;; Enter sequence mode and input . with a timeout of 250\n(defalias dot-sequence (macro (sequence 250) 10 .))\n\n;; Enter sequence mode and input . with a timeout of 250 and using hidden-delay-type\n(defalias dot-sequence (macro (sequence 250 hidden-delay-type) 10 .))\n----\n\n==== sequence-noerase\n\nWhen you have a keyboard locale that uses dead keys,\nyou may be pressing two keys that only actually output one symbol.\nBy default, when the `visible-backspaced` input mode does the backtracking backspaces,\nit backspaces according to input count.\nWith dead keys, this may result in too many backspaces.\n\nThe `sequence-noerase` action is a no-output action\nthat tells the sequences action to have one fewer backspace\nwhen backtracking with visible-backspaced.\n\n.Example:\n[source]\n----\n(deflayermap (base)\n 0 sldr\n u (t! maybe-noerase u)\n)\n(deftemplate maybe-noerase (char)\n (multi\n (switch\n ((key-history ' 1)) (sequence-noerase 1) fallthrough\n () $char break\n ))\n)\n(defvirtualkeys seq-output-1 (macro a b c d e f g))\n(defseq seq-output-1 (' u))\n\n----\n\n==== More about sequences\n\nFor more context about sequences, you can read the\nhttps://github.com/jtroo/kanata/issues/97[design and motivation of sequences].\nYou may also be interested in\nhttps://github.com/jtroo/kanata/blob/main/docs/sequence-adding-chords-ideas.md[the document describing chords in sequences]\nto read about how chords in sequences behave.\n\n[[input-chords]]\n=== Input chords\n\nNot to be confused with <>, `+chord+`\nactions allow you to perform various actions based on which specific combination\nof input keys are pressed together. Such an unordered combination of keys\nis called a \"chord\". Each chord can perform a different action, allowing you\nto bind up to `+2^n - 1+` different actions to just `+n+` keys.\n\nInput chords are configured similarly to `+defalias+` with two extra parameters\nat the beginning of each `+defchords+` group: the name of the group and a\ntimeout value after which a chord triggers if it isn't triggered by a key release\nor press of a non-chord key before the timeout expires.\n\n[source]\n----\n(defsrc a b c)\n(deflayer default\n @cha @chb @chc\n)\n\n(defalias\n cha (chord example a)\n chb (chord example b)\n chc (chord example c)\n)\n\n(defchords example 500\n (a ) a\n ( b ) b\n (a c) C-v\n (a b c) @three\n)\n----\n\nThe first item of each pair specifies the keys that make up a given chord.\nThe second item of each pair is the action to be executed when the given chord\nis pressed and may be any regular or advanced action, including aliases. It\ncurrently cannot however contain another `+chord+` action.\n\nNote that unlike with `+defseq+`, these keys do not directly correspond to real\nkeys and are merely arbitrary labels that make sense within the context of the\nchord.\nThey are mapped to real keys in layers by configuring the key in the layer to\nmap to a `+(chord name key)+` action where `+name+` is the name of the chords\ngroup (above `+example+`) and `+key+` is one of these arbitrary labels.\n\nIt is perfectly valid to nest these `+chord+` actions that enter \"chording mode\"\nwithin other actions like `+tap-dance+` and that will work as one would expect.\nHowever, this only applies to the first key used to enter \"chording mode\".\nOnce \"chording mode\" is active, all other keys will be directly handled by\n\"chording mode\" with no regard for wrapper actions; e.g. if a key is pressed\nand it maps to a tap-hold with a chord as the hold action within, that chord\nkey will immediately activate instead of the key needing to be held for the\ntimeout period.\n\n**Release behaviour**\n\nFor single key actions and output chords — like `lctl` or `S-tab` —\nand for `layer-while-held`,\nan input chord will release the action only when all keys that are part of\nthe input chord have been released.\nIn other words, if even one key is held for the input chord\nthen the output action will be continued to be held,\nbut only for the mentioned action categories.\nThe behaviour also applies to the actions mentioned above\nwhen used inside of `multi` but not within any other action.\n\nAn exception to the behaviour described above\nfor the action categories that would normally apply\nis if a chord decomposition occurs.\nA chord decomposition occurs when you input a chord\nthat does not correspond to any action.\nWhen this happens, kanata splits up the key presses to activate\nother actions from the components of the input chord.\nIn this scenario, the behaviour described in the next paragraph will occur.\n\nFor chord decompositions and all other action categories,\nthe release behaviour is more confusing:\nthe output action will end when any key is released during the timeout,\nor if the timeout expires, the output action ends when the *first* key\nthat was pressed in the chord gets released.\nThis inconsistency is a limitation of the current implementation.\nIn these scenarios it is recommended\nto hold down all keys if you want to keep holding\nand to release all keys if you want to do a release.\nThis is because it will probably be difficult\nto know which key was pressed first.\n\nIf you want to bypass the behaviour of keys being held for chord outputs,\nyou could change the chord output actions to be <> instead.\nUsing a macro will guarantee a rapid press+release for the output keys.\n\n[[defaliasenvcond]]\n=== defaliasenvcond\n\nNOTE: this configuration item is older and instead you may want to use\nthe newer and more generalized <> configuration.\n\nThere is a variant of `defalias`: `defaliasenvcond`.\nThis variant is parsed similarly,\nbut there must be an extra list parameter\nthat comes before all of the name-action pairs.\n\nThe list must contain two strings.\nIn order, these strings are:\nan environment variable name,\nand the environment variable value.\nWhen the environment variable defined by the name\nhas the corresponding value when starting kanata,\nthe aliases within will be active.\nOtherwise, the aliases will be skipped.\n\nA use case for `defaliasenvcond` is when one has multiple devices\nwhich vary in layout of keys,\ne.g. different special keys on the bottom row.\nUsing environment variables, one can use the same kanata\nconfiguration across those multiple devices\nwhile changing key behaviours to keep consistent behaviour\nof specific key positions across the multiple devices,\nwhen the hardware keys at those physical key positions are not\nthe same.\n\n\n.Example:\n[source]\n----\n(defaliasenvcond (LAPTOP lp1)\n met @lp1met\n)\n\n(defaliasenvcond (LAPTOP lp2)\n met @lp2met\n)\n----\n\n.Set environment variables in the current terminal process:\n[source]\n----\n# powershell\n$env:VAR_NAME = \"var_value\"\n\n# bash\nVAR_NAME=var_value\n----\n\n[[custom-tap-hold-behaviour]]\n=== Custom tap-hold behaviour\n\nThis is not currently configurable without modifying the source code, but if\nyou're willing and/or capable, there is a tap-hold behaviour that is currently\nnot exposed. Using this behaviour, one can be very particular about when and how\ntap vs. hold will activate by using extra information. The available\ninformation that can be used is exactly which keys have been pressed or\nreleased as well as the timing in milliseconds of those key presses.\nThe action `+tap-hold-release-keys+` makes use of some of this capability, but\ndoesn't make full use of the power of this functionality.\n\nFor more context, you can read the\nhttps://github.com/jtroo/kanata/issues/128[motivation for custom tap-hold behaviour].\n\n\n[[fancy-key-symbols]]\n=== Fancy key symbols\n\nInstead of using the same `+a-z+` letters for special keys, e.g., `+lsft+` for `+LeftShift+`\nyou can use much shorter, yet more visible, key symbols like `+‹⇧+`.\n\nFor more details see\nhttps://github.com/jtroo/kanata/blob/main/docs/fancy_symbols.md[symbol list] and\nhttps://github.com/jtroo/kanata/blob/main/cfg_samples/fancy_symbols.kbd[example config], which not only uses these symbols in layer definitions, but also repurposes `+⎇›+` and `+⇧›+` `+⎇›+` keys into \"symbol\" keys that allow you to insert these fancy symbols by pressing the key, e.g.,\n\n* hold `+⎇›+` and tap `+Delete+` would insert `+␡+`\n\n[[windows-only-work-elevated]]\n=== Windows only: enable in elevated windows\n\nThe default `kanata.exe` binary doesn't work in elevated windows (run with administrative privileges),\ne.g., `Control Panel`. However, you can use AutoHotkey's \"EnableUIAccess\" script to self-sign the binary,\nmove it to \"Program Files\", then launching kanata from there will also work in these elevated windows.\nSee https://github.com/jtroo/kanata/blob/main/EnableUIAccess[EnableUIAccess] folder with the script\nand its required libraries (needs https://www.autohotkey.com/download/[AutoHotkey v2] installed)\n\nIf compiling yourself, you should add the feature flag `win_manifest`\nto enable the use of the `EnableUIAccess` script:\n\n```\ncargo build --win_manifest\n```\n\n[[windows-only-win-tray]]\n=== Windows only: win-tray\n\nKanata can be compiled as a Windows GUI tray app with the feature flag `gui`.\nThis can simplify launching the app on user login by placing a `.lnk`\nat `%APPDATA%\\Microsoft\\Windows\\Start Menu\\Programs\\Startup`, show custom icon indicator per config\n\n\nimage:https://github.com/jtroo/kanata/blob/main/docs/win-tray/win-tray-screen.png[icon indicator per config,477,129]\n\nas well as dynamic icon indicator per layer (might need to click on the gif below to play)\n\nimage:https://github.com/jtroo/kanata/blob/main/docs/win-tray/win-tray-layer-change.gif[icon indicator per layer,33,35,opts=autoplay]\n\n(see <>). It also supports (re)loading configs.\n\nCurrently the only configuration supported is tray icon per profile, all other configuration should\nbe done by passing cli flags in the `Target` field of `.lnk`, e.g., `\"C:\\Program Files\\kanata\\kanata.exe\" -d -n`\nto launch kanata without a delay in a debug mode\n\nWhen launched from a command line, the app outputs log to the console, but otherwise the logs are currently\nonly available via an app capable of viewing `OutputDebugString` debugs, e.g., https://github.com/smourier/TraceSpy[TraceSpy].\n\n[[test-your-config]]\n=== Test your config\n\nKanata has a `+kanata_simulated_input+` tool\nto help test your configuration in a predictable manner.\n\nYou can try it out on https://jtroo.github.io/[GitHub pages].\n\nCode for the CLI tool can be found under link:https://github.com/jtroo/kanata/blob/main/simulated_input/[simulated_input].\n\nInstead of physically typing to test something\nand wondering whether you didn't get the expected result because your config is wrong or\nbecause you mistyped something,\nyou can write a sequence of key presses in a `+sim.txt+` file,\nrun the tool with your config\nand get a \"timeline\" view of input/output events that can help understand how kanata translates\nyour input into various key/mouse presses.\n\nWARNING: The format of this view may change. Emoji output may break vertical alignment.\n\nFor more details download the files below and run `kanata_simulated_input -c sim.kbd -s sim.txt` +\n - https://github.com/jtroo/kanata/blob/main/docs/simulated_output/sim.kbd[example config] with simple home row mod bindings +\n - https://github.com/jtroo/kanata/blob/main/docs/simulated_output/sim.txt[example input sequence] +\n - https://github.com/jtroo/kanata/blob/main/docs/simulated_output/sim_out.txt[example output sequence] +\n\nInput sequence file format: whitespace insensitive list of `prefix:key` pairs where prefix is one of: +\n - `🕐`, `t`, or `tick` to add time between key events in `ms` +\n - `↓`, `d`, `down`, or `press` +\n - `↑`, `u`, `up`, or `release` +\n - `⟳`, `r`, or `repeat` +\n - `🎭`, `fakekey`, `vk`, or `virtualkey` to activate virtual keys +\n - `🔀`, `ls`, or `layer-switch` to switch layers +\n\nVirtual key format is `vk:name[:action]`, `fakekey:name[:action]`, or `virtualkey:name[:action]`. +\nWhen using the emoji prefix, the format is `🎭name[:action]`. Action is one of: +\n - `press` or `p` (default if omitted) +\n - `release` +\n - `tap` or `t` +\n - `toggle` or `g` +\nExample: `vk:vk_bear:tap` or `🎭vk_bear:tap`. +\n\nLayer switch format is `ls:name` or `layer-switch:name`. +\nWhen using the emoji prefix, the format is `🔀name`. +\nThis switches to the specified layer as the new default layer. +\nExample: `ls:nav` or `🔀nav`. +\n\nAnd key names are defined in the https://github.com/jtroo/kanata/blob/main/parser/src/keys/mod.rs[str_to_oscode function],\nfor example, `1` for the numeric key 1 or `kp1`/`🔢₁` for the keypad numeric key 1\n\nUsing unicode symbols `🕐`,`↓`,`↑`,`⟳`,`🎭`,`🔀` allows skipping the `:` separator, e.g., `↓k` ≝ `↓:k` ≝ `d:k`\n\n[[zippychord]]\n=== Zippychord\n\n**Reference**\n\nYou may define a single `+defzippy+` configuration item.\nThis configuration enables chorded text expansion.\n\n.Configuration syntax within the kanata configuration\n[source]\n----\n(defzippy\n $zippy-filename ;; required\n on-first-press-chord-deadline $deadline-millis ;; optional\n idle-reactivate-time $idle-time-millis ;; optional\n smart-space $smart-space-cfg ;; optional\n smart-space-punctuation ( ;; optional\n $punc1 $punc2 ... $puncN)\n output-character-mappings ( ;; optional\n $character1 $output-mapping1\n $character2 $output-mapping2\n ;; ...\n $characterN $output-mappingN\n )\n)\n----\n\n[cols=\"1,4\"]\n|===\n| `$zippy-filename`\n| Relative or absolute file path.\nIf relative, its path is relative to\nthe directory containing the kanata configuration file.\nThis must be the first item following `defzippy`.\n\n| `$deadline-millis`\n| Number of milliseconds.\nAfter the first press while zippy is enabled,\nif no chord activates within this configured time,\nzippy is temporarily disabled.\n\n| `$idle-time-millis`\n| Number of milliseconds.\nAfter typing ends and this configured number of milliseconds elapses,\nzippy will be re-enabled from being temporarily disabled.\n\n| `$smart-space-cfg`\n| Determines the smart space behaviour.\nThe options are `none`, `add-space-only`, and `full`.\nWith `none`, outputs are typed as-is.\nWith `add-space-only`, spaces are automatically added after outputs\nwhich end with neither a space or a backspace ⌫.\nWith `full`, the `add-space-only` behaviour applies\nalongside additional behaviour:\ntyping punctuation (default characters: `, . ;`)\nafter a zippy activation will delete a prior automatically-added space.\n\n| `$punc`\n| A character defined in `output-character-mappings`\nor a known key name, which shall be considered as punctuation.\nThe `smart-space-punctuation` configuration\nwill overwrite the default punctuation list\nconsidered by smart-space;\nif you want to include the default characters,\nyou must include them in this configuration.\n\n| `$character`\n| A single unicode codepoint for use\nin the output column of the zippy configuration file.\n\n| `$output-mapping`\n| Key or output chord to tell kanata how to type `$character`\nwhen seen in the zippy file output column.\nMust be a single key or output chord.\nThe output chord may contain `AG-` to tell kanata to press with AltGr\nand may contain `S-` to tell kanata to press with Shift.\n\nThe list items `no-erase` and `single-output` are also usable in this position.\n\n| `no-erase`\n| Accepts a single key or output chord as a parameter.\nThe zippy system will not backspace this character\nin case of auto-erasure by a superset chord or followup chord.\nUse for dead keys or compose keys.\n\n| `single-output`\n| Accepts one or more keys or output chords as a parameter.\nThe zippy system send only one backspace\nin case of auto-erasure by a superset chord or followup chord.\nUse for a dead key or compose key sequence with one output symbol.\n|===\n\nRegarding output mappings,\nyou can configure the output of the special-lisp-syntax characters\n`+) ( \"+` via these lines:\n\n[source]\n----\n \")\" $right-paren-output\n \"(\" $left-paren-output\n r#\"\"\"# $double-quote-output\n----\n\nAs an example, for the US layout these should be the correct lines:\n\n[source]\n----\n \")\" S-0\n \"(\" S-9\n r#\"\"\"# S-'\n----\n\n.Configuration syntax within the zippy configuration file\n[source]\n----\n// This is a comment.\n// inputs ↹ outputs\n$chord1 $follow-chord1.1...1.M\t$output1\n$chord2 $follow-chord2.1...2.M\t$output2\n// ...\n$chordN $follow-chordN.1...N.M\t$outputN\n----\n\nThe format is two columns separated by a single Tab character.\nThe first column is input and the second is output.\n\n[cols=\"1,4\"]\n|===\n|`$chord`\n| A set of characters.\nYou can use space by including it as the first character in the chord;\nfor an example see `Alphabet` in the sample below.\nWith 0 optional follow chords,\nthe corresponding output on the same line (`$output`)\nwill activate when zippy is enabled\nand all the defined chord keys are pressed simultaneously.\nThe order of presses is not important.\n\n| `$follow-chord`\n| 0 or more chords, used the same way as `$chord`.\nHaving follow chords means the `$output` on the same line\nwill activate upon first activating the earlier chord(s) in the same line,\nreleasing all keys, and pressing the keys in `$follow-chordN.M`.\nFollow chords are separated from the previous chord by a space.\nIf using a space in the follow chord, use two spaces;\nfor an example see `Washington` in the sample below.\n\n| `$output`\n| The characters to type when the chord and optional follow chord(s)\nare all pressed by the user.\nThis is separated from the input chord column\nby a single Tab character.\nThe characters are typed in sequence\nand must all be singular-name key names\nas one would configure in `defsrc`.\nA capitalized single-character key name\nwill be parsed successfully\nand these will be outputted alongside Shift to output the capitalized key.\nAdditionally, `output-character-mappings` configuration can be used\nto inform kanata of additional mappings that may use Shift or AltGr.\n|===\n\n**Examples**\n\n.Sample kanata configuration\n[source]\n----\n(defzippy\n zippy.txt\n on-first-press-chord-deadline 500\n idle-reactivate-time 500\n smart-space-punctuation (? ! . , ; :)\n output-character-mappings (\n ;; This should work for US international.\n ! S-1\n ? S-/\n % S-5\n \"(\" S-9\n \")\" S-0\n : S-;\n < S-,\n > S-.\n r#\"\"\"# S-'\n | S-\\\n _ S--\n ® AG-r\n ’ (no-erase `)\n é (single-output ' e)\n )\n)\n----\n\n.Sample zippy file content\n\n[source]\n----\ndy\tday\ndy 1\tMonday\ndy 2\tTuesday\n abc\talphabet\n w a\tWashington\ngi\tgit\ngi f p\tgit fetch -p\n----\n\n**Description**\n\nZippychord is yet another chording mechanism in Kanata.\nThe inspiration behind it is primarily the\nhttps://github.com/psoukie/zipchord[zipchord project].\nThe name is similar; it is named \"zippy\" instead of \"zip\" because\nKanata's implementation is not a port and does not aim for 100%\nbehavioural compatibility.\n\nThe intended use case is shorthands, or accelerating character output.\nWithin zippychord, inputs are keycode chords or sequences,\nand the outputs are also purely keycodes.\nIn other words, all other actions are unsupported;\ne.g. layers, switch, one-shot.\n\nZippychord behaves on outputted keycodes, i.e. the key outputs\nafter kanata has finished processing your\ninputs, layers, switch logic and other configurations.\nThis is similar to how sequences operate\nand is unlike chords(v1) and chordsv2.\nFurthermore, outputs are all eager like `visible-backspaced` on sequences.\nIf a zippychord activation occurs, typed keys are backspaced.\n\nTo give an example, if one configures zippychord with a line like:\n\n[source]\n----\ngi\tgit\n----\n\nthen either of the following typing event sequences\nwill erase the input characters\nand then proceed to type the output \"git\"\nlike if it was `(macro bspc bspc g i t)`.\n\n[source]\n----\n(press g) (press i)\n(press i) (press g)\n----\n\nNote that there aren't any release events listed.\nTo contrast, the following event sequence would not result in an activation:\n\n[source]\n----\n(press g) (release g) (press i)\n----\n\nZippychord supports fully overlapping chords and sequences.\nFor example, this configuration is allowed:\n\n[source]\n----\ngi\tgit␣\ngi s\tgit␣status\ngi c\tgit checkout␣\ngi c b\tgit checkout -b␣\ngi c a\tgit commit --amend␣\ngi c n\tgit commit --amend --no-edit\ngi c a m\tgit commit --amend -m 'FIX_THIS_COMMIT_MESSAGE'\n----\n\nWhen you begin with the `(g i)` chord, you can follow up\nwith various character sequences to output different git commands.\nThis use case is quite similar to git aliases.\nOne advantage of zippychord is that it eagerly shows you\nthe true underlying command as you type.\n" }, { "path": "docs/design.md", "content": "# Design doc\n\n## Obligatory diagram\n\n\n\n## main\n\n- read args\n- read config\n- start event loops\n\n## event loop\n\n- read key events\n- send events to processing loop on channel\n\n## processing loop\n\n- check for events on mpsc\n- if event: send event to layout\n- tick() the keyberon layout, send any events needed\n- if no event: sleep for 1ms\n- separate monotonic time checks, because can't rely on sleep to be\n fine-grained or accurate\n- send `ServerMessage`s to the TCP server\n\n## TCP server\n\n- listen for `ClientMessage`s and act on them\n- recv `ServerMessage`s from processing loop and forward to all connected\n clients\n\n## layout\n\n- uses keyberon\n- indices of `kanata_keyberon::layout::Event::{Press, Release}(x,y)`:\n\n x = 0 or 1 (0 is for physical key presses, 1 is for fake keys)\n y = OS code of key used as an index\n\n## OS-specific code\n\nMost of the OS specific code is in `oskbd/` and `keys/`. There's a bit of it in\n`kanata/` since the event loops to receive OS events are different.\n" }, { "path": "docs/fancy_symbols.md", "content": "### Supported key symbols\n\n |Symbol(s)[^1] \t|Key `name` \t|\n |--------- \t|-------- \t|\n |‹x x› \t| Left/Right modifiers (e.g., ‹⎈ LCtrl) \t|\n |⇧ \t| Shift \t|\n |⎈ ⌃ \t| Control \t|\n |⌘ ◆ ❖ \t| Windows/Command \t|\n |⎇ ⌥ \t| Alt \t|\n |⇪ \t| capslock \t|\n |⎋ \t|`escape` \t|\n |⭾ ↹ \t|`tab` \t|\n |␠ ␣ \t| `spc` spacebar \t|\n |␈ ⌫ \t|`bspc` backspace (delete backward) |\n |␡ ⌦ \t|`del` delete forward \t|\n |⏎ ↩ ⌤ ␤ \t|`ret` return or enter \t|\n |︔ ⸴ ．⁄ \t|semicolon `;` / comma `,` / period `.` / slash `/`\t|\n |⧵ ＼ \t| backslash `\\` \t|\n |﹨ < \t|`non_us_backslash` \t|\n |【 「 〔 ⎡ \t|`open_bracket` \t|\n |】 」 〕 ⎣ \t|`close_bracket` \t|\n |ˋ ˜ \t|`grave_accent_and_tilde` \t|\n |‐ ₌ \t|`hyphen` `equal_sign` \t|\n |▲ ▼ ◀ ▶ \t|`up`/`down`/`left`/`right` (arrows) |\n |⇞ ⇟ \t|`pgup`/`pgdn` (page up, page down)\t |\n |⎀ \t|`insert` \t|\n |⇤ ⤒ ↖ \t|`home` \t|\n |⇥ ⤓ ↘ \t|`end` \t|\n |⇭ \t|`numlock` \t|\n |🔢₁ 🔢₂ 🔢₃ 🔢₄ 🔢₅\t|`keypad_` `1`–`5` \t|\n |🔢₆ 🔢₇ 🔢₈ 🔢₉ 🔢₀\t|`keypad_` `6`–`0` \t|\n |🔢₋ 🔢₌ 🔢₊ \t|`keypad_` `hyphen`/`equal_sign`/`plus` \t|\n |🔢⁄ 🔢．🔢∗ \t|`keypad_` `slash`/`period`/`asterisk` \t|\n |◀◀ ▶⏸ ▶▶ \t|`vk_consumer_` `previous`/`play`/`next`\t|\n |🔊 🔈+ or ➕₊⊕ \t|`volume_up` \t|\n |🔉 🔈− or ➖₋⊖ \t|`volume_down` \t|\n |🔇 🔈⓪ or ⓿ ₀ \t|`mute` \t|\n |🔆 🔅 \t|`vk_consumer_brightness_` `up`/`down` \t|\n |⌨💡+ or ➕₊⊕ \t|`vk_consumer_illumination_up` \t|\n |⌨💡− or ➖₋⊖ \t|`vk_consumer_illumination_down` \t|\n |🎛 \t|`vk_dashboard` \t|\n |▤ ☰ 𝌆 \t|`application` \t|\n |🖰1 🖰2 ... 🖰5 \t|`button` `1`–`5` \t|\n |‹🖰 🖰› \t|`button` `1` `2` \t|\n\n[^1]: space-separated list of keys; `or` means only last symbol in a pair changes\n" }, { "path": "docs/interception.md", "content": "# Windows Interception driver implementation notes\n\n- Interception handle is `!Send` and `!Sync`\n - means a single thread should own both input and output\n - `KbdOut` will need to send keyboard output events to that thread as opposed\n to Linux using `uinput` and the original Windows code using `SendInput`\n which are independent of the input devices.\n - Maybe save channel in kanata struct as part of new kanata\n- Interception can filter for only keyboard events\n - should use this filter feature; don't want to intercept mouse\n- Need to save previous device for sending to, in case wait/receive (with\n timeout) don't return anything so that sending stuff can be sent to some\n device.\n- Input `ScanCode` maps to the keyberon `KeyCode`; they both use the USB\n standard codes.\n - For ease of integration will probably need to unfortunately convert it to\n an `OsCode` even though the processing loop will soon after just convert it\n back to `KeyCode`. Oh well.\n" }, { "path": "docs/kmonad_comparison.md", "content": "# Comparison with kmonad\n\nThe kmonad project is the closest alternative for this project.\n\n## Benefits of kmonad over kanata\n\n- ~MacOS support~ (this is implemented now)\n- Different features\n\n## Why I built and use kanata\n\n- [Double-tapping a tap-hold key](https://github.com/kmonad/kmonad/issues/163) did not behave\n [how I want it to](https://docs.qmk.fm/#/tap_hold?id=tapping-force-hold)\n- Some key sequences with tap-hold keys [didn't behave how I want](https://github.com/kmonad/kmonad/issues/466):\n - `(press lsft) (press a) (release lsft) (release a)` (a is a tap-hold key)\n - The above outputs `a` in kmonad, but I want it to output `A`\n- kmonad was missing [mouse buttons](https://github.com/kmonad/kmonad/issues/150)\n\nThe issues listed are all fixable in kmonad and I hope they are one day! For me\nthough, I didn't and still don't know Haskell well enough to contribute to\nkmonad. That's why I instead built kanata based off of the excellent work that\nhad already gone into the\n[keyberon](https://github.com/TeXitoi/keyberon),\n[ktrl](https://github.com/ItayGarin/ktrl), and\n[kbremap](https://github.com/timokroeger/kbremap) projects.\n\nIf you want to see the features that kanata offers, the\n[configuration guide](./config.adoc) is a good starting point.\n\nI dogfood kanata myself and it works great for my use cases. Though kanata is a\nyounger project than kmonad, it now has more features. If you give kanata a\ntry, feel free to ask for help in an issue or discussion, or let me know how it\nwent 🙂.\n" }, { "path": "docs/locales.adoc", "content": "////\nCommented out since it doesn't seem to add anything for now, but maybe in the future\n:sectlinks:\n:sectanchors:\n////\n\nifdef::env-github[]\n:tip-caption: :bulb:\n:note-caption: :information_source:\n:important-caption: :heavy_exclamation_mark:\n:caution-caption: :fire:\n:warning-caption: :warning:\nendif::[]\n\n= Keyboard locales\n\n////\nCommented out since doc is short enough without a ToC for the time being.\n:toc:\n:toc-title: pass:[TABLE OF CONTENTS]\n:toclevels: 3\n////\n\n== ISO 100% Keyboard (event.code)\n\nNOTE: Tested on Linux only\n\n[%collapsible]\n====\n----\n(defsrc\n Escape F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PrintScreen ScrollLock Pause\n Backquote Digit1 Digit2 Digit3 Digit4 Digit5 Digit6 Digit7 Digit8 Digit9 Digit0 Minus Equal Backspace Insert Home PageUp NumLock NumpadDivide NumpadMultiply NumpadSubtract\n Tab KeyQ KeyW KeyE KeyR KeyT KeyY KeyU KeyI KeyO KeyP BracketLeft BracketRight Enter Delete End PageDown Numpad7 Numpad8 Numpad9 NumpadAdd\n CapsLock KeyA KeyS KeyD KeyF KeyG KeyH KeyJ KeyK KeyL Semicolon Quote Backslash Numpad4 Numpad5 Numpad6\n ShiftLeft IntlBackslash KeyZ KeyX KeyC KeyV KeyB KeyN KeyM Comma Period Slash ShiftRight ArrowUp Numpad3 Numpad2 Numpad1 NumpadEnter\n ControlLeft MetaLeft AltLeft Space AltRight MetaRight ContextMenu ControlRight ArrowLeft ArrowDown ArrowRight Numpad0 NumpadDecimal \n)\n----\n====\n\n== ISO German QWERTZ (Windows, non-interception)[[german]]\n\n=== Using `deflocalkeys-win`:[[german-defwin]]\n\n[%collapsible]\n====\n----\n(defcustomkeys\n ü 186\n + 187\n # 191\n ö 192\n ß 219\n ^ 220\n ´ 221\n ä 222\n < 226\n)\n\n(defsrc\n ^ 1 2 3 4 5 6 7 8 9 0 ß ´ bspc\n tab q w e r t z u i o p ü +\n caps a s d f g h j k l ö ä # ret\n lsft < y x c v b n m , . - rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n----\n====\n\n=== Without using `deflocalkeys`:[[german-nodeflocalkeys]]\n\n[%collapsible]\n====\n----\n(defsrc\n \\ 1 2 3 4 5 6 7 8 9 0 [ ] bspc\n tab q w e r t z u i o p ; =\n caps a s d f g h j k l grv ' / ret\n lsft 102d y x c v b n m , . - rsft\n lctl lmet lalt spc ralt rmet rctl\n)\n----\n====\n\n=== Example aliases[[german-aliases]]\n\n[%collapsible]\n====\n----\n(defalias\n ;; shifted german keys\n ! S-1\n ˝ S-2 ;; unicode 02DD ˝ look-a-like is used because @\" is no valid alias, to be displayed correctly\n ;; in console requires a font that can - e.g. cascadia\n §\tS-3\n $\tS-4\n %\tS-5\n &\tS-6\n /\tS-7\n ﴾\tS-8 ;; unicode FD3E ﴾ look-a-like is used because @( is no valid alias, to be displayed correctly...\n ﴿\tS-9 ;; unicode FD3F ﴿ look-a-like is used because @) is no valid alias, to be displayed correctly ...\n =\tS-0\n ? S-ß\n * S-+\n ' S-#\n ; S-,\n : S-.\n _ S--\n > S-<\n < < ;; not really needed but having @< and @> looks consistent\n\n ;; change dead keys in normal keys\n ´ (macro ´ spc )\t ;; ´ \n ` (macro S-´ spc ) ;; `\n ^ (macro ^ spc ) ;; ^ = \\ - shifting @^ will produce an incorrect space now\n ° S-^\n \n ;; AltGr german keys\n ~ A-C-+\n \\ A-C-ß\n ẞ A-C-S-ß\n | A-C-<\n } A-C-0\n { A-C-7\n ] A-C-9\n [ A-C-8\t\n € A-C-e\n @ A-C-q\n ² A-C-2\n ³ A-C-3\n µ A-C-m\n)\n----\n====\n\n== ISO German QWERTZ (MacOS)[[german]]\n\n=== Using `deflocalkeys-macos`:[[german-defmac]]\n\n[%collapsible]\n====\n----\n(deflocalkeys-macos\n ß 12\n ´ 13\n z 21\n ü 26\n + 27\n ö 39\n ä 40\n < 41\n # 43\n y 44\n - 53\n ^ 86\n)\n\n(defsrc\n ⎋ f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12\n ^ 1 2 3 4 5 6 7 8 9 0 ß ´ ⌫\n ↹ q w e r t z u i o p ü +\n ⇪ a s d f g h j k l ö ä # ↩\n ‹⇧ < y x c v b n m , . - ▲ ⇧›\n fn ‹⌃ ‹⌥ ‹⌘ ␣ ⌘› ⌥› ◀ ▼ ▶\n)\n----\n====\n\n== ISO French Azerty (MacOS)[[french]]\n\n=== Using `deflocalkeys-macos`:[[french-defmac]]\n\n[%collapsible]\n====\n----\n(deflocalkeys-macos\n @ 50\n par 12 ;; Close parentheses\n - 13\n ^ 73\n $ 164\n ù 85\n ` 192\n < 41\n / 191\n = 53\n a 16\n q 30\n z 17\n w 44\n m 39\n)\n\n(defsrc\n ⎋ f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12\n @ 1 2 3 4 5 6 7 8 9 0 par - ⌫\n ↹ a z e r t y u i o p ^ $\n ⇪ q s d f g h j k l m ù ` ↩\n ‹⇧ < w x c v b n , . / = ▲ ⇧›\n fn ‹⌃ ‹⌥ ‹⌘ ␣ ⌘› ⌥› ◀ ▼ ▶\n)\n----\n====\n\n== ISO French AZERTY (Windows, non-interception)[[french]]\n\nNOTE: This is for the https://kbdlayout.info/kbdfr?arrangement=ISO105[French AZERTY layout] (ISO105 arrangement). Tested on Windows only.\n\n[%collapsible]\n====\n----\n(deflocalkeys-win\n\tk252 223 ;; ref to the key [!] (VK_OEM_8)\n)\n\n(defsrc ;; french\n ' 1 2 3 4 5 6 7 8 9 0 [ eql bspc\n tab a z e r t y u i o p ] ;\n caps q s d f g h j k l m ` bksl ret\n lsft nubs w x c v b n comm . / k252 rsft\n lctl lmet lalt spc ralt rctl\n)\n----\n====\n\n== ISO Turkish QWERTY (Linux)[[turkish]]\n\nNOTE: This is for the https://kbdlayout.info/kbdtuq?arrangement=ISO105[Turkish QWERTY layout] (ISO105 arrangement). Tested on Linux only.\n\n[%collapsible]\n====\n----\n(deflocalkeys-linux\n\t* \t12\n\t- \t13\n\tı \t23\n\tğ \t26\n\tü \t27\n\tş \t39\n\tİ \t40\n\t, \t43\n\t< \t86\n\tö \t51\n\tç \t52\n\t. \t53\n)\n\n(defsrc ;; turkish-iso105\n\tgrv \t1\t2\t3\t4\t5\t6\t7\t8\t9\t0\t*\t-\tbspc\n\ttab \tq\tw\te\tr\tt\ty\tu\tı\to\tp\tğ\tü\n\tcaps \ta\ts\td\tf\tg\th\tj\tk\tl\tş\tİ\t,\tret\n\tlsft \t<\tz\tx\tc\tv\tb\tn\tm\tö\tç\t.\t\trsft\n\tlctl\tlmet\tlalt\t\t\t\tspc\t\t\t\t\tralt\trmet\trctl\n)\n\n;; We use İ instead of i because kanata doesn't allow using i in deflocalkeys, as it is a default key name.\n----\n====\n\n== ABNT2 Brazillian Portuguese QWERTY (Linux)[[portuguese]]\n\nNOTE: This is for the https://kbdlayout.info/kbdbr[ABNT2 QWERTY layout]. Tested on Linux only.\n\n[%collapsible]\n====\n----\n(deflocalkeys-linux\n ´ 26\n [ 27\n ç 39\n ~ 40\n ' 41\n ] 43\n ; 53\n \\ 86\n / 89\n)\n\n(defsrc ;; brazillian-abnt2\n esc f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12 \n ' 1 2 3 4 5 6 7 8 9 0 - = bspc\n tab q w e r t y u i o p ´ [ ret\n caps a s d f g h j k l ç ~ ] \n lsft \\ z x c v b n m , . ; rsft\n lctl lmet lalt spc ralt /\n)\n----\n====\n\n== ISO Swedish QWERTY (Linux)[[swedish]]\n\n[%collapsible]\n====\n----\n;; Swedish ISO105\n(deflocalkeys-linux\n § 41\n + 12\n ´ 13 ;; Acute accent. Opposite to the grave accent (grv).\n å 26\n ¨ 27\n ö 39\n ä 40\n ' 43\n < 86\n , 51\n . 52\n - 53\n)\n\n(defsrc ;; Swedish ISO105\n § 1 2 3 4 5 6 7 8 9 0 + ´ bspc\n tab q w e r t y u i o p å ¨\n caps a s d f g h j k l ö ä ' ret\n lsft < z x c v b n m , . - rsft\n lctl lmet lalt spc ralt rmet menu rctl\n)\n\n;; Empty layer that matches the Swedish layout\n(deflayer default\n _ _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _ _ _ _ _ _\n _ _ _ _ _ _ _ _\n)\n----\n====\n\n\n== Swedish QWERTY Localkeys (Windows)[[swedish]]\n\n[%collapsible]\n====\n----\n(deflocalkeys-win\n § 220\n + 187\n ´ 219\n å 221\n ¨ 186\n ö 192\n ä 222\n ' 191\n < 226\n , 188\n . 190\n - 189\n)\n----\n====\n" }, { "path": "docs/platform-known-issues.adoc", "content": "= Hardware known issues\n\nAt the electric circuit layer of many keyboards,\ncost-saving measures can lead to key presses not registering\nwhen pressing multiple keys simultaneously.\nUsually this happens with at least 3 key presses.\nKanata cannot fix this issue.\nYou can work around it by avoiding\nthe problem key combination,\nor using a different keyboard.\n\n= Platform-dependent known issues\n\n== Preface\n\nThis document contains a list of known issues\nwhich are unique to a given platform.\nThe platform supported by the core maintainer (jtroo)\nare Windows 11 and Linux.\nWindows 10 is expected to work fine,\nbut as Windows 10 end-of-support is approaching in 2025,\njtroo no longer has any devices with it installed.\n\nOn Windows, there are two backing mechanisms that can be used\nfor keyboard input/output and they have different issues.\nThese will be differentiated by the words \"LLHOOK\" and \"Interception\",\nwhich map to the binaries\n`kanata.exe` and `kanata_wintercept.exe` respectively.\n\n== Windows 11 LLHOOK\n\n* Some input key combinations (e.g. Win+L) cannot be intercepted before\n running their default action\n** https://github.com/jtroo/kanata/issues/192\n** https://github.com/jtroo/kanata/discussions/428\n* OS-level key remapping behaves differently vs. Linux or Interception\n** Does not affect winiov2 variant\n** https://github.com/jtroo/kanata/issues/152\n* Certain applications that also use the LLHOOK mechanism may not behave correctly\n** https://github.com/jtroo/kanata/issues/55\n** https://github.com/jtroo/kanata/issues/250\n** https://github.com/jtroo/kanata/issues/430\n** https://github.com/espanso/espanso/issues/1488\n* AltGr / ralt / Right Alt can misbehave\n** https://github.com/jtroo/kanata/blob/main/docs/config.adoc#windows-only-windows-altgr\n* NumLock state can mess with arrow keys in unexpected ways\n** Does not affect winiov2 variant\n** https://github.com/jtroo/kanata/issues/78\n** https://github.com/jtroo/kanata/issues/667\n** Workaround: use the correct https://github.com/jtroo/kanata/discussions/354[numlock state]\n* Without `process-unmapped-keys yes`, using arrow keys\nwithout also having the shift keys in `defsrc` will break shift highlighting\n** Does not affect winiov2 variant\n** https://github.com/jtroo/kanata/issues/858\n** Workaround: add shift keys to `defsrc` or use `process-unmapped-keys yes` in `defcfg`\n\n== Windows 11 Interception\n\n* Sleeping your system or unplugging/replugging devices enough times causes\n inputs to stop working\n** https://github.com/oblitum/Interception/issues/25\n* Some less-frequently used keys are not supported or handled correctly\n** https://github.com/jtroo/kanata/issues/127\n** https://github.com/jtroo/kanata/issues/164\n** https://github.com/jtroo/kanata/issues/425\n** https://github.com/jtroo/kanata/issues/532\n\n== Linux\n\n* Key repeats can occur when they normally wouldn't in some cases\n** https://github.com/jtroo/kanata/discussions/422\n** https://github.com/jtroo/kanata/issues/450\n** https://github.com/jtroo/kanata/issues/1441\n* Unicode support has varying success due to many applications\n not supporting the `ibus` input mechanism.\n Using xkb to map keys to unicode\n or using clipboard actions are more consistent solutions\n** https://github.com/jtroo/kanata/discussions/703\n* Key actions can behave incorrectly due to the rapidity of key events\n** https://github.com/jtroo/kanata/discussions/733\n** https://github.com/jtroo/kanata/issues/740\n** adjusting https://github.com/jtroo/kanata/blob/main/docs/config.adoc#rapid-event-delay[rapid-event-delay] can potentially be a workaround\n* Macro keys on certain gaming keyboards might stop being processed\n** Context: search for `POTENTIAL PROBLEM - G-keys` in\nlink:../src/kanata/mod.rs[the code].\n** Workaround: leave `process-unmapped-keys` disabled\nand explicitly map keys in `defsrc` instead\n\n== MacOS\n\n* Only left, right, and middle mouse buttons are implemented for clicking\n* Mouse input processing is not implemented, e.g. putting `mlft` into `defsrc` does nothing\n" }, { "path": "docs/release-template.md", "content": "## Configuration guide\n\n\n\nLink to the appropriate configuration guide version: [guide link TODO: FIX LINK](https://github.com/jtroo/kanata/blob/FIXME/docs/config.adoc).\n\n## Changelog (since )\n\n
\nChange log\n* TODO: fill this out\n
\n\n## Sample configuration file\n\nThe attached `kanata.kbd` file is tested to work with the current version. The one in the `main` branch of the repository may have extra features that are not supported in this release.\n\n## Windows\n\n
\nInstructions\n\nDownload the appropriate `kanata-windows-variant.zip` file for your machine CPU. Extract and move the desired binary variant to its intended location. Optionally, download `kanata.kbd`. With the two files in the same directory, you can double-click the extracted `.exe` file to start kanata. Kanata does not start a background process, so the window needs to stay open after startup. See [this discussion](https://github.com/jtroo/kanata/discussions/193) for tips to run kanata in the background.\n\nYou need to run via `cmd` or `powershell` to use a different configuration file:\n\n`kanata_windows_binaryvariant.exe --cfg `\n\n### Binary variants\n\nExplanation of items in the binary variant:\n\n- x64 vs. arm64:\n - Select x64 if your machine's CPU is Intel or AMD. If ARM, use arm64.\n- tty vs gui:\n - tty runs in a terminal, gui runs as a system tray application\n- cmd\\_allowed vs. not\n - cmd\\_allowed allows the `cmd` actions; otherwise, they are compiled out of the application\n- winIOv2 vs. wintercept\n - winIOv2 uses the LLHOOK and SendInput Windows mechanisms to intercept and send events.\n - wintercept uses the [Interception driver](https://github.com/oblitum/Interception). Beware of its known issue that disables keyboards and mice until system reboot: [Link to issue](https://github.com/oblitum/Interception/issues/25).\n - you will need to install the driver using the release or from the [copy in this repo](https://github.com/jtroo/kanata/tree/main/assets).\n - the benefit of using this driver is that it is a lower-level mechanism than Windows hooks, and `kanata` will work in more applications.\n\n### wintercept installation\n\n#### Steps to install the driver\n\n- extract the `.zip`\n- run a shell with administrator privilege\n- run the script `\"command line installer/install-interception.exe\"`\n- reboot\n\n#### Additional installation steps\n\nThe above steps are those recommended by the interception driver author. However, I have found that those steps work inconsistently and sometimes the dll stops being able to be loaded. I suspect it has something to do with being installed in the privileged location of `system32\\drivers`.\n\nTo help with the dll issue, you can copy the following file in the zip archive to the directory that kanata starts from: `Interception\\library\\x64\\interception.dll`.\n\nE.g. if you start kanata from your `Documents` folder, put the file there:\n\n**Example:**\n\n```\nC:\\Users\\my_user\\Documents\\\n kanata_windows_wintercept_x64.exe\n kanata.kbd\n interception.dll\n```\n\n### kanata\\_passthru_x64.dll\n\nThe Windows `kanata_passthru_x64.dll` file allows using Kanata as a library within AutoHotkey to avoid conflicts between keyboard hooks installed by both. You can channel keyboard input events received by AutoHotkey into Kanata's keyboard engine and get the transformed keyboard output events (per your Kanata config) that AutoHotkey can then send to the OS.\n\nTo make use of this, take `kanata_passthru_x64.dll`, then the [simulated\\_passthru\\_ahk](https://github.com/jtroo/kanata/blob/main/docs/simulated_passthru_ahk) folder with a brief example, place the dll there, open `kanata_passthru.ahk` to read what the example does and then double-click to launch it.\n\n
\n\n## Linux\n\n
\nInstructions\n\nDownload the `kanata-linux-x64.zip` file.\n\n Extract and move the desired binary variant to its intended location. Run the binary in a terminal and point it to a valid configuration file. Kanata does not start a background process, so the window needs to stay open after startup. See [this discussion](https://github.com/jtroo/kanata/discussions/130) for how to set up kanata with systemd.\n\n**Example:**\n\n```\nchmod +x kanata # may be downloaded without executable permissions\nsudo ./kanata_linux_x64 --cfg `\n```\n\nTo avoid requiring `sudo`, [follow the instructions here](https://github.com/jtroo/kanata/wiki/Avoid-using-sudo-on-Linux).\n\n### Binary variants\n\nExplanation of items in the binary variant:\n\n- cmd\\_allowed vs. not\n - cmd\\_allowed allows the `cmd` actions; otherwise, they are compiled out of the application\n\n
\n\n## macOS\n\n
\nInstructions\n\nThe supported Karabiner driver version in this release is `v6.2.0`.\n\n**WARNING**: macOS does not support mouse as input. The `mbck` and `mfwd` mouse button actions are also not operational.\n\n### Binary variants\n\nExplanation of items in the binary variant:\n\n- x64 vs. arm64:\n - Select x64 if your machine's CPU is Intel. If ARM, use arm64.\n- cmd\\_allowed vs. not\n - cmd\\_allowed allows the `cmd` actions; otherwise, they are compiled out of the application\n\n### Instructions for macOS 11 and newer\n\nYou must use the Karabiner driver version `v6.2.0`.\n\nPlease read through this issue comment:\n\nhttps://github.com/jtroo/kanata/issues/1264#issuecomment-2763085239\n\nAlso have a read through this discussion:\n\nhttps://github.com/jtroo/kanata/discussions/1537\n\nAt some point it may be beneficial to provide concise and accurate instructions within this documentation. The maintainer (jtroo) does not own macOS devices to validate; please contribute the instructions to the file `docs/release-template.md` if you are able.\n\n### Install Karabiner driver for macOS 10 and older:\n\n- Install the [Karabiner kernel extension](https://github.com/pqrs-org/Karabiner-VirtualHIDDevice).\n\n### After installing the appropriate driver for your OS (both macOS <=10 and >=11)\n\nDownload the appropriate `kanata-macos-variant.zip` for your machine CPU.\n\nExtract and move the desired binary variant to its intended location. Run the binary in a terminal and point it to a valid configuration file. Kanata does not start a background process, so the window needs to stay open after startup.\n\n**Example:**\n\n```\nchmod +x kanata_macos_arm64 # may be downloaded without executable permissions\nsudo ./kanata_macos_arm64 --cfg `\n```\n\n### Add permissions\n\nIf Kanata is not behaving correctly, you may need to add permissions. Please see this issue: [link to macOS permissions issue](https://github.com/jtroo/kanata/issues/1211).\n\n
\n\n## sha256 checksums\n\n
\nSums\n\n```\nTODO: fill this out\n```\n\n
\n" }, { "path": "docs/sequence-adding-chords-ideas.md", "content": "# Sequence improvement: sequence chords\n\n## Preface\n\nThis document is a record of designing/braindumping\nfor the improvement to the sequences feature to add chord support.\nIt is left in an informal and disorganized state \n— as opposed to a being presentable design doc — out of laziness.\nApologies ahead of time if you read this and it's hard to follow,\nfeel free to contribute a PR to create a new and more polished doc.\n\n## Motivation\n\nThe desire is to be able to add output chords to a sequence.\nThe effect of this is that: `(S-(a b))` can be differentiated from `(S-a b)`.\nToday, chords are not supported at all.\nThe two sequences above could be written as `(lsft a b)`;\nhowever, the code today has no way to decide the difference\nbetween `lsft` being applied to only `a` or to both `a` and `b`.\n\nThe feature will codenamed \"seqchords\" for brevity in this document.\n\n## An exploration of an idea: track releases?\n\nToday, the sequence `(lsft a b c)` doesn't care when the `lsft`,\nor even `a` or `b` are released relative to when the subsequent keys\nare pressed. However, with seqchords, the code could be potentially changed to\nmake sequences release-aware.\n\nIt seems a little difficult to integrate\nthis into the trie structure used to track sequences though.\nWith an implementation that is release-aware,\nit seems like the code would need to figure out how to conditionally\nadd release events to the trie, depending if the seq was\n`(lsft a)` or `(S-a)`\n\nFor now, I think a different approach would be better.\n\n## A different idea: modify presses held with mod keys.\n\nThe current sequence type is `Vec` since keys don't fit into `u8`.\nHowever, there are fewer than 1024 (2^10) keys total.\nThat means there are 6 bits to play with.\n6 bits are enough for the types of modifiers (of which there are 4),\nbut differentiating both sides (increases to 8).\nPerhaps one only cares to use both left and right shifts though, and maybe\nboth left and right alts.\nOne could also use a `u32` instead, but that seems unnecessary for now.\nI see no backwards compatibility issues if one\ndesired that change in the future.\n\nWith this in mind, while modifiers are held, set the upper unused bits of\nthe stored `u16` values.\n\n### Backwards compatibility?\n\nThis does mean that `(lsft a b)` behaves differently\nwith vs. without seqchords.\nUnless maybe the code automatically generates the various permutations\nof this type of sequence, but that seems complicated.\nOr maybe have a `u16` with a special bit pattern that could be used\nto differentiate between `(S-(a b))` and `(lsft a b)`.\nFor now, let's say that the bit pattern is `0xFFFF`.\nIf a modifier is pressed and the sequence `[..., , 0xFFFF]`\nexists in the trie: continue processing the sequence in mod-aware mode.\n\nOR for simplicity, just say \"screw backwards compatibility\" and force users\nto be clear about what they mean and define the extra permutations, if they\nwant them. I prefer this.\n\n### Data format examples\n\nLet's begin the description of the new data format.\nSince shifted keys seem like they will be the main use case for seqchords,\nonly that will be described in this document for now.\nHere are the numerical key values relevant to the examples.\n\n- `a: 0x001E`\n- `b: 0x0030`.\n- `lsft: 0x002A`.\n\nThis differs by OS, but that's not important.\n\nThe transformation of `(lsft a b)` to a sequence in the trie today\nlooks like:\n\n- `[0x002A, 0x001E, 0x0030]`\n\nThis will remain unchanged with seqchords.\nLet's say that chorded keys using `lsft`\nwill have the otherwise-unused MSB (bit 15) set.\n\nThe transformation of some sequences using chords will be:\n\n1. `(S-(a b)) => [0x802A, 0x801E, 0x8030]`\n2. ` (S-a b) => [0x802A, 0x801E, 0x0030]`\n3. `(S-a S-b) => [0x802A, 0x801E, 0x802A, 0x8030]`\n\nNotably, `lsft` is modifying its own upper bits.\nThis should simplify the implementation logic\nso that the code does not need to add a special-case check\nthat the newly-pressed key is itself a modifier.\n\nOne may need to define different sequences if one wishes to use both\nleft and right shifts to be able to trigger these shifted sequences.\nThe syntax does not exist today, but maybe `(S-(a b))` and `(RS-(a b))`\nas an example for left and right shifts.\nThe reason different sequences would be required is because the\nsequence->trie check operates on the integers that correspond to the keycodes.\n\nConsideration: maybe there could be transformations for the right modifier\nkeys to ensure they get translated to the left modifier keys.\nThis seems like it could be a sensible default to start with.\nIf a change is desired in the future to **not** do this transformation,\nit doesn't seem too difficult to add a configuration item to do so.\nFor now that will be left out, deferring to the YAGNI principle.\n\n### Backwards compatibility revisited\n\nThinking back on the topic of backwards compatibility,\nI'm scrapping that idea of special bit patterns.\nI thought of a probably-better way:\nbacktracking with modifier cancellation.\n\nBy default when seqchords gets added,\nthe modified bit patterns will be used\nto check in the trie for valid sequences.\nHowever, with a `defcfg` item `sequence-backtrack-modcancel`\n— which should be `yes` by default for back-compat reasons —\nif the code encounters an invalid sequence with the modded bit pattern,\nit will try again with the unmodded bit pattern, and only if that does not\nmatch will sequence-mode end with an invalid termination.\nThis backtracking can be turned off if desired,\ne.g. if it behaves badly in some future seqchords use cases.\n" }, { "path": "docs/setup-linux.md", "content": "# Instructions\n\nIn Linux, kanata needs to be able to access the input and uinput subsystem to inject events. To do this, your user needs to have permissions. Follow the steps in this page to obtain user permissions.\n\n### 1. Create the uinput group (if it doesn’t exist)\n\n```bash\nsudo groupdel uinput 2>/dev/null\nsudo groupadd --system uinput\n```\n\n### 2. Add your user to the `input` and `uinput` group\n\n```sh\nsudo usermod -aG input $USER\nsudo usermod -aG uinput $USER\n```\n\nVerify:\n\n```sh\ngroups\n```\n\nYou may need to log out and back in for it to take effect.\n\n### 3. Load the uinput kernel module\n\n```sh\nsudo modprobe uinput\n```\n\nThis ensures `/dev/uinput` exists.\n\n### 4. Make sure the uinput device file has the right permissions.\n\nCreate the udev rule:\n\n```bash\nsudo tee /etc/udev/rules.d/99-input.rules > /dev/null < /dev/uinput\n```\n\n## 5. (Optional) Run Kanata immediately if the group change isn’t active\n\nIf `uinput` is not listed in `groups` even after adding your user:\n\n```bash\nnewgrp uinput -c kanata\n```\n\nThis temporarily gives the current shell the `uinput` group so kanata can access `/dev/uinput` until the next login.\n\n### 6a. (Optional) Create and enable a systemd user service\n\nFirst, create the directory for user services:\n\n```bash\nmkdir -p ~/.config/systemd/user\n```\n\nThen add this to: `~/.config/systemd/user/kanata.service`:\n\n```bash\n[Unit]\nDescription=Kanata keyboard remapper\nDocumentation=https://github.com/jtroo/kanata\n\n[Service]\nEnvironment=PATH=/usr/local/bin:/usr/local/sbin:/usr/bin:/bin\n# Uncomment the 4 lines beneath this to increase process priority\n# of Kanata in case you encounter lagginess when resource constrained.\n# WARNING: doing so will require the service to run as an elevated user such as root.\n# Implementing least privilege access is an exercise left to the reader.\n#\n# CPUSchedulingPolicy=rr\n# CPUSchedulingPriority=99\n# IOSchedulingClass=realtime\n# Nice=-20\nType=simple\nExecStart=/usr/bin/sh -c 'exec $$(which kanata) --cfg $${HOME}/.config/kanata/config.kbd --no-wait'\nRestart=on-failure\nRestartSec=3\n\n[Install]\nWantedBy=default.target\n```\n\nNote: The `--no-wait` flag is required for `Restart=on-failure` to work.\nWithout it, kanata waits for user input on exit, which blocks automatic restart.\n\nMake sure to update the executable location for sh in the snippet above.\nThis would be the line starting with `ExecStart=/usr/bin/sh -c`.\nYou can check the executable path with:\n\n```bash\nwhich sh\n```\n\nAlso, verify if the path to kanata is included in the line `Environment=PATH=[...]`.\nFor example, if executing `which kanata` returns `/home/[user]/.cargo/bin/kanata`, the `PATH` line should be appended with `/home/[user]/.cargo/bin` or `:%h/.cargo/bin`.\n`%h` is one of the specifiers allowed in systemd, more can be found in https://www.freedesktop.org/software/systemd/man/latest/systemd.unit.html#Specifiers\n\nThen run:\n\n```bash\nsystemctl --user daemon-reload\nsystemctl --user enable kanata.service\nsystemctl --user start kanata.service\nsystemctl --user status kanata.service # check whether the service is running\n```\n\n### 6b. To create and enable an OpenRC daemon service\n\nEdit new file `/etc/init.d/kanata` as root, replacing \\ as appropriate:\n\n```bash\n#!/sbin/openrc-run\n\ncommand=\"/home//.cargo/bin/kanata\"\n#command_args=\"--config=/home//.config/kanata/kanata.kbd\"\n\ncommand_background=true\npidfile=\"/run/${RC_SVCNAME}.pid\"\n\ncommand_user=\"\"\n```\n\nThen run:\n\n```\nsudo chmod +x /etc/init.d/kanata # script must be executable\nsudo rc-service kanata start\nrc-status # check that kanata isn't listed as [ crashed ]\nsudo rc-update add kanata default # start the service automatically at boot\n```\n\n# Credits\n\nThe original text was taken and adapted from: https://github.com/kmonad/kmonad/blob/master/doc/faq.md#linux\n" }, { "path": "docs/simulated_output/sim.kbd", "content": "(defcfg\n process-unmapped-keys\tyes\t;;|no| enable processing of keys that are not in defsrc, useful if mapping a few keys in defsrc instead of most of the keys on your keyboard. Without this, the tap-hold-release and tap-hold-press actions will not activate for keys that are not in defsrc. Disabled because some keys may not work correctly if they are intercepted. E.g. rctl/altgr on Windows; see the windows-altgr configuration item above for context.\n log-layer-changes \tyes\t;;|no| overhead\n)\n(defvar ;; declare commonly-used values. prefix with $ to call them. They are refered with `$`\n tap-repress-timeout \t1000 ;;|500|\n hold-timeout\t 1500 ;;|500|\n 🕐↕ \t $tap-repress-timeout\n 🕐🠿 \t $hold-timeout\n)\n(defalias\n ;; home row mods ↕tap 🠿hold\n ;; pinky ring middle index | index middle ring pinky\n ;; \t timeout ↕tap 🠿hold¦↕tap 🠿hold action\n ⌂‹◆\t(tap-hold-release $🕐↕ $🕐🠿 a ‹◆)\t;;\n ⌂‹⎇\t(tap-hold-release $🕐↕ $🕐🠿 s ‹⎇)\t;;\n ⌂‹⎈\t(tap-hold-release $🕐↕ $🕐🠿 d ‹⎈)\t;;\n ⌂‹⇧\t(tap-hold-release $🕐↕ $🕐🠿 f ‹⇧)\t;;\n ⌂⇧›\t(tap-hold-release $🕐↕ $🕐🠿 j ⇧›)\t;; same actions for the right side\n ⌂⎈›\t(tap-hold-release $🕐↕ $🕐🠿 k ⎈›)\t;;\n ⌂⎇›\t(tap-hold-release $🕐↕ $🕐🠿 l ⎇›)\t;;\n ⌂◆›\t(tap-hold-release $🕐↕ $🕐🠿 ; ◆›)\t;;\n)\n\n(defsrc\n` 1 2\na\ts\td\tf\t\t\tj\tk\tl\t;)\n(deflayer ⌂ ;; modtap layer for home row mods and 1 printing a 🤲🏿 char (will appear as 🤲 until kanata's unicode feature is extended)\n ‗ 🔣🤲🏿 ‗\n @⌂‹◆ @⌂‹⎇ @⌂‹⎈ @⌂‹⇧ @⌂⇧› @⌂⎈› @⌂⎇› @⌂◆›)\n" }, { "path": "docs/simulated_output/sim.txt", "content": "↓j 🕐1600 ↓l 🕐5000 ↓1 🕐50 ↑1 🕐50 ↓1 🕐50 ↑1 🕐50 ↑j 🕐50 ↑l 🕐50\n" }, { "path": "docs/simulated_output/sim_out.txt", "content": "🕐Δms│ 1500 100 1500 3500 50 50 50 50 50\nIn───┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n k↑ │ 1 1 J L\n k↓ │ J L 1 1\n k⟳ │\nΣin │ ↓J 🕐1600 ↓L 🕐5000 ↓1 🕐50 ↑1 🕐50 ↓1 🕐50 ↑1 🕐50 ↑J 🕐50 ↑L 🕐50\nOut──┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n k↑ │ ⇧› ⎇›\n k↓ │ ⇧› ⎇›\n 🖰↑ │\n 🖰↓ │\n 🖰 │\n 🔣 │ 🤲 🤲\n code│\n raw↑│\n raw↓│\nΣout │ ↓⇧› ↓⎇› 🤲 🤲 ↑⇧› ↑⎇›\n" }, { "path": "docs/simulated_passthru_ahk/[COPY HERE] kanata_passthru.dll _", "content": "" }, { "path": "docs/simulated_passthru_ahk/kanata_dll.kbd", "content": ";;Test config for kanata.dll use by AutoHotkey, only maps two keys (f,j) to left/right modtap home row mod Shifts\n(defcfg\n process-unmapped-keys\tyes\t;;|no| enable processing of keys that are not in defsrc\n log-layer-changes \tno \t;;|no| overhead\n)\n\n(defvar\n 🕐↕\t1000 ;;|500| tap-repress-timeout\n 🕐🠿\t1500 ;;|500| hold-timeout\n )\n(defalias\t;; timeout→ \ttap\t hold ¦\t tap\t hold ←action\n f⌂‹⇧ \t(tap-hold-release\t$🕐↕\t$🕐🠿 \tf \t‹⇧)\n j⌂⇧› \t(tap-hold-release\t$🕐↕\t$🕐🠿 \tj \t⇧›)\n )\n\n(defsrc f j )\n(deflayer ⌂ @f⌂‹⇧ @j⌂⇧›)\n" }, { "path": "docs/simulated_passthru_ahk/kanata_passthru.ahk", "content": "#Requires AutoHotKey 2.1-alpha.4\n/*\nA short example of using Kanata as a library with AutoHotkey, first F8 press will load the library, second F8 press will activate Kanata for a few (ihDuration) seconds with 'f'/'j' turned into home row Shift mods.\nThe more useful script would not use F8, but f/j directly as hotkeys, but this owl hasn't been drawn yet...\nBoth Kanata and this script mainly output to Windows debug log, use github.com/smourier/TraceSpy to view it\nDependencies and config:\n*/\n libPath \t:= \"./\" \t; kanata_passthru.dll @ this folder\n kanata_cfg\t:= \"./kanata_dll.kbd\"\t; kanata config @ this file location\n ihDuration\t:= 10 \t; seconds of activity after pressing F8\n dbg \t:= 1 \t; script's debug level (0 to silence some of its output)\n dbg_dll \t:= 1 ; kanata's debug level (Err=1 Warn=2 Inf=3 Dbg=4 Trace=5)\n/*\nBrief overview of the architecture:\nSetup:\n - AHK: configures cbKanataOut callback to Send keys out and shares its address with Kanata\n - Kanata: exports 4 functions\n - fnKanata_main: set up paths to config and initialize\n - fnKanata_in_ev: get input key events\n - K_output_ev_check: check if output key events exist\n - fnKanata_reset: reset Kanata's state without exiting\n! AHK enables inputhook, so intercepts all keyboard input\n← Redirects all intercepted input to Kanata, where we hit 2 limitations\n ✗ Kanata can't send keys out itself as it'll be intercepted by AHK's inputhook\n ✗ Kanata's thread that processes input can't call AHK function in the main thread since AHK is single-threaded\n✓ Kanata opens an async channel from the input processing thread (with Keyberon state machine) to its main\n ← sends key out data back to the main thread\n → our script after sending input keys calls Kanata to read this channel until it's empty, and then Sends these keys out\n*/\n\nget_thread_id() {\n return DllCall(\"GetCurrentThreadId\", \"UInt\")\n}\n\nF8::kanata_dll('vk77')\nkanata_dll(vkC) {\n ; static K\t:= keyConstant , vk := K._map, sc := K._mapsc ; various key name constants, gets vk code to avoid issues with another layout\n ; , s \t:= helperString ; K.▼ = vk['▼']\n static is_init := false\n ,lErr:=1, lWarn:=2, lInf:=3, lDbg:=4, lTrace:=5, log_lvl := dbg_dll ; Kanata's\n ,last↓ := [0,0]\n ,id_thread := get_thread_id()\n ,Cvk_d := GetKeyVK(vkC), Csc_d := GetKeySC(vkC), token1 := 1, ih0 := 0 ; decimal value\n ,C↑ := false, cleanup := false ; track whether the trigger key has been released to not release it twice on kanata cleanup\n ; set up machinery for AHK and Kanata to communicate\n ,libNm \t:= \"kanata_passthru\"\n ,lib𝑓 \t:= libNm '\\' 'lib_kanata_passthru' ; receives AHK's address of AHK's cb KanataOut that accepts simulated output events\n ,lib𝑓input_ev \t:= libNm '\\' 'input_ev_listener' ; receives key input and uses event_loop's input event handler callback (which will in turn communicate via the internal kanata's channels to keyberon state machine etc.)\n ,lib𝑓output_ev \t:= libNm '\\' 'output_ev_check' ; checks if output event is ready (it's sent to our callback if it is)\n ,lib𝑓reset \t:= libNm '\\' 'reset_kanata_state' ; reset kanata's state\n ,hModule \t:= DllCall(\"LoadLibrary\", \"Str\",libPath libNm '.dll', \"Ptr\") ; Avoids the need for DllCall in the loop to load the library\n ,fnKanata_main \t:= DllCall.Bind(lib𝑓, 'Ptr',unset, 'Str',unset, 'Int',unset)\n ,fnKanata_in_ev \t:= DllCall.Bind(lib𝑓input_ev, 'Int',unset , 'Int',unset, 'Int',unset)\n ,K_output_ev_check\t:= DllCall.Bind(lib𝑓output_ev)\n ,fnKanata_reset \t:= DllCall.Bind(lib𝑓reset, 'Int',unset)\n static ih := InputHook(\"T\" ihDuration \" I1\")\n , 🕐k_pre := A_TickCount\n , 🕐k_now := A_TickCount\n hooks := \"hooks#: \" gethookcount()\n\n addr_cbKanataOut := CallbackCreate(cbKanataOut)\n if not is_init {\n is_init := true\n\n ; setup inputhook callback functions\n ih.KeyOpt( \t'{All}','NSI') ; N: Notify. OnKeyDown/OnKeyUp callbacks to be called each time the key is pressed\n ih.OnKeyDown\t:= cbK↓.Bind(1)\t;\n ih.OnKeyUp \t:= cbK↑.Bind(0)\t;\n\n OutputDebug('¦' id_thread \"¦registered inputhook with VisibleText=\" ih.VisibleText \" VisibleNonText=\" ih.VisibleNonText \"`nIlevel=\" ih.MinSendLevel ' hooks#: ' gethookcount() ' →kanata addr#' addr_cbKanataOut)\n fnKanata_main(addr_cbKanataOut,kanata_cfg,log_lvl) ; setup kanata, passign ahk callback to accept out key events\n return\n }\n\n cbK↓(token, ih,vk,sc) {\n static _d := 1, isUp := false, dir := (isUp?'↑':'↓')\n 🕐k_pre := 🕐k_now\n 🕐k_now := A_TickCount\n if (dbg>=_d) {\n dbgtxt := ''\n vk_hex := Format(\"vk{:x}\",vk)\n key_name := GetKeyName(Format(\"vk{:x}\",vk)) ; bugs with layouts, not english even if english is active\n dbgtxt .= \"ih\" dir (isSet(key_name)?key_name:'') \" 🢥🄺: vk=\" vk \"¦\" vk_hex \" sc=\" sc ' l' A_SendLevel \" ¦\" id_thread \"¦\"\n OutputDebug(dbgtxt)\n }\n isH := fnKanata_in_ev(vk,sc,isUp)\n dbgOut := ''\n for i in [4,4,4,5,5,5] { ; poll a key out channel@kanata) a few times to see if there are key events\n sleep(i)\n isOut := K_output_ev_check(), dbgOut.=isOut\n if (isOut < 0) { ; get as many keys as are available untill reception errors out\n break\n }\n } ;🔚∎🏁\n (dbg<_d+1)?'':(dbgtxt:='🏁ih' dir ' pos isH=' isH ' isOut=' dbgOut ' ' format(\" 🕐Δ{:.3f}\",A_TickCount - 🕐k_now) ' ' A_ThisFunc ' ¦' id_thread '¦', OutputDebug(dbgtxt))\n }\n cbK↑(token, ih,vk,sc) {\n static _d := 1, isUp := true, dir := (isUp?'↑':'↓')\n 🕐k_pre := 🕐k_now\n 🕐k_now := A_TickCount\n if (dbg>=_d) {\n dbgtxt := ''\n vk_hex := Format(\"vk{:x}\",vk)\n key_name := GetKeyName(Format(\"vk{:x}\",vk)) ; bugs with layouts, not english even if english is active\n dbgtxt .= \"ih\" dir (isSet(key_name)?key_name:'') \" 🢥🄺: vk=\" vk \"¦\" vk_hex \" sc=\" sc ' l' A_SendLevel \" ¦\" id_thread \"¦\"\n OutputDebug(dbgtxt)\n }\n isH := fnKanata_in_ev(vk,sc,isUp)\n dbgOut := ''\n for i in [4,4,4,5,5,5] { ; poll a key out channel@kanata) a few times to see if there are key events\n sleep(i)\n isOut := K_output_ev_check(), dbgOut.=isOut\n if (isOut < 0) { ; get as many keys as are available until reception errors out\n break\n }\n }\n (dbg<_d+1)?'':(dbgtxt:='🏁ih' dir ' pos isH=' isH ' isOut=' dbgOut ' ' format(\" 🕐Δ{:.3f}\",A_TickCount - 🕐k_now) ' ' A_ThisFunc ' ¦' id_thread '¦', OutputDebug(dbgtxt))\n }\n ; set up machinery for AHK to receive data from kanata\n cbKanataOut(kvk,ksc,up) {\n ; static K\t:= keyConstant, vk:=K._map, vkr:=K._mapr, vkl:=K._maplng, vkrl:=K._maprlng, vk→en:=vkrl['en'], sc:=K._mapsc ; various key name constants, gets vk code to avoid issues with another layout\n static _d := 1, lvl_to := 0\n 🕐1 := preciseTΔ()\n vk_hex := Format(\"vk{:x}\",kvk)\n if not C↑ && up && (kvk=Cvk_d) {\n C↑ := true , (dbg<_d)?'':(OutputDebug('trigger key released'))\n }\n if cleanup && C↑ && up && (kvk=Cvk_d) { ; todo: check for physical position before excluding?\n (dbg<_d)?'':(OutputDebug(\"dupe release of trigger key on kanata's cleanup, ignore\"))\n C↑ := false\n return\n }\n ; Critical ; todo: needed??? avoid being interrupted by itself (or any other thread)\n if (dbg>=_d) {\n dbgtxt := ''\n dir := (up?'↑':'↓')\n key_name := GetKeyName(vk_hex) ; bugs with layouts, not english even if english is active\n ; key_name := vk→en.Get(vk_hex,key_name_cur)\n hooks := \"hooks#: \" gethookcount()\n dbgtxt .= dir\n }\n if isSet(vk_hex) {\n (dbg<_d)?'':(dbgtxt .= key_name \" 🄷🢦 : vk=\" kvk '¦' vk_hex ' @l' A_SendLevel ' → ' lvl_to ' ' hooks ' ¦' id_thread '¦ ' A_ThisFunc, OutputDebug(dbgtxt))\n if up {\n ; SendEvent('{' vk_hex ' up}')\n SendInput('{' vk_hex ' up}')\n } else {\n ; SendEvent('{' vk_hex ' down}')\n SendInput('{' vk_hex ' down}')\n }\n } else {\n (dbg<_d)?'':(dbgtxt .= '✗name' \" 🄷🢦 : vk=\" kvk '¦' vk_hex ' @l' A_SendLevel ' → ' lvl_to ' ' hooks ' ¦' id_thread '¦ ' A_ThisFunc, OutputDebug(dbgtxt))\n }\n 🕐2 := preciseTΔ(), 🕐Δ := 🕐2-🕐1\n if 🕐Δ > 0.5 {\n (dbg<_d+1)?'':(OutputDebug('🐢🏁 ' format(\" 🕐Δ{:.3f}\",🕐Δ) ' ¦' id_thread '¦ ' A_ThisFunc))\n } else {\n (dbg<_d+1)?'':(OutputDebug('🐇🏁 ' format(\" 🕐Δ{:.3f}\",🕐Δ) ' ¦' id_thread '¦ ' A_ThisFunc))\n }\n return 1\n }\n ; CallbackFree(cbKanataOut)\n\n if (Cvk_d) { ; modtap; send the activating hotkey to Kanata so it can take it into acount\n cbK↓(token1,ih0,Cvk_d,Csc_d)\n }\n ih.Start()\t\t;\n ih.Wait() \t\t; Waits until the Input is terminated (InProgress is false)\n if (ih.EndReason = \"Timeout\") { ; cleanup kanata's state\n ; key_name := GetKeyName(Format(\"vk{:x}\",last↓[1]))\n OutputDebug('—`n`n——————————————— Timeout')\n 🕐k_now := A_TickCount, 🕐Δ := 🕐k_now - 🕐k_pre\n cleanup := true\n res := fnKanata_reset(🕐Δ) ; reset kanata's state, progressing time to catch up, release held keys (even those physically held since reset is reset, so from kanata's perspective they should be released)\n cleanup := false\n dbgtxt := ''\n dbgtxt .= 'ih¦' 🕐Δ '🕐Δ timeout A_TimeSinceThisHotkey ' A_TimeSinceThisHotkey\n dbgOut := ''\n loop 10 { ; get the remaining out keys from kanata\n isOut := K_output_ev_check(), dbgOut.=isOut\n if (isOut < 0) {\n break\n }\n }\n OutputDebug(dbgtxt '`n`n——————————————— isOut=' dbgOut ' ')\n }\n\n ; DllCall(\"FreeLibrary\", \"Ptr\",hModule) ; to conserve memory, the DLL may be unloaded after using it\n hModule:=0\n}\n\ngethookcount() {\n if (A_KeybdHookInstalled = 0) {\n return \"_¦_\"\n } else if (A_KeybdHookInstalled = 3) {\n return \"✓¦✓\"\n } else if (A_KeybdHookInstalled = 2) {\n return \"_¦✓\"\n } else if (A_KeybdHookInstalled = 1) {\n return \"✓¦_\"\n } else {\n return \"?\"\n }\n}\n\npreciseTΔ(n:=3) {\n static start := nativeFunc.GetSystemTimePreciseAsFileTime()\n t := round( nativeFunc.GetSystemTimePreciseAsFileTime() - start,n)\n return t\n}\nclass nativeFunc {\n static GetSystemTimePreciseAsFileTime() {\n /* learn.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getsystemtimepreciseasfiletime\n retrieves the current system date and time with the highest possible level of precision (<1us)\n FILETIME structure contains a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC)\n 100 ns -> 0.1 µs -> 0.001 ms -> 0.00001 s\n 1 sec -> 1000 ms -> 1000000 µs\n 0.1 sec -> 100 ms -> 100000 µs\n 0.001 sec -> 10 ms -> 10000 µs\n */\n static interval2sec := (10 * 1000 * 1000) ; 100ns * 10 → µs * 1000 → ms * 1000 → sec\n DllCall(\"GetSystemTimePreciseAsFileTime\", \"int64*\",&ft:=0)\n return ft / interval2sec\n }\n}\n" }, { "path": "docs/switch-design", "content": "# Preface:\n\nThis document is a scratch space for the design of the switch action.\nIt may be out of date and is kept around for posterity.\n\n.syntax:\n----\n(switch\n (or a b c) (cmd ) break\n (and a b (or c d)) (cmd ) fallthrough\n (and a b (or c d) (or e f)) fallthrough\n ()\n)\n----\n\n\n.opcode format examples:\n----\n(or a b c)\nOR-4 a b c\n\n(and a b (or c d))\nAND-6 a b OR-6 c d\n\n(and a b (or c d) (or e f))\nAND-9 a b OR-6 c d OR-9 e f\n----\n\n.opcodes:\n----\nkey: all values < 1024\nOR/AND: OP & 0xF000\n OR : 0x1000\n AND: 0x2000\n length: OP & 0x0FFF\n----\n\n.Rough algorithm for opcodes:\n----\nvalue=true\npush first opcode\nWHILE stack is not empty\n WHILE index <= ending_index\n switch\n opcode:\n push, continue\n key(OR):\n value=true: skip to index, pop\n value=false: continue\n key(AND):\n value=true: continue\n value=false: skip to index, pop\n pop\n switch\n current_value(OR):\n value=true: skip to index, pop\n value=false: continue\n current_value(AND):\n value=true: continue\n value=false: skip to index, pop\nreturn value\n----\n\n.statestruct:\n----\n value\n current_index\n current_end_index\n current_op\n stack (op, ending_index)\n----\n\n.rough sequence 1:\n----\npressed: y y y y y y\nopcodes: AND-9 a b OR-6 c d OR-9 e f\n\nindex: 0\n push: AND-9\n stack: AND-9\n\nindex: 1\n val: true\n\nindex: 2\n val: true\n\nindex: 3\n push: OR-6\n stack: AND-9 OR-6\n\nindex: 4\n val: true\n skip to 6\n pop\n stack: AND-9\n\nindex: 6\n push: OR-9\n stack: AND-9 OR-9\n\nindex: 7\n val: true\n skip to 9\n pop\n stack: AND-9-true\n\nindex 9:\n pop\n stack: empty\n return val: true\n----\n\n.rough sequence 2:\n----\npressed: y y n n y y\nopcodes: AND-9 a b OR-6 c d OR-9 e f\n\nindex: 0\n push: AND-9\n stack: AND-9\n\nindex: 1\n val: true\n\nindex: 2\n val: true\n\nindex: 3\n push: OR-6\n stack: AND-9 OR-6\n val: true\n\nindex: 4\n val: false\n\nindex: 5\n val: false\n\nindex: 6\n val: false\n pop\n stack: AND-9\n skip to 9\n pop\n stack: empty\n return val: false\n----\n\n.rough sequence 3:\n----\npressed: n y n n y y\nopcodes: AND-9 a b OR-6 c d OR-9 e f\n\nindex: 0\n push: AND-9\n stack: AND-9\n\nindex: 1\n val: false\n skip to 9\n pop\n stack: empty\n return val: false\n----\n\n\n.pseudo code again:\n----\nlet mut value = true\nlet mut current_index = 1\nlet mut current_end_index = first_opcode - end_index\nlet mut current_op = OR\nwhile current_index < slice_length {\n if index >= current_end_index:\n if stack is empty:\n break\n else:\n pop stack to current_op and current_end_index\n switch\n current_value(OR):\n value=true: skip to current_end_index; continue\n current_value(AND):\n value=false: skip to current_end_index; continue\n switch\n opcode:\n push (current_end_index,current_op)\n update (current_end_index,current_op) with opcode\n key(OR):\n value=true: skip to current_end_index; continue\n value=false\n key(AND):\n value=true\n value=false: skip to current_end_index; continue\n current_index++;\n}\nreturn value\n----\n" }, { "path": "example_tcp_client/.gitignore", "content": "target\n" }, { "path": "example_tcp_client/Cargo.toml", "content": "[package]\nname = \"kanata_example_tcp_client\"\ndescription = \"Example kanata TCP client\"\nversion = \"1.1.0\"\nedition = \"2021\"\nlicense = \"LGPL-3.0\"\nauthors = [\"jtroo \"]\n\n[dependencies]\nanyhow = \"1\"\nclap = { version = \"4\", features = [ \"derive\" ] }\nkanata-tcp-protocol = { path = \"../tcp_protocol\" }\nlog = \"0.4.8\"\nsimplelog = \"0.12\"\nserde_json = \"1\"" }, { "path": "example_tcp_client/src/main.rs", "content": "use clap::Parser;\nuse kanata_tcp_protocol::*;\nuse simplelog::*;\nuse std::io::{BufRead, BufReader, Write, stdin};\nuse std::net::{SocketAddr, TcpStream};\nuse std::process::exit;\nuse std::time::Duration;\n\n#[derive(Parser, Debug)]\n#[clap(author, version, about, long_about = None)]\nstruct Args {\n /// Port that kanata's TCP server is listening on\n #[clap(short, long)]\n port: Option,\n\n /// Enable debug logging\n #[clap(short, long)]\n debug: bool,\n\n /// Enable trace logging (implies --debug as well)\n #[clap(short, long)]\n trace: bool,\n}\n\nfn main() {\n let args = Args::parse();\n init_logger(&args);\n print_usage();\n\n let port = match args.port {\n Some(p) => p,\n None => {\n log::error!(\"no port provided via the -p|--port flag; exiting\");\n exit(1);\n }\n };\n log::info!(\"attempting to connect to kanata\");\n let kanata_conn = TcpStream::connect_timeout(\n &SocketAddr::from(([127, 0, 0, 1], port)),\n Duration::from_secs(5),\n )\n .expect(\"connect to kanata\");\n log::info!(\"successfully connected\");\n let writer_stream = kanata_conn.try_clone().expect(\"clone writer\");\n let reader_stream = kanata_conn;\n std::thread::spawn(move || write_to_kanata(writer_stream));\n read_from_kanata(reader_stream);\n}\n\nfn print_usage() {\n log::info!(\n \"\\n\\\n You can also use any other software to connect to kanata over TCP.\\n\\\n The protocol is plaintext JSON with newline terminated messages.\n\\n\\\n Layer change notifications from kanata look like:\\n\\\n {}\n\\n\\\n Requests to change kanata's layer look like:\\n\\\n {}\n\\n\\\n Configuration reload commands:\\n\\\n - reload: {}\\n\\\n - reload next: {}\\n\\\n - reload previous: {}\\n\\\n - reload specific index: {}\\n\\\n - reload specific file: {}\n\\n\\\n Server responses for commands look like:\\n\\\n - Success: {}\\n\\\n - Error: {}\n \",\n serde_json::to_string(&ServerMessage::LayerChange {\n new: \"newly-changed-to-layer\".into()\n })\n .expect(\"deserializable\"),\n serde_json::to_string(&ClientMessage::ChangeLayer {\n new: \"requested-layer\".into()\n })\n .expect(\"deserializable\"),\n serde_json::to_string(&ClientMessage::Reload {\n wait: None,\n timeout_ms: None\n })\n .expect(\"deserializable\"),\n serde_json::to_string(&ClientMessage::ReloadNext {\n wait: None,\n timeout_ms: None\n })\n .expect(\"deserializable\"),\n serde_json::to_string(&ClientMessage::ReloadPrev {\n wait: None,\n timeout_ms: None\n })\n .expect(\"deserializable\"),\n serde_json::to_string(&ClientMessage::ReloadNum {\n index: 1,\n wait: None,\n timeout_ms: None\n })\n .expect(\"deserializable\"),\n serde_json::to_string(&ClientMessage::ReloadFile {\n path: \"/path/to/config.kbd\".to_string(),\n wait: None,\n timeout_ms: None,\n })\n .expect(\"deserializable\"),\n serde_json::to_string(&ServerResponse::Ok).expect(\"deserializable\"),\n serde_json::to_string(&ServerResponse::Error {\n msg: \"Invalid config index: 5. Only 2 configs are available (0-1).\".to_string()\n })\n .expect(\"deserializable\"),\n )\n}\n\nfn init_logger(args: &Args) {\n let log_lvl = match (args.debug, args.trace) {\n (_, true) => LevelFilter::Trace,\n (true, false) => LevelFilter::Debug,\n (false, false) => LevelFilter::Info,\n };\n let mut log_cfg = ConfigBuilder::new();\n if let Err(e) = log_cfg.set_time_offset_to_local() {\n eprintln!(\"WARNING: could not set log TZ to local: {e:?}\");\n };\n CombinedLogger::init(vec![TermLogger::new(\n log_lvl,\n log_cfg.build(),\n TerminalMode::Mixed,\n ColorChoice::AlwaysAnsi,\n )])\n .expect(\"init logger\");\n log::info!(\n \"kanata_example_tcp_client v{} starting\",\n env!(\"CARGO_PKG_VERSION\")\n );\n}\n\nfn write_to_kanata(mut s: TcpStream) {\n log::info!(\"writer starting\");\n log::info!(\"writer: enter commands to send to kanata:\");\n log::info!(\" - layer name: change to that layer\");\n log::info!(\" - fk:KEYNAME: tap fake key\");\n log::info!(\" - reload: reload current config\");\n log::info!(\" - reload-next: reload next config\");\n log::info!(\" - reload-prev: reload previous config\");\n log::info!(\" - reload-num:N: reload config at index N\");\n log::info!(\" - reload-file:PATH: reload config file at PATH\");\n let mut input = String::new();\n loop {\n stdin().read_line(&mut input).expect(\"stdin is readable\");\n let command = input.trim_end().to_owned();\n\n let msg = if command.starts_with(\"fk:\") {\n let fkname = command.trim_start_matches(\"fk:\").into();\n log::info!(\"writer: telling kanata to tap fake key \\\"{fkname}\\\"\");\n serde_json::to_string(&ClientMessage::ActOnFakeKey {\n name: fkname,\n action: FakeKeyActionMessage::Tap,\n })\n .expect(\"deserializable\")\n } else if command == \"reload\" {\n log::info!(\"writer: telling kanata to reload current config\");\n serde_json::to_string(&ClientMessage::Reload {\n wait: None,\n timeout_ms: None,\n })\n .expect(\"deserializable\")\n } else if command == \"reload-next\" {\n log::info!(\"writer: telling kanata to reload next config\");\n serde_json::to_string(&ClientMessage::ReloadNext {\n wait: None,\n timeout_ms: None,\n })\n .expect(\"deserializable\")\n } else if command == \"reload-prev\" {\n log::info!(\"writer: telling kanata to reload previous config\");\n serde_json::to_string(&ClientMessage::ReloadPrev {\n wait: None,\n timeout_ms: None,\n })\n .expect(\"deserializable\")\n } else if command.starts_with(\"reload-num:\") {\n let index_str = command.trim_start_matches(\"reload-num:\");\n match index_str.parse::() {\n Ok(index) => {\n log::info!(\"writer: telling kanata to reload config at index {index}\");\n serde_json::to_string(&ClientMessage::ReloadNum {\n index,\n wait: None,\n timeout_ms: None,\n })\n .expect(\"deserializable\")\n }\n Err(_) => {\n log::error!(\"Invalid number format for reload-num: {index_str}\");\n input.clear();\n continue;\n }\n }\n } else if command.starts_with(\"reload-file:\") {\n let path = command.trim_start_matches(\"reload-file:\").to_string();\n log::info!(\"writer: telling kanata to reload config file \\\"{path}\\\"\");\n serde_json::to_string(&ClientMessage::ReloadFile {\n path,\n wait: None,\n timeout_ms: None,\n })\n .expect(\"deserializable\")\n } else {\n log::info!(\"writer: telling kanata to change layer to \\\"{command}\\\"\");\n serde_json::to_string(&ClientMessage::ChangeLayer { new: command })\n .expect(\"deserializable\")\n };\n\n s.write_all(msg.as_bytes()).expect(\"stream writable\");\n input.clear();\n }\n}\n\nfn read_from_kanata(s: TcpStream) {\n log::info!(\"reader starting\");\n let mut reader = BufReader::new(s);\n let mut msg = String::new();\n loop {\n msg.clear();\n reader.read_line(&mut msg).expect(\"stream readable\");\n\n // Try to parse as ServerResponse first (for command responses)\n if let Ok(response) = serde_json::from_str::(&msg) {\n match response {\n ServerResponse::Ok => {\n log::info!(\"✓ Command executed successfully\");\n }\n ServerResponse::Error { msg } => {\n log::error!(\"✗ Command failed: {}\", msg);\n }\n }\n continue;\n }\n\n // Fall back to parsing as ServerMessage (for notifications)\n let parsed_msg: ServerMessage = match serde_json::from_str(&msg) {\n Ok(msg) => msg,\n Err(e) => {\n log::warn!(\"could not parse server message {msg}: {e:?}\");\n std::process::exit(1);\n }\n };\n match parsed_msg {\n ServerMessage::LayerChange { new } => {\n log::info!(\"reader: kanata changed layers to \\\"{new}\\\"\");\n }\n msg => {\n log::info!(\"got msg: {msg:?}\");\n }\n }\n }\n}\n" }, { "path": "interception/Cargo.toml", "content": "[workspace]\nmembers = [\".\"]\n\n[package]\nname = \"kanata-interception\"\ndescription = \"Safe wrapper for Interception. Forked for use with kanata.\"\nversion = \"0.3.0\"\nauthors = [\"Joe Kaushal \"]\nedition = \"2018\"\nrepository = \"https://github.com/jtroo/kanata\"\nlicense = \"MIT OR Apache-2.0\"\n\n[dependencies]\ninterception-sys = \"0.1.3\"\nbitflags = \"1.2.1\"\nnum_enum = \"0.6.0\"\nserde = { version = \"1.0.114\", features = [\"derive\"] }\n" }, { "path": "interception/src/lib.rs", "content": "pub extern crate interception_sys;\n\n#[macro_use]\nextern crate bitflags;\n\npub use interception_sys as raw;\npub mod scancode;\n\npub use scancode::ScanCode;\n\nuse std::convert::{TryFrom, TryInto};\nuse std::default::Default;\nuse std::time::Duration;\nuse std::vec::Vec;\n\npub type Device = i32;\npub type Precedence = i32;\n\npub enum Filter {\n MouseFilter(MouseFilter),\n KeyFilter(KeyFilter),\n}\n\npub type Predicate = extern \"C\" fn(device: Device) -> bool;\n\nbitflags! {\n pub struct MouseState: u16 {\n const LEFT_BUTTON_DOWN = 1;\n const LEFT_BUTTON_UP = 2;\n\n const RIGHT_BUTTON_DOWN = 4;\n const RIGHT_BUTTON_UP = 8;\n\n const MIDDLE_BUTTON_DOWN = 16;\n const MIDDLE_BUTTON_UP = 32;\n\n const BUTTON_4_DOWN = 64;\n const BUTTON_4_UP = 128;\n\n const BUTTON_5_DOWN = 256;\n const BUTTON_5_UP = 512;\n\n const WHEEL = 1024;\n const HWHEEL = 2048;\n\n // MouseFilter only\n const MOVE = 4096;\n }\n}\n\npub type MouseFilter = MouseState;\n\nbitflags! {\n pub struct MouseFlags: u16 {\n const MOVE_RELATIVE = 0;\n const MOVE_ABSOLUTE = 1;\n\n const VIRTUAL_DESKTOP = 2;\n const ATTRIBUTES_CHANGED = 4;\n\n const MOVE_NO_COALESCE = 8;\n\n const TERMSRV_SRC_SHADOW = 256;\n }\n}\n\nbitflags! {\n pub struct KeyState: u16 {\n const DOWN = 0;\n const UP = 1;\n\n const E0 = 2;\n const E1 = 3;\n\n const TERMSRV_SET_LED = 8;\n const TERMSRV_SHADOW = 16;\n const TERMSRV_VKPACKET = 32;\n }\n}\n\nbitflags! {\n pub struct KeyFilter: u16 {\n const DOWN = 1;\n const UP = 2;\n\n const E0 = 4;\n const E1 = 8;\n\n const TERMSRV_SET_LED = 16;\n const TERMSRV_SHADOW = 32;\n const TERMSRV_VKPACKET = 64;\n }\n}\n\n#[derive(Debug, Copy, Clone)]\npub enum Stroke {\n Mouse {\n state: MouseState,\n flags: MouseFlags,\n rolling: i16,\n x: i32,\n y: i32,\n information: u32,\n },\n\n Keyboard {\n code: ScanCode,\n state: KeyState,\n information: u32,\n },\n}\n\nimpl TryFrom for Stroke {\n type Error = &'static str;\n\n fn try_from(raw_stroke: raw::InterceptionMouseStroke) -> Result {\n let state = match MouseState::from_bits(raw_stroke.state) {\n Some(state) => state,\n None => return Err(\"Extra bits in raw mouse state\"),\n };\n\n let flags = match MouseFlags::from_bits(raw_stroke.flags) {\n Some(flags) => flags,\n None => return Err(\"Extra bits in raw mouse flags\"),\n };\n\n Ok(Stroke::Mouse {\n state: state,\n flags: flags,\n rolling: raw_stroke.rolling,\n x: raw_stroke.x,\n y: raw_stroke.y,\n information: raw_stroke.information,\n })\n }\n}\n\nimpl TryFrom for Stroke {\n type Error = &'static str;\n\n fn try_from(raw_stroke: raw::InterceptionKeyStroke) -> Result {\n let state = match KeyState::from_bits(raw_stroke.state) {\n Some(state) => state,\n None => return Err(\"Extra bits in raw keyboard state\"),\n };\n\n let code = match ScanCode::try_from(raw_stroke.code) {\n Ok(code) => code,\n Err(_) => ScanCode::Esc,\n };\n\n Ok(Stroke::Keyboard {\n code: code,\n state: state,\n information: raw_stroke.information,\n })\n }\n}\n\nimpl TryFrom for raw::InterceptionMouseStroke {\n type Error = &'static str;\n\n fn try_from(stroke: Stroke) -> Result {\n if let Stroke::Mouse {\n state,\n flags,\n rolling,\n x,\n y,\n information,\n } = stroke\n {\n Ok(raw::InterceptionMouseStroke {\n state: state.bits(),\n flags: flags.bits(),\n rolling: rolling,\n x: x,\n y: y,\n information: information,\n })\n } else {\n Err(\"Stroke must be a mouse stroke\")\n }\n }\n}\n\nimpl TryFrom for raw::InterceptionKeyStroke {\n type Error = &'static str;\n\n fn try_from(stroke: Stroke) -> Result {\n if let Stroke::Keyboard {\n code,\n state,\n information,\n } = stroke\n {\n Ok(raw::InterceptionKeyStroke {\n code: code as u16,\n state: state.bits(),\n information: information,\n })\n } else {\n Err(\"Stroke must be a keyboard stroke\")\n }\n }\n}\n\npub struct Interception {\n ctx: raw::InterceptionContext,\n}\n\nimpl Interception {\n pub fn new() -> Option {\n let ctx = unsafe { raw::interception_create_context() };\n\n if ctx == std::ptr::null_mut() {\n return None;\n }\n\n Some(Interception { ctx: ctx })\n }\n\n pub fn get_precedence(&self, device: Device) -> Precedence {\n unsafe { raw::interception_get_precedence(self.ctx, device) }\n }\n\n pub fn set_precedence(&self, device: Device, precedence: Precedence) {\n unsafe { raw::interception_set_precedence(self.ctx, device, precedence) }\n }\n\n pub fn get_filter(&self, device: Device) -> Filter {\n if is_invalid(device) {\n return Filter::KeyFilter(KeyFilter::empty());\n }\n\n let raw_filter = unsafe { raw::interception_get_filter(self.ctx, device) };\n if is_mouse(device) {\n let filter = match MouseFilter::from_bits(raw_filter) {\n Some(filter) => filter,\n None => MouseFilter::empty(),\n };\n\n Filter::MouseFilter(filter)\n } else {\n let filter = match KeyFilter::from_bits(raw_filter) {\n Some(filter) => filter,\n None => KeyFilter::empty(),\n };\n\n Filter::KeyFilter(filter)\n }\n }\n\n pub fn set_filter(&self, predicate: Predicate, filter: Filter) {\n let filter = match filter {\n Filter::MouseFilter(filter) => filter.bits(),\n Filter::KeyFilter(filter) => filter.bits(),\n };\n\n unsafe {\n let predicate = std::mem::transmute(Some(predicate));\n raw::interception_set_filter(self.ctx, predicate, filter)\n }\n }\n\n pub fn wait(&self) -> Device {\n unsafe { raw::interception_wait(self.ctx) }\n }\n\n pub fn wait_with_timeout(&self, duration: Duration) -> Device {\n let millis = match u32::try_from(duration.as_millis()) {\n Ok(m) => m,\n Err(_) => u32::MAX,\n };\n\n unsafe { raw::interception_wait_with_timeout(self.ctx, millis) }\n }\n\n pub fn send(&self, device: Device, strokes: &[Stroke]) -> i32 {\n if is_mouse(device) {\n self.send_internal::(device, strokes)\n } else if is_keyboard(device) {\n self.send_internal::(device, strokes)\n } else {\n 0\n }\n }\n\n fn send_internal>(&self, device: Device, strokes: &[Stroke]) -> i32 {\n let mut raw_strokes = Vec::new();\n\n for stroke in strokes {\n if let Ok(raw_stroke) = T::try_from(*stroke) {\n raw_strokes.push(raw_stroke)\n }\n }\n\n let ptr = raw_strokes.as_ptr();\n let len = match u32::try_from(raw_strokes.len()) {\n Ok(l) => l,\n Err(_) => u32::MAX,\n };\n\n unsafe { raw::interception_send(self.ctx, device, std::mem::transmute(ptr), len) }\n }\n\n pub fn receive(&self, device: Device, strokes: &mut [Stroke]) -> i32 {\n if is_mouse(device) {\n self.receive_internal::(device, strokes)\n } else if is_keyboard(device) {\n self.receive_internal::(device, strokes)\n } else {\n 0\n }\n }\n\n fn receive_internal + Default + Copy>(\n &self,\n device: Device,\n strokes: &mut [Stroke],\n ) -> i32 {\n let mut raw_strokes: Vec = Vec::with_capacity(strokes.len());\n raw_strokes.resize_with(strokes.len(), Default::default);\n\n let ptr = raw_strokes.as_ptr();\n let len = match u32::try_from(raw_strokes.len()) {\n Ok(l) => l,\n Err(_) => u32::MAX,\n };\n\n let num_read =\n unsafe { raw::interception_receive(self.ctx, device, std::mem::transmute(ptr), len) };\n\n let mut num_valid: i32 = 0;\n for i in 0..num_read {\n if let Ok(stroke) = raw_strokes[i as usize].try_into() {\n strokes[num_valid as usize] = stroke;\n num_valid += 1;\n }\n }\n\n num_valid\n }\n\n pub fn get_hardware_id(&self, device: Device, buffer: &mut [u8]) -> u32 {\n let ptr = buffer.as_mut_ptr();\n let len = match u32::try_from(buffer.len()) {\n Ok(l) => l,\n Err(_) => u32::MAX,\n };\n\n unsafe {\n raw::interception_get_hardware_id(self.ctx, device, std::mem::transmute(ptr), len)\n }\n }\n}\n\nimpl Drop for Interception {\n fn drop(&mut self) {\n unsafe { raw::interception_destroy_context(self.ctx) }\n }\n}\n\npub extern \"C\" fn is_invalid(device: Device) -> bool {\n unsafe { raw::interception_is_invalid(device) != 0 }\n}\n\npub extern \"C\" fn is_keyboard(device: Device) -> bool {\n unsafe { raw::interception_is_keyboard(device) != 0 }\n}\n\npub extern \"C\" fn is_mouse(device: Device) -> bool {\n unsafe { raw::interception_is_mouse(device) != 0 }\n}\n" }, { "path": "interception/src/scancode.rs", "content": "use num_enum::TryFromPrimitive;\nuse serde::{Deserialize, Serialize};\n\n// ref: https://handmade.network/wiki/2823-keyboard_inputs_-_scancodes,_raw_input,_text_input,_key_names\n#[derive(Serialize, Deserialize, Hash, Debug, Eq, PartialEq, Copy, Clone, TryFromPrimitive)]\n#[repr(u16)]\npub enum ScanCode {\n Esc = 0x01,\n\n Num1 = 0x02,\n Num2 = 0x03,\n Num3 = 0x04,\n Num4 = 0x05,\n Num5 = 0x06,\n Num6 = 0x07,\n Num7 = 0x08,\n Num8 = 0x09,\n Num9 = 0x0A,\n Num0 = 0x0B,\n\n Minus = 0x0C,\n Equals = 0x0D,\n Backspace = 0x0E,\n\n Tab = 0x0F,\n\n Q = 0x10,\n W = 0x11,\n E = 0x12,\n R = 0x13,\n T = 0x14,\n Y = 0x15,\n U = 0x16,\n I = 0x17,\n O = 0x18,\n P = 0x19,\n LeftBracket = 0x1A,\n RightBracket = 0x1B,\n Enter = 0x1C,\n LeftControl = 0x1D,\n A = 0x1E,\n S = 0x1F,\n D = 0x20,\n F = 0x21,\n G = 0x22,\n H = 0x23,\n J = 0x24,\n K = 0x25,\n L = 0x26,\n SemiColon = 0x27,\n Apostrophe = 0x28,\n Grave = 0x29,\n LeftShift = 0x2A,\n BackSlash = 0x2B,\n Z = 0x2C,\n X = 0x2D,\n C = 0x2E,\n V = 0x2F,\n B = 0x30,\n N = 0x31,\n M = 0x32,\n Comma = 0x33,\n Period = 0x34,\n Slash = 0x35,\n RightShift = 0x36,\n NumpadMultiply = 0x37,\n LeftAlt = 0x38,\n Space = 0x39,\n CapsLock = 0x3A,\n F1 = 0x3B,\n F2 = 0x3C,\n F3 = 0x3D,\n F4 = 0x3E,\n F5 = 0x3F,\n F6 = 0x40,\n F7 = 0x41,\n F8 = 0x42,\n F9 = 0x43,\n F10 = 0x44,\n NumLock = 0x45,\n ScrollLock = 0x46,\n Numpad7 = 0x47,\n Numpad8 = 0x48,\n Numpad9 = 0x49,\n NumpadMinus = 0x4A,\n Numpad4 = 0x4B,\n Numpad5 = 0x4C,\n Numpad6 = 0x4D,\n NumpadPlus = 0x4E,\n Numpad1 = 0x4F,\n Numpad2 = 0x50,\n Numpad3 = 0x51,\n Numpad0 = 0x52,\n NumpadPeriod = 0x53,\n AltPrintScreen = 0x54,\n SC_55 = 0x55,\n Int1 = 0x56,\n F11 = 0x57,\n F12 = 0x58,\n SC_59 = 0x59,\n Oem1 = 0x5A,\n Oem2 = 0x5B,\n Oem3 = 0x5C,\n EraseEOF = 0x5D,\n Oem4 = 0x5E,\n Oem5 = 0x5F,\n SC_60 = 0x60,\n SC_61 = 0x61,\n Zoom = 0x62,\n Help = 0x63,\n F13 = 0x64,\n F14 = 0x65,\n F15 = 0x66,\n F16 = 0x67,\n F17 = 0x68,\n F18 = 0x69,\n F19 = 0x6A,\n F20 = 0x6B,\n F21 = 0x6C,\n F22 = 0x6D,\n F23 = 0x6E,\n Oem6 = 0x6F,\n Katakana = 0x70,\n Oem7 = 0x71,\n SC_72 = 0x72,\n SC_73 = 0x73,\n SC_74 = 0x74,\n SC_75 = 0x75,\n F24 = 0x76,\n SBCSChar = 0x77,\n SC_78 = 0x78,\n Convert = 0x79,\n SC_7A = 0x7A,\n NonConvert = 0x7B,\n SC_7C = 0x7C,\n SC_7D = 0x7D,\n SC_7E = 0x7E,\n SC_7F = 0x7F,\n SC_80 = 0x80,\n SC_81 = 0x81,\n SC_82 = 0x82,\n SC_83 = 0x83,\n SC_84 = 0x84,\n SC_85 = 0x85,\n SC_86 = 0x86,\n SC_87 = 0x87,\n SC_88 = 0x88,\n SC_89 = 0x89,\n SC_8A = 0x8A,\n SC_8B = 0x8B,\n SC_8C = 0x8C,\n SC_8D = 0x8D,\n SC_8E = 0x8E,\n SC_8F = 0x8F,\n SC_90 = 0x90,\n SC_91 = 0x91,\n SC_92 = 0x92,\n SC_93 = 0x93,\n SC_94 = 0x94,\n SC_95 = 0x95,\n SC_96 = 0x96,\n SC_97 = 0x97,\n SC_98 = 0x98,\n SC_99 = 0x99,\n SC_9A = 0x9A,\n SC_9B = 0x9B,\n SC_9C = 0x9C,\n SC_9D = 0x9D,\n SC_9E = 0x9E,\n SC_9F = 0x9F,\n SC_A0 = 0xA0,\n SC_A1 = 0xA1,\n SC_A2 = 0xA2,\n SC_A3 = 0xA3,\n SC_A4 = 0xA4,\n SC_A5 = 0xA5,\n SC_A6 = 0xA6,\n SC_A7 = 0xA7,\n SC_A8 = 0xA8,\n SC_A9 = 0xA9,\n SC_AA = 0xAA,\n SC_AB = 0xAB,\n SC_AC = 0xAC,\n SC_AD = 0xAD,\n SC_AE = 0xAE,\n SC_AF = 0xAF,\n SC_B0 = 0xB0,\n SC_B1 = 0xB1,\n SC_B2 = 0xB2,\n SC_B3 = 0xB3,\n SC_B4 = 0xB4,\n SC_B5 = 0xB5,\n SC_B6 = 0xB6,\n SC_B7 = 0xB7,\n SC_B8 = 0xB8,\n SC_B9 = 0xB9,\n SC_BA = 0xBA,\n SC_BB = 0xBB,\n SC_BC = 0xBC,\n SC_BD = 0xBD,\n SC_BE = 0xBE,\n SC_BF = 0xBF,\n SC_C0 = 0xC0,\n SC_C1 = 0xC1,\n SC_C2 = 0xC2,\n SC_C3 = 0xC3,\n SC_C4 = 0xC4,\n SC_C5 = 0xC5,\n SC_C6 = 0xC6,\n SC_C7 = 0xC7,\n SC_C8 = 0xC8,\n SC_C9 = 0xC9,\n SC_CA = 0xCA,\n SC_CB = 0xCB,\n SC_CC = 0xCC,\n SC_CD = 0xCD,\n SC_CE = 0xCE,\n SC_CF = 0xCF,\n SC_D0 = 0xD0,\n SC_D1 = 0xD1,\n SC_D2 = 0xD2,\n SC_D3 = 0xD3,\n SC_D4 = 0xD4,\n SC_D5 = 0xD5,\n SC_D6 = 0xD6,\n SC_D7 = 0xD7,\n SC_D8 = 0xD8,\n SC_D9 = 0xD9,\n SC_DA = 0xDA,\n SC_DB = 0xDB,\n SC_DC = 0xDC,\n SC_DD = 0xDD,\n SC_DE = 0xDE,\n SC_DF = 0xDF,\n SC_E0 = 0xE0,\n SC_E1 = 0xE1,\n SC_E2 = 0xE2,\n SC_E3 = 0xE3,\n SC_E4 = 0xE4,\n SC_E5 = 0xE5,\n SC_E6 = 0xE6,\n SC_E7 = 0xE7,\n SC_E8 = 0xE8,\n SC_E9 = 0xE9,\n SC_EA = 0xEA,\n SC_EB = 0xEB,\n SC_EC = 0xEC,\n SC_ED = 0xED,\n SC_EE = 0xEE,\n SC_EF = 0xEF,\n SC_F0 = 0xF0,\n SC_F1 = 0xF1,\n SC_F2 = 0xF2,\n SC_F3 = 0xF3,\n SC_F4 = 0xF4,\n SC_F5 = 0xF5,\n SC_F6 = 0xF6,\n SC_F7 = 0xF7,\n SC_F8 = 0xF8,\n SC_F9 = 0xF9,\n SC_FA = 0xFA,\n SC_FB = 0xFB,\n SC_FC = 0xFC,\n SC_FD = 0xFD,\n SC_FE = 0xFE,\n SC_NonExtendMax = 0xFF,\n}\n" }, { "path": "justfile", "content": "set windows-shell := [\"powershell.exe\", \"-NoLogo\", \"-Command\"]\n\n# Build the release binaries for Linux and put the binaries+cfg in the output directory\nbuild_release_linux output_dir:\n cargo build --release\n cp target/release/kanata \"{{output_dir}}/kanata\"\n strip \"{{output_dir}}/kanata\"\n cargo build --release --features cmd\n cp target/release/kanata \"{{output_dir}}/kanata_cmd_allowed\"\n strip \"{{output_dir}}/kanata_cmd_allowed\"\n cp cfg_samples/kanata.kbd \"{{output_dir}}\"\n\n# Build the release binaries for Windows and put the binaries+cfg in the output directory.\nbuild_release_windows output_dir:\n cargo build --release --no-default-features --features tcp_server,win_manifest; cp target/release/kanata.exe \"{{output_dir}}\\kanata_legacy_output.exe\"\n cargo build --release --features win_manifest,interception_driver; cp target/release/kanata.exe \"{{output_dir}}\\kanata_wintercept.exe\"\n cargo build --release --features win_manifest,win_sendinput_send_scancodes; cp target/release/kanata.exe \"{{output_dir}}\\kanata.exe\"\n cargo build --release --features win_manifest,win_sendinput_send_scancodes,win_llhook_read_scancodes; cp target/release/kanata.exe \"{{output_dir}}\\kanata_winIOv2.exe\"\n cargo build --release --features win_manifest,cmd,win_sendinput_send_scancodes; cp target/release/kanata.exe \"{{output_dir}}\\kanata_cmd_allowed.exe\"\n cargo build --release --features win_manifest,cmd,interception_driver; cp target/release/kanata.exe \"{{output_dir}}\\kanata_wintercept_cmd_allowed.exe\"\n cargo build --release --features passthru_ahk --package=simulated_passthru; cp target/release/kanata_passthru.dll \"{{output_dir}}\\kanata_passthru.dll\"\n cargo build --release --features win_manifest,gui ; cp target/release/kanata.exe \"{{output_dir}}\\kanata_gui.exe\"\n cargo build --release --features win_manifest,gui,cmd; cp target/release/kanata.exe \"{{output_dir}}\\kanata_gui_cmd_allowed.exe\"\n cargo build --release --features win_manifest,gui,interception_driver ; cp target/release/kanata.exe \"{{output_dir}}\\kanata_gui_wintercept.exe\"\n cargo build --release --features win_manifest,gui,cmd,interception_driver; cp target/release/kanata.exe \"{{output_dir}}\\kanata_gui_wintercept_cmd_allowed.exe\"\n cp cfg_samples/kanata.kbd \"{{output_dir}}\"\n\n# Generate the sha256sums for all files in the output directory\nsha256sums output_dir:\n rm -f {{output_dir}}/sha256sums\n cd {{output_dir}}; sha256sum * > sha256sums\n\ntest:\n cargo test -p kanata -p kanata-parser -p kanata-keyberon -p kanata-wasm -p kanata-tcp-protocol -- --nocapture\n cargo test --features=simulated_output sim_tests\n cargo test --features=simulated_output -- must_be_single_threaded --ignored --test-threads=1\n cargo clippy --all\n\nfmt:\n cargo fmt --all\n\n[doc('Run fmt, check, and clippy')]\ncheck:\n cargo fmt --all\n cargo check\n cargo clippy --all\n\nguic:\n cargo check --features=gui\nguif:\n cargo fmt --all\n cargo clippy --all --fix --features=gui -- -D warnings\n\nahkc:\n cargo check --features=passthru_ahk\nahkf:\n cargo fmt --all\n cargo clippy --all --fix --features=passthru_ahk -- -D warnings\n\nchange_subcrate_versions version:\n sed -i 's/^version = \".*\"$/version = \"{{version}}\"/' parser/Cargo.toml tcp_protocol/Cargo.toml keyberon/Cargo.toml\n sed -i 's/^\\(#\\? \\?kanata-\\(keyberon\\|parser\\|tcp-protocol\\).*version\\) = \"[0-9.]*\"/\\1 = \"{{version}}\"/' Cargo.toml parser/Cargo.toml\n\ncov:\n cargo llvm-cov clean --workspace\n cargo llvm-cov --no-report --workspace --no-default-features\n cargo llvm-cov --no-report --workspace\n cargo llvm-cov --no-report --workspace --features=cmd,win_llhook_read_scancodes,win_sendinput_send_scancodes\n cargo llvm-cov --no-report --workspace --features=cmd,interception_driver,win_sendinput_send_scancodes\n cargo llvm-cov --no-report --features=simulated_output -- sim_tests\n cargo llvm-cov report --html\n\npublish:\n cd keyberon; cargo publish\n cd tcp_protocol; cargo publish\n cd parser; cargo publish\n cargo publish\n\n# Include the trailing `\\` or `/` in the output_dir parameter. The parameter should be an absolute path.\ncfg_to_html output_dir:\n cd docs ; asciidoctor config.adoc\n cd docs ; cp config.html \"{{output_dir}}config.html\"; rm config.html\n\n[doc('Deprecated. The wasm-pack project is no longer maintained; prefer wasm-build instead.\nInclude the trailing `\\` or `/` in the output_dir parameter. The parameter should be an absolute path.\n')]\nwasm_pack output_dir:\n cd wasm; wasm-pack build --target web; cd pkg; cp kanata_wasm_bg.wasm \"{{output_dir}}\"; cp kanata_wasm.js \"{{output_dir}}\"\n\n[doc('Include the trailing `\\` or `/` in the output_dir parameter. The parameter should be an absolute path.')]\nwasm-build output_dir:\n cd wasm; echo \"*\" > pkg/.gitignore\n cd wasm; cargo build --lib --release --target wasm32-unknown-unknown\n cd wasm; wasm-bindgen target/wasm32-unknown-unknown/release/kanata_wasm.wasm --out-dir pkg --typescript --target web\n wasm-opt wasm/pkg/kanata_wasm_bg.wasm -o wasm/pkg/kanata_wasm.wasm-opt.wasm -Oz\n rm wasm/pkg/kanata_wasm_bg.wasm\n mv wasm/pkg/kanata_wasm.wasm-opt.wasm wasm/pkg/kanata_wasm_bg.wasm\n cp wasm/pkg/kanata_wasm_bg.wasm \"{{output_dir}}\"\n cp wasm/pkg/kanata_wasm.js \"{{output_dir}}\"\n" }, { "path": "key-sort-add/Cargo.toml", "content": "[workspace]\nmembers = [\".\"]\n\n[package]\nname = \"key-sort-add\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\n" }, { "path": "key-sort-add/README.md", "content": "# key-sort-add\n\nA small program that was used to sort and fill in OsCode mappings.\n" }, { "path": "key-sort-add/mapping.txt", "content": "=== kc to osc\nKeyCode::Escape => OsCode::KEY_ESC,\nKeyCode::Kb1 => OsCode::KEY_1,\nKeyCode::Kb2 => OsCode::KEY_2,\nKeyCode::Kb3 => OsCode::KEY_3,\nKeyCode::Kb4 => OsCode::KEY_4,\nKeyCode::Kb5 => OsCode::KEY_5,\nKeyCode::Kb6 => OsCode::KEY_6,\nKeyCode::Kb7 => OsCode::KEY_7,\nKeyCode::Kb8 => OsCode::KEY_8,\nKeyCode::Kb9 => OsCode::KEY_9,\nKeyCode::Kb0 => OsCode::KEY_0,\nKeyCode::Minus => OsCode::KEY_MINUS,\nKeyCode::Equal => OsCode::KEY_EQUAL,\nKeyCode::BSpace => OsCode::KEY_BACKSPACE,\nKeyCode::Tab => OsCode::KEY_TAB,\nKeyCode::Q => OsCode::KEY_Q,\nKeyCode::W => OsCode::KEY_W,\nKeyCode::E => OsCode::KEY_E,\nKeyCode::R => OsCode::KEY_R,\nKeyCode::T => OsCode::KEY_T,\nKeyCode::Y => OsCode::KEY_Y,\nKeyCode::U => OsCode::KEY_U,\nKeyCode::I => OsCode::KEY_I,\nKeyCode::O => OsCode::KEY_O,\nKeyCode::P => OsCode::KEY_P,\nKeyCode::LBracket => OsCode::KEY_LEFTBRACE,\nKeyCode::RBracket => OsCode::KEY_RIGHTBRACE,\nKeyCode::Enter => OsCode::KEY_ENTER,\nKeyCode::LCtrl => OsCode::KEY_LEFTCTRL,\nKeyCode::A => OsCode::KEY_A,\nKeyCode::S => OsCode::KEY_S,\nKeyCode::D => OsCode::KEY_D,\nKeyCode::F => OsCode::KEY_F,\nKeyCode::G => OsCode::KEY_G,\nKeyCode::H => OsCode::KEY_H,\nKeyCode::J => OsCode::KEY_J,\nKeyCode::K => OsCode::KEY_K,\nKeyCode::L => OsCode::KEY_L,\nKeyCode::SColon => OsCode::KEY_SEMICOLON,\nKeyCode::Quote => OsCode::KEY_APOSTROPHE,\nKeyCode::Grave => OsCode::KEY_GRAVE,\nKeyCode::LShift => OsCode::KEY_LEFTSHIFT,\nKeyCode::Bslash => OsCode::KEY_BACKSLASH,\nKeyCode::Z => OsCode::KEY_Z,\nKeyCode::X => OsCode::KEY_X,\nKeyCode::C => OsCode::KEY_C,\nKeyCode::V => OsCode::KEY_V,\nKeyCode::B => OsCode::KEY_B,\nKeyCode::N => OsCode::KEY_N,\nKeyCode::M => OsCode::KEY_M,\nKeyCode::Comma => OsCode::KEY_COMMA,\nKeyCode::Dot => OsCode::KEY_DOT,\nKeyCode::Slash => OsCode::KEY_SLASH,\nKeyCode::RShift => OsCode::KEY_RIGHTSHIFT,\nKeyCode::KpAsterisk => OsCode::KEY_KPASTERISK,\nKeyCode::LAlt => OsCode::KEY_LEFTALT,\nKeyCode::Space => OsCode::KEY_SPACE,\nKeyCode::CapsLock => OsCode::KEY_CAPSLOCK,\nKeyCode::F1 => OsCode::KEY_F1,\nKeyCode::F2 => OsCode::KEY_F2,\nKeyCode::F3 => OsCode::KEY_F3,\nKeyCode::F4 => OsCode::KEY_F4,\nKeyCode::F5 => OsCode::KEY_F5,\nKeyCode::F6 => OsCode::KEY_F6,\nKeyCode::F7 => OsCode::KEY_F7,\nKeyCode::F8 => OsCode::KEY_F8,\nKeyCode::F9 => OsCode::KEY_F9,\nKeyCode::F10 => OsCode::KEY_F10,\nKeyCode::NumLock => OsCode::KEY_NUMLOCK,\nKeyCode::Clear => OsCode::KEY_CLEAR,\nKeyCode::ScrollLock => OsCode::KEY_SCROLLLOCK,\nKeyCode::Kp7 => OsCode::KEY_KP7,\nKeyCode::Kp8 => OsCode::KEY_KP8,\nKeyCode::Kp9 => OsCode::KEY_KP9,\nKeyCode::KpMinus => OsCode::KEY_KPMINUS,\nKeyCode::Kp4 => OsCode::KEY_KP4,\nKeyCode::Kp5 => OsCode::KEY_KP5,\nKeyCode::Kp6 => OsCode::KEY_KP6,\nKeyCode::KpPlus => OsCode::KEY_KPPLUS,\nKeyCode::Kp1 => OsCode::KEY_KP1,\nKeyCode::Kp2 => OsCode::KEY_KP2,\nKeyCode::Kp3 => OsCode::KEY_KP3,\nKeyCode::Kp0 => OsCode::KEY_KP0,\nKeyCode::KpDot => OsCode::KEY_KPDOT,\nKeyCode::F11 => OsCode::KEY_F11,\nKeyCode::F12 => OsCode::KEY_F12,\nKeyCode::KpEnter => OsCode::KEY_KPENTER,\nKeyCode::RCtrl => OsCode::KEY_RIGHTCTRL,\nKeyCode::KpSlash => OsCode::KEY_KPSLASH,\nKeyCode::SysReq => OsCode::KEY_SYSRQ,\nKeyCode::RAlt => OsCode::KEY_RIGHTALT,\nKeyCode::Home => OsCode::KEY_HOME,\nKeyCode::Up => OsCode::KEY_UP,\nKeyCode::PgUp => OsCode::KEY_PAGEUP,\nKeyCode::Left => OsCode::KEY_LEFT,\nKeyCode::Right => OsCode::KEY_RIGHT,\nKeyCode::End => OsCode::KEY_END,\nKeyCode::Down => OsCode::KEY_DOWN,\nKeyCode::PgDown => OsCode::KEY_PAGEDOWN,\nKeyCode::Insert => OsCode::KEY_INSERT,\nKeyCode::Delete => OsCode::KEY_DELETE,\nKeyCode::Mute => OsCode::KEY_MUTE,\nKeyCode::VolDown => OsCode::KEY_VOLUMEDOWN,\nKeyCode::VolUp => OsCode::KEY_VOLUMEUP,\nKeyCode::Power => OsCode::KEY_POWER,\nKeyCode::KpEqual => OsCode::KEY_KPEQUAL,\nKeyCode::Pause => OsCode::KEY_PAUSE,\nKeyCode::KpComma => OsCode::KEY_KPCOMMA,\nKeyCode::LGui => OsCode::KEY_LEFTMETA,\nKeyCode::RGui => OsCode::KEY_RIGHTMETA,\nKeyCode::Stop => OsCode::KEY_STOP,\nKeyCode::Again => OsCode::KEY_AGAIN,\nKeyCode::Undo => OsCode::KEY_UNDO,\nKeyCode::Copy => OsCode::KEY_COPY,\nKeyCode::Paste => OsCode::KEY_PASTE,\nKeyCode::Find => OsCode::KEY_FIND,\nKeyCode::Cut => OsCode::KEY_CUT,\nKeyCode::Help => OsCode::KEY_HELP,\nKeyCode::Menu => OsCode::KEY_MENU,\nKeyCode::MediaCalc => OsCode::KEY_CALC,\nKeyCode::MediaSleep => OsCode::KEY_SLEEP,\nKeyCode::MediaWWW => OsCode::KEY_WWW,\nKeyCode::MediaCoffee => OsCode::KEY_COFFEE,\nKeyCode::MediaBack => OsCode::KEY_BACK,\nKeyCode::MediaForward => OsCode::KEY_FORWARD,\nKeyCode::MediaEjectCD => OsCode::KEY_EJECTCD,\nKeyCode::MediaNextSong => OsCode::KEY_NEXTSONG,\nKeyCode::MediaPlayPause => OsCode::KEY_PLAYPAUSE,\nKeyCode::MediaPreviousSong => OsCode::KEY_PREVIOUSSONG,\nKeyCode::MediaStopCD => OsCode::KEY_STOPCD,\nKeyCode::MediaRefresh => OsCode::KEY_REFRESH,\nKeyCode::MediaEdit => OsCode::KEY_EDIT,\nKeyCode::MediaScrollUp => OsCode::KEY_SCROLLUP,\nKeyCode::MediaScrollDown => OsCode::KEY_SCROLLDOWN,\nKeyCode::F13 => OsCode::KEY_F13,\nKeyCode::F14 => OsCode::KEY_F14,\nKeyCode::F15 => OsCode::KEY_F15,\nKeyCode::F16 => OsCode::KEY_F16,\nKeyCode::F17 => OsCode::KEY_F17,\nKeyCode::F18 => OsCode::KEY_F18,\nKeyCode::F19 => OsCode::KEY_F19,\nKeyCode::F20 => OsCode::KEY_F20,\nKeyCode::F21 => OsCode::KEY_F21,\nKeyCode::F22 => OsCode::KEY_F22,\nKeyCode::F23 => OsCode::KEY_F23,\nKeyCode::F24 => OsCode::KEY_F24,\nKeyCode::Wakeup => OsCode::KEY_WAKEUP,\nKeyCode::BrightnessUp => OsCode::KEY_BRIGHTNESSUP,\nKeyCode::BrightnessDown => OsCode::KEY_BRIGHTNESSDOWN,\nKeyCode::KbdIllumUp => OsCode::KEY_KBDILLUMUP,\nKeyCode::KbdIllumDown => OsCode::KEY_KBDILLUMDOWN,\nKeyCode::Lang1 => OsCode::KEY_HANGEUL,\nKeyCode::Lang2 => OsCode::KEY_HANJA,\nKeyCode::NonUsBslash => OsCode::KEY_102ND,\nKeyCode::PScreen => OsCode::KEY_PRINT,\nKeyCode::Application => OsCode::KEY_COMPOSE,\nKeyCode::AltErase => OsCode::KEY_ALTERASE,\nKeyCode::Cancel => OsCode::KEY_CANCEL,\nKeyCode::MediaMute => OsCode::KEY_MICMUTE,\nKeyCode::Intl1 => OsCode::KEY_RO,\nKeyCode::Intl3 => OsCode::KEY_YEN,\nKeyCode::K0xAA => OsCode::KEY_MEDIA,\nKeyCode::K0xAB => OsCode::KEY_EMAIL,\nKeyCode::K0xAC => OsCode::KEY_PLAYER,\nKeyCode::K0xAD => OsCode::KEY_HOMEPAGE,\nKeyCode::K0xAE => OsCode::KEY_MAIL,\nKeyCode::K0xAF => OsCode::KEY_MUHENKAN,\nKeyCode::K0xB0 => OsCode::KEY_HENKAN,\nKeyCode::K0xB1 => OsCode::KEY_KATAKANA,\nKeyCode::K0xB2 => OsCode::KEY_KATAKANAHIRAGANA,\nKeyCode::K0xB3 => OsCode::KEY_HIRAGANA,\nKeyCode::K252 => OsCode::KEY_252,\nKeyCode::K253 => OsCode::KEY_253,\nKeyCode::K254 => OsCode::KEY_254,\nKeyCode::K255 => OsCode::KEY_255,\nKeyCode::K256 => OsCode::BTN_0,\nKeyCode::K257 => OsCode::BTN_1,\nKeyCode::K258 => OsCode::BTN_2,\nKeyCode::K259 => OsCode::BTN_3,\nKeyCode::K260 => OsCode::BTN_4,\nKeyCode::K261 => OsCode::BTN_5,\nKeyCode::K262 => OsCode::BTN_6,\nKeyCode::K263 => OsCode::BTN_7,\nKeyCode::K264 => OsCode::BTN_8,\nKeyCode::K265 => OsCode::BTN_9,\nKeyCode::K266 => OsCode::KEY_266,\nKeyCode::K267 => OsCode::KEY_267,\nKeyCode::K268 => OsCode::KEY_268,\nKeyCode::K269 => OsCode::KEY_269,\nKeyCode::K270 => OsCode::KEY_270,\nKeyCode::K271 => OsCode::KEY_271,\nKeyCode::K272 => OsCode::BTN_LEFT,\nKeyCode::K273 => OsCode::BTN_RIGHT,\nKeyCode::K274 => OsCode::BTN_MIDDLE,\nKeyCode::K275 => OsCode::BTN_SIDE,\nKeyCode::K276 => OsCode::BTN_EXTRA,\nKeyCode::K277 => OsCode::BTN_FORWARD,\nKeyCode::K278 => OsCode::BTN_BACK,\nKeyCode::K279 => OsCode::BTN_TASK,\nKeyCode::K280 => OsCode::KEY_280,\nKeyCode::K281 => OsCode::KEY_281,\nKeyCode::K282 => OsCode::KEY_282,\nKeyCode::K283 => OsCode::KEY_283,\nKeyCode::K284 => OsCode::KEY_284,\nKeyCode::K285 => OsCode::KEY_285,\nKeyCode::K286 => OsCode::KEY_286,\nKeyCode::K287 => OsCode::KEY_287,\nKeyCode::K288 => OsCode::BTN_TRIGGER,\nKeyCode::K289 => OsCode::BTN_THUMB,\nKeyCode::K290 => OsCode::BTN_THUMB2,\nKeyCode::K291 => OsCode::BTN_TOP,\nKeyCode::K292 => OsCode::BTN_TOP2,\nKeyCode::K293 => OsCode::BTN_PINKIE,\nKeyCode::K294 => OsCode::BTN_BASE,\nKeyCode::K295 => OsCode::BTN_BASE2,\nKeyCode::K296 => OsCode::BTN_BASE3,\nKeyCode::K297 => OsCode::BTN_BASE4,\nKeyCode::K298 => OsCode::BTN_BASE5,\nKeyCode::K299 => OsCode::BTN_BASE6,\nKeyCode::K300 => OsCode::KEY_300,\nKeyCode::K301 => OsCode::KEY_301,\nKeyCode::K302 => OsCode::KEY_302,\nKeyCode::K303 => OsCode::BTN_DEAD,\nKeyCode::K304 => OsCode::BTN_SOUTH,\nKeyCode::K305 => OsCode::BTN_EAST,\nKeyCode::K306 => OsCode::BTN_C,\nKeyCode::K307 => OsCode::BTN_NORTH,\nKeyCode::K308 => OsCode::BTN_WEST,\nKeyCode::K309 => OsCode::BTN_Z,\nKeyCode::K310 => OsCode::BTN_TL,\nKeyCode::K311 => OsCode::BTN_TR,\nKeyCode::K312 => OsCode::BTN_TL2,\nKeyCode::K313 => OsCode::BTN_TR2,\nKeyCode::K314 => OsCode::BTN_SELECT,\nKeyCode::K315 => OsCode::BTN_START,\nKeyCode::K316 => OsCode::BTN_MODE,\nKeyCode::K317 => OsCode::BTN_THUMBL,\nKeyCode::K318 => OsCode::BTN_THUMBR,\nKeyCode::K319 => OsCode::KEY_319,\nKeyCode::K320 => OsCode::BTN_TOOL_PEN,\nKeyCode::K321 => OsCode::BTN_TOOL_RUBBER,\nKeyCode::K322 => OsCode::BTN_TOOL_BRUSH,\nKeyCode::K323 => OsCode::BTN_TOOL_PENCIL,\nKeyCode::K324 => OsCode::BTN_TOOL_AIRBRUSH,\nKeyCode::K325 => OsCode::BTN_TOOL_FINGER,\nKeyCode::K326 => OsCode::BTN_TOOL_MOUSE,\nKeyCode::K327 => OsCode::BTN_TOOL_LENS,\nKeyCode::K328 => OsCode::BTN_TOOL_QUINTTAP,\nKeyCode::K329 => OsCode::BTN_STYLUS3,\nKeyCode::K330 => OsCode::BTN_TOUCH,\nKeyCode::K331 => OsCode::BTN_STYLUS,\nKeyCode::K332 => OsCode::BTN_STYLUS2,\nKeyCode::K333 => OsCode::BTN_TOOL_DOUBLETAP,\nKeyCode::K334 => OsCode::BTN_TOOL_TRIPLETAP,\nKeyCode::K335 => OsCode::BTN_TOOL_QUADTAP,\nKeyCode::K336 => OsCode::BTN_GEAR_DOWN,\nKeyCode::K337 => OsCode::BTN_GEAR_UP,\nKeyCode::K338 => OsCode::KEY_338,\nKeyCode::K339 => OsCode::KEY_339,\nKeyCode::K340 => OsCode::KEY_340,\nKeyCode::K341 => OsCode::KEY_341,\nKeyCode::K342 => OsCode::KEY_342,\nKeyCode::K343 => OsCode::KEY_343,\nKeyCode::K344 => OsCode::KEY_344,\nKeyCode::K345 => OsCode::KEY_345,\nKeyCode::K346 => OsCode::KEY_346,\nKeyCode::K347 => OsCode::KEY_347,\nKeyCode::K348 => OsCode::KEY_348,\nKeyCode::K349 => OsCode::KEY_349,\nKeyCode::K350 => OsCode::KEY_350,\nKeyCode::K351 => OsCode::KEY_351,\nKeyCode::K352 => OsCode::KEY_OK,\nKeyCode::K353 => OsCode::KEY_SELECT,\nKeyCode::K354 => OsCode::KEY_GOTO,\nKeyCode::K355 => OsCode::KEY_CLEAR,\nKeyCode::K356 => OsCode::KEY_POWER2,\nKeyCode::K357 => OsCode::KEY_OPTION,\nKeyCode::K358 => OsCode::KEY_INFO,\nKeyCode::K359 => OsCode::KEY_TIME,\nKeyCode::K360 => OsCode::KEY_VENDOR,\nKeyCode::K361 => OsCode::KEY_ARCHIVE,\nKeyCode::K362 => OsCode::KEY_PROGRAM,\nKeyCode::K363 => OsCode::KEY_CHANNEL,\nKeyCode::K364 => OsCode::KEY_FAVORITES,\nKeyCode::K365 => OsCode::KEY_EPG,\nKeyCode::K366 => OsCode::KEY_PVR,\nKeyCode::K367 => OsCode::KEY_MHP,\nKeyCode::K368 => OsCode::KEY_LANGUAGE,\nKeyCode::K369 => OsCode::KEY_TITLE,\nKeyCode::K370 => OsCode::KEY_SUBTITLE,\nKeyCode::K371 => OsCode::KEY_ANGLE,\nKeyCode::K372 => OsCode::KEY_FULL_SCREEN,\nKeyCode::K373 => OsCode::KEY_MODE,\nKeyCode::K374 => OsCode::KEY_KEYBOARD,\nKeyCode::K375 => OsCode::KEY_ASPECT_RATIO,\nKeyCode::K376 => OsCode::KEY_PC,\nKeyCode::K377 => OsCode::KEY_TV,\nKeyCode::K378 => OsCode::KEY_TV2,\nKeyCode::K379 => OsCode::KEY_VCR,\nKeyCode::K380 => OsCode::KEY_VCR2,\nKeyCode::K381 => OsCode::KEY_SAT,\nKeyCode::K382 => OsCode::KEY_SAT2,\nKeyCode::K383 => OsCode::KEY_CD,\nKeyCode::K384 => OsCode::KEY_TAPE,\nKeyCode::K385 => OsCode::KEY_RADIO,\nKeyCode::K386 => OsCode::KEY_TUNER,\nKeyCode::K387 => OsCode::KEY_PLAYER,\nKeyCode::K388 => OsCode::KEY_TEXT,\nKeyCode::K389 => OsCode::KEY_DVD,\nKeyCode::K390 => OsCode::KEY_AUX,\nKeyCode::K391 => OsCode::KEY_MP3,\nKeyCode::K392 => OsCode::KEY_AUDIO,\nKeyCode::K393 => OsCode::KEY_VIDEO,\nKeyCode::K394 => OsCode::KEY_DIRECTORY,\nKeyCode::K395 => OsCode::KEY_LIST,\nKeyCode::K396 => OsCode::KEY_MEMO,\nKeyCode::K397 => OsCode::KEY_CALENDAR,\nKeyCode::K398 => OsCode::KEY_RED,\nKeyCode::K399 => OsCode::KEY_GREEN,\nKeyCode::K400 => OsCode::KEY_YELLOW,\nKeyCode::K401 => OsCode::KEY_BLUE,\nKeyCode::K402 => OsCode::KEY_CHANNELUP,\nKeyCode::K403 => OsCode::KEY_CHANNELDOWN,\nKeyCode::K404 => OsCode::KEY_FIRST,\nKeyCode::K405 => OsCode::KEY_LAST,\nKeyCode::K406 => OsCode::KEY_AB,\nKeyCode::K407 => OsCode::KEY_NEXT,\nKeyCode::K408 => OsCode::KEY_RESTART,\nKeyCode::K409 => OsCode::KEY_SLOW,\nKeyCode::K410 => OsCode::KEY_SHUFFLE,\nKeyCode::K411 => OsCode::KEY_BREAK,\nKeyCode::K412 => OsCode::KEY_PREVIOUS,\nKeyCode::K413 => OsCode::KEY_DIGITS,\nKeyCode::K414 => OsCode::KEY_TEEN,\nKeyCode::K415 => OsCode::KEY_TWEN,\nKeyCode::K416 => OsCode::KEY_VIDEOPHONE,\nKeyCode::K417 => OsCode::KEY_GAMES,\nKeyCode::K418 => OsCode::KEY_ZOOMIN,\nKeyCode::K419 => OsCode::KEY_ZOOMOUT,\nKeyCode::K420 => OsCode::KEY_ZOOMRESET,\nKeyCode::K421 => OsCode::KEY_WORDPROCESSOR,\nKeyCode::K422 => OsCode::KEY_EDITOR,\nKeyCode::K423 => OsCode::KEY_SPREADSHEET,\nKeyCode::K424 => OsCode::KEY_GRAPHICSEDITOR,\nKeyCode::K425 => OsCode::KEY_PRESENTATION,\nKeyCode::K426 => OsCode::KEY_DATABASE,\nKeyCode::K427 => OsCode::KEY_NEWS,\nKeyCode::K428 => OsCode::KEY_VOICEMAIL,\nKeyCode::K429 => OsCode::KEY_ADDRESSBOOK,\nKeyCode::K430 => OsCode::KEY_MESSENGER,\nKeyCode::K431 => OsCode::KEY_DISPLAYTOGGLE,\nKeyCode::K432 => OsCode::KEY_SPELLCHECK,\nKeyCode::K433 => OsCode::KEY_LOGOFF,\nKeyCode::K434 => OsCode::KEY_DOLLAR,\nKeyCode::K435 => OsCode::KEY_EURO,\nKeyCode::K436 => OsCode::KEY_FRAMEBACK,\nKeyCode::K437 => OsCode::KEY_FRAMEFORWARD,\nKeyCode::K438 => OsCode::KEY_CONTEXT_MENU,\nKeyCode::K439 => OsCode::KEY_MEDIA_REPEAT,\nKeyCode::K440 => OsCode::KEY_10CHANNELSUP,\nKeyCode::K441 => OsCode::KEY_10CHANNELSDOWN,\nKeyCode::K442 => OsCode::KEY_IMAGES,\nKeyCode::K443 => OsCode::KEY_443,\nKeyCode::K444 => OsCode::KEY_444,\nKeyCode::K445 => OsCode::KEY_445,\nKeyCode::K446 => OsCode::KEY_446,\nKeyCode::K447 => OsCode::KEY_447,\nKeyCode::K448 => OsCode::KEY_DEL_EOL,\nKeyCode::K449 => OsCode::KEY_DEL_EOS,\nKeyCode::K450 => OsCode::KEY_INS_LINE,\nKeyCode::K451 => OsCode::KEY_DEL_LINE,\nKeyCode::K452 => OsCode::KEY_452,\nKeyCode::K453 => OsCode::KEY_453,\nKeyCode::K454 => OsCode::KEY_454,\nKeyCode::K455 => OsCode::KEY_455,\nKeyCode::K456 => OsCode::KEY_456,\nKeyCode::K457 => OsCode::KEY_457,\nKeyCode::K458 => OsCode::KEY_458,\nKeyCode::K459 => OsCode::KEY_459,\nKeyCode::K460 => OsCode::KEY_460,\nKeyCode::K461 => OsCode::KEY_461,\nKeyCode::K462 => OsCode::KEY_462,\nKeyCode::K463 => OsCode::KEY_463,\nKeyCode::K464 => OsCode::KEY_FN,\nKeyCode::K465 => OsCode::KEY_FN_ESC,\nKeyCode::K466 => OsCode::KEY_FN_F1,\nKeyCode::K467 => OsCode::KEY_FN_F2,\nKeyCode::K468 => OsCode::KEY_FN_F3,\nKeyCode::K469 => OsCode::KEY_FN_F4,\nKeyCode::K470 => OsCode::KEY_FN_F5,\nKeyCode::K471 => OsCode::KEY_FN_F6,\nKeyCode::K472 => OsCode::KEY_FN_F7,\nKeyCode::K473 => OsCode::KEY_FN_F8,\nKeyCode::K474 => OsCode::KEY_FN_F9,\nKeyCode::K475 => OsCode::KEY_FN_F10,\nKeyCode::K476 => OsCode::KEY_FN_F11,\nKeyCode::K477 => OsCode::KEY_FN_F12,\nKeyCode::K478 => OsCode::KEY_FN_1,\nKeyCode::K479 => OsCode::KEY_FN_2,\nKeyCode::K480 => OsCode::KEY_FN_D,\nKeyCode::K481 => OsCode::KEY_FN_E,\nKeyCode::K482 => OsCode::KEY_FN_F,\nKeyCode::K483 => OsCode::KEY_FN_S,\nKeyCode::K484 => OsCode::KEY_FN_B,\nKeyCode::K485 => OsCode::KEY_485,\nKeyCode::K486 => OsCode::KEY_486,\nKeyCode::K487 => OsCode::KEY_487,\nKeyCode::K488 => OsCode::KEY_488,\nKeyCode::K489 => OsCode::KEY_489,\nKeyCode::K490 => OsCode::KEY_490,\nKeyCode::K491 => OsCode::KEY_491,\nKeyCode::K492 => OsCode::KEY_492,\nKeyCode::K493 => OsCode::KEY_493,\nKeyCode::K494 => OsCode::KEY_494,\nKeyCode::K495 => OsCode::KEY_495,\nKeyCode::K496 => OsCode::KEY_496,\nKeyCode::K497 => OsCode::KEY_BRL_DOT1,\nKeyCode::K498 => OsCode::KEY_BRL_DOT2,\nKeyCode::K499 => OsCode::KEY_BRL_DOT3,\nKeyCode::K500 => OsCode::KEY_BRL_DOT4,\nKeyCode::K501 => OsCode::KEY_BRL_DOT5,\nKeyCode::K502 => OsCode::KEY_BRL_DOT6,\nKeyCode::K503 => OsCode::KEY_BRL_DOT7,\nKeyCode::K504 => OsCode::KEY_BRL_DOT8,\nKeyCode::K505 => OsCode::KEY_BRL_DOT9,\nKeyCode::K506 => OsCode::KEY_BRL_DOT10,\nKeyCode::K507 => OsCode::KEY_507,\nKeyCode::K508 => OsCode::KEY_508,\nKeyCode::K509 => OsCode::KEY_509,\nKeyCode::K510 => OsCode::KEY_510,\nKeyCode::K511 => OsCode::KEY_511,\nKeyCode::K512 => OsCode::KEY_NUMERIC_0,\nKeyCode::K513 => OsCode::KEY_NUMERIC_1,\nKeyCode::K514 => OsCode::KEY_NUMERIC_2,\nKeyCode::K515 => OsCode::KEY_NUMERIC_3,\nKeyCode::K516 => OsCode::KEY_NUMERIC_4,\nKeyCode::K517 => OsCode::KEY_NUMERIC_5,\nKeyCode::K518 => OsCode::KEY_NUMERIC_6,\nKeyCode::K519 => OsCode::KEY_NUMERIC_7,\nKeyCode::K520 => OsCode::KEY_NUMERIC_8,\nKeyCode::K521 => OsCode::KEY_NUMERIC_9,\nKeyCode::K522 => OsCode::KEY_NUMERIC_STAR,\nKeyCode::K523 => OsCode::KEY_NUMERIC_POUND,\nKeyCode::K524 => OsCode::KEY_NUMERIC_A,\nKeyCode::K525 => OsCode::KEY_NUMERIC_B,\nKeyCode::K526 => OsCode::KEY_NUMERIC_C,\nKeyCode::K527 => OsCode::KEY_NUMERIC_D,\nKeyCode::K528 => OsCode::KEY_CAMERA_FOCUS,\nKeyCode::K529 => OsCode::KEY_WPS_BUTTON,\nKeyCode::K530 => OsCode::KEY_TOUCHPAD_TOGGLE,\nKeyCode::K531 => OsCode::KEY_TOUCHPAD_ON,\nKeyCode::K532 => OsCode::KEY_TOUCHPAD_OFF,\nKeyCode::K533 => OsCode::KEY_CAMERA_ZOOMIN,\nKeyCode::K534 => OsCode::KEY_CAMERA_ZOOMOUT,\nKeyCode::K535 => OsCode::KEY_CAMERA_UP,\nKeyCode::K536 => OsCode::KEY_CAMERA_DOWN,\nKeyCode::K537 => OsCode::KEY_CAMERA_LEFT,\nKeyCode::K538 => OsCode::KEY_CAMERA_RIGHT,\nKeyCode::K539 => OsCode::KEY_ATTENDANT_ON,\nKeyCode::K540 => OsCode::KEY_ATTENDANT_OFF,\nKeyCode::K541 => OsCode::KEY_ATTENDANT_TOGGLE,\nKeyCode::K542 => OsCode::KEY_LIGHTS_TOGGLE,\nKeyCode::K543 => OsCode::KEY_543,\nKeyCode::K544 => OsCode::BTN_DPAD_UP,\nKeyCode::K545 => OsCode::BTN_DPAD_DOWN,\nKeyCode::K546 => OsCode::BTN_DPAD_LEFT,\nKeyCode::K547 => OsCode::BTN_DPAD_RIGHT,\nKeyCode::K548 => OsCode::KEY_548,\nKeyCode::K549 => OsCode::KEY_549,\nKeyCode::K550 => OsCode::KEY_550,\nKeyCode::K551 => OsCode::KEY_551,\nKeyCode::K552 => OsCode::KEY_552,\nKeyCode::K553 => OsCode::KEY_553,\nKeyCode::K554 => OsCode::KEY_554,\nKeyCode::K555 => OsCode::KEY_555,\nKeyCode::K556 => OsCode::KEY_556,\nKeyCode::K557 => OsCode::KEY_557,\nKeyCode::K558 => OsCode::KEY_558,\nKeyCode::K559 => OsCode::KEY_559,\nKeyCode::K560 => OsCode::KEY_ALS_TOGGLE,\nKeyCode::K561 => OsCode::KEY_ROTATE_LOCK_TOGGLE,\nKeyCode::K562 => OsCode::KEY_562,\nKeyCode::K563 => OsCode::KEY_563,\nKeyCode::K564 => OsCode::KEY_564,\nKeyCode::K565 => OsCode::KEY_565,\nKeyCode::K566 => OsCode::KEY_566,\nKeyCode::K567 => OsCode::KEY_567,\nKeyCode::K568 => OsCode::KEY_568,\nKeyCode::K569 => OsCode::KEY_569,\nKeyCode::K570 => OsCode::KEY_570,\nKeyCode::K571 => OsCode::KEY_571,\nKeyCode::K572 => OsCode::KEY_572,\nKeyCode::K573 => OsCode::KEY_573,\nKeyCode::K574 => OsCode::KEY_574,\nKeyCode::K575 => OsCode::KEY_575,\nKeyCode::K576 => OsCode::KEY_BUTTONCONFIG,\nKeyCode::K577 => OsCode::KEY_TASKMANAGER,\nKeyCode::K578 => OsCode::KEY_JOURNAL,\nKeyCode::K579 => OsCode::KEY_CONTROLPANEL,\nKeyCode::K580 => OsCode::KEY_APPSELECT,\nKeyCode::K581 => OsCode::KEY_SCREENSAVER,\nKeyCode::K582 => OsCode::KEY_VOICECOMMAND,\nKeyCode::K583 => OsCode::KEY_ASSISTANT,\nKeyCode::K584 => OsCode::KEY_KBD_LAYOUT_NEXT,\nKeyCode::K585 => OsCode::KEY_585,\nKeyCode::K586 => OsCode::KEY_586,\nKeyCode::K587 => OsCode::KEY_587,\nKeyCode::K588 => OsCode::KEY_588,\nKeyCode::K589 => OsCode::KEY_589,\nKeyCode::K590 => OsCode::KEY_590,\nKeyCode::K591 => OsCode::KEY_591,\nKeyCode::K592 => OsCode::KEY_BRIGHTNESS_MIN,\nKeyCode::K593 => OsCode::KEY_BRIGHTNESS_MAX,\nKeyCode::K594 => OsCode::KEY_594,\nKeyCode::K595 => OsCode::KEY_595,\nKeyCode::K596 => OsCode::KEY_596,\nKeyCode::K597 => OsCode::KEY_597,\nKeyCode::K598 => OsCode::KEY_598,\nKeyCode::K599 => OsCode::KEY_599,\nKeyCode::K600 => OsCode::KEY_600,\nKeyCode::K601 => OsCode::KEY_601,\nKeyCode::K602 => OsCode::KEY_602,\nKeyCode::K603 => OsCode::KEY_603,\nKeyCode::K604 => OsCode::KEY_604,\nKeyCode::K605 => OsCode::KEY_605,\nKeyCode::K606 => OsCode::KEY_606,\nKeyCode::K607 => OsCode::KEY_607,\nKeyCode::K608 => OsCode::KEY_KBDINPUTASSIST_PREV,\nKeyCode::K609 => OsCode::KEY_KBDINPUTASSIST_NEXT,\nKeyCode::K610 => OsCode::KEY_KBDINPUTASSIST_PREVGROUP,\nKeyCode::K611 => OsCode::KEY_KBDINPUTASSIST_NEXTGROUP,\nKeyCode::K612 => OsCode::KEY_KBDINPUTASSIST_ACCEPT,\nKeyCode::K613 => OsCode::KEY_KBDINPUTASSIST_CANCEL,\nKeyCode::K614 => OsCode::KEY_RIGHT_UP,\nKeyCode::K615 => OsCode::KEY_RIGHT_DOWN,\nKeyCode::K616 => OsCode::KEY_LEFT_UP,\nKeyCode::K617 => OsCode::KEY_LEFT_DOWN,\nKeyCode::K618 => OsCode::KEY_ROOT_MENU,\nKeyCode::K619 => OsCode::KEY_MEDIA_TOP_MENU,\nKeyCode::K620 => OsCode::KEY_NUMERIC_11,\nKeyCode::K621 => OsCode::KEY_NUMERIC_12,\nKeyCode::K622 => OsCode::KEY_AUDIO_DESC,\nKeyCode::K623 => OsCode::KEY_3D_MODE,\nKeyCode::K624 => OsCode::KEY_NEXT_FAVORITE,\nKeyCode::K625 => OsCode::KEY_STOP_RECORD,\nKeyCode::K626 => OsCode::KEY_PAUSE_RECORD,\nKeyCode::K627 => OsCode::KEY_VOD,\nKeyCode::K628 => OsCode::KEY_UNMUTE,\nKeyCode::K629 => OsCode::KEY_FASTREVERSE,\nKeyCode::K630 => OsCode::KEY_SLOWREVERSE,\nKeyCode::K631 => OsCode::KEY_DATA,\nKeyCode::K632 => OsCode::KEY_ONSCREEN_KEYBOARD,\nKeyCode::K633 => OsCode::KEY_633,\nKeyCode::K634 => OsCode::KEY_634,\nKeyCode::K635 => OsCode::KEY_635,\nKeyCode::K636 => OsCode::KEY_636,\nKeyCode::K637 => OsCode::KEY_637,\nKeyCode::K638 => OsCode::KEY_638,\nKeyCode::K639 => OsCode::KEY_639,\nKeyCode::K640 => OsCode::KEY_640,\nKeyCode::K641 => OsCode::KEY_641,\nKeyCode::K642 => OsCode::KEY_642,\nKeyCode::K643 => OsCode::KEY_643,\nKeyCode::K644 => OsCode::KEY_644,\nKeyCode::K645 => OsCode::KEY_645,\nKeyCode::K646 => OsCode::KEY_646,\nKeyCode::K647 => OsCode::KEY_647,\nKeyCode::K648 => OsCode::KEY_648,\nKeyCode::K649 => OsCode::KEY_649,\nKeyCode::K650 => OsCode::KEY_650,\nKeyCode::K651 => OsCode::KEY_651,\nKeyCode::K652 => OsCode::KEY_652,\nKeyCode::K653 => OsCode::KEY_653,\nKeyCode::K654 => OsCode::KEY_654,\nKeyCode::K655 => OsCode::KEY_655,\nKeyCode::K656 => OsCode::KEY_656,\nKeyCode::K657 => OsCode::KEY_657,\nKeyCode::K658 => OsCode::KEY_658,\nKeyCode::K659 => OsCode::KEY_659,\nKeyCode::K660 => OsCode::KEY_660,\nKeyCode::K661 => OsCode::KEY_661,\nKeyCode::K662 => OsCode::KEY_662,\nKeyCode::K663 => OsCode::KEY_663,\nKeyCode::K664 => OsCode::KEY_664,\nKeyCode::K665 => OsCode::KEY_665,\nKeyCode::K666 => OsCode::KEY_666,\nKeyCode::K667 => OsCode::KEY_667,\nKeyCode::K668 => OsCode::KEY_668,\nKeyCode::K669 => OsCode::KEY_669,\nKeyCode::K670 => OsCode::KEY_670,\nKeyCode::K671 => OsCode::KEY_671,\nKeyCode::K672 => OsCode::KEY_672,\nKeyCode::K673 => OsCode::KEY_673,\nKeyCode::K674 => OsCode::KEY_674,\nKeyCode::K675 => OsCode::KEY_675,\nKeyCode::K676 => OsCode::KEY_676,\nKeyCode::K677 => OsCode::KEY_677,\nKeyCode::K678 => OsCode::KEY_678,\nKeyCode::K679 => OsCode::KEY_679,\nKeyCode::K680 => OsCode::KEY_680,\nKeyCode::K681 => OsCode::KEY_681,\nKeyCode::K682 => OsCode::KEY_682,\nKeyCode::K683 => OsCode::KEY_683,\nKeyCode::K684 => OsCode::KEY_684,\nKeyCode::K685 => OsCode::KEY_685,\nKeyCode::K686 => OsCode::KEY_686,\nKeyCode::K687 => OsCode::KEY_687,\nKeyCode::K688 => OsCode::KEY_688,\nKeyCode::K689 => OsCode::KEY_689,\nKeyCode::K690 => OsCode::KEY_690,\nKeyCode::K691 => OsCode::KEY_691,\nKeyCode::K692 => OsCode::KEY_692,\nKeyCode::K693 => OsCode::KEY_693,\nKeyCode::K694 => OsCode::KEY_694,\nKeyCode::K695 => OsCode::KEY_695,\nKeyCode::K696 => OsCode::KEY_696,\nKeyCode::K697 => OsCode::KEY_697,\nKeyCode::K698 => OsCode::KEY_698,\nKeyCode::K699 => OsCode::KEY_699,\nKeyCode::K700 => OsCode::KEY_700,\nKeyCode::K701 => OsCode::KEY_701,\nKeyCode::K702 => OsCode::KEY_702,\nKeyCode::K703 => OsCode::KEY_703,\nKeyCode::K704 => OsCode::BTN_TRIGGER_HAPPY1,\nKeyCode::K705 => OsCode::BTN_TRIGGER_HAPPY2,\nKeyCode::K706 => OsCode::BTN_TRIGGER_HAPPY3,\nKeyCode::K707 => OsCode::BTN_TRIGGER_HAPPY4,\nKeyCode::K708 => OsCode::BTN_TRIGGER_HAPPY5,\nKeyCode::K709 => OsCode::BTN_TRIGGER_HAPPY6,\nKeyCode::K710 => OsCode::BTN_TRIGGER_HAPPY7,\nKeyCode::K711 => OsCode::BTN_TRIGGER_HAPPY8,\nKeyCode::K712 => OsCode::BTN_TRIGGER_HAPPY9,\nKeyCode::K713 => OsCode::BTN_TRIGGER_HAPPY10,\nKeyCode::K714 => OsCode::BTN_TRIGGER_HAPPY11,\nKeyCode::K715 => OsCode::BTN_TRIGGER_HAPPY12,\nKeyCode::K716 => OsCode::BTN_TRIGGER_HAPPY13,\nKeyCode::K717 => OsCode::BTN_TRIGGER_HAPPY14,\nKeyCode::K718 => OsCode::BTN_TRIGGER_HAPPY15,\nKeyCode::K719 => OsCode::BTN_TRIGGER_HAPPY16,\nKeyCode::K720 => OsCode::BTN_TRIGGER_HAPPY17,\nKeyCode::K721 => OsCode::BTN_TRIGGER_HAPPY18,\nKeyCode::K722 => OsCode::BTN_TRIGGER_HAPPY19,\nKeyCode::K723 => OsCode::BTN_TRIGGER_HAPPY20,\nKeyCode::K724 => OsCode::BTN_TRIGGER_HAPPY21,\nKeyCode::K725 => OsCode::BTN_TRIGGER_HAPPY22,\nKeyCode::K726 => OsCode::BTN_TRIGGER_HAPPY23,\nKeyCode::K727 => OsCode::BTN_TRIGGER_HAPPY24,\nKeyCode::K728 => OsCode::BTN_TRIGGER_HAPPY25,\nKeyCode::K729 => OsCode::BTN_TRIGGER_HAPPY26,\nKeyCode::K730 => OsCode::BTN_TRIGGER_HAPPY27,\nKeyCode::K731 => OsCode::BTN_TRIGGER_HAPPY28,\nKeyCode::K732 => OsCode::BTN_TRIGGER_HAPPY29,\nKeyCode::K733 => OsCode::BTN_TRIGGER_HAPPY30,\nKeyCode::K734 => OsCode::BTN_TRIGGER_HAPPY31,\nKeyCode::K735 => OsCode::BTN_TRIGGER_HAPPY32,\nKeyCode::K736 => OsCode::BTN_TRIGGER_HAPPY33,\nKeyCode::K737 => OsCode::BTN_TRIGGER_HAPPY34,\nKeyCode::K738 => OsCode::BTN_TRIGGER_HAPPY35,\nKeyCode::K739 => OsCode::BTN_TRIGGER_HAPPY36,\nKeyCode::K740 => OsCode::BTN_TRIGGER_HAPPY37,\nKeyCode::K741 => OsCode::BTN_TRIGGER_HAPPY38,\nKeyCode::K742 => OsCode::BTN_TRIGGER_HAPPY39,\nKeyCode::K743 => OsCode::BTN_TRIGGER_HAPPY40,\nKeyCode::K744 => OsCode::BTN_MAX,\nKeyCode::MWU => OsCode::MouseWheelUp,\nKeyCode::MWD => OsCode::MouseWheelDown,\nKeyCode::MWL => OsCode::MouseWheelLeft,\nKeyCode::MWR => OsCode::MouseWheelRight,\n\n=== osc to u16\nKEY_RESERVED = 0,\nKEY_ESC = 1,\nKEY_1 = 2,\nKEY_2 = 3,\nKEY_3 = 4,\nKEY_4 = 5,\nKEY_5 = 6,\nKEY_6 = 7,\nKEY_7 = 8,\nKEY_8 = 9,\nKEY_9 = 10,\nKEY_0 = 11,\nKEY_MINUS = 12,\nKEY_EQUAL = 13,\nKEY_BACKSPACE = 14,\nKEY_TAB = 15,\nKEY_Q = 16,\nKEY_W = 17,\nKEY_E = 18,\nKEY_R = 19,\nKEY_T = 20,\nKEY_Y = 21,\nKEY_U = 22,\nKEY_I = 23,\nKEY_O = 24,\nKEY_P = 25,\nKEY_LEFTBRACE = 26,\nKEY_RIGHTBRACE = 27,\nKEY_ENTER = 28,\nKEY_LEFTCTRL = 29,\nKEY_A = 30,\nKEY_S = 31,\nKEY_D = 32,\nKEY_F = 33,\nKEY_G = 34,\nKEY_H = 35,\nKEY_J = 36,\nKEY_K = 37,\nKEY_L = 38,\nKEY_SEMICOLON = 39,\nKEY_APOSTROPHE = 40,\nKEY_GRAVE = 41,\nKEY_LEFTSHIFT = 42,\nKEY_BACKSLASH = 43,\nKEY_Z = 44,\nKEY_X = 45,\nKEY_C = 46,\nKEY_V = 47,\nKEY_B = 48,\nKEY_N = 49,\nKEY_M = 50,\nKEY_COMMA = 51,\nKEY_DOT = 52,\nKEY_SLASH = 53,\nKEY_RIGHTSHIFT = 54,\nKEY_KPASTERISK = 55,\nKEY_LEFTALT = 56,\nKEY_SPACE = 57,\nKEY_CAPSLOCK = 58,\nKEY_F1 = 59,\nKEY_F2 = 60,\nKEY_F3 = 61,\nKEY_F4 = 62,\nKEY_F5 = 63,\nKEY_F6 = 64,\nKEY_F7 = 65,\nKEY_F8 = 66,\nKEY_F9 = 67,\nKEY_F10 = 68,\nKEY_NUMLOCK = 69,\nKEY_SCROLLLOCK = 70,\nKEY_KP7 = 71,\nKEY_KP8 = 72,\nKEY_KP9 = 73,\nKEY_KPMINUS = 74,\nKEY_KP4 = 75,\nKEY_KP5 = 76,\nKEY_KP6 = 77,\nKEY_KPPLUS = 78,\nKEY_KP1 = 79,\nKEY_KP2 = 80,\nKEY_KP3 = 81,\nKEY_KP0 = 82,\nKEY_KPDOT = 83,\nKEY_84 = 84,\nKEY_ZENKAKUHANKAKU = 85,\nKEY_102ND = 86,\nKEY_F11 = 87,\nKEY_F12 = 88,\nKEY_RO = 89,\nKEY_KATAKANA = 90,\nKEY_HIRAGANA = 91,\nKEY_HENKAN = 92,\nKEY_KATAKANAHIRAGANA = 93,\nKEY_MUHENKAN = 94,\nKEY_KPJPCOMMA = 95,\nKEY_KPENTER = 96,\nKEY_RIGHTCTRL = 97,\nKEY_KPSLASH = 98,\nKEY_SYSRQ = 99,\nKEY_RIGHTALT = 100,\nKEY_LINEFEED = 101,\nKEY_HOME = 102,\nKEY_UP = 103,\nKEY_PAGEUP = 104,\nKEY_LEFT = 105,\nKEY_RIGHT = 106,\nKEY_END = 107,\nKEY_DOWN = 108,\nKEY_PAGEDOWN = 109,\nKEY_INSERT = 110,\nKEY_DELETE = 111,\nKEY_MACRO = 112,\nKEY_MUTE = 113,\nKEY_VOLUMEDOWN = 114,\nKEY_VOLUMEUP = 115,\nKEY_POWER = 116,\nKEY_KPEQUAL = 117,\nKEY_KPPLUSMINUS = 118,\nKEY_PAUSE = 119,\nKEY_SCALE = 120,\nKEY_KPCOMMA = 121,\nKEY_HANGEUL = 122,\nKEY_HANJA = 123,\nKEY_YEN = 124,\nKEY_LEFTMETA = 125,\nKEY_RIGHTMETA = 126,\nKEY_COMPOSE = 127,\nKEY_STOP = 128,\nKEY_AGAIN = 129,\nKEY_PROPS = 130,\nKEY_UNDO = 131,\nKEY_FRONT = 132,\nKEY_COPY = 133,\nKEY_OPEN = 134,\nKEY_PASTE = 135,\nKEY_FIND = 136,\nKEY_CUT = 137,\nKEY_HELP = 138,\nKEY_MENU = 139,\nKEY_CALC = 140,\nKEY_SETUP = 141,\nKEY_SLEEP = 142,\nKEY_WAKEUP = 143,\nKEY_FILE = 144,\nKEY_SENDFILE = 145,\nKEY_DELETEFILE = 146,\nKEY_XFER = 147,\nKEY_PROG1 = 148,\nKEY_PROG2 = 149,\nKEY_WWW = 150,\nKEY_MSDOS = 151,\nKEY_COFFEE = 152,\nKEY_ROTATE_DISPLAY = 153,\nKEY_CYCLEWINDOWS = 154,\nKEY_MAIL = 155,\nKEY_BOOKMARKS = 156,\nKEY_COMPUTER = 157,\nKEY_BACK = 158,\nKEY_FORWARD = 159,\nKEY_CLOSECD = 160,\nKEY_EJECTCD = 161,\nKEY_EJECTCLOSECD = 162,\nKEY_NEXTSONG = 163,\nKEY_PLAYPAUSE = 164,\nKEY_PREVIOUSSONG = 165,\nKEY_STOPCD = 166,\nKEY_RECORD = 167,\nKEY_REWIND = 168,\nKEY_PHONE = 169,\nKEY_ISO = 170,\nKEY_CONFIG = 171,\nKEY_HOMEPAGE = 172,\nKEY_REFRESH = 173,\nKEY_EXIT = 174,\nKEY_MOVE = 175,\nKEY_EDIT = 176,\nKEY_SCROLLUP = 177,\nKEY_SCROLLDOWN = 178,\nKEY_KPLEFTPAREN = 179,\nKEY_KPRIGHTPAREN = 180,\nKEY_NEW = 181,\nKEY_REDO = 182,\nKEY_F13 = 183,\nKEY_F14 = 184,\nKEY_F15 = 185,\nKEY_F16 = 186,\nKEY_F17 = 187,\nKEY_F18 = 188,\nKEY_F19 = 189,\nKEY_F20 = 190,\nKEY_F21 = 191,\nKEY_F22 = 192,\nKEY_F23 = 193,\nKEY_F24 = 194,\nKEY_195 = 195,\nKEY_196 = 196,\nKEY_197 = 197,\nKEY_198 = 198,\nKEY_199 = 199,\nKEY_PLAYCD = 200,\nKEY_PAUSECD = 201,\nKEY_PROG3 = 202,\nKEY_PROG4 = 203,\nKEY_DASHBOARD = 204,\nKEY_SUSPEND = 205,\nKEY_CLOSE = 206,\nKEY_PLAY = 207,\nKEY_FASTFORWARD = 208,\nKEY_BASSBOOST = 209,\nKEY_PRINT = 210,\nKEY_HP = 211,\nKEY_CAMERA = 212,\nKEY_SOUND = 213,\nKEY_QUESTION = 214,\nKEY_EMAIL = 215,\nKEY_CHAT = 216,\nKEY_SEARCH = 217,\nKEY_CONNECT = 218,\nKEY_FINANCE = 219,\nKEY_SPORT = 220,\nKEY_SHOP = 221,\nKEY_ALTERASE = 222,\nKEY_CANCEL = 223,\nKEY_BRIGHTNESSDOWN = 224,\nKEY_BRIGHTNESSUP = 225,\nKEY_MEDIA = 226,\nKEY_SWITCHVIDEOMODE = 227,\nKEY_KBDILLUMTOGGLE = 228,\nKEY_KBDILLUMDOWN = 229,\nKEY_KBDILLUMUP = 230,\nKEY_SEND = 231,\nKEY_REPLY = 232,\nKEY_FORWARDMAIL = 233,\nKEY_SAVE = 234,\nKEY_DOCUMENTS = 235,\nKEY_BATTERY = 236,\nKEY_BLUETOOTH = 237,\nKEY_WLAN = 238,\nKEY_UWB = 239,\nKEY_UNKNOWN = 240,\nKEY_VIDEO_NEXT = 241,\nKEY_VIDEO_PREV = 242,\nKEY_BRIGHTNESS_CYCLE = 243,\nKEY_BRIGHTNESS_AUTO = 244,\nKEY_DISPLAY_OFF = 245,\nKEY_WWAN = 246,\nKEY_RFKILL = 247,\nKEY_MICMUTE = 248,\nKEY_249 = 249,\nKEY_250 = 250,\nKEY_251 = 251,\nKEY_252 = 252,\nKEY_253 = 253,\nKEY_254 = 254,\nKEY_255 = 255,\nBTN_0 = 256,\nBTN_1 = 257,\nBTN_2 = 258,\nBTN_3 = 259,\nBTN_4 = 260,\nBTN_5 = 261,\nBTN_6 = 262,\nBTN_7 = 263,\nBTN_8 = 264,\nBTN_9 = 265,\nKEY_266 = 266,\nKEY_267 = 267,\nKEY_268 = 268,\nKEY_269 = 269,\nKEY_270 = 270,\nKEY_271 = 271,\nBTN_LEFT = 272,\nBTN_RIGHT = 273,\nBTN_MIDDLE = 274,\nBTN_SIDE = 275,\nBTN_EXTRA = 276,\nBTN_FORWARD = 277,\nBTN_BACK = 278,\nBTN_TASK = 279,\nKEY_280 = 280,\nKEY_281 = 281,\nKEY_282 = 282,\nKEY_283 = 283,\nKEY_284 = 284,\nKEY_285 = 285,\nKEY_286 = 286,\nKEY_287 = 287,\nBTN_TRIGGER = 288,\nBTN_THUMB = 289,\nBTN_THUMB2 = 290,\nBTN_TOP = 291,\nBTN_TOP2 = 292,\nBTN_PINKIE = 293,\nBTN_BASE = 294,\nBTN_BASE2 = 295,\nBTN_BASE3 = 296,\nBTN_BASE4 = 297,\nBTN_BASE5 = 298,\nBTN_BASE6 = 299,\nKEY_300 = 300,\nKEY_301 = 301,\nKEY_302 = 302,\nBTN_DEAD = 303,\nBTN_SOUTH = 304,\nBTN_EAST = 305,\nBTN_C = 306,\nBTN_NORTH = 307,\nBTN_WEST = 308,\nBTN_Z = 309,\nBTN_TL = 310,\nBTN_TR = 311,\nBTN_TL2 = 312,\nBTN_TR2 = 313,\nBTN_SELECT = 314,\nBTN_START = 315,\nBTN_MODE = 316,\nBTN_THUMBL = 317,\nBTN_THUMBR = 318,\nKEY_319 = 319,\nBTN_TOOL_PEN = 320,\nBTN_TOOL_RUBBER = 321,\nBTN_TOOL_BRUSH = 322,\nBTN_TOOL_PENCIL = 323,\nBTN_TOOL_AIRBRUSH = 324,\nBTN_TOOL_FINGER = 325,\nBTN_TOOL_MOUSE = 326,\nBTN_TOOL_LENS = 327,\nBTN_TOOL_QUINTTAP = 328,\nBTN_STYLUS3 = 329,\nBTN_TOUCH = 330,\nBTN_STYLUS = 331,\nBTN_STYLUS2 = 332,\nBTN_TOOL_DOUBLETAP = 333,\nBTN_TOOL_TRIPLETAP = 334,\nBTN_TOOL_QUADTAP = 335,\nBTN_GEAR_DOWN = 336,\nBTN_GEAR_UP = 337,\nKEY_338 = 338,\nKEY_339 = 339,\nKEY_340 = 340,\nKEY_341 = 341,\nKEY_342 = 342,\nKEY_343 = 343,\nKEY_344 = 344,\nKEY_345 = 345,\nKEY_346 = 346,\nKEY_347 = 347,\nKEY_348 = 348,\nKEY_349 = 349,\nKEY_350 = 350,\nKEY_351 = 351,\nKEY_OK = 352,\nKEY_SELECT = 353,\nKEY_GOTO = 354,\nKEY_CLEAR = 355,\nKEY_POWER2 = 356,\nKEY_OPTION = 357,\nKEY_INFO = 358,\nKEY_TIME = 359,\nKEY_VENDOR = 360,\nKEY_ARCHIVE = 361,\nKEY_PROGRAM = 362,\nKEY_CHANNEL = 363,\nKEY_FAVORITES = 364,\nKEY_EPG = 365,\nKEY_PVR = 366,\nKEY_MHP = 367,\nKEY_LANGUAGE = 368,\nKEY_TITLE = 369,\nKEY_SUBTITLE = 370,\nKEY_ANGLE = 371,\nKEY_FULL_SCREEN = 372,\nKEY_MODE = 373,\nKEY_KEYBOARD = 374,\nKEY_ASPECT_RATIO = 375,\nKEY_PC = 376,\nKEY_TV = 377,\nKEY_TV2 = 378,\nKEY_VCR = 379,\nKEY_VCR2 = 380,\nKEY_SAT = 381,\nKEY_SAT2 = 382,\nKEY_CD = 383,\nKEY_TAPE = 384,\nKEY_RADIO = 385,\nKEY_TUNER = 386,\nKEY_PLAYER = 387,\nKEY_TEXT = 388,\nKEY_DVD = 389,\nKEY_AUX = 390,\nKEY_MP3 = 391,\nKEY_AUDIO = 392,\nKEY_VIDEO = 393,\nKEY_DIRECTORY = 394,\nKEY_LIST = 395,\nKEY_MEMO = 396,\nKEY_CALENDAR = 397,\nKEY_RED = 398,\nKEY_GREEN = 399,\nKEY_YELLOW = 400,\nKEY_BLUE = 401,\nKEY_CHANNELUP = 402,\nKEY_CHANNELDOWN = 403,\nKEY_FIRST = 404,\nKEY_LAST = 405,\nKEY_AB = 406,\nKEY_NEXT = 407,\nKEY_RESTART = 408,\nKEY_SLOW = 409,\nKEY_SHUFFLE = 410,\nKEY_BREAK = 411,\nKEY_PREVIOUS = 412,\nKEY_DIGITS = 413,\nKEY_TEEN = 414,\nKEY_TWEN = 415,\nKEY_VIDEOPHONE = 416,\nKEY_GAMES = 417,\nKEY_ZOOMIN = 418,\nKEY_ZOOMOUT = 419,\nKEY_ZOOMRESET = 420,\nKEY_WORDPROCESSOR = 421,\nKEY_EDITOR = 422,\nKEY_SPREADSHEET = 423,\nKEY_GRAPHICSEDITOR = 424,\nKEY_PRESENTATION = 425,\nKEY_DATABASE = 426,\nKEY_NEWS = 427,\nKEY_VOICEMAIL = 428,\nKEY_ADDRESSBOOK = 429,\nKEY_MESSENGER = 430,\nKEY_DISPLAYTOGGLE = 431,\nKEY_SPELLCHECK = 432,\nKEY_LOGOFF = 433,\nKEY_DOLLAR = 434,\nKEY_EURO = 435,\nKEY_FRAMEBACK = 436,\nKEY_FRAMEFORWARD = 437,\nKEY_CONTEXT_MENU = 438,\nKEY_MEDIA_REPEAT = 439,\nKEY_10CHANNELSUP = 440,\nKEY_10CHANNELSDOWN = 441,\nKEY_IMAGES = 442,\nKEY_443 = 443,\nKEY_444 = 444,\nKEY_445 = 445,\nKEY_446 = 446,\nKEY_447 = 447,\nKEY_DEL_EOL = 448,\nKEY_DEL_EOS = 449,\nKEY_INS_LINE = 450,\nKEY_DEL_LINE = 451,\nKEY_452 = 452,\nKEY_453 = 453,\nKEY_454 = 454,\nKEY_455 = 455,\nKEY_456 = 456,\nKEY_457 = 457,\nKEY_458 = 458,\nKEY_459 = 459,\nKEY_460 = 460,\nKEY_461 = 461,\nKEY_462 = 462,\nKEY_463 = 463,\nKEY_FN = 464,\nKEY_FN_ESC = 465,\nKEY_FN_F1 = 466,\nKEY_FN_F2 = 467,\nKEY_FN_F3 = 468,\nKEY_FN_F4 = 469,\nKEY_FN_F5 = 470,\nKEY_FN_F6 = 471,\nKEY_FN_F7 = 472,\nKEY_FN_F8 = 473,\nKEY_FN_F9 = 474,\nKEY_FN_F10 = 475,\nKEY_FN_F11 = 476,\nKEY_FN_F12 = 477,\nKEY_FN_1 = 478,\nKEY_FN_2 = 479,\nKEY_FN_D = 480,\nKEY_FN_E = 481,\nKEY_FN_F = 482,\nKEY_FN_S = 483,\nKEY_FN_B = 484,\nKEY_485 = 485,\nKEY_486 = 486,\nKEY_487 = 487,\nKEY_488 = 488,\nKEY_489 = 489,\nKEY_490 = 490,\nKEY_491 = 491,\nKEY_492 = 492,\nKEY_493 = 493,\nKEY_494 = 494,\nKEY_495 = 495,\nKEY_496 = 496,\nKEY_BRL_DOT1 = 497,\nKEY_BRL_DOT2 = 498,\nKEY_BRL_DOT3 = 499,\nKEY_BRL_DOT4 = 500,\nKEY_BRL_DOT5 = 501,\nKEY_BRL_DOT6 = 502,\nKEY_BRL_DOT7 = 503,\nKEY_BRL_DOT8 = 504,\nKEY_BRL_DOT9 = 505,\nKEY_BRL_DOT10 = 506,\nKEY_507 = 507,\nKEY_508 = 508,\nKEY_509 = 509,\nKEY_510 = 510,\nKEY_511 = 511,\nKEY_NUMERIC_0 = 512,\nKEY_NUMERIC_1 = 513,\nKEY_NUMERIC_2 = 514,\nKEY_NUMERIC_3 = 515,\nKEY_NUMERIC_4 = 516,\nKEY_NUMERIC_5 = 517,\nKEY_NUMERIC_6 = 518,\nKEY_NUMERIC_7 = 519,\nKEY_NUMERIC_8 = 520,\nKEY_NUMERIC_9 = 521,\nKEY_NUMERIC_STAR = 522,\nKEY_NUMERIC_POUND = 523,\nKEY_NUMERIC_A = 524,\nKEY_NUMERIC_B = 525,\nKEY_NUMERIC_C = 526,\nKEY_NUMERIC_D = 527,\nKEY_CAMERA_FOCUS = 528,\nKEY_WPS_BUTTON = 529,\nKEY_TOUCHPAD_TOGGLE = 530,\nKEY_TOUCHPAD_ON = 531,\nKEY_TOUCHPAD_OFF = 532,\nKEY_CAMERA_ZOOMIN = 533,\nKEY_CAMERA_ZOOMOUT = 534,\nKEY_CAMERA_UP = 535,\nKEY_CAMERA_DOWN = 536,\nKEY_CAMERA_LEFT = 537,\nKEY_CAMERA_RIGHT = 538,\nKEY_ATTENDANT_ON = 539,\nKEY_ATTENDANT_OFF = 540,\nKEY_ATTENDANT_TOGGLE = 541,\nKEY_LIGHTS_TOGGLE = 542,\nKEY_543 = 543,\nBTN_DPAD_UP = 544,\nBTN_DPAD_DOWN = 545,\nBTN_DPAD_LEFT = 546,\nBTN_DPAD_RIGHT = 547,\nKEY_548 = 548,\nKEY_549 = 549,\nKEY_550 = 550,\nKEY_551 = 551,\nKEY_552 = 552,\nKEY_553 = 553,\nKEY_554 = 554,\nKEY_555 = 555,\nKEY_556 = 556,\nKEY_557 = 557,\nKEY_558 = 558,\nKEY_559 = 559,\nKEY_ALS_TOGGLE = 560,\nKEY_ROTATE_LOCK_TOGGLE = 561,\nKEY_562 = 562,\nKEY_563 = 563,\nKEY_564 = 564,\nKEY_565 = 565,\nKEY_566 = 566,\nKEY_567 = 567,\nKEY_568 = 568,\nKEY_569 = 569,\nKEY_570 = 570,\nKEY_571 = 571,\nKEY_572 = 572,\nKEY_573 = 573,\nKEY_574 = 574,\nKEY_575 = 575,\nKEY_BUTTONCONFIG = 576,\nKEY_TASKMANAGER = 577,\nKEY_JOURNAL = 578,\nKEY_CONTROLPANEL = 579,\nKEY_APPSELECT = 580,\nKEY_SCREENSAVER = 581,\nKEY_VOICECOMMAND = 582,\nKEY_ASSISTANT = 583,\nKEY_KBD_LAYOUT_NEXT = 584,\nKEY_585 = 585,\nKEY_586 = 586,\nKEY_587 = 587,\nKEY_588 = 588,\nKEY_589 = 589,\nKEY_590 = 590,\nKEY_591 = 591,\nKEY_BRIGHTNESS_MIN = 592,\nKEY_BRIGHTNESS_MAX = 593,\nKEY_594 = 594,\nKEY_595 = 595,\nKEY_596 = 596,\nKEY_597 = 597,\nKEY_598 = 598,\nKEY_599 = 599,\nKEY_600 = 600,\nKEY_601 = 601,\nKEY_602 = 602,\nKEY_603 = 603,\nKEY_604 = 604,\nKEY_605 = 605,\nKEY_606 = 606,\nKEY_607 = 607,\nKEY_KBDINPUTASSIST_PREV = 608,\nKEY_KBDINPUTASSIST_NEXT = 609,\nKEY_KBDINPUTASSIST_PREVGROUP = 610,\nKEY_KBDINPUTASSIST_NEXTGROUP = 611,\nKEY_KBDINPUTASSIST_ACCEPT = 612,\nKEY_KBDINPUTASSIST_CANCEL = 613,\nKEY_RIGHT_UP = 614,\nKEY_RIGHT_DOWN = 615,\nKEY_LEFT_UP = 616,\nKEY_LEFT_DOWN = 617,\nKEY_ROOT_MENU = 618,\nKEY_MEDIA_TOP_MENU = 619,\nKEY_NUMERIC_11 = 620,\nKEY_NUMERIC_12 = 621,\nKEY_AUDIO_DESC = 622,\nKEY_3D_MODE = 623,\nKEY_NEXT_FAVORITE = 624,\nKEY_STOP_RECORD = 625,\nKEY_PAUSE_RECORD = 626,\nKEY_VOD = 627,\nKEY_UNMUTE = 628,\nKEY_FASTREVERSE = 629,\nKEY_SLOWREVERSE = 630,\nKEY_DATA = 631,\nKEY_ONSCREEN_KEYBOARD = 632,\nKEY_633 = 633,\nKEY_634 = 634,\nKEY_635 = 635,\nKEY_636 = 636,\nKEY_637 = 637,\nKEY_638 = 638,\nKEY_639 = 639,\nKEY_640 = 640,\nKEY_641 = 641,\nKEY_642 = 642,\nKEY_643 = 643,\nKEY_644 = 644,\nKEY_645 = 645,\nKEY_646 = 646,\nKEY_647 = 647,\nKEY_648 = 648,\nKEY_649 = 649,\nKEY_650 = 650,\nKEY_651 = 651,\nKEY_652 = 652,\nKEY_653 = 653,\nKEY_654 = 654,\nKEY_655 = 655,\nKEY_656 = 656,\nKEY_657 = 657,\nKEY_658 = 658,\nKEY_659 = 659,\nKEY_660 = 660,\nKEY_661 = 661,\nKEY_662 = 662,\nKEY_663 = 663,\nKEY_664 = 664,\nKEY_665 = 665,\nKEY_666 = 666,\nKEY_667 = 667,\nKEY_668 = 668,\nKEY_669 = 669,\nKEY_670 = 670,\nKEY_671 = 671,\nKEY_672 = 672,\nKEY_673 = 673,\nKEY_674 = 674,\nKEY_675 = 675,\nKEY_676 = 676,\nKEY_677 = 677,\nKEY_678 = 678,\nKEY_679 = 679,\nKEY_680 = 680,\nKEY_681 = 681,\nKEY_682 = 682,\nKEY_683 = 683,\nKEY_684 = 684,\nKEY_685 = 685,\nKEY_686 = 686,\nKEY_687 = 687,\nKEY_688 = 688,\nKEY_689 = 689,\nKEY_690 = 690,\nKEY_691 = 691,\nKEY_692 = 692,\nKEY_693 = 693,\nKEY_694 = 694,\nKEY_695 = 695,\nKEY_696 = 696,\nKEY_697 = 697,\nKEY_698 = 698,\nKEY_699 = 699,\nKEY_700 = 700,\nKEY_701 = 701,\nKEY_702 = 702,\nKEY_703 = 703,\nBTN_TRIGGER_HAPPY1 = 704,\nBTN_TRIGGER_HAPPY2 = 705,\nBTN_TRIGGER_HAPPY3 = 706,\nBTN_TRIGGER_HAPPY4 = 707,\nBTN_TRIGGER_HAPPY5 = 708,\nBTN_TRIGGER_HAPPY6 = 709,\nBTN_TRIGGER_HAPPY7 = 710,\nBTN_TRIGGER_HAPPY8 = 711,\nBTN_TRIGGER_HAPPY9 = 712,\nBTN_TRIGGER_HAPPY10 = 713,\nBTN_TRIGGER_HAPPY11 = 714,\nBTN_TRIGGER_HAPPY12 = 715,\nBTN_TRIGGER_HAPPY13 = 716,\nBTN_TRIGGER_HAPPY14 = 717,\nBTN_TRIGGER_HAPPY15 = 718,\nBTN_TRIGGER_HAPPY16 = 719,\nBTN_TRIGGER_HAPPY17 = 720,\nBTN_TRIGGER_HAPPY18 = 721,\nBTN_TRIGGER_HAPPY19 = 722,\nBTN_TRIGGER_HAPPY20 = 723,\nBTN_TRIGGER_HAPPY21 = 724,\nBTN_TRIGGER_HAPPY22 = 725,\nBTN_TRIGGER_HAPPY23 = 726,\nBTN_TRIGGER_HAPPY24 = 727,\nBTN_TRIGGER_HAPPY25 = 728,\nBTN_TRIGGER_HAPPY26 = 729,\nBTN_TRIGGER_HAPPY27 = 730,\nBTN_TRIGGER_HAPPY28 = 731,\nBTN_TRIGGER_HAPPY29 = 732,\nBTN_TRIGGER_HAPPY30 = 733,\nBTN_TRIGGER_HAPPY31 = 734,\nBTN_TRIGGER_HAPPY32 = 735,\nBTN_TRIGGER_HAPPY33 = 736,\nBTN_TRIGGER_HAPPY34 = 737,\nBTN_TRIGGER_HAPPY35 = 738,\nBTN_TRIGGER_HAPPY36 = 739,\nBTN_TRIGGER_HAPPY37 = 740,\nBTN_TRIGGER_HAPPY38 = 741,\nBTN_TRIGGER_HAPPY39 = 742,\nBTN_TRIGGER_HAPPY40 = 743,\nBTN_MAX = 744,\nMouseWheelUp = 745,\nMouseWheelDown = 746,\nMouseWheelLeft = 747,\nMouseWheelRight = 748,\nKEY_MAX = 767,\n\n=== all kcs\nNo,\nErrorRollOver,\nPostFail,\nErrorUndefined,\nA,\nB,\nC,\nD,\nE,\nF,\nG,\nH,\nI,\nJ,\nK,\nL,\nM,\nN,\nO,\nP,\nQ,\nR,\nS,\nT,\nU,\nV,\nW,\nX,\nY,\nZ,\nKb1,\nKb2,\nKb3,\nKb4,\nKb5,\nKb6,\nKb7,\nKb8,\nKb9,\nKb0,\nEnter,\nEscape,\nBSpace,\nTab,\nSpace,\nMinus,\nEqual,\nLBracket,\nRBracket,\nBslash,\nNonUsHash,\nSColon,\nQuote,\nGrave,\nComma,\nDot,\nSlash,\nCapsLock,\nF1,\nF2,\nF3,\nF4,\nF5,\nF6,\nF7,\nF8,\nF9,\nF10,\nF11,\nF12,\nPScreen,\nScrollLock,\nPause,\nInsert,\nHome,\nPgUp,\nDelete,\nEnd,\nPgDown,\nRight,\nLeft,\nDown,\nUp,\nNumLock,\nKpSlash,\nKpAsterisk,\nKpMinus,\nKpPlus,\nKpEnter,\nKp1,\nKp2,\nKp3,\nKp4,\nKp5,\nKp6,\nKp7,\nKp8,\nKp9,\nKp0,\nKpDot,\nNonUsBslash,\nApplication,\nPower,\nKpEqual,\nF13,\nF14,\nF15,\nF16,\nF17,\nF18,\nF19,\nF20,\nF21,\nF22,\nF23,\nF24,\nExecute,\nHelp,\nMenu,\nSelect,\nStop,\nAgain,\nUndo,\nCut,\nCopy,\nPaste,\nFind,\nMute,\nVolUp,\nVolDown,\nLockingCapsLock,\nLockingNumLock,\nLockingScrollLock,\nKpComma,\nKpEqualSign,\nIntl1,\nIntl2,\nIntl3,\nIntl4,\nIntl5,\nIntl6,\nIntl7,\nIntl8,\nIntl9,\nLang1,\nLang2,\nLang3,\nLang4,\nLang5,\nLang6,\nLang7,\nLang8,\nLang9,\nAltErase,\nSysReq,\nCancel,\nClear,\nPrior,\nReturn,\nSeparator,\nOut,\nOper,\nClearAgain,\nCrSel,\nExSel,\nWakeup,\nBrightnessUp,\nBrightnessDown,\nKbdIllumUp,\nKbdIllumDown,\nK0xAA,\nK0xAB,\nK0xAC,\nK0xAD,\nK0xAE,\nK0xAF,\nK0xB0,\nK0xB1,\nK0xB2,\nK0xB3,\nK0xB4,\nK0xB5,\nK0xB6,\nK0xB7,\nK0xB8,\nK0xB9,\nK0xBA,\nK0xBB,\nK0xBC,\nK0xBD,\nK0xBE,\nK0xBF,\nK0xC0,\nK0xC1,\nK0xC2,\nK0xC3,\nK0xC4,\nK0xC5,\nK0xC6,\nK0xC7,\nK0xC8,\nK0xC9,\nK0xCA,\nK0xCB,\nK0xCC,\nK0xCD,\nK0xCE,\nK0xCF,\nK0xD0,\nK0xD1,\nK0xD2,\nK0xD3,\nK0xD4,\nK0xD5,\nK0xD6,\nK0xD7,\nK0xD8,\nK0xD9,\nK0xDA,\nK0xDB,\nK0xDC,\nK0xDD,\nK0xDE,\nK0xDF,\nLCtrl,\nLShift,\nLAlt,\nLGui,\nRCtrl,\nRShift,\nRAlt,\nRGui,\nMediaPlayPause,\nMediaStopCD,\nMediaPreviousSong,\nMediaNextSong,\nMediaEjectCD,\nMediaVolUp,\nMediaVolDown,\nMediaMute,\nMediaWWW,\nMediaBack,\nMediaForward,\nMediaStop,\nMediaFind,\nMediaScrollUp,\nMediaScrollDown,\nMediaEdit,\nMediaSleep,\nMediaCoffee,\nMediaRefresh,\nMediaCalc,\nK252,\nK253,\nK254,\nK255,\nK256,\nK257,\nK258,\nK259,\nK260,\nK261,\nK262,\nK263,\nK264,\nK265,\nK266,\nK267,\nK268,\nK269,\nK270,\nK271,\nK272,\nK273,\nK274,\nK275,\nK276,\nK277,\nK278,\nK279,\nK280,\nK281,\nK282,\nK283,\nK284,\nK285,\nK286,\nK287,\nK288,\nK289,\nK290,\nK291,\nK292,\nK293,\nK294,\nK295,\nK296,\nK297,\nK298,\nK299,\nK300,\nK301,\nK302,\nK303,\nK304,\nK305,\nK306,\nK307,\nK308,\nK309,\nK310,\nK311,\nK312,\nK313,\nK314,\nK315,\nK316,\nK317,\nK318,\nK319,\nK320,\nK321,\nK322,\nK323,\nK324,\nK325,\nK326,\nK327,\nK328,\nK329,\nK330,\nK331,\nK332,\nK333,\nK334,\nK335,\nK336,\nK337,\nK338,\nK339,\nK340,\nK341,\nK342,\nK343,\nK344,\nK345,\nK346,\nK347,\nK348,\nK349,\nK350,\nK351,\nK352,\nK353,\nK354,\nK355,\nK356,\nK357,\nK358,\nK359,\nK360,\nK361,\nK362,\nK363,\nK364,\nK365,\nK366,\nK367,\nK368,\nK369,\nK370,\nK371,\nK372,\nK373,\nK374,\nK375,\nK376,\nK377,\nK378,\nK379,\nK380,\nK381,\nK382,\nK383,\nK384,\nK385,\nK386,\nK387,\nK388,\nK389,\nK390,\nK391,\nK392,\nK393,\nK394,\nK395,\nK396,\nK397,\nK398,\nK399,\nK400,\nK401,\nK402,\nK403,\nK404,\nK405,\nK406,\nK407,\nK408,\nK409,\nK410,\nK411,\nK412,\nK413,\nK414,\nK415,\nK416,\nK417,\nK418,\nK419,\nK420,\nK421,\nK422,\nK423,\nK424,\nK425,\nK426,\nK427,\nK428,\nK429,\nK430,\nK431,\nK432,\nK433,\nK434,\nK435,\nK436,\nK437,\nK438,\nK439,\nK440,\nK441,\nK442,\nK443,\nK444,\nK445,\nK446,\nK447,\nK448,\nK449,\nK450,\nK451,\nK452,\nK453,\nK454,\nK455,\nK456,\nK457,\nK458,\nK459,\nK460,\nK461,\nK462,\nK463,\nK464,\nK465,\nK466,\nK467,\nK468,\nK469,\nK470,\nK471,\nK472,\nK473,\nK474,\nK475,\nK476,\nK477,\nK478,\nK479,\nK480,\nK481,\nK482,\nK483,\nK484,\nK485,\nK486,\nK487,\nK488,\nK489,\nK490,\nK491,\nK492,\nK493,\nK494,\nK495,\nK496,\nK497,\nK498,\nK499,\nK500,\nK501,\nK502,\nK503,\nK504,\nK505,\nK506,\nK507,\nK508,\nK509,\nK510,\nK511,\nK512,\nK513,\nK514,\nK515,\nK516,\nK517,\nK518,\nK519,\nK520,\nK521,\nK522,\nK523,\nK524,\nK525,\nK526,\nK527,\nK528,\nK529,\nK530,\nK531,\nK532,\nK533,\nK534,\nK535,\nK536,\nK537,\nK538,\nK539,\nK540,\nK541,\nK542,\nK543,\nK544,\nK545,\nK546,\nK547,\nK548,\nK549,\nK550,\nK551,\nK552,\nK553,\nK554,\nK555,\nK556,\nK557,\nK558,\nK559,\nK560,\nK561,\nK562,\nK563,\nK564,\nK565,\nK566,\nK567,\nK568,\nK569,\nK570,\nK571,\nK572,\nK573,\nK574,\nK575,\nK576,\nK577,\nK578,\nK579,\nK580,\nK581,\nK582,\nK583,\nK584,\nK585,\nK586,\nK587,\nK588,\nK589,\nK590,\nK591,\nK592,\nK593,\nK594,\nK595,\nK596,\nK597,\nK598,\nK599,\nK600,\nK601,\nK602,\nK603,\nK604,\nK605,\nK606,\nK607,\nK608,\nK609,\nK610,\nK611,\nK612,\nK613,\nK614,\nK615,\nK616,\nK617,\nK618,\nK619,\nK620,\nK621,\nK622,\nK623,\nK624,\nK625,\nK626,\nK627,\nK628,\nK629,\nK630,\nK631,\nK632,\nK633,\nK634,\nK635,\nK636,\nK637,\nK638,\nK639,\nK640,\nK641,\nK642,\nK643,\nK644,\nK645,\nK646,\nK647,\nK648,\nK649,\nK650,\nK651,\nK652,\nK653,\nK654,\nK655,\nK656,\nK657,\nK658,\nK659,\nK660,\nK661,\nK662,\nK663,\nK664,\nK665,\nK666,\nK667,\nK668,\nK669,\nK670,\nK671,\nK672,\nK673,\nK674,\nK675,\nK676,\nK677,\nK678,\nK679,\nK680,\nK681,\nK682,\nK683,\nK684,\nK685,\nK686,\nK687,\nK688,\nK689,\nK690,\nK691,\nK692,\nK693,\nK694,\nK695,\nK696,\nK697,\nK698,\nK699,\nK700,\nK701,\nK702,\nK703,\nK704,\nK705,\nK706,\nK707,\nK708,\nK709,\nK710,\nK711,\nK712,\nK713,\nK714,\nK715,\nK716,\nK717,\nK718,\nK719,\nK720,\nK721,\nK722,\nK723,\nK724,\nK725,\nK726,\nK727,\nK728,\nK729,\nK730,\nK731,\nK732,\nK733,\nK734,\nK735,\nK736,\nK737,\nK738,\nK739,\nK740,\nK741,\nK742,\nK743,\nK744,\nMWU,\nMWD,\nMWL,\nMWR,\nKeyMax,\n" }, { "path": "key-sort-add/src/main.rs", "content": "//! one:\n//!\n//! Takes a file formatted as:\n//!\n//! KEY_RESERVED = 0,\n//! KEY_ESC = 1,\n//! KEY_1 = 2,\n//! KEY_2 = 3,\n//! KEY_3 = 4,\n//! KEY_4 = 5,\n//! ...\n//!\n//! Outputs to stdout a sorted version of the file with numeric gaps filled in with:\n//!\n//! KEY_X = X,\n//!\n//! two: mapping.txt to ensure KeyCode and OsCode can simply be transmuted into each other.\n\nuse std::io::Read;\n\nfn main() {\n match std::env::args().nth(1).expect(\"function parameter\").as_str() {\n \"one\" => one(),\n \"two\" => two(),\n _ => panic!(\"unknown capabality\"),\n }\n}\n\nfn one() {\n let mut f = std::fs::File::open(std::env::args().nth(2).expect(\"filename parameter\"))\n .expect(\"file open\");\n let mut s = String::new();\n f.read_to_string(&mut s).expect(\"read file\");\n let mut keys = s\n .lines()\n .map(|l| {\n let mut segments = l.trim_end_matches(',').trim().split(\" = \");\n let key = segments.next().expect(\"a string\");\n let num: u16 = u16::from_str_radix(\n segments\n .next()\n .map(|s| s.trim_start_matches(\"0x\"))\n .expect(\"string after =\"),\n 10,\n )\n .expect(\"u16\");\n (key.to_owned(), num)\n })\n .collect::>();\n keys.sort_by_key(|k| k.1);\n let mut keys_to_add = vec![];\n let mut cur_key = keys.iter();\n let mut prev_key = keys.iter();\n cur_key.next();\n for cur in cur_key {\n let prev = prev_key.next().expect(\"lagging iterator is valid\");\n for missing in prev.1 + 1..cur.1 {\n keys_to_add.push((format!(\"K{missing}\"), missing));\n }\n }\n keys.append(&mut keys_to_add);\n keys.sort_by_key(|k| k.1);\n for key in keys {\n println!(\"{} = {},\", key.0, key.1);\n }\n}\n\nfn two() {\n use std::collections::HashMap;\n\n let mut f = std::fs::File::open(std::env::args().nth(2).expect(\"filename parameter\"))\n .expect(\"file open\");\n let mut s = String::new();\n f.read_to_string(&mut s).expect(\"read file\");\n let mut lines = s.lines();\n\n // filter out useless lines\n while let Some(line) = lines.next() {\n if line == \"=== kc to osc\" {\n break;\n }\n }\n\n // parse kc to osc\n let mut kc_to_osc: HashMap<&str, &str> = HashMap::new();\n while let Some(line) = lines.next() {\n if line.trim().is_empty() {\n continue;\n }\n if line == \"=== osc to u16\" {\n break;\n }\n let (kc, osc) = line.split_once(\" => \").expect(\"arrow separator\");\n let kc = kc.trim_start_matches(\"KeyCode::\");\n let osc = osc.trim_end_matches(',')\n .trim_start_matches(\"OsCode::\");\n kc_to_osc.insert(kc, osc);\n }\n\n // parse osc to u16\n let mut osc_vals: HashMap<&str, u16> = HashMap::new();\n while let Some(line) = lines.next() {\n if line.trim().is_empty() {\n continue;\n }\n if line == \"=== all kcs\" {\n break;\n }\n let (kc, num) = line.split_once(\" = \").expect(\"equal separator\");\n let num = num.trim_end_matches(',').parse::().expect(\"u16\");\n osc_vals.insert(kc, num);\n }\n\n // parse kcs\n let mut kc_vals: Vec<(&str, Option)> = vec![];\n while let Some(line) = lines.next() {\n if line.trim().is_empty() {\n continue;\n }\n let kc = line.trim_end_matches(',');\n let val: Option = kc_to_osc.get(&kc)\n .and_then(|osc| osc_vals.get(osc))\n .copied();\n kc_vals.push((kc, val));\n }\n\n for (kc, val) in kc_vals.iter() {\n println!(\"{kc} = {},\", val.unwrap_or(65535));\n }\n}\n" }, { "path": "keyberon/.gitignore", "content": "# Ignore Cargo.lock since this is a library crate\nCargo.lock\n" }, { "path": "keyberon/CHANGELOG.md", "content": "# v0.2.0\n\n* New Keyboard::leds_mut function for getting underlying leds object.\n* Made Layout::current_layer public for getting current active layer.\n* Added a procedural macro for defining layouts (`keyberon::layout::layout`)\n* Corrected HID report descriptor\n* Add max_packet_size() to HidDevice to allow differing report sizes\n* Allows default layer to be set on a Layout externally\n* Add Chording for multiple keys pressed at the same time to equal another key\n\nBreaking changes:\n* Row and Column pins are now a simple array. For the STM32 MCU, you\n should now use `.downgrade()` to have an homogenous array. \n* `Action::HoldTap` now takes a configuration for different behaviors.\n* `Action::HoldTap` now takes the `tap_hold_interval` field. Not\n implemented yet.\n* `Action` is now generic, for the `Action::Custom(T)` variant,\n allowing custom actions to be handled outside of keyberon. This\n functionality can be used to drive non keyboard actions, such as resetting\n the microcontroller, driving leds (for backlight or underglow for\n example), managing a mouse emulation, or any other ideas you can\n have. As there is a default value for the type parameter, the update\n should be transparent.\n* Layers don't sum anymore, the last pressed layer action set the layer.\n* Rename MeidaCoffee in MediaCoffee to fix typo.\n\n# v0.1.1\n\n* HidClass::control_xxx: check interface number [#26](https://github.com/TeXitoi/keyberon/pull/26)\n\n# v0.1.0\n\nFirst published version.\n" }, { "path": "keyberon/Cargo.toml", "content": "[package]\nname = \"kanata-keyberon\"\nversion = \"0.1110.0\"\nauthors = [\"Guillaume Pinot \", \"Robin Krahl \", \"jtroo \"]\nedition = \"2021\"\ndescription = \"Pure Rust keyboard firmware. Fork intended for use with kanata.\"\ndocumentation = \"https://docs.rs/keyberon\"\nrepository = \"https://github.com/TeXitoi/keyberon\"\nkeywords = [\"keyboard\", \"kanata\"]\ncategories = [\"no-std\"]\nlicense = \"MIT\"\nreadme = \"README.md\"\n\n[features]\ntap_hold_tracker = []\n\n[dependencies]\nkanata-keyberon-macros = { version = \"0.2.0\" }\nheapless = \"0.7.16\"\nrustc-hash = \"1.1.0\"\narraydeque = { version = \"0.5.1\", default-features = false }\n" }, { "path": "keyberon/KEYBOARDS.md", "content": "| Keyboard | PCB or Handwired | MCU | Feature Status |\n| - | - | - | - |\n| [KeySeeBee](https://github.com/TeXitoi/keyseebee) | PCB | STM32F072 |
  • [x] Matrix
  • [x] Split
|\n| [Keyberon-f4](https://github.com/TeXitoi/keyberon-f4) | Handwired | STM32F401 |
  • [x] Matrix
|\n| [Arisu](https://github.com/help-14/arisu-handwired) | Handwired | STM32F401 |
  • [x] Matrix
|\n| [ortho60-keyberon](https://github.com/TeXitoi/ortho60-keyberon) | PCB | STM32F103 |
  • [x] Matrix
|\n| [keyberon-grid](https://github.com/TeXitoi/keyberon-grid) | Handwired | STM32F103 |
  • [x] Matrix
|\n| [Clueboard 66% LP](https://github.com/wezm/clueboard-rust-firmware) | PCB | STM32F303 |
  • [x] Matrix
  • [ ] LEDs
  • [ ] Speakers
|\n| [anne-keyberon](https://github.com/hdhoang/anne-keyberon) | PCB | STM32L151 |
  • [ ] Matrix
  • [ ] BT proto
  • [ ] LED proto
  • [ ] LED MCU
|\n| [corne-xiao](https://github.com/lehmanju/corne-xiao) | PCB | ATSAMD21 |
  • [x] Matrix
|\n| [pinci](https://github.com/camrbuss/pinci) | PCB | RP2040 |
  • [x] Matrix
  • [x] Split
|\n| [nibble-rp2040-rs](https://github.com/DrewTChrist/nibble-rp2040-rs) | PCB | RP2040 |
  • [x] Matrix
  • [ ] Rotary Encoder
  • [ ] RGB LEDs
  • [ ] OLED
|\n| [keyboard-labs](https://github.com/rgoulter/keyboard-labs) | PCB | STM32F401 |
  • [x] Matrix
  • [x] Split
|\n| [makerdiary M60](https://github.com/jamesmunns/m60-keyboard/) | PCB | nRF52840 |
  • [x] Matrix
  • [x] RGB LEDs
    • |\n| [PouetPouet](https://github.com/dkm/pouetpouet-board) | PCB | STM32F072 |
    • [x] Matrix
    |\n| [corne](https://github.com/simmsb/keyboard) | PCB | nRF52840 |
    • [x] Matrix
    • [x] RGB LEDs
    • [x] OLED
    • [x] split
    |\n| [Cantor](https://github.com/dariogoetz/cantor-firmware-keyberon) | PCB | STM32F401 |
    • [x] Matrix
    • [ ] LEDs
    • [x] Split
    • [x] Diodeless
    |\n" }, { "path": "keyberon/LICENSE", "content": "MIT License\n\nCopyright (c) 2019 Guillaume P.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n" }, { "path": "keyberon/README.md", "content": "# kanata-keyberon\n\n## Note\n\nThis is a fork intended for use by the [kanata keyboard remapper software](https://github.com/jtroo/kanata).\nPlease make contributions to the [original project](https://github.com/TeXitoi/keyberon) where applicable.\n\nThis crate does not follow semver. It tracks the version of kanata.\n" }, { "path": "keyberon/keyberon-macros/Cargo.toml", "content": "[package]\nname = \"kanata-keyberon-macros\"\nversion = \"0.2.0\"\nauthors = [\"Antoni Simka \"]\nedition = \"2018\"\ndescription = \"Macros for keyberon. Fork for kanata project\"\nlicense = \"MIT\"\n\n[lib]\nproc-macro = true\n\n[dependencies]\nproc-macro2 = \"1.0\"\nquote = \"1.0\"\n" }, { "path": "keyberon/keyberon-macros/README.md", "content": "# kanata keyberon macros\n\n## Note\n\nThis is a fork intended for use by the [kanata keyboard remapper software](https://github.com/jtroo/keyberon).\nPlease make contributions to the [original project](https://github.com/TeXitoi/keyberon) where applicable.\n" }, { "path": "keyberon/keyberon-macros/src/lib.rs", "content": "extern crate proc_macro;\nuse proc_macro2::{Delimiter, Group, Literal, Punct, Spacing, TokenStream, TokenTree};\nuse quote::quote;\n\n#[proc_macro]\npub fn layout(input: proc_macro::TokenStream) -> proc_macro::TokenStream {\n let input: TokenStream = input.into();\n\n let mut out = TokenStream::new();\n\n let mut inside = TokenStream::new();\n\n for t in input {\n match t {\n TokenTree::Group(g) if g.delimiter() == Delimiter::Brace => {\n let layer = parse_layer(g.stream());\n inside.extend(quote! {\n [#layer],\n });\n }\n _ => panic!(\"{}\", \"Invalid token, expected layer: {{ ... }}\"),\n }\n }\n\n let all: TokenStream = quote! { [#inside] };\n out.extend(all);\n\n out.into()\n}\n\nfn parse_layer(input: TokenStream) -> TokenStream {\n let mut out = TokenStream::new();\n for t in input {\n match t {\n TokenTree::Group(g) if g.delimiter() == Delimiter::Bracket => {\n let row = parse_row(g.stream());\n out.extend(quote! {\n [#row],\n });\n }\n TokenTree::Punct(p) if p.as_char() == ',' => (),\n _ => panic!(\"Invalid token, expected row: [ ... ]\"),\n }\n }\n out\n}\n\nfn parse_row(input: TokenStream) -> TokenStream {\n let mut out = TokenStream::new();\n for t in input {\n match t {\n TokenTree::Ident(i) => match i.to_string().as_str() {\n \"n\" => out.extend(quote! { keyberon::action::Action::NoOp, }),\n \"t\" => out.extend(quote! { keyberon::action::Action::Trans, }),\n _ => out.extend(quote! {\n keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::#i),\n }),\n },\n TokenTree::Punct(p) => punctuation_to_keycode(&p, &mut out),\n TokenTree::Literal(l) => literal_to_keycode(&l, &mut out),\n TokenTree::Group(g) => parse_group(&g, &mut out),\n }\n }\n out\n}\n\nfn parse_group(g: &Group, out: &mut TokenStream) {\n match g.delimiter() {\n // Handle empty groups\n Delimiter::Parenthesis if g.stream().is_empty() => {\n eprintln!(\"Expected a layer number in layer switch\");\n }\n Delimiter::Brace if g.stream().is_empty() => {\n eprintln!(\"Expected an action - group cannot be empty\");\n }\n Delimiter::Bracket if g.stream().is_empty() => {\n eprintln!(\"Expected keycodes - keycode group cannot be empty\");\n }\n\n // Momentary layer switch (Action::Layer)\n Delimiter::Parenthesis => {\n let tokens = g.stream();\n out.extend(quote! { keyberon::action::Action::Layer(#tokens), });\n }\n // Pass the expression unchanged (adding a comma after it)\n Delimiter::Brace => out.extend(g.stream().into_iter().chain(TokenStream::from(\n TokenTree::Punct(Punct::new(',', Spacing::Alone)),\n ))),\n // Multiple keycodes (Action::MultipleKeyCodes)\n Delimiter::Bracket => parse_keycode_group(g.stream(), out),\n\n // Is this reachable?\n Delimiter::None => eprintln!(\"Unexpected group\"),\n }\n}\n\nfn parse_keycode_group(input: TokenStream, out: &mut TokenStream) {\n let mut inner = TokenStream::new();\n for t in input {\n match t {\n TokenTree::Ident(i) => inner.extend(quote! {\n keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::#i),\n }),\n TokenTree::Punct(p) => punctuation_to_keycode(&p, &mut inner),\n TokenTree::Literal(l) => literal_to_keycode(&l, &mut inner),\n TokenTree::Group(g) => parse_group(&g, &mut inner),\n }\n }\n out.extend(quote! { keyberon::action::Action::MultipleActions(&[#inner].as_slice()), });\n}\n\nfn punctuation_to_keycode(p: &Punct, out: &mut TokenStream) {\n match p.as_char() {\n // Normal punctuation\n '-' => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Minus), }),\n '=' => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Equal), }),\n ';' => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::SColon), }),\n ',' => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Comma), }),\n '.' => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Dot), }),\n '/' => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Slash), }),\n\n // Shifted punctuation\n '!' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Kb1].as_slice()), }),\n '@' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Kb2].as_slice()), }),\n '#' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Kb3].as_slice()), }),\n '$' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Kb4].as_slice()), }),\n '%' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Kb5].as_slice()), }),\n '^' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Kb6].as_slice()), }),\n '&' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Kb7].as_slice()), }),\n '*' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Kb8].as_slice()), }),\n '_' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Minus].as_slice()), }),\n '+' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Equal].as_slice()), }),\n '|' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Bslash].as_slice()), }),\n '~' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Grave].as_slice()), }),\n '<' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Comma].as_slice()), }),\n '>' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Dot].as_slice()), }),\n '?' => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Slash].as_slice()), }),\n // Is this reachable?\n _ => eprintln!(\"Punctuation could not be parsed as a keycode\")\n }\n}\n\nfn literal_to_keycode(l: &Literal, out: &mut TokenStream) {\n //let repr = l.to_string();\n match l.to_string().as_str() {\n \"1\" => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Kb1), }),\n \"2\" => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Kb2), }),\n \"3\" => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Kb3), }),\n \"4\" => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Kb4), }),\n \"5\" => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Kb5), }),\n \"6\" => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Kb6), }),\n \"7\" => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Kb7), }),\n \"8\" => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Kb8), }),\n \"9\" => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Kb9), }),\n \"0\" => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Kb0), }),\n\n // Char literals; mostly punctuation which can't be properly tokenized alone\n r#\"'\\''\"# => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Quote), }),\n r#\"'\\\\'\"# => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Bslash), }),\n // Shifted characters\n \"'['\" => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::LBracket), }),\n \"']'\" => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::RBracket), }),\n \"'`'\" => out.extend(quote! { keyberon::action::Action::KeyCode(keyberon::key_code::KeyCode::Grave), }),\n \"'\\\"'\" => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Quote].as_slice()), }),\n \"'('\" => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Kb9].as_slice()), }),\n \"')'\" => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Kb0].as_slice()), }),\n \"'{'\" => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::LBracket].as_slice()), }),\n \"'}'\" => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::RBracket].as_slice()), }),\n \"'_'\" => out.extend(quote! { keyberon::action::Action::MultipleKeyCodes(&[keyberon::key_code::KeyCode::LShift, keyberon::key_code::KeyCode::Minus].as_slice()), }),\n\n s if s.starts_with('\\'') => eprintln!(\"Literal could not be parsed as a keycode\"),\n\n s if s.starts_with('\\\"') => {\n eprintln!(\"Typing strings on key press is not yet supported\")\n }\n _ => eprintln!(\"Literal could not be parsed as a keycode\")\n }\n}\n" }, { "path": "keyberon/src/action/switch.rs", "content": "//! Handle processing of the switch action for Keyberon.\n//!\n//! Limitations:\n//! - Maximum opcode length: 4095\n//! - Maximum boolean expression depth: 8\n//! - Maximum key recency: 7, where 0 is the most recent key press\n//!\n//! The intended use is to build up a `Switch` struct and use that in the `Layout`.\n//!\n//! The `Layout` will use `Switch::actions` to iterate over the actions that should be activated\n//! when the corresponding key is pressed.\n\nuse super::*;\nuse crate::layout::{HistoricalEvent, KCoord};\n\nuse crate::key_code::*;\n\nuse BooleanOperator::*;\nuse BreakOrFallthrough::*;\n\npub const MAX_OPCODE_LEN: u16 = 0x0FFF;\npub const OP_MASK: u16 = 0xF000;\npub const MAX_BOOL_EXPR_DEPTH: usize = 8;\npub const MAX_KEY_RECENCY: u8 = 7;\n\npub type Case<'a, T> = (&'a [OpCode], &'a Action<'a, T>, BreakOrFallthrough);\n\n#[derive(Debug, Clone, Copy, PartialEq)]\n/// Behaviour of a switch action. Each case is a 3-tuple of:\n///\n/// - the boolean expression (array of opcodes)\n/// - the action to evaluate if the expression evaluates to true\n/// - whether to break or fallthrough to the next case if the expression evaluates to true\npub struct Switch<'a, T: 'a> {\n pub cases: &'a [Case<'a, T>],\n}\n\n// NOTE: have exhausted our opcodes for u16!\n//\n// Future rewrite: do traditional u8 opcodes, with variable length for the total opcode depending\n// on the first one encountered? Or could be lazy and use u32 and have 4 bytes for every opcode.\n// This probably isn't that performance-sensitive anyway... it's triggering on every input.\n\nconst OR_VAL: u16 = 0x1000;\nconst AND_VAL: u16 = 0x2000;\nconst NOT_VAL: u16 = 0x3000;\n\nconst INPUT_VAL: u16 = 851;\nconst HISTORICAL_INPUT_VAL: u16 = 852;\nconst LAYER_VAL: u16 = 853;\nconst BASE_LAYER_VAL: u16 = 854;\n\n// Binary values:\n// 0b0100 ...\n// 0b0110 ...\n//\n// How-far-back are in bits 12-10 (3 bits)\n// Time is compressed in bits 9-0 (10 bits)\nconst TICKS_SINCE_VAL_GT: u16 = 0x4000;\nconst TICKS_SINCE_VAL_LT: u16 = 0x6000;\n\n// Highest bit in u16. Lower 3 bits in the highest nibble are \"how far back\". This means that\n// switch can look back up to 8 keys.\nconst HISTORICAL_KEYCODE_VAL: u16 = 0x8000;\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\n/// Boolean operator. Notably missing today is Not.\npub enum BooleanOperator {\n Or,\n And,\n Not,\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]\n/// OpCode for a switch case boolean expression.\npub struct OpCode(u16);\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\n/// The more useful interpretion of an OpCode.\nenum OpCodeType {\n BooleanOp(OperatorAndEndIndex),\n KeyCode(u16),\n HistoricalKeyCode(HistoricalKeyCode),\n Input(KCoord),\n HistoricalInput(HistoricalInput),\n TicksSinceLessThan(TicksSinceNthKey),\n TicksSinceGreaterThan(TicksSinceNthKey),\n Layer(u16),\n BaseLayer(u16),\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\n/// The operation type and the opcode index at which evaluating this type ends.\nstruct OperatorAndEndIndex {\n pub op: BooleanOperator,\n pub idx: usize,\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\n/// An op that checks specifically for a key that is a certain number of key presses back in\n/// history.\nstruct HistoricalKeyCode {\n key_code: u16,\n how_far_back: u8,\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\n/// An op that checks specifically for a key that is a certain number of key presses back in\n/// history.\nstruct HistoricalInput {\n input: KCoord,\n how_far_back: u8,\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\nstruct TicksSinceNthKey {\n nth_key: u8,\n ticks_since: u16,\n}\n\n#[derive(Debug, Copy, Clone, PartialEq)]\n/// Whether or not a case should break out of the switch if it evaluates to true or fallthrough to\n/// the next case.\npub enum BreakOrFallthrough {\n Break,\n Fallthrough,\n}\n\nimpl<'a, T> Switch<'a, T> {\n /// Iterates over the actions (if any) that are activated in the `Switch` based on its cases,\n /// the currently active keys, and historically pressed keys.\n ///\n /// The `historical_keys` parameter should iterate in the order of most-recent-first.\n pub fn actions(\n &self,\n active_keys: A1,\n active_positions: A2,\n historical_keys: H1,\n historical_positions: H2,\n layers: L,\n default_layer: u16,\n ) -> SwitchActions<'a, T, A1, A2, H1, H2, L>\n where\n A1: Iterator + Clone,\n A2: Iterator + Clone,\n H1: Iterator> + Clone,\n H2: Iterator> + Clone,\n L: Iterator + Clone,\n {\n SwitchActions {\n cases: self.cases,\n active_keys,\n active_positions,\n historical_keys,\n historical_positions,\n layers,\n default_layer,\n case_index: 0,\n }\n }\n}\n\n#[derive(Debug, Clone)]\n/// Iterator returned by `Switch::actions`.\npub struct SwitchActions<'a, T, A1, A2, H1, H2, L>\nwhere\n A1: Iterator + Clone,\n A2: Iterator + Clone,\n H1: Iterator> + Clone,\n H2: Iterator> + Clone,\n L: Iterator + Clone,\n{\n cases: &'a [(&'a [OpCode], &'a Action<'a, T>, BreakOrFallthrough)],\n active_keys: A1,\n active_positions: A2,\n historical_keys: H1,\n historical_positions: H2,\n layers: L,\n default_layer: u16,\n case_index: usize,\n}\n\nimpl<'a, T, A1, A2, H1, H2, L> Iterator for SwitchActions<'a, T, A1, A2, H1, H2, L>\nwhere\n A1: Iterator + Clone,\n A2: Iterator + Clone,\n H1: Iterator> + Clone,\n H2: Iterator> + Clone,\n L: Iterator + Clone,\n{\n type Item = &'a Action<'a, T>;\n\n fn next(&mut self) -> Option {\n while self.case_index < self.cases.len() {\n let case = &self.cases[self.case_index];\n if evaluate_boolean(\n case.0,\n self.active_keys.clone(),\n self.active_positions.clone(),\n self.historical_keys.clone(),\n self.historical_positions.clone(),\n self.layers.clone(),\n self.default_layer,\n ) {\n let ret_ac = case.1;\n match case.2 {\n Break => self.case_index = self.cases.len(),\n Fallthrough => self.case_index += 1,\n }\n return Some(ret_ac);\n }\n self.case_index += 1;\n }\n None\n }\n}\n\nimpl BooleanOperator {\n fn to_u16(self) -> u16 {\n match self {\n Or => OR_VAL,\n And => AND_VAL,\n Not => NOT_VAL,\n }\n }\n}\nfn lossy_compress_ticks(t: u16) -> u16 {\n match t {\n 0..=255 => t,\n 256..=2303 => (t - 255) / 8 + 255,\n _ => (t - 2303) / 128 + 511,\n }\n}\n\nfn lossy_decompress_ticks(t: u16) -> u16 {\n match t {\n 0..=255 => t,\n 256..=511 => (t - 255) * 8 + 255,\n _ => (t - 511) * 128 + 2303,\n }\n}\n\nimpl OpCode {\n /// Return a new OpCode that checks if the key active or not.\n pub fn new_key(kc: KeyCode) -> Self {\n assert!((kc as u16) <= KEY_MAX);\n Self(kc as u16 & MAX_OPCODE_LEN)\n }\n\n /// Return a new OpCode that checks if the n'th most recent key, defined by `key_recency`,\n /// matches the input keycode.\n pub fn new_key_history(kc: KeyCode, key_recency: u8) -> Self {\n assert!((kc as u16) <= MAX_OPCODE_LEN);\n assert!(key_recency <= MAX_KEY_RECENCY);\n Self((kc as u16 & MAX_OPCODE_LEN) | HISTORICAL_KEYCODE_VAL | ((key_recency as u16) << 12))\n }\n\n /// Returns a new opcode that returns true if the n'th most recent key was pressed greater\n /// than `ticks_since` ticks ago.\n ///\n /// At 256 ticks or above, this has a resolution of 8ms (rounded down). At 2304 ticks or\n /// above, this has a resolution of 128 ms (rounded down).\n pub fn new_ticks_since_gt(nth_key: u8, ticks_since: u16) -> Self {\n assert!(nth_key <= MAX_KEY_RECENCY);\n Self(TICKS_SINCE_VAL_GT | lossy_compress_ticks(ticks_since) | (u16::from(nth_key) << 10))\n }\n\n /// Returns a new opcode that returns true if the n'th most recent key was pressed greater\n /// than `ticks_since` ticks ago.\n ///\n /// At 256 ticks or above, this has a resolution of 8ms (rounded down). At 2304 ticks or\n /// above, this has a resolution of 128 ms (rounded down).\n pub fn new_ticks_since_lt(nth_key: u8, ticks_since: u16) -> Self {\n assert!(nth_key <= MAX_KEY_RECENCY);\n Self(TICKS_SINCE_VAL_LT | lossy_compress_ticks(ticks_since) | (u16::from(nth_key) << 10))\n }\n\n /// Return a new OpCode for a boolean operation that ends (non-inclusive) at the specified\n /// index.\n pub fn new_bool(op: BooleanOperator, end_idx: u16) -> Self {\n assert!(end_idx <= MAX_OPCODE_LEN);\n Self((end_idx & MAX_OPCODE_LEN) + op.to_u16())\n }\n\n /// Return OpCodes specifying an active input check.\n pub fn new_active_input(input: KCoord) -> (Self, Self) {\n assert!(input.0 < 4);\n assert!(input.1 < 0x0400);\n (\n Self(INPUT_VAL),\n Self((u16::from(input.0 & 3) << 14) + input.1),\n )\n }\n\n /// Return OpCodes specifying an active input check.\n pub fn new_historical_input(input: KCoord, key_recency: u8) -> (Self, Self) {\n assert!(input.0 < 4);\n assert!(input.1 < 0x0400);\n assert!(key_recency < 0x8);\n (\n Self(HISTORICAL_INPUT_VAL),\n Self((u16::from(input.0 & 3) << 14) + (u16::from(key_recency) << 11) + input.1),\n )\n }\n\n /// Return OpCodes specifying an active layer check.\n pub fn new_layer(layer: u16) -> (Self, Self) {\n assert!(usize::from(layer) < crate::layout::MAX_LAYERS);\n (Self(LAYER_VAL), Self(layer))\n }\n\n /// Return OpCodes specifying an base layer check.\n pub fn new_base_layer(base_layer: u16) -> (Self, Self) {\n assert!(usize::from(base_layer) < crate::layout::MAX_LAYERS);\n (Self(BASE_LAYER_VAL), Self(base_layer))\n }\n\n /// Return the interpretation of this `OpCode`.\n fn opcode_type(self, next: Option) -> OpCodeType {\n if self.0 < KEY_MAX {\n OpCodeType::KeyCode(self.0)\n } else if self.0 <= MAX_OPCODE_LEN {\n let op2 = next.expect(\"next should be some for opcode {self:?}\");\n match self.0 {\n INPUT_VAL => OpCodeType::Input((((op2.0 >> 14) & 0x3) as u8, op2.0 & 0x3FF)),\n HISTORICAL_INPUT_VAL => OpCodeType::HistoricalInput(HistoricalInput {\n input: (((op2.0 >> 14) & 0x3) as u8, op2.0 & 0x3FF),\n how_far_back: (op2.0 >> 11) as u8 & 0x7,\n }),\n LAYER_VAL => OpCodeType::Layer(op2.0),\n BASE_LAYER_VAL => OpCodeType::BaseLayer(op2.0),\n _ => unreachable!(\"unexpected opcode {self:?}\"),\n }\n } else {\n match self.0 & 0xE000 {\n TICKS_SINCE_VAL_LT => OpCodeType::TicksSinceLessThan(TicksSinceNthKey {\n nth_key: ((self.0 & 0x1C00) >> 10) as u8,\n ticks_since: lossy_decompress_ticks(self.0 & 0x03FF),\n }),\n TICKS_SINCE_VAL_GT => OpCodeType::TicksSinceGreaterThan(TicksSinceNthKey {\n nth_key: ((self.0 & 0x1C00) >> 10) as u8,\n ticks_since: lossy_decompress_ticks(self.0 & 0x03FF),\n }),\n 0x8000..=0xF000 => OpCodeType::HistoricalKeyCode(HistoricalKeyCode {\n key_code: self.0 & 0x0FFF,\n how_far_back: ((self.0 & 0x7000) >> 12) as u8,\n }),\n _ => OpCodeType::BooleanOp(OperatorAndEndIndex::from(self.0)),\n }\n }\n }\n}\n\nimpl From for OperatorAndEndIndex {\n fn from(value: u16) -> Self {\n Self {\n op: match value & OP_MASK {\n OR_VAL => Or,\n AND_VAL => And,\n NOT_VAL => Not,\n _ => unreachable!(\"public interface should protect from this\"),\n },\n idx: usize::from(value & MAX_OPCODE_LEN),\n }\n }\n}\n\n/// Evaluate the return value of an expression evaluated on the given key codes.\nfn evaluate_boolean(\n bool_expr: &[OpCode],\n key_codes: impl Iterator + Clone,\n inputs: impl Iterator + Clone,\n historical_keys: impl Iterator> + Clone,\n historical_inputs: impl Iterator> + Clone,\n layers: impl Iterator + Clone,\n default_layer: u16,\n) -> bool {\n let mut ret = true;\n let mut current_index = 0;\n let mut current_end_index = bool_expr.len();\n let mut current_op = Or;\n let mut stack: arraydeque::ArrayDeque<\n OperatorAndEndIndex,\n MAX_BOOL_EXPR_DEPTH,\n arraydeque::behavior::Saturating,\n > = Default::default();\n while current_index < bool_expr.len() {\n if current_index >= current_end_index {\n match stack.pop_back() {\n Some(operator) => {\n (current_op, current_end_index) = (operator.op, operator.idx);\n }\n None => break,\n }\n // Short-circuiting logic\n if matches!((ret, current_op), (true, Or | Not) | (false, And))\n || current_index >= current_end_index\n {\n if current_op == Not {\n ret = false;\n }\n current_index = current_end_index;\n continue;\n }\n }\n match bool_expr[current_index].opcode_type(bool_expr.get(current_index + 1).copied()) {\n OpCodeType::BooleanOp(operator) => {\n let res = stack.push_back(OperatorAndEndIndex {\n op: current_op,\n idx: current_end_index,\n });\n assert!(\n res.is_ok(),\n \"exceeded boolean op depth {MAX_BOOL_EXPR_DEPTH}\"\n );\n (current_op, current_end_index) = (operator.op, operator.idx);\n current_index += 1;\n continue;\n }\n OpCodeType::KeyCode(kc) => {\n ret = key_codes.clone().any(|kc_input| kc_input as u16 == kc);\n }\n OpCodeType::HistoricalKeyCode(hkc) => {\n ret = historical_keys\n .clone()\n .nth(hkc.how_far_back as usize)\n .map(|he| he.event as u16 == hkc.key_code)\n .unwrap_or(false);\n }\n OpCodeType::TicksSinceLessThan(tsnk) => {\n ret = historical_keys\n .clone()\n .nth(tsnk.nth_key.into())\n .map(|he| he.ticks_since_occurrence <= tsnk.ticks_since)\n .unwrap_or(false);\n }\n OpCodeType::TicksSinceGreaterThan(tsnk) => {\n ret = historical_keys\n .clone()\n .nth(tsnk.nth_key.into())\n .map(|he| he.ticks_since_occurrence > tsnk.ticks_since)\n .unwrap_or(false);\n }\n OpCodeType::Input(coord) => {\n // opcode has size 2\n current_index += 1;\n ret = inputs.clone().any(|c| c == coord)\n }\n OpCodeType::HistoricalInput(hki) => {\n // opcode has size 2\n current_index += 1;\n ret = historical_inputs\n .clone()\n .nth(hki.how_far_back as usize)\n .map(|he| he.event == hki.input)\n .unwrap_or(false)\n }\n OpCodeType::Layer(layer) => {\n // opcode has size 2\n current_index += 1;\n ret = layers.clone().next().map(|l| l == layer).unwrap_or(false)\n }\n OpCodeType::BaseLayer(base_layer) => {\n // opcode has size 2\n current_index += 1;\n ret = default_layer == base_layer;\n }\n };\n if current_op == Not {\n ret = !ret;\n }\n if matches!((ret, current_op), (true, Or) | (false, And | Not)) {\n current_index = current_end_index;\n continue;\n }\n current_index += 1;\n }\n while let Some(OperatorAndEndIndex { op, .. }) = stack.pop_back() {\n if op == Not {\n ret = !ret;\n }\n }\n ret\n}\n\n#[cfg(test)]\nfn evaluate_bool_test(opcodes: &[OpCode], keycodes: impl Iterator + Clone) -> bool {\n evaluate_boolean(\n opcodes,\n keycodes,\n [].iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n 0,\n )\n}\n\n#[test]\nfn bool_evaluation_test_0() {\n let opcodes = [\n OpCode::new_bool(And, 9),\n OpCode::new_key(KeyCode::A),\n OpCode::new_key(KeyCode::B),\n OpCode::new_bool(Or, 6),\n OpCode::new_key(KeyCode::C),\n OpCode::new_key(KeyCode::D),\n OpCode::new_bool(Or, 9),\n OpCode::new_key(KeyCode::E),\n OpCode::new_key(KeyCode::F),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::D, KeyCode::F];\n assert!(evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_1() {\n let opcodes = [\n OpCode::new_bool(And, 9),\n OpCode::new_key(KeyCode::A),\n OpCode::new_key(KeyCode::B),\n OpCode::new_bool(Or, 6),\n OpCode::new_key(KeyCode::C),\n OpCode::new_key(KeyCode::D),\n OpCode::new_bool(Or, 9),\n OpCode::new_key(KeyCode::E),\n OpCode::new_key(KeyCode::F),\n ];\n let keycodes = [\n KeyCode::A,\n KeyCode::B,\n KeyCode::C,\n KeyCode::D,\n KeyCode::E,\n KeyCode::F,\n ];\n assert!(evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_2() {\n let opcodes = [\n OpCode(0x2009),\n OpCode(KeyCode::A as u16),\n OpCode(KeyCode::B as u16),\n OpCode(0x1006),\n OpCode(KeyCode::C as u16),\n OpCode(KeyCode::D as u16),\n OpCode(0x1009),\n OpCode(KeyCode::E as u16),\n OpCode(KeyCode::F as u16),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::E, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_3() {\n let opcodes = [\n OpCode(0x2009),\n OpCode(KeyCode::A as u16),\n OpCode(KeyCode::B as u16),\n OpCode(0x1006),\n OpCode(KeyCode::C as u16),\n OpCode(KeyCode::D as u16),\n OpCode(0x1009),\n OpCode(KeyCode::E as u16),\n OpCode(KeyCode::F as u16),\n ];\n let keycodes = [KeyCode::B, KeyCode::C, KeyCode::D, KeyCode::E, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_4() {\n let opcodes = [];\n let keycodes = [];\n assert!(evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_5() {\n let opcodes = [];\n let keycodes = [\n KeyCode::A,\n KeyCode::B,\n KeyCode::C,\n KeyCode::D,\n KeyCode::E,\n KeyCode::F,\n ];\n assert!(evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_6() {\n let opcodes = [OpCode(KeyCode::A as u16), OpCode(KeyCode::B as u16)];\n let keycodes = [\n KeyCode::A,\n KeyCode::B,\n KeyCode::C,\n KeyCode::D,\n KeyCode::E,\n KeyCode::F,\n ];\n assert!(evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_7() {\n let opcodes = [OpCode(KeyCode::A as u16), OpCode(KeyCode::B as u16)];\n let keycodes = [KeyCode::C, KeyCode::D, KeyCode::E, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_9() {\n let opcodes = [\n OpCode(0x2003),\n OpCode(KeyCode::A as u16),\n OpCode(KeyCode::B as u16),\n OpCode(KeyCode::C as u16),\n ];\n let keycodes = [KeyCode::C, KeyCode::D, KeyCode::E, KeyCode::F];\n assert!(evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_10() {\n let opcodes = [\n OpCode(0x2004),\n OpCode(KeyCode::A as u16),\n OpCode(KeyCode::B as u16),\n OpCode(KeyCode::C as u16),\n ];\n let keycodes = [KeyCode::C, KeyCode::D, KeyCode::E, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_11() {\n let opcodes = [\n OpCode(0x1003),\n OpCode(KeyCode::A as u16),\n OpCode(KeyCode::B as u16),\n ];\n let keycodes = [KeyCode::C, KeyCode::D, KeyCode::E, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_12() {\n let opcodes = [\n OpCode(0x1005),\n OpCode(0x2004),\n OpCode(KeyCode::A as u16),\n OpCode(KeyCode::B as u16),\n OpCode(KeyCode::C as u16),\n ];\n let keycodes = [KeyCode::C, KeyCode::D, KeyCode::E, KeyCode::F];\n assert!(evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_max_depth_does_not_panic() {\n let opcodes = [\n OpCode(0x1008),\n OpCode(0x1008),\n OpCode(0x1008),\n OpCode(0x1008),\n OpCode(0x1008),\n OpCode(0x1008),\n OpCode(0x1008),\n OpCode(0x1008),\n ];\n let keycodes = [];\n assert!(evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\n#[should_panic]\nfn bool_evaluation_test_more_than_max_depth_panics() {\n let opcodes = [\n OpCode(0x1009),\n OpCode(0x1009),\n OpCode(0x1009),\n OpCode(0x1009),\n OpCode(0x1009),\n OpCode(0x1009),\n OpCode(0x1009),\n OpCode(0x1009),\n OpCode(0x1009),\n ];\n let keycodes = [];\n assert!(evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn switch_fallthrough() {\n let sw = Switch {\n cases: &[\n (&[], &Action::<()>::KeyCode(KeyCode::A), Fallthrough),\n (&[], &Action::<()>::KeyCode(KeyCode::B), Fallthrough),\n ],\n };\n let mut actions = sw.actions(\n [].iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n 0,\n );\n assert_eq!(actions.next(), Some(&Action::<()>::KeyCode(KeyCode::A)));\n assert_eq!(actions.next(), Some(&Action::<()>::KeyCode(KeyCode::B)));\n assert_eq!(actions.next(), None);\n}\n\n#[test]\nfn switch_break() {\n let sw = Switch {\n cases: &[\n (&[], &Action::<()>::KeyCode(KeyCode::A), Break),\n (&[], &Action::<()>::KeyCode(KeyCode::B), Break),\n ],\n };\n let mut actions = sw.actions(\n [].iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n 0,\n );\n assert_eq!(actions.next(), Some(&Action::<()>::KeyCode(KeyCode::A)));\n assert_eq!(actions.next(), None);\n}\n\n#[test]\nfn switch_no_actions() {\n let sw = Switch {\n cases: &[\n (\n &[OpCode::new_key(KeyCode::A)],\n &Action::<()>::KeyCode(KeyCode::A),\n Break,\n ),\n (\n &[OpCode::new_key(KeyCode::A)],\n &Action::<()>::KeyCode(KeyCode::B),\n Break,\n ),\n ],\n };\n let mut actions = sw.actions(\n [].iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n 0,\n );\n assert_eq!(actions.next(), None);\n}\n\n#[test]\nfn switch_historical_1() {\n let opcode_true = [OpCode(0x8000 | KeyCode::A as u16)];\n let opcode_true2 = [OpCode(0xF000 | KeyCode::H as u16)];\n let opcode_false = [OpCode(0x9000 | KeyCode::A as u16)];\n let opcode_false2 = [OpCode(0xE000 | KeyCode::H as u16)];\n assert_eq!(\n OpCode::new_key_history(KeyCode::A, 0),\n OpCode(0x8000 | KeyCode::A as u16)\n );\n assert_eq!(\n OpCode::new_key_history(KeyCode::H, 7),\n OpCode(0xF000 | KeyCode::H as u16)\n );\n let hist_keycodes = [\n HistoricalEvent {\n event: KeyCode::A,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::B,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::C,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::D,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::E,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::F,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::G,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::H,\n ticks_since_occurrence: 0,\n },\n ];\n assert!(evaluate_boolean(\n opcode_true.as_slice(),\n [].iter().copied(),\n [].iter().copied(),\n hist_keycodes.iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n 0,\n ));\n assert!(evaluate_boolean(\n opcode_true2.as_slice(),\n [].iter().copied(),\n [].iter().copied(),\n hist_keycodes.iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n 0,\n ));\n assert!(!evaluate_boolean(\n opcode_false.as_slice(),\n [].iter().copied(),\n [].iter().copied(),\n hist_keycodes.iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n 0,\n ));\n assert!(!evaluate_boolean(\n opcode_false2.as_slice(),\n [].iter().copied(),\n [].iter().copied(),\n hist_keycodes.iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n 0,\n ));\n}\n\n#[test]\nfn switch_historical_bools() {\n let opcodes_true_and = [\n OpCode::new_bool(And, 3),\n OpCode::new_key_history(KeyCode::A, 0),\n OpCode::new_key_history(KeyCode::B, 1),\n ];\n let opcodes_false_and1 = [\n OpCode::new_bool(And, 3),\n OpCode::new_key_history(KeyCode::A, 0),\n OpCode::new_key_history(KeyCode::B, 2),\n ];\n let opcodes_false_and2 = [\n OpCode::new_bool(And, 3),\n OpCode::new_key_history(KeyCode::B, 2),\n OpCode::new_key_history(KeyCode::A, 0),\n ];\n let opcodes_true_or1 = [\n OpCode::new_bool(Or, 3),\n OpCode::new_key_history(KeyCode::A, 0),\n OpCode::new_key_history(KeyCode::B, 1),\n ];\n let opcodes_true_or2 = [\n OpCode::new_bool(Or, 3),\n OpCode::new_key_history(KeyCode::A, 0),\n OpCode::new_key_history(KeyCode::B, 2),\n ];\n let opcodes_true_or3 = [\n OpCode::new_bool(Or, 3),\n OpCode::new_key_history(KeyCode::B, 2),\n OpCode::new_key_history(KeyCode::A, 0),\n ];\n let opcodes_false_or = [\n OpCode::new_bool(Or, 3),\n OpCode::new_key_history(KeyCode::A, 1),\n OpCode::new_key_history(KeyCode::B, 2),\n ];\n let hist_keycodes = [\n HistoricalEvent {\n event: KeyCode::A,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::B,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::C,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::D,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::E,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::F,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::G,\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: KeyCode::H,\n ticks_since_occurrence: 0,\n },\n ];\n\n let test = |opcodes: &[OpCode], expectation: bool| {\n assert_eq!(\n evaluate_boolean(\n opcodes,\n [].iter().copied(),\n [].iter().copied(),\n hist_keycodes.iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n 0,\n ),\n expectation\n );\n };\n test(&opcodes_true_and, true);\n test(&opcodes_true_or1, true);\n test(&opcodes_true_or2, true);\n test(&opcodes_true_or3, true);\n test(&opcodes_false_and1, false);\n test(&opcodes_false_and2, false);\n test(&opcodes_false_or, false);\n}\n\n#[test]\nfn switch_historical_ticks_since() {\n let opcodes_true_and = [\n OpCode::new_bool(And, 3),\n OpCode::new_ticks_since_gt(0, 99),\n OpCode::new_ticks_since_lt(0, 101),\n ];\n let opcodes_false_and1 = [\n OpCode::new_bool(And, 3),\n OpCode::new_ticks_since_gt(1, 200),\n OpCode::new_ticks_since_lt(1, 240),\n ];\n let opcodes_false_and2 = [\n OpCode::new_bool(And, 3),\n OpCode::new_ticks_since_gt(2, 300),\n OpCode::new_ticks_since_lt(2, 300),\n ];\n let opcodes_true_or1 = [\n OpCode::new_bool(Or, 3),\n OpCode::new_ticks_since_gt(3, 500),\n OpCode::new_ticks_since_lt(3, 510),\n ];\n let opcodes_true_or2 = [\n OpCode::new_bool(Or, 3),\n OpCode::new_ticks_since_gt(4, 500),\n OpCode::new_ticks_since_lt(4, 511),\n ];\n let opcodes_true_or3 = [\n OpCode::new_bool(Or, 3),\n OpCode::new_ticks_since_gt(5, 980),\n OpCode::new_ticks_since_lt(5, 999),\n ];\n let opcodes_false_or1 = [\n OpCode::new_bool(Or, 3),\n OpCode::new_ticks_since_gt(6, 40200),\n OpCode::new_ticks_since_lt(6, 39999),\n ];\n let opcodes_false_or2 = [\n OpCode::new_bool(Or, 3),\n OpCode::new_ticks_since_gt(5, 1030),\n OpCode::new_ticks_since_lt(5, 999),\n ];\n let opcodes_false_or3 = [\n OpCode::new_bool(Or, 3),\n OpCode::new_ticks_since_gt(4, 520),\n OpCode::new_ticks_since_lt(4, 511),\n ];\n let opcodes_false_or4 = [\n OpCode::new_bool(Or, 3),\n OpCode::new_ticks_since_gt(3, 520),\n OpCode::new_ticks_since_lt(3, 510),\n ];\n let opcodes_false_or5 = [\n OpCode::new_bool(Or, 3),\n OpCode::new_ticks_since_gt(2, 265),\n OpCode::new_ticks_since_lt(2, 255),\n ];\n let opcodes_false_or6 = [\n OpCode::new_bool(Or, 3),\n OpCode::new_ticks_since_gt(1, 256),\n OpCode::new_ticks_since_lt(1, 254),\n ];\n let hist_keycodes = [\n HistoricalEvent {\n event: KeyCode::A,\n ticks_since_occurrence: 100,\n },\n HistoricalEvent {\n event: KeyCode::B,\n ticks_since_occurrence: 255,\n },\n HistoricalEvent {\n event: KeyCode::C,\n ticks_since_occurrence: 256,\n },\n HistoricalEvent {\n event: KeyCode::D,\n ticks_since_occurrence: 511,\n },\n HistoricalEvent {\n event: KeyCode::E,\n ticks_since_occurrence: 512,\n },\n HistoricalEvent {\n event: KeyCode::F,\n ticks_since_occurrence: 1000,\n },\n HistoricalEvent {\n event: KeyCode::G,\n ticks_since_occurrence: 40000,\n },\n ];\n\n let test = |opcodes: &[OpCode], expectation: bool| {\n assert_eq!(\n evaluate_boolean(\n opcodes,\n [].iter().copied(),\n [].iter().copied(),\n hist_keycodes.iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n 0,\n ),\n expectation\n );\n };\n test(&opcodes_true_and, true);\n test(&opcodes_true_or1, true);\n test(&opcodes_true_or2, true);\n test(&opcodes_true_or3, true);\n test(&opcodes_false_and1, false);\n test(&opcodes_false_and2, false);\n test(&opcodes_false_or1, false);\n test(&opcodes_false_or2, false);\n test(&opcodes_false_or3, false);\n test(&opcodes_false_or4, false);\n test(&opcodes_false_or5, false);\n test(&opcodes_false_or6, false);\n}\n\n#[test]\nfn bool_evaluation_test_not_0() {\n // Full inverse of a previous test\n let opcodes = [\n OpCode::new_bool(Not, 10),\n OpCode::new_bool(And, 10),\n OpCode::new_key(KeyCode::A),\n OpCode::new_key(KeyCode::B),\n OpCode::new_bool(Or, 7),\n OpCode::new_key(KeyCode::C),\n OpCode::new_key(KeyCode::D),\n OpCode::new_bool(Or, 10),\n OpCode::new_key(KeyCode::E),\n OpCode::new_key(KeyCode::F),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::D, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_not_1() {\n // Both A and B exist, should be false\n let opcodes = [\n OpCode::new_bool(Not, 3),\n OpCode::new_key(KeyCode::A),\n OpCode::new_key(KeyCode::B),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::D, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_not_2() {\n // Neither X nor Y exist, should be false\n let opcodes = [\n OpCode::new_bool(Not, 3),\n OpCode::new_key(KeyCode::X),\n OpCode::new_key(KeyCode::Y),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::D, KeyCode::F];\n assert!(evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_not_3() {\n let opcodes = [\n OpCode::new_key(KeyCode::C),\n OpCode::new_bool(Not, 3),\n OpCode::new_key(KeyCode::D),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::D, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_not_4() {\n let opcodes = [\n OpCode::new_bool(And, 10),\n OpCode::new_key(KeyCode::A),\n OpCode::new_key(KeyCode::B),\n OpCode::new_bool(Or, 7),\n OpCode::new_key(KeyCode::C),\n OpCode::new_bool(Not, 7),\n OpCode::new_key(KeyCode::D),\n OpCode::new_bool(Or, 10),\n OpCode::new_key(KeyCode::E),\n OpCode::new_key(KeyCode::F),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::D, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_not_5() {\n let opcodes = [\n OpCode::new_bool(Not, 4),\n OpCode::new_key(KeyCode::C),\n OpCode::new_bool(Not, 4),\n OpCode::new_key(KeyCode::D),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::D, KeyCode::F];\n assert!(evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_not_6() {\n // C does not exist, D does. Ensure C nonexistence does not short-circuit\n // and existence of D is checked.\n let opcodes = [\n OpCode::new_bool(Not, 3),\n OpCode::new_key(KeyCode::C),\n OpCode::new_key(KeyCode::D),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::D, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_or_equivalency_not_6() {\n let opcodes = [\n OpCode::new_bool(Not, 4),\n OpCode::new_bool(Or, 4),\n OpCode::new_key(KeyCode::C),\n OpCode::new_key(KeyCode::D),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::D, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_not_7() {\n // A exists, make sure this short-circuits, and E nonexistence does not override the return.\n let opcodes = [\n OpCode::new_bool(Not, 3),\n OpCode::new_key(KeyCode::A),\n OpCode::new_key(KeyCode::E),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::D, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_or_equivalency_not_7() {\n let opcodes = [\n OpCode::new_bool(Not, 4),\n OpCode::new_bool(Or, 4),\n OpCode::new_key(KeyCode::A),\n OpCode::new_key(KeyCode::E),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::D, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_not_8() {\n let opcodes = [\n OpCode::new_bool(Not, 4),\n OpCode::new_bool(Not, 4),\n OpCode::new_bool(Not, 4),\n OpCode::new_key(KeyCode::A),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::D, KeyCode::F];\n assert!(!evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn bool_evaluation_test_not_9() {\n let opcodes = [\n OpCode::new_bool(Not, 4),\n OpCode::new_bool(Not, 4),\n OpCode::new_bool(Not, 4),\n OpCode::new_key(KeyCode::C),\n ];\n let keycodes = [KeyCode::A, KeyCode::B, KeyCode::D, KeyCode::F];\n assert!(evaluate_bool_test(\n opcodes.as_slice(),\n keycodes.iter().copied(),\n ));\n}\n\n#[test]\nfn switch_inputs() {\n let (op1, op2) = OpCode::new_active_input((0, 1));\n let (op3, op4) = OpCode::new_active_input((1, 2));\n let (op5, op6) = OpCode::new_active_input((1, 3));\n let (op7, op8) = OpCode::new_active_input((3, 3));\n let opcodes_true_and = [OpCode::new_bool(And, 5), op1, op2, op3, op4];\n let opcodes_false_and1 = [OpCode::new_bool(And, 5), op1, op2, op5, op6];\n let opcodes_false_and2 = [OpCode::new_bool(And, 5), op5, op6, op1, op2];\n let opcodes_false_or = [OpCode::new_bool(Or, 5), op7, op8, op5, op6];\n let opcodes_true_or1 = [OpCode::new_bool(Or, 5), op1, op2, op5, op6];\n let opcodes_true_or2 = [OpCode::new_bool(Or, 5), op7, op8, op3, op4];\n let active_inputs = [(0, 1), (1, 2), (2, 3), (3, 4)];\n let test = |opcodes: &[OpCode], expectation: bool| {\n assert_eq!(\n evaluate_boolean(\n opcodes,\n [].iter().copied(),\n active_inputs.iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n 0,\n ),\n expectation\n );\n };\n test(&opcodes_true_and, true);\n test(&opcodes_false_and1, false);\n test(&opcodes_false_and2, false);\n test(&opcodes_false_or, false);\n test(&opcodes_true_or1, true);\n test(&opcodes_true_or2, true);\n}\n\n#[test]\nfn switch_historical_inputs() {\n let (op1, op2) = OpCode::new_historical_input((0, 0), 0);\n let (op3, op4) = OpCode::new_historical_input((3, 750), 7);\n let (op5, op6) = OpCode::new_historical_input((1, 3), 0);\n let (op7, op8) = OpCode::new_historical_input((3, 3), 7);\n let opcodes_true_and = [OpCode::new_bool(And, 5), op1, op2, op3, op4];\n let opcodes_false_and1 = [OpCode::new_bool(And, 5), op1, op2, op5, op6];\n let opcodes_false_and2 = [OpCode::new_bool(And, 5), op5, op6, op1, op2];\n let opcodes_false_or = [OpCode::new_bool(Or, 5), op7, op8, op5, op6];\n let opcodes_true_or1 = [OpCode::new_bool(Or, 5), op1, op2, op5, op6];\n let opcodes_true_or2 = [OpCode::new_bool(Or, 5), op7, op8, op3, op4];\n let historical_inputs = [\n HistoricalEvent {\n event: (0, 0),\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: (1, 750),\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: (2, 1),\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: (3, 749),\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: (0, 1),\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: (1, 2),\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: (2, 3),\n ticks_since_occurrence: 0,\n },\n HistoricalEvent {\n event: (3, 750),\n ticks_since_occurrence: 0,\n },\n ];\n let test = |opcodes: &[OpCode], expectation: bool| {\n assert_eq!(\n evaluate_boolean(\n opcodes,\n [].iter().copied(),\n [].iter().copied(),\n [].iter().copied(),\n historical_inputs.iter().copied(),\n [].iter().copied(),\n 0,\n ),\n expectation\n );\n };\n test(&opcodes_true_and, true);\n test(&opcodes_false_and1, false);\n test(&opcodes_false_and2, false);\n test(&opcodes_false_or, false);\n test(&opcodes_true_or1, true);\n test(&opcodes_true_or2, true);\n}\n" }, { "path": "keyberon/src/action.rs", "content": "//! The different actions that can be executed via any given key.\n\nuse crate::key_code::KeyCode;\nuse crate::layout::{KCoord, QueuedIter, WaitingAction};\nuse core::fmt::Debug;\n\npub mod switch;\npub use switch::*;\n\n/// The different types of actions we support for key sequences/macros\n#[non_exhaustive]\n#[derive(Clone, Copy, Eq, PartialEq)]\npub enum SequenceEvent<'a, T: 'a> {\n /// No operation action: just do nothing (a placeholder).\n NoOp,\n /// A keypress/keydown\n Press(KeyCode),\n /// Key release/keyup\n Release(KeyCode),\n /// A shortcut for `Press(KeyCode), Release(KeyCode)`\n Tap(KeyCode),\n /// For sequences that need to wait a bit before continuing\n Delay {\n /// How long (in ticks) this Delay will last\n duration: u32, // NOTE: This isn't a u16 because that's only max ~65 seconds (assuming 1000 ticks/sec)\n },\n /// Custom event in sequence.\n Custom(&'a T),\n /// Cancels the running sequence and can be used to mark the end of a sequence\n /// instead of using a number of Release() events\n Complete,\n}\n\nimpl Debug for SequenceEvent<'_, T> {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n match self {\n Self::NoOp => write!(f, \"NoOp\"),\n Self::Press(arg0) => f.debug_tuple(\"Press\").field(arg0).finish(),\n Self::Release(arg0) => f.debug_tuple(\"Release\").field(arg0).finish(),\n Self::Tap(arg0) => f.debug_tuple(\"Tap\").field(arg0).finish(),\n Self::Delay { duration } => {\n f.debug_struct(\"Delay\").field(\"duration\", duration).finish()\n }\n Self::Custom(_) => write!(f, \"Custom\"),\n Self::Complete => write!(f, \"Complete\"),\n }\n }\n}\n\n/// Behavior configuration of HoldTap.\n#[non_exhaustive]\n#[derive(Clone, Copy)]\npub enum HoldTapConfig<'a> {\n /// Only the timeout will determine between hold and tap action.\n ///\n /// This is a sane default.\n Default,\n /// If there is a key press, the hold action is activated.\n ///\n /// This behavior is interesting for a key which the tap action is\n /// not used in the flow of typing, like escape for example. If\n /// you are annoyed by accidental tap, you can try this behavior.\n HoldOnOtherKeyPress,\n /// Resolves based on release order after both keys are down.\n /// If the other key releases first (modifier still held) → Hold.\n /// If the modifier releases first (other key still held) → Tap.\n /// The buffer field specifies a grace period in ticks (ms) after the\n /// initial press during which release-order logic is ignored and fast\n /// typing will resolve as Tap.\n Order { buffer: u16 },\n /// If there is a press and release of another key, the hold\n /// action is activated.\n ///\n /// This behavior is interesting for fast typist: the different\n /// between hold and tap would more be based on the sequence of\n /// events than on timing. Be aware that doing the good succession\n /// of key might require some training.\n PermissiveHold,\n /// A custom configuration. Allows the behavior to be controlled by a caller\n /// supplied handler function.\n ///\n /// The first argument to the custom handler will be an iterator that returns\n /// [Stacked] [Events](Event). The order of the events matches the order the\n /// corresponding key was pressed/released, i.e. the first event is the\n /// event first received after the HoldTap action key is pressed.\n ///\n /// The second argument is the coordinate `(row, col)` of the key that\n /// initiated the HoldTap action, allowing the handler to identify which\n /// physical key is waiting for resolution.\n ///\n /// The return value should be the intended action that should be used. A\n /// [Some] value will cause one of: [WaitingAction::Tap] for the configured\n /// tap action, [WaitingAction::Hold] for the hold action, and\n /// [WaitingAction::NoOp] to drop handling of the key press. A [None]\n /// value will cause a fallback to the timeout-based approach. If the\n /// timeout is not triggered, the next tick will call the custom handler\n /// again.\n /// The bool value defines if the timeout check should be skipped at the\n /// next tick. This should generally be false. This is used by `tap-hold-\n /// except-keys` to handle presses even when the timeout has been reached.\n #[allow(clippy::type_complexity)]\n Custom(&'a (dyn Fn(QueuedIter, KCoord) -> (Option, bool) + Send + Sync)),\n}\n\nimpl Debug for HoldTapConfig<'_> {\n fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {\n match self {\n HoldTapConfig::Default => f.write_str(\"Default\"),\n HoldTapConfig::HoldOnOtherKeyPress => f.write_str(\"HoldOnOtherKeyPress\"),\n HoldTapConfig::Order { .. } => f.write_str(\"Order\"),\n HoldTapConfig::PermissiveHold => f.write_str(\"PermissiveHold\"),\n HoldTapConfig::Custom(_) => f.write_str(\"Custom\"),\n }\n }\n}\n\nimpl PartialEq for HoldTapConfig<'_> {\n fn eq(&self, other: &Self) -> bool {\n #[allow(clippy::match_like_matches_macro)]\n match (self, other) {\n (HoldTapConfig::Default, HoldTapConfig::Default)\n | (HoldTapConfig::HoldOnOtherKeyPress, HoldTapConfig::HoldOnOtherKeyPress)\n | (HoldTapConfig::PermissiveHold, HoldTapConfig::PermissiveHold) => true,\n (HoldTapConfig::Order { .. }, HoldTapConfig::Order { .. }) => true,\n _ => false,\n }\n }\n}\n\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]\n/// A state that that can be released from the active states via the ReleaseState action.\npub enum ReleasableState {\n /// Release an active keycode\n KeyCode(KeyCode),\n /// Release an active layer\n Layer(usize),\n}\n\n/// Perform different actions on key hold/tap.\n///\n/// If the key is held more than `timeout` ticks (usually\n/// milliseconds), performs the `hold` action, else performs the\n/// `tap` action. Mostly used with a modifier for the hold action\n/// and a normal key on the tap action. Any action can be\n/// performed, but using a `HoldTap` in a `HoldTap` is not\n/// specified (but guaranteed to not crash).\n///\n/// Different behaviors can be configured using the config field,\n/// but whatever the configuration is, if the key is pressed more\n/// than `timeout`, the hold action is activated (if no other\n/// action was determined before).\n#[derive(Debug, Clone, Copy, PartialEq)]\npub struct HoldTapAction<'a, T>\nwhere\n T: 'a,\n{\n /// The duration, in ticks (usually milliseconds) giving the\n /// difference between a hold and a tap.\n pub timeout: u16,\n /// The hold action.\n pub hold: Action<'a, T>,\n /// The tap action.\n pub tap: Action<'a, T>,\n /// The timeout action\n pub timeout_action: Action<'a, T>,\n /// Behavior configuration.\n pub config: HoldTapConfig<'a>,\n /// Configuration of the tap and hold holds the tap action.\n ///\n /// If you press and release the key in such a way that the tap\n /// action is performed, and then press it again in less than\n /// `tap_hold_interval` ticks, the tap action will\n /// be held. This allows the tap action to be held by\n /// pressing, releasing and holding the key, allowing the computer\n /// to auto repeat the tap behavior. The timeout starts on the\n /// first press of the key, NOT on the release.\n ///\n /// Pressing a different key in between will not result in the\n /// behaviour described above; the HoldTap key must be pressed twice\n /// in a row.\n ///\n /// To deactivate the functionality, set this to 0.\n pub tap_hold_interval: u16,\n /// Specifically the `tap-hold-release-timeout` action variant\n /// can benefit from resetting the timeout after a new press,\n /// because a human might have a slow release but they did\n /// indeed want a hold to activate.\n pub on_press_reset_timeout_to: Option,\n /// Per-action override for the global `tap_hold_require_prior_idle` setting.\n /// If `Some(n)`, uses `n` instead of the global value (0 = disabled for this action).\n /// If `None`, falls back to the global `defcfg` value.\n pub require_prior_idle: Option,\n}\n\n/// Define one shot key behaviour.\n#[derive(Debug, Clone, Copy, PartialEq)]\npub struct OneShot<'a, T = core::convert::Infallible>\nwhere\n T: 'a,\n{\n /// Action to activate until timeout expires or exactly one non-one-shot key is activated.\n pub action: &'a Action<'a, T>,\n /// Timeout after which one shot will expire. Note: timeout will be overwritten if another\n /// one shot key is pressed.\n pub timeout: u16,\n /// Configuration of one shot end behaviour. Note: this will be overwritten if another one shot\n /// key is pressed. Consider keeping this consistent between all your one shot keys to prevent\n /// surprising behaviour.\n pub end_config: OneShotEndConfig,\n}\n\n/// Determine the ending behaviour of the one shot key.\n#[non_exhaustive]\n#[derive(Debug, Clone, Copy, Eq, PartialEq)]\npub enum OneShotEndConfig {\n /// End one shot activation on first non-one-shot key press.\n EndOnFirstPress,\n /// End one shot activation on first non-one-shot key press or a repress of an already-pressed\n /// one-shot key.\n EndOnFirstPressOrRepress,\n /// End one shot activation on first non-one-shot key release.\n EndOnFirstRelease,\n /// End one shot activation on first non-one-shot key release or a repress of an already-pressed\n /// one-shot key.\n EndOnFirstReleaseOrRepress,\n}\n\n/// Defines the maximum number of one shot keys that can be combined.\npub const ONE_SHOT_MAX_ACTIVE: usize = 16;\n\n/// Define tap dance behaviour.\n#[derive(Debug, Clone, Copy, PartialEq)]\npub struct TapDance<'a, T = core::convert::Infallible>\nwhere\n T: 'a,\n{\n /// List of actions that activate based on number of taps. Only one of the actions will\n /// activate. Tapping the tap-dance key once will activate the action in index 0, three\n /// times will activate the action in index 2.\n pub actions: &'a [&'a Action<'a, T>],\n /// Timeout after which a tap will expire and become an action. A new tap for the same\n /// tap-dance key will reset this timeout.\n pub timeout: u16,\n /// Determine behaviour of tap dance. Eager evaluation will activate every action in the\n /// sequence as keys are pressed. Lazy will activate only a single action, decided by the\n /// number of taps in the sequence.\n pub config: TapDanceConfig,\n}\n\n/// Determines the behaviour for a `TapDance`.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]\npub enum TapDanceConfig {\n Lazy,\n Eager,\n}\n\n/// A group of chords (actions mapped to a combination of multiple physical keys pressed together).\n#[derive(Debug, Clone, Copy, PartialEq)]\npub struct ChordsGroup<'a, T = core::convert::Infallible>\nwhere\n T: 'a,\n{\n /// List of key coordinates participating in this chord group, each with the corresponding [ChordKeys] they map to.\n pub coords: &'a [((u8, u16), ChordKeys)],\n /// Map of chords to actions they execute.\n pub chords: &'a [(ChordKeys, &'a Action<'a, T>)],\n /// Timeout after which a chord will expire and either trigger its action or be discarded if there is no corresponding action.\n /// A chord may trigger its action even before this timeout expires, if a chord key is released, a non-chord key is pressed or the pressed chord is already uniquely identifyable.\n pub timeout: u16,\n}\n\nimpl<'a, T> ChordsGroup<'a, T> {\n /// Gets the chord keys corresponding to the given key coordinates.\n pub fn get_keys(&self, coord: (u8, u16)) -> Option {\n self.coords.iter().find(|c| c.0 == coord).map(|c| c.1)\n }\n\n /// Gets the chord action assigned to the given chord keys.\n pub fn get_chord(&self, keys: ChordKeys) -> Option<&'a Action<'a, T>> {\n self.chords\n .iter()\n .find(|(chord_keys, _)| *chord_keys == keys)\n .map(|(_, action)| *action)\n }\n\n /// Gets the chord action assigned to the given chord keys if they are already unambigous (i.e. there is no key that could still be pressed that would result in a different chord).\n pub fn get_chord_if_unambiguous(&self, keys: ChordKeys) -> Option<&'a Action<'a, T>> {\n self.chords\n .iter()\n .try_fold(None, |res, &(chord_keys, action)| {\n if chord_keys == keys {\n Ok(Some(action))\n } else if chord_keys | keys == chord_keys {\n // The given keys are a subset of this chord but not an exact match\n // -> ambiguity\n Err(())\n } else {\n Ok(res)\n }\n })\n .unwrap_or_default()\n }\n}\n\n/// A set of virtual keys (represented as a bit mask) pressed together.\n/// The keys do not directly correspond to physical keys. They are unique to a given [ChordGroup] and their mapping from physical keys is definied in [ChordGroup.coords].\n/// As such, each chord group can effectively have at most 32 different keys (though multiple physical keys may be mapped to the same virtual key).\npub type ChordKeys = u128;\n\n/// Defines the maximum number of (virtual) keys that can be used in a single chords group.\npub const MAX_CHORD_KEYS: usize = ChordKeys::BITS as usize;\n\n/// An action that can do one of two actions. The `left` action is the default. The `right` action\n/// will trigger if any of the key codes in `right_triggers` are active in the current layout\n/// state.\n#[derive(Debug, Clone, Copy, PartialEq)]\npub struct ForkConfig<'a, T> {\n pub left: Action<'a, T>,\n pub right: Action<'a, T>,\n pub right_triggers: &'a [KeyCode],\n}\n\n/// The different actions that can be done.\n#[derive(Clone, Copy, PartialEq, Debug)]\npub enum Action<'a, T = core::convert::Infallible>\nwhere\n T: 'a,\n{\n /// No operation action: just do nothing.\n NoOp,\n /// Transparent, i.e. get the action from the default layer. On\n /// the default layer, it is equivalent to `NoOp`.\n Trans,\n /// A key code, i.e. a classic key.\n KeyCode(KeyCode),\n /// Multiple key codes sent at the same time, as if these keys\n /// were pressed at the same time. Useful to send a shifted key,\n /// or complex shortcuts like Ctrl+Alt+Del in a single key press.\n MultipleKeyCodes(&'a &'a [KeyCode]),\n /// Multiple actions sent at the same time.\n MultipleActions(&'a &'a [Action<'a, T>]),\n /// While pressed, change the current layer. That's the classic\n /// Fn key. If several layer actions are hold at the same time,\n /// the last pressed defines the current layer.\n Layer(usize),\n /// Change the default layer.\n DefaultLayer(usize),\n\n /// A sequence of SequenceEvents\n Sequence {\n /// An array of SequenceEvents that will be triggered (in order)\n events: &'a &'a [SequenceEvent<'a, T>],\n },\n /// A sequence of SequenceEvents, which will be repeated so long as the key is held.\n RepeatableSequence {\n /// An array of SequenceEvents that will be triggered (in order)\n events: &'a &'a [SequenceEvent<'a, T>],\n },\n /// Cancels any running sequences\n CancelSequences,\n /// Action to release either a keycode state or a layer state.\n ReleaseState(ReleasableState),\n\n /// Perform different actions on key hold/tap (see [`HoldTapAction`]).\n HoldTap(&'a HoldTapAction<'a, T>),\n /// Custom action.\n ///\n /// Define a user defined action. This enum can be anything you\n /// want, as long as it has the `'a` lifetime. It can be used\n /// to drive any non keyboard related actions that you might\n /// manage with key events.\n Custom(T),\n /// One shot key. Also known as \"sticky key\". See `struct OneShot` for configuration info.\n /// Activates `action` until a single other key that is not also a one shot key is used. For\n /// example, a one shot key can be used to activate shift for exactly one keypress or switch to\n /// another layer for exactly one keypress. Holding a one shot key will be treated as a normal\n /// held keypress.\n ///\n /// If you use one shot outside of its intended use cases (modifier key action or layer\n /// action) then you will likely have undesired behaviour. E.g. one shot with the space\n /// key will hold space until either another key is pressed or the timeout occurs, which will\n /// probably send many undesired space characters to your active application.\n OneShot(&'a OneShot<'a, T>),\n /// An action to ignore processing of events for OneShot.\n OneShotIgnoreEventsTicks(u16),\n /// Tap-dance key. When tapping the key N times in quck succession, activates the N'th action\n /// in `actions`. The action will activate in the following conditions:\n ///\n /// - a different key is pressed\n /// - `timeout` ticks elapse since the last tap of the same tap-dance key\n /// - the number of taps is equal to the length of `actions`.\n TapDance(&'a TapDance<'a, T>),\n /// Chord key. Enters chording mode where multiple keys may be pressed together to active\n /// different actions depending on the specific combination (\"chord\") pressed.\n /// See `struct ChordGroup` for configuration info.\n ///\n /// Keys participating in chording mode are listed in `coords`.\n /// Chording mode ends when a non-participating key is pressed, a participating key is released,\n /// the timeout expires, or when the pressed chord uniquely identifies an action (i.e. there are\n /// no more keys you could press to change the result).\n Chords(&'a ChordsGroup<'a, T>),\n /// Repeat the previous action.\n Repeat,\n /// Fork action that can activate one of two potential actions depending on what keys are\n /// currently active.\n Fork(&'a ForkConfig<'a, T>),\n /// Action that can activate 0 to N actions based on what keys are currently\n /// active and the boolean logic of each case.\n ///\n /// The maximum number of actions that can activate the same time is governed by\n /// `ACTION_QUEUE_LEN`.\n Switch(&'a Switch<'a, T>),\n /// Disregard the entire layer stack, i.e. the current base layer and any while-held layers,\n /// and select the action from `Layout.src_keys`.\n Src,\n}\n\nimpl Action<'_, T> {\n /// Gets the layer number if the action is the `Layer` action.\n pub fn layer(self) -> Option {\n match self {\n Action::Layer(l) => Some(l),\n _ => None,\n }\n }\n /// Returns an iterator on the `KeyCode` corresponding to the action.\n pub fn key_codes(&self) -> impl Iterator + '_ {\n match self {\n Action::KeyCode(kc) => core::slice::from_ref(kc).iter().cloned(),\n Action::MultipleKeyCodes(kcs) => kcs.iter().cloned(),\n _ => [].iter().cloned(),\n }\n }\n}\n\n/// A shortcut to create a `Action::KeyCode`, useful to create compact\n/// layout.\npub const fn k(kc: KeyCode) -> Action<'static, T> {\n Action::KeyCode(kc)\n}\n\n/// A shortcut to create a `Action::Layer`, useful to create compact\n/// layout.\npub const fn l(layer: usize) -> Action<'static, T> {\n Action::Layer(layer)\n}\n\n/// A shortcut to create a `Action::DefaultLayer`, useful to create compact\n/// layout.\npub const fn d(layer: usize) -> Action<'static, T> {\n Action::DefaultLayer(layer)\n}\n" }, { "path": "keyberon/src/chord.rs", "content": "//! Module for chords v2 implementation.\n\nuse std::cell::Cell;\n\nuse arraydeque::ArrayDeque;\nuse heapless::Vec as HVec;\nuse rustc_hash::FxHashMap;\n\nuse crate::{\n action::Action,\n key_code::KEY_MAX,\n layout::{Event, Queue, Queued, QueuedAction},\n};\n\n// Macro to help with this boilerplate.\n// $v should probably be `self` at points of use.\n// Ownership rules make this difficult to do as a regular fn,\n// because impl function calls don't understand split borrowing.\nmacro_rules! no_chord_activations {\n ($v:expr) => {{\n $v.ticks_to_ignore_chord = $v.configured_ticks_to_ignore_chord;\n }};\n}\n\npub(crate) const TRIGGER_TAPHOLD_COORD: (u8, u16) = (0, 0);\n\n#[derive(Copy, Clone, Debug, PartialEq, Eq)]\npub enum ReleaseBehaviour {\n OnFirstRelease,\n OnLastRelease,\n}\n\n#[derive(Clone)]\npub struct ChordV2<'a, T> {\n /// The action associated with this chord.\n pub action: &'a Action<'a, T>,\n /// The full set of keys that need to be pressed to activate this chord.\n pub participating_keys: &'a [u16],\n /// The number of ticks during which, after the first press of a participant,\n /// this chord can be activated if all participants get pressed.\n /// In other words, after the number of ticks defined by `pending_duration`\n /// elapses, this chord can no longer be completed.\n pub pending_duration: u16,\n /// The layers on which this chord is disabled.\n pub disabled_layers: &'a [u16],\n /// When should the action for this chord be released.\n pub release_behaviour: ReleaseBehaviour,\n}\n\nimpl<'a, T> std::fmt::Debug for ChordV2<'a, T> {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {\n f.debug_struct(\"Point\")\n .field(\"participating_keys\", &self.participating_keys)\n .field(\"pending_duration\", &self.pending_duration)\n .field(\"disabled_layers\", &self.disabled_layers)\n .field(\"release_behaviour\", &self.release_behaviour)\n .finish()\n }\n}\n\n#[derive(Debug, Clone)]\npub struct ChordsForKey<'a, T> {\n /// Chords that this key participates in.\n pub chords: Vec<&'a ChordV2<'a, T>>,\n}\n\n#[derive(Debug, Clone)]\npub struct ChordsForKeys<'a, T> {\n pub mapping: FxHashMap>,\n}\n\nconst SMOL_Q_LEN: usize = 16;\n\nstruct ActiveChord<'a, T> {\n /// Chords uses a virtual coordinate in the keyberon state for an activated chord.\n /// This field tracks which coordinate to release when the chord itself is released.\n coordinate: u16,\n /// Keys left to release.\n /// For OnFirstRelease, this should have length 0.\n remaining_keys_to_release: HVec,\n /// Necessary to include here make sure that, for OnFirstRelease,\n /// random other releases that are not part of this chord,\n /// do not release this chord.\n participating_keys: &'a [u16],\n /// Action associated with the active chord.\n /// This needs to be stored here\n action: &'a Action<'a, T>,\n /// In the case of Unread, this chord has not yet been consumed by the layout code.\n /// This might happen for a while because of tap-hold-related delays.\n /// In the Releasable status, the active chord has been consumed and can be released.\n status: ActiveChordStatus,\n /// Tracks how old an action is.\n delay: u16,\n}\n\nfn tick_ach(acc: &mut ActiveChord) {\n acc.delay = acc.delay.saturating_add(1);\n}\n\n#[derive(Clone, Copy, Debug, PartialEq, Eq)]\nenum ActiveChordStatus {\n /// -> UnreadPendingRelease if chord released before being consumed\n /// -> Releasable if consumed\n Unread,\n /// -> Released once consumed\n UnreadReleased,\n /// Can remove at any time.\n /// -> Released once released\n Releasable,\n /// Remove on next tick_chv2\n Released,\n}\nuse ActiveChordStatus::*;\n\n/// Like the layout Queue but smaller.\npub(crate) type SmolQueue = ArrayDeque;\n\n/// Global input chords configuration.\npub struct ChordsV2<'a, T> {\n // Note: Interior fields do not need to be pub or mutable via impl pub fn.\n // Like a layout, this should be destroyed and recreated on a live reload.\n //\n /// Queued inputs that can potentially activate a chord but have not yet.\n /// Inputs will leave if they are determined that they will not activate a chord,\n /// or if a chord activates.\n queue: Queue,\n /// Information about what chords are possible and what keys they are associated with.\n chords: ChordsForKeys<'a, T>,\n /// Chords that are active, i.e. ones that have not yet been released.\n active_chords: HVec, 10>,\n /// When a key leaves the combo queue without activating a chord,\n /// this activates a timer during which keys cannot activate chords\n /// and are always forwarded directly to the standard input queue.\n ///\n /// This keeps track of the timer.\n ticks_to_ignore_chord: u16,\n /// Initial value for the above when the appropriate event happens.\n /// This must have a minimum value even if not configured by the user,\n /// or if configured by the user to be zero. (maybe forbid that config)\n configured_ticks_to_ignore_chord: u16,\n /// Optimization: if there are no new inputs, the code can skip some processing work.\n /// This tracks the next time that a change will happen, so that the processing work\n /// is **not** skipped when something needs to be checked.\n ticks_until_next_state_change: u16,\n /// Optimization: the below is part of skipping processing work - if this is has changed,\n /// then processing work cannot be skipped.\n prev_active_layer: u16,\n /// Optimization: the below is part of skipping processing work - if this is has changed,\n /// then processing work cannot be skipped.\n prev_queue_len: u8,\n /// Virtual coordinate for use in the layout state.\n next_coord: Cell,\n}\n\nimpl std::fmt::Debug for ChordsV2<'_, T> {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n write!(f, \"ChordsV2\")\n }\n}\n\nimpl<'a, T> ChordsV2<'a, T> {\n pub fn new(chords: ChordsForKeys<'a, T>, ticks_ignore_chord: u16) -> Self {\n assert!(ticks_ignore_chord >= 5);\n Self {\n queue: Queue::new(),\n chords,\n active_chords: HVec::new(),\n ticks_to_ignore_chord: 0,\n configured_ticks_to_ignore_chord: ticks_ignore_chord,\n ticks_until_next_state_change: 0,\n prev_active_layer: u16::MAX,\n prev_queue_len: u8::MAX,\n next_coord: Cell::new(KEY_MAX + 1),\n }\n }\n\n pub fn is_idle_chv2(&self) -> bool {\n self.queue.is_empty() && self.active_chords.is_empty()\n }\n\n pub fn accepts_chords_chv2(&self) -> bool {\n self.ticks_to_ignore_chord == 0\n }\n\n pub fn push_back_chv2(&mut self, item: Queued) -> Option {\n self.queue.push_back(item)\n }\n\n pub fn chords(&self) -> &ChordsForKeys<'a, T> {\n &self.chords\n }\n\n pub(crate) fn get_action_chv2(&mut self) -> QueuedAction<'a, T> {\n self.active_chords\n .iter_mut()\n .find_map(|ach| match ach.status {\n Unread => {\n ach.status = Releasable;\n // Note on LayerStack being default (empty):\n // A chordv2 is not allowed to use transparency,\n // so it does not need to handle this case.\n Some(Some((\n (0, ach.coordinate),\n ach.delay,\n ach.action,\n Default::default(),\n )))\n }\n UnreadReleased => {\n ach.status = Released;\n Some(Some((\n (0, ach.coordinate),\n ach.delay,\n ach.action,\n Default::default(),\n )))\n }\n Releasable | Released => None,\n })\n .unwrap_or_default()\n }\n\n /// Update the times in the queue without activating any chords yet.\n /// Returns queued events that are no longer usable in chords.\n pub(crate) fn tick_chv2(&mut self, active_layer: u16) -> SmolQueue {\n let mut q = SmolQueue::new();\n self.queue.iter_mut().for_each(Queued::tick_qd);\n let prev_active_chord_len = self.active_chords.len();\n self.active_chords.iter_mut().for_each(tick_ach);\n self.drain_inputs(&mut q, active_layer);\n if self.active_chords.len() != prev_active_chord_len {\n // A chord was activated. Forward a no-op press event to potentially trigger\n // HoldOnOtherKeyPress or PermissiveHold.\n // FLAW: this does not associate with the actual input keys and thus cannot correctly\n // trigger the early tap for *-keys variants of kanata tap-hold.\n q.push_back(Queued::new_press(\n TRIGGER_TAPHOLD_COORD.0,\n TRIGGER_TAPHOLD_COORD.1,\n ));\n }\n if self\n .active_chords\n .iter()\n .any(|ach| matches!(ach.status, UnreadReleased | Released))\n {\n // A chord was released. Forward a no-op release event to potentially trigger\n // PermissiveHold.\n // FLAW: see above\n q.push_back(Queued::new_release(\n TRIGGER_TAPHOLD_COORD.0,\n TRIGGER_TAPHOLD_COORD.1,\n ));\n }\n self.clear_released_chords(&mut q);\n self.ticks_to_ignore_chord = self.ticks_to_ignore_chord.saturating_sub(1);\n q\n }\n\n fn next_coord(&self) -> u16 {\n let ret = self.next_coord.get();\n let mut new = ret + 1;\n if new > KEY_MAX + 50 {\n new = KEY_MAX + 1;\n }\n self.next_coord.set(new);\n ret\n }\n\n fn drain_inputs(&mut self, drainq: &mut SmolQueue, active_layer: u16) {\n if self.ticks_to_ignore_chord > 0 {\n self.drain_without_new_activations(drainq);\n return;\n }\n if self.ticks_until_next_state_change > 0\n && self.prev_active_layer == active_layer\n && usize::from(self.prev_queue_len) == self.queue.len()\n {\n self.ticks_until_next_state_change =\n self.ticks_until_next_state_change.saturating_sub(1);\n return;\n }\n self.ticks_until_next_state_change = 0;\n self.prev_active_layer = active_layer;\n debug_assert!(self.queue.capacity() < 255);\n self.prev_queue_len = self.queue.len() as u8;\n\n self.drain_virtual_keys(drainq);\n self.drain_releases(drainq);\n self.process_presses(active_layer);\n }\n\n /// Used to process keys while chordsv2 is in the disabled state from rapid typing.\n /// Releases must still be processed to release already-activated chords.\n fn drain_without_new_activations(&mut self, drainq: &mut SmolQueue) {\n let achs = &mut self.active_chords;\n for qd in self.queue.iter() {\n if let Event::Release(_, j) = qd.event {\n // Release the key from active chords.\n achs.iter_mut().for_each(|ach| {\n if !ach.participating_keys.contains(&j) {\n return;\n }\n ach.remaining_keys_to_release.retain(|pk| *pk != j);\n if ach.remaining_keys_to_release.is_empty() {\n ach.status = match ach.status {\n Unread | UnreadReleased => UnreadReleased,\n Releasable | Released => Released,\n }\n }\n });\n }\n drainq.push_back(*qd);\n }\n self.queue.clear();\n }\n\n fn drain_virtual_keys(&mut self, drainq: &mut SmolQueue) {\n self.queue.retain(|qd| {\n match qd.event {\n // Only row 0 is real inputs.\n // Drain other rows (at the time of writing should only be index 1).\n Event::Press(0, _) | Event::Release(0, _) => true,\n _ => {\n let overflow = drainq.push_back(*qd);\n assert!(overflow.is_none(), \"oops overflowed drain queue\");\n false\n }\n }\n });\n }\n\n fn drain_releases(&mut self, drainq: &mut SmolQueue) {\n let achs = &mut self.active_chords;\n let mut presses = HVec::<_, SMOL_Q_LEN>::new();\n self.queue.retain(|qd| match qd.event {\n Event::Press(_, j) => {\n let overflow = presses.push(j);\n debug_assert!(overflow.is_ok());\n true\n }\n Event::Release(_, j) => {\n // Release the key from active chords.\n achs.iter_mut().for_each(|ach| {\n if !ach.participating_keys.contains(&j) {\n return;\n }\n ach.remaining_keys_to_release.retain(|pk| *pk != j);\n if ach.remaining_keys_to_release.is_empty() {\n ach.status = match ach.status {\n Unread | UnreadReleased => UnreadReleased,\n Releasable | Released => Released,\n }\n }\n });\n if presses.is_empty() {\n drainq.push_back(*qd);\n false\n } else {\n true\n }\n }\n })\n }\n\n fn process_presses(&mut self, active_layer: u16) {\n let mut presses = HVec::::new();\n let mut relevant_release_found = false;\n for qd in self.queue.iter() {\n match qd.event {\n Event::Press(_, j) => {\n let overflowed = presses.push(j);\n debug_assert!(overflowed.is_ok(), \"too many presses in queue\");\n }\n Event::Release(_, j) => {\n if presses.contains(&j) {\n relevant_release_found = true;\n break;\n }\n }\n }\n }\n let prev_active_chords_len = self.active_chords.len();\n let Some(starting_press) = presses.first() else {\n return;\n };\n let Some(possible_chords) = self.chords.mapping.get(starting_press) else {\n no_chord_activations!(self);\n return;\n };\n\n // For subsequent keypresses,\n // all must fit into a single chord for chord state to remain pending\n // instead of activating a chord,\n // and there must also be a longer chord that can still potentially be activated.\n //\n // Prioritization of chord activation:\n // 1. Timed out chord\n // 2. Longer chord\n let mut accumulated_presses = HVec::::new();\n let mut chord_candidates = HVec::<&ChordV2<'a, T>, SMOL_Q_LEN>::new();\n let mut prev_count = usize::MAX;\n let mut min_timeout;\n\n assert!(!presses.is_empty());\n let since = self.queue.iter().next().unwrap().since;\n\n for press in presses.iter().copied() {\n min_timeout = u16::MAX;\n accumulated_presses\n .push(press)\n .expect(\"accpresses same len as presses\");\n\n let count_possible = if prev_count == chord_candidates.len() {\n // optimization: no longer need to check the whole list.\n // chord_candidates will keep getting shrunk.\n chord_candidates.retain(|chc| chc.participating_keys.contains(&press));\n for chc in chord_candidates.iter() {\n if chc.pending_duration > since {\n min_timeout = std::cmp::min(min_timeout, chc.pending_duration);\n }\n }\n chord_candidates.len()\n } else {\n chord_candidates.clear();\n possible_chords\n .chords\n .iter()\n .filter(|pch| !pch.disabled_layers.contains(&active_layer))\n .filter(|pch| {\n if accumulated_presses\n .iter()\n .all(|acp| pch.participating_keys.contains(acp))\n {\n // If full, can't run the optimization above, but not fatal.\n // Can ignore the overflow.\n let _overflow = chord_candidates.push(pch);\n if pch.pending_duration > since {\n min_timeout = std::cmp::min(min_timeout, pch.pending_duration);\n }\n true\n } else {\n false\n }\n })\n .count()\n };\n\n match count_possible {\n 1 => {\n // Found a chord that is not fully overlapped by another.\n // Activate the chord if it is completed\n let coord = self.next_coord();\n let cch = chord_candidates[0];\n if cch\n .participating_keys\n .iter()\n .all(|pk| accumulated_presses.contains(pk))\n {\n let ach = get_active_chord(cch, since, coord, relevant_release_found);\n let overflow = self.active_chords.push(ach);\n assert!(overflow.is_ok(), \"active chords has room\");\n break;\n }\n }\n 0 => {\n // If reached this, it means we went from 2+ -> 0,\n // or we got to zero at the first iteration.\n // Backtrack one accumulated press then:\n // - activate a chord if one completed\n // - clear the input queue otherwise\n let _ = accumulated_presses.pop();\n chord_candidates.clear();\n let completed_chord = possible_chords\n .chords\n .iter()\n .filter(|pch| !pch.disabled_layers.contains(&active_layer))\n .find(\n // Ensure the two lists have the same set of keys\n |pch| {\n accumulated_presses\n .iter()\n .all(|acp| pch.participating_keys.contains(acp))\n && pch\n .participating_keys\n .iter()\n .all(|pk| accumulated_presses.contains(pk))\n },\n );\n match completed_chord {\n Some(cch) => {\n let coord = self.next_coord();\n let ach = get_active_chord(cch, since, coord, relevant_release_found);\n let overflow = self.active_chords.push(ach);\n assert!(overflow.is_ok(), \"active chords has room\");\n }\n None => no_chord_activations!(self),\n }\n break;\n }\n _ => {}\n }\n self.ticks_until_next_state_change = match min_timeout {\n u16::MAX => 0,\n t => t.saturating_sub(since),\n };\n prev_count = count_possible;\n }\n if self.ticks_until_next_state_change == 0 || relevant_release_found {\n // Find a chord that matches exactly and activate that,\n // otherwise clear the input queue.\n let completed_chord = if chord_candidates.is_full() {\n possible_chords\n .chords\n .iter()\n .filter(|pch| !pch.disabled_layers.contains(&active_layer))\n .find(\n // Ensure the two lists have the same set of keys\n |pch| {\n accumulated_presses\n .iter()\n .all(|acp| pch.participating_keys.contains(acp))\n && pch\n .participating_keys\n .iter()\n .all(|pk| accumulated_presses.contains(pk))\n },\n )\n } else {\n chord_candidates\n .iter()\n .filter(|pch| !pch.disabled_layers.contains(&active_layer))\n .find(\n // Ensure the two lists have the same set of keys\n |pch| {\n accumulated_presses\n .iter()\n .all(|acp| pch.participating_keys.contains(acp))\n && pch\n .participating_keys\n .iter()\n .all(|pk| accumulated_presses.contains(pk))\n },\n )\n };\n match completed_chord {\n Some(cch) => {\n let ach =\n get_active_chord(cch, since, self.next_coord(), relevant_release_found);\n let overflow = self.active_chords.push(ach);\n assert!(overflow.is_ok(), \"active chords has room\");\n }\n None => {\n no_chord_activations!(self)\n }\n }\n }\n\n // Clear presses from the queue if they were consumed by a chord.\n if self.active_chords.len() > prev_active_chords_len {\n self.queue.retain(|qd| match qd.event {\n Event::Press(_, j) => !accumulated_presses.contains(&j),\n _ => true,\n });\n }\n }\n\n fn clear_released_chords(&mut self, drainq: &mut SmolQueue) {\n self.active_chords.retain(|ach| {\n if ach.status == Released {\n let overflow = drainq.push_back(Queued {\n event: Event::Release(0, ach.coordinate),\n since: 0,\n });\n assert!(overflow.is_none(), \"oops overflowed drain queue\");\n false\n } else {\n true\n }\n });\n }\n}\n\nfn get_active_chord<'a, T>(\n cch: &ChordV2<'a, T>,\n since: u16,\n coord: u16,\n release_found: bool,\n) -> ActiveChord<'a, T> {\n let mut remaining_keys_to_release = HVec::new();\n if cch.release_behaviour == ReleaseBehaviour::OnLastRelease {\n remaining_keys_to_release.extend(cch.participating_keys.iter().copied());\n };\n ActiveChord {\n coordinate: coord,\n remaining_keys_to_release,\n participating_keys: cch.participating_keys,\n action: cch.action,\n status: if release_found && cch.release_behaviour == ReleaseBehaviour::OnFirstRelease {\n ActiveChordStatus::UnreadReleased\n } else {\n ActiveChordStatus::Unread\n },\n delay: since,\n }\n}\n" }, { "path": "keyberon/src/key_code.rs", "content": "//! Key code definitions.\n\n/// Used for switch opcode purposes. Keys should not exceed this amount.\npub const KEY_MAX: u16 = 850;\n\n#[test]\nfn keycode_max_test() {\n assert!((KeyCode::KeyMax as u16) < KEY_MAX);\n}\n\n#[allow(missing_docs)]\n/// Define a key code according to the HID specification. Their names\n/// correspond to the american QWERTY layout.\n#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]\n#[repr(u16)]\npub enum KeyCode {\n ErrorUndefined = 0,\n Escape = 1,\n Kb1 = 2,\n Kb2 = 3,\n Kb3 = 4,\n Kb4 = 5,\n Kb5 = 6,\n Kb6 = 7,\n Kb7 = 8,\n Kb8 = 9,\n Kb9 = 10,\n Kb0 = 11,\n Minus = 12,\n Equal = 13,\n BSpace = 14,\n Tab = 15,\n Q = 16,\n W = 17,\n E = 18,\n R = 19,\n T = 20,\n Y = 21,\n U = 22,\n I = 23,\n O = 24,\n P = 25,\n LBracket = 26,\n RBracket = 27,\n Enter = 28,\n LCtrl = 29,\n A = 30,\n S = 31,\n D = 32,\n F = 33,\n G = 34,\n H = 35,\n J = 36,\n K = 37,\n L = 38,\n SColon = 39,\n Quote = 40,\n Grave = 41,\n LShift = 42,\n Bslash = 43,\n Z = 44,\n X = 45,\n C = 46,\n V = 47,\n B = 48,\n N = 49,\n M = 50,\n Comma = 51,\n Dot = 52,\n Slash = 53,\n RShift = 54,\n KpAsterisk = 55,\n LAlt = 56,\n Space = 57,\n CapsLock = 58,\n F1 = 59,\n F2 = 60,\n F3 = 61,\n F4 = 62,\n F5 = 63,\n F6 = 64,\n F7 = 65,\n F8 = 66,\n F9 = 67,\n F10 = 68,\n NumLock = 69,\n ScrollLock = 70,\n Kp7 = 71,\n Kp8 = 72,\n Kp9 = 73,\n KpMinus = 74,\n Kp4 = 75,\n Kp5 = 76,\n Kp6 = 77,\n KpPlus = 78,\n Kp1 = 79,\n Kp2 = 80,\n Kp3 = 81,\n Kp0 = 82,\n KpDot = 83,\n K0xBF = 84,\n K0xC0 = 85,\n NonUsBslash = 86,\n F11 = 87,\n F12 = 88,\n Intl1 = 89,\n K0xB1 = 90,\n K0xB3 = 91,\n K0xB0 = 92,\n K0xB2 = 93,\n K0xAF = 94,\n NonUsHash = 95,\n KpEnter = 96,\n RCtrl = 97,\n KpSlash = 98,\n SysReq = 99,\n RAlt = 100,\n K0xC1 = 101,\n Home = 102,\n Up = 103,\n PgUp = 104,\n Left = 105,\n Right = 106,\n End = 107,\n Down = 108,\n PgDown = 109,\n Insert = 110,\n Delete = 111,\n K0xC2 = 112,\n Mute = 113,\n VolDown = 114,\n VolUp = 115,\n Power = 116,\n KpEqual = 117,\n K0xC3 = 118,\n Pause = 119,\n K0xC4 = 120,\n KpComma = 121,\n Lang1 = 122,\n Lang2 = 123,\n Intl3 = 124,\n LGui = 125,\n RGui = 126,\n Application = 127,\n Stop = 128,\n Again = 129,\n K0xC5 = 130,\n Undo = 131,\n K0xC6 = 132,\n Copy = 133,\n K0xC7 = 134,\n Paste = 135,\n Find = 136,\n Cut = 137,\n Help = 138,\n Menu = 139,\n MediaCalc = 140,\n K0xC8 = 141,\n MediaSleep = 142,\n Wakeup = 143,\n K0xC9 = 144,\n K0xCA = 145,\n K0xCB = 146,\n K0xCC = 147,\n K0xCD = 148,\n K0xCE = 149,\n MediaWWW = 150,\n K0xCF = 151,\n MediaCoffee = 152,\n K0xD0 = 153,\n K0xD1 = 154,\n K0xAE = 155,\n K0xD2 = 156,\n K0xD3 = 157,\n MediaBack = 158,\n MediaForward = 159,\n MediaStop = 160,\n MediaEjectCD = 161,\n MediaFind = 162,\n MediaNextSong = 163,\n MediaPlayPause = 164,\n MediaPreviousSong = 165,\n MediaStopCD = 166,\n K0xD4 = 167,\n K0xD5 = 168,\n K0xD6 = 169,\n K0xD7 = 170,\n K0xD8 = 171,\n K0xAD = 172,\n MediaRefresh = 173,\n K0xD9 = 174,\n K0xDA = 175,\n MediaEdit = 176,\n MediaScrollUp = 177,\n MediaScrollDown = 178,\n K0xDB = 179,\n K0xDC = 180,\n K0xDD = 181,\n K0xDE = 182,\n F13 = 183,\n F14 = 184,\n F15 = 185,\n F16 = 186,\n F17 = 187,\n F18 = 188,\n F19 = 189,\n F20 = 190,\n F21 = 191,\n F22 = 192,\n F23 = 193,\n F24 = 194,\n Execute = 195,\n LockingCapsLock = 196,\n LockingNumLock = 197,\n LockingScrollLock = 198,\n KpEqualSign = 199,\n Intl2 = 200,\n Intl4 = 201,\n Intl5 = 202,\n Intl6 = 203,\n Intl7 = 204,\n Intl8 = 205,\n Intl9 = 206,\n Select = 207,\n Lang3 = 208,\n Lang4 = 209,\n PScreen = 210,\n Lang5 = 211,\n Lang6 = 212,\n Lang7 = 213,\n Lang8 = 214,\n K0xAB = 215,\n Lang9 = 216,\n K0xDF = 217,\n K0xBE = 218,\n Clear = 219,\n K220 = 220,\n K0xAC = 221,\n AltErase = 222,\n Cancel = 223,\n BrightnessDown = 224,\n BrightnessUp = 225,\n K0xAA = 226,\n Prior = 227,\n Return = 228,\n KbdIllumDown = 229,\n KbdIllumUp = 230,\n Separator = 231,\n Out = 232,\n Oper = 233,\n ClearAgain = 234,\n CrSel = 235,\n ExSel = 236,\n K0xB4 = 237,\n K0xB5 = 238,\n K0xB6 = 239,\n No = 240,\n K0xB7 = 241,\n K0xB8 = 242,\n K0xB9 = 243,\n K0xBA = 244,\n K0xBB = 245,\n K0xBC = 246,\n K0xBD = 247,\n MediaMute = 248,\n K249 = 249,\n PostFail = 250,\n ErrorRollOver = 251,\n K252 = 252,\n K253 = 253,\n K254 = 254,\n K255 = 255,\n K256 = 256,\n K257 = 257,\n K258 = 258,\n K259 = 259,\n K260 = 260,\n K261 = 261,\n K262 = 262,\n K263 = 263,\n K264 = 264,\n K265 = 265,\n K266 = 266,\n K267 = 267,\n K268 = 268,\n K269 = 269,\n K270 = 270,\n K271 = 271,\n K272 = 272,\n K273 = 273,\n K274 = 274,\n K275 = 275,\n K276 = 276,\n K277 = 277,\n K278 = 278,\n K279 = 279,\n K280 = 280,\n K281 = 281,\n K282 = 282,\n K283 = 283,\n K284 = 284,\n K285 = 285,\n K286 = 286,\n K287 = 287,\n K288 = 288,\n K289 = 289,\n K290 = 290,\n K291 = 291,\n K292 = 292,\n K293 = 293,\n K294 = 294,\n K295 = 295,\n K296 = 296,\n K297 = 297,\n K298 = 298,\n K299 = 299,\n K300 = 300,\n K301 = 301,\n K302 = 302,\n K303 = 303,\n K304 = 304,\n K305 = 305,\n K306 = 306,\n K307 = 307,\n K308 = 308,\n K309 = 309,\n K310 = 310,\n K311 = 311,\n K312 = 312,\n K313 = 313,\n K314 = 314,\n K315 = 315,\n K316 = 316,\n K317 = 317,\n K318 = 318,\n K319 = 319,\n K320 = 320,\n K321 = 321,\n K322 = 322,\n K323 = 323,\n K324 = 324,\n K325 = 325,\n K326 = 326,\n K327 = 327,\n K328 = 328,\n K329 = 329,\n K330 = 330,\n K331 = 331,\n K332 = 332,\n K333 = 333,\n K334 = 334,\n K335 = 335,\n K336 = 336,\n K337 = 337,\n K338 = 338,\n K339 = 339,\n K340 = 340,\n K341 = 341,\n K342 = 342,\n K343 = 343,\n K344 = 344,\n K345 = 345,\n K346 = 346,\n K347 = 347,\n K348 = 348,\n K349 = 349,\n K350 = 350,\n K351 = 351,\n K352 = 352,\n K353 = 353,\n K354 = 354,\n K355 = 355,\n K356 = 356,\n K357 = 357,\n K358 = 358,\n K359 = 359,\n K360 = 360,\n K361 = 361,\n K362 = 362,\n K363 = 363,\n K364 = 364,\n K365 = 365,\n K366 = 366,\n K367 = 367,\n K368 = 368,\n K369 = 369,\n K370 = 370,\n K371 = 371,\n K372 = 372,\n K373 = 373,\n K374 = 374,\n K375 = 375,\n K376 = 376,\n K377 = 377,\n K378 = 378,\n K379 = 379,\n K380 = 380,\n K381 = 381,\n K382 = 382,\n K383 = 383,\n K384 = 384,\n K385 = 385,\n K386 = 386,\n K387 = 387,\n K388 = 388,\n K389 = 389,\n K390 = 390,\n K391 = 391,\n K392 = 392,\n K393 = 393,\n K394 = 394,\n K395 = 395,\n K396 = 396,\n K397 = 397,\n K398 = 398,\n K399 = 399,\n K400 = 400,\n K401 = 401,\n K402 = 402,\n K403 = 403,\n K404 = 404,\n K405 = 405,\n K406 = 406,\n K407 = 407,\n K408 = 408,\n K409 = 409,\n K410 = 410,\n K411 = 411,\n K412 = 412,\n K413 = 413,\n K414 = 414,\n K415 = 415,\n K416 = 416,\n K417 = 417,\n K418 = 418,\n K419 = 419,\n K420 = 420,\n K421 = 421,\n K422 = 422,\n K423 = 423,\n K424 = 424,\n K425 = 425,\n K426 = 426,\n K427 = 427,\n K428 = 428,\n K429 = 429,\n K430 = 430,\n K431 = 431,\n K432 = 432,\n K433 = 433,\n K434 = 434,\n K435 = 435,\n K436 = 436,\n K437 = 437,\n K438 = 438,\n K439 = 439,\n K440 = 440,\n K441 = 441,\n K442 = 442,\n K443 = 443,\n K444 = 444,\n K445 = 445,\n K446 = 446,\n K447 = 447,\n K448 = 448,\n K449 = 449,\n K450 = 450,\n K451 = 451,\n K452 = 452,\n K453 = 453,\n K454 = 454,\n K455 = 455,\n K456 = 456,\n K457 = 457,\n K458 = 458,\n K459 = 459,\n K460 = 460,\n K461 = 461,\n K462 = 462,\n K463 = 463,\n K464 = 464,\n K465 = 465,\n K466 = 466,\n K467 = 467,\n K468 = 468,\n K469 = 469,\n K470 = 470,\n K471 = 471,\n K472 = 472,\n K473 = 473,\n K474 = 474,\n K475 = 475,\n K476 = 476,\n K477 = 477,\n K478 = 478,\n K479 = 479,\n K480 = 480,\n K481 = 481,\n K482 = 482,\n K483 = 483,\n K484 = 484,\n K485 = 485,\n K486 = 486,\n K487 = 487,\n K488 = 488,\n K489 = 489,\n K490 = 490,\n K491 = 491,\n K492 = 492,\n K493 = 493,\n K494 = 494,\n K495 = 495,\n K496 = 496,\n K497 = 497,\n K498 = 498,\n K499 = 499,\n K500 = 500,\n K501 = 501,\n K502 = 502,\n K503 = 503,\n K504 = 504,\n K505 = 505,\n K506 = 506,\n K507 = 507,\n K508 = 508,\n K509 = 509,\n K510 = 510,\n K511 = 511,\n K512 = 512,\n K513 = 513,\n K514 = 514,\n K515 = 515,\n K516 = 516,\n K517 = 517,\n K518 = 518,\n K519 = 519,\n K520 = 520,\n K521 = 521,\n K522 = 522,\n K523 = 523,\n K524 = 524,\n K525 = 525,\n K526 = 526,\n K527 = 527,\n K528 = 528,\n K529 = 529,\n K530 = 530,\n K531 = 531,\n K532 = 532,\n K533 = 533,\n K534 = 534,\n K535 = 535,\n K536 = 536,\n K537 = 537,\n K538 = 538,\n K539 = 539,\n K540 = 540,\n K541 = 541,\n K542 = 542,\n K543 = 543,\n K544 = 544,\n K545 = 545,\n K546 = 546,\n K547 = 547,\n K548 = 548,\n K549 = 549,\n K550 = 550,\n K551 = 551,\n K552 = 552,\n K553 = 553,\n K554 = 554,\n K555 = 555,\n K556 = 556,\n K557 = 557,\n K558 = 558,\n K559 = 559,\n K560 = 560,\n K561 = 561,\n K562 = 562,\n K563 = 563,\n K564 = 564,\n K565 = 565,\n K566 = 566,\n K567 = 567,\n K568 = 568,\n K569 = 569,\n K570 = 570,\n K571 = 571,\n K572 = 572,\n K573 = 573,\n K574 = 574,\n K575 = 575,\n K576 = 576,\n K577 = 577,\n K578 = 578,\n K579 = 579,\n K580 = 580,\n K581 = 581,\n K582 = 582,\n K583 = 583,\n K584 = 584,\n K585 = 585,\n K586 = 586,\n K587 = 587,\n K588 = 588,\n K589 = 589,\n K590 = 590,\n K591 = 591,\n K592 = 592,\n K593 = 593,\n K594 = 594,\n K595 = 595,\n K596 = 596,\n K597 = 597,\n K598 = 598,\n K599 = 599,\n K600 = 600,\n K601 = 601,\n K602 = 602,\n K603 = 603,\n K604 = 604,\n K605 = 605,\n K606 = 606,\n K607 = 607,\n K608 = 608,\n K609 = 609,\n K610 = 610,\n K611 = 611,\n K612 = 612,\n K613 = 613,\n K614 = 614,\n K615 = 615,\n K616 = 616,\n K617 = 617,\n K618 = 618,\n K619 = 619,\n K620 = 620,\n K621 = 621,\n K622 = 622,\n K623 = 623,\n K624 = 624,\n K625 = 625,\n K626 = 626,\n K627 = 627,\n K628 = 628,\n K629 = 629,\n K630 = 630,\n K631 = 631,\n K632 = 632,\n K633 = 633,\n K634 = 634,\n K635 = 635,\n K636 = 636,\n K637 = 637,\n K638 = 638,\n K639 = 639,\n K640 = 640,\n K641 = 641,\n K642 = 642,\n K643 = 643,\n K644 = 644,\n K645 = 645,\n K646 = 646,\n K647 = 647,\n K648 = 648,\n K649 = 649,\n K650 = 650,\n K651 = 651,\n K652 = 652,\n K653 = 653,\n K654 = 654,\n K655 = 655,\n K656 = 656,\n K657 = 657,\n K658 = 658,\n K659 = 659,\n K660 = 660,\n K661 = 661,\n K662 = 662,\n K663 = 663,\n K664 = 664,\n K665 = 665,\n K666 = 666,\n K667 = 667,\n K668 = 668,\n K669 = 669,\n K670 = 670,\n K671 = 671,\n K672 = 672,\n K673 = 673,\n K674 = 674,\n K675 = 675,\n K676 = 676,\n K677 = 677,\n K678 = 678,\n K679 = 679,\n K680 = 680,\n K681 = 681,\n K682 = 682,\n K683 = 683,\n K684 = 684,\n K685 = 685,\n K686 = 686,\n K687 = 687,\n K688 = 688,\n K689 = 689,\n K690 = 690,\n K691 = 691,\n K692 = 692,\n K693 = 693,\n K694 = 694,\n K695 = 695,\n K696 = 696,\n K697 = 697,\n K698 = 698,\n K699 = 699,\n K700 = 700,\n K701 = 701,\n K702 = 702,\n K703 = 703,\n K704 = 704,\n K705 = 705,\n K706 = 706,\n K707 = 707,\n K708 = 708,\n K709 = 709,\n K710 = 710,\n K711 = 711,\n K712 = 712,\n K713 = 713,\n K714 = 714,\n K715 = 715,\n K716 = 716,\n K717 = 717,\n K718 = 718,\n K719 = 719,\n K720 = 720,\n K721 = 721,\n K722 = 722,\n K723 = 723,\n K724 = 724,\n K725 = 725,\n K726 = 726,\n K727 = 727,\n K728 = 728,\n K729 = 729,\n K730 = 730,\n K731 = 731,\n K732 = 732,\n K733 = 733,\n K734 = 734,\n K735 = 735,\n K736 = 736,\n K737 = 737,\n K738 = 738,\n K739 = 739,\n K740 = 740,\n K741 = 741,\n K742 = 742,\n K743 = 743,\n K744 = 744,\n MWU = 745,\n MWD = 746,\n MWL = 747,\n MWR = 748,\n K749 = 749,\n K750 = 750,\n K751 = 751,\n K752 = 752,\n K753 = 753,\n K754 = 754,\n K755 = 755,\n K756 = 756,\n K757 = 757,\n K758 = 758,\n K759 = 759,\n K760 = 760,\n K761 = 761,\n K762 = 762,\n K763 = 763,\n K764 = 764,\n K765 = 765,\n K766 = 766,\n KeyMax = 767,\n}\n\nimpl KeyCode {\n pub fn is_mod(self) -> bool {\n use KeyCode::*;\n matches!(\n self,\n LShift | RShift | LCtrl | RCtrl | LAlt | RAlt | LGui | RGui\n )\n }\n}\n\nuse core::fmt;\nimpl fmt::Display for KeyCode {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n match self {\n KeyCode::Kb1 => write!(f, \"1\"),\n KeyCode::Kb2 => write!(f, \"2\"),\n KeyCode::Kb3 => write!(f, \"3\"),\n KeyCode::Kb4 => write!(f, \"4\"),\n KeyCode::Kb5 => write!(f, \"5\"),\n KeyCode::Kb6 => write!(f, \"6\"),\n KeyCode::Kb7 => write!(f, \"7\"),\n KeyCode::Kb8 => write!(f, \"8\"),\n KeyCode::Kb9 => write!(f, \"9\"),\n KeyCode::Kb0 => write!(f, \"0\"),\n KeyCode::LCtrl => write!(f, \"‹⎈\"),\n KeyCode::RCtrl => write!(f, \"⎈›\"),\n KeyCode::LShift => write!(f, \"‹⇧\"),\n KeyCode::RShift => write!(f, \"⇧›\"),\n KeyCode::LAlt => write!(f, \"‹⎇\"),\n KeyCode::RAlt => write!(f, \"⎇›\"),\n KeyCode::LGui => write!(f, \"‹◆\"),\n KeyCode::RGui => write!(f, \"◆›\"),\n KeyCode::Enter => write!(f, \"⏎\"),\n KeyCode::Escape => write!(f, \"⎋\"),\n KeyCode::BSpace => write!(f, \"␈\"),\n KeyCode::Tab => write!(f, \"⭾\"),\n KeyCode::Space => write!(f, \"␠\"),\n KeyCode::Minus => write!(f, \"−\"),\n KeyCode::Equal => write!(f, \"=\"),\n KeyCode::LBracket => write!(f, \"[\"),\n KeyCode::RBracket => write!(f, \"]\"),\n KeyCode::Bslash => write!(f, \"\\\\\"),\n KeyCode::NonUsHash => write!(f, \"#\"),\n KeyCode::SColon => write!(f, \";\"),\n KeyCode::Quote => write!(f, \"'\"),\n KeyCode::Grave => write!(f, \"`\"),\n KeyCode::Comma => write!(f, \",\"),\n KeyCode::Dot => write!(f, \".\"),\n KeyCode::Slash => write!(f, \"/\"),\n KeyCode::CapsLock => write!(f, \"⇪\"),\n KeyCode::Insert => write!(f, \"⎀\"),\n KeyCode::Delete => write!(f, \"␡\"),\n KeyCode::Home => write!(f, \"⇤\"),\n KeyCode::End => write!(f, \"⇥\"),\n KeyCode::PgDown => write!(f, \"⇟\"),\n KeyCode::PgUp => write!(f, \"⇞\"),\n KeyCode::Down => write!(f, \"▼\"),\n KeyCode::Up => write!(f, \"▲\"),\n KeyCode::Right => write!(f, \"▶\"),\n KeyCode::Left => write!(f, \"◀\"),\n KeyCode::NumLock => write!(f, \"⇭\"),\n KeyCode::KpSlash => write!(f, \"🔢/\"),\n KeyCode::KpAsterisk => write!(f, \"🔢*\"),\n KeyCode::KpMinus => write!(f, \"🔢−\"),\n KeyCode::KpPlus => write!(f, \"🔢+\"),\n KeyCode::KpEnter => write!(f, \"🔢⏎\"),\n KeyCode::Kp0 => write!(f, \"🔢0\"),\n KeyCode::Kp1 => write!(f, \"🔢1\"),\n KeyCode::Kp2 => write!(f, \"🔢2\"),\n KeyCode::Kp3 => write!(f, \"🔢3\"),\n KeyCode::Kp4 => write!(f, \"🔢4\"),\n KeyCode::Kp5 => write!(f, \"🔢5\"),\n KeyCode::Kp6 => write!(f, \"🔢6\"),\n KeyCode::Kp7 => write!(f, \"🔢7\"),\n KeyCode::Kp8 => write!(f, \"🔢8\"),\n KeyCode::Kp9 => write!(f, \"🔢9\"),\n KeyCode::KpDot => write!(f, \"🔢.\"),\n KeyCode::KpEqual => write!(f, \"🔢=\"),\n KeyCode::NonUsBslash => write!(f, \"|\"),\n KeyCode::Application => write!(f, \"☰\"),\n KeyCode::Mute => write!(f, \"🔇\"),\n KeyCode::VolUp => write!(f, \"🔊\"),\n KeyCode::VolDown => write!(f, \"🔉\"),\n _ => write!(f, \"{self:?}\"),\n }\n }\n}\n" }, { "path": "keyberon/src/layout/contextual_execution.rs", "content": "//! Information about what state the keyberon layout is in\r\n//! and handling conditional execution based on state.\r\n\r\nuse super::*;\r\n\r\n#[derive(Clone, Copy, Debug)]\r\npub(super) struct ContextualExecution {\r\n /// Known pause case:\r\n /// - When replicating output keys during chordv1 activation.\r\n pub(super) pause_historical_keys_updates: bool,\r\n}\r\n\r\nimpl ContextualExecution {\r\n pub(super) fn new() -> Self {\r\n Self {\r\n pause_historical_keys_updates: false,\r\n }\r\n }\r\n\r\n /// Push into historical keys while checking the pause state.\r\n pub(super) fn push_historical_key(&self, h: &mut History, e: T) {\r\n if !self.pause_historical_keys_updates {\r\n h.push_front(e);\r\n }\r\n }\r\n}\r\n" }, { "path": "keyberon/src/layout.rs", "content": "//! Layout management.\n\n/// A procedural macro to generate [Layers](type.Layers.html)\n/// ## Syntax\n/// Items inside the macro are converted to Actions as such:\n/// - [`Action::KeyCode`]: Idents are automatically understood as keycodes: `A`, `RCtrl`, `Space`\n/// - Punctuation, numbers and other literals that aren't special to the rust parser are converted\n/// to KeyCodes as well: `,` becomes `KeyCode::Commma`, `2` becomes `KeyCode::Kb2`, `/` becomes `KeyCode::Slash`\n/// - Characters which require shifted keys are converted to `Action::MultipleKeyCodes(&[LShift, ])`:\n/// `!` becomes `Action::MultipleKeyCodes(&[LShift, Kb1])` etc\n/// - Characters special to the rust parser (parentheses, brackets, braces, quotes, apostrophes, underscores, backslashes and backticks)\n/// left alone cause parsing errors and as such have to be enclosed by apostrophes: `'['` becomes `KeyCode::LBracket`,\n/// `'\\''` becomes `KeyCode::Quote`, `'\\\\'` becomes `KeyCode::BSlash`\n/// - [`Action::NoOp`]: Lowercase `n`\n/// - [`Action::Trans`]: Lowercase `t`\n/// - [`Action::Layer`]: A number in parentheses: `(1)`, `(4 - 2)`, `(0x4u8 as usize)`\n/// - [`Action::MultipleActions`]: Actions in brackets: `[LCtrl S]`, `[LAlt LCtrl C]`, `[(2) B {Action::NoOp}]`\n/// - Other `Action`s: anything in braces (`{}`) is copied unchanged to the final layout - `{ Action::Custom(42) }`\n/// simply becomes `Action::Custom(42)`\n///\n/// **Important note**: comma (`,`) is a keycode on its own, and can't be used to separate keycodes as one would have\n/// to do when not using a macro.\npub use kanata_keyberon_macros::*;\n\nmod contextual_execution;\nuse contextual_execution::*;\n\nuse std::num::NonZeroU16;\n\nuse crate::chord::*;\nuse crate::key_code::KeyCode;\nuse crate::{action::*, multikey_buffer::MultiKeyBuffer};\nuse arraydeque::ArrayDeque;\nuse heapless::Vec;\n\nuse State::*;\n\n/// The coordinate type.\n/// First item is either 0 or 1 denoting real key or virtual key, respectively.\n/// Second item is the position in layout.\npub type KCoord = (u8, u16);\n\n/// The Layers type.\n///\n/// `Layers` type is an array of layers which contain the description\n/// of actions on the switch matrix. For example `layers[1][2][3]`\n/// corresponds to the key on the first layer, row 2, column 3.\n/// The generic parameters are in order: the number of columns, rows and layers,\n/// and the type contained in custom actions.\npub type Layers<'a, const C: usize, const R: usize, T = core::convert::Infallible> =\n &'a [[[Action<'a, T>; C]; R]];\n\nconst QUEUE_SIZE: usize = 32;\npub type QueueLen = u8;\n\n#[test]\nfn check_queue_size() {\n use std::convert::TryFrom;\n let _v = QueueLen::try_from(QUEUE_SIZE).unwrap();\n}\n\n/// The current event queue.\n///\n/// Events can be retrieved by iterating over this struct and calling [Queued::event].\npub(crate) type Queue = ArrayDeque;\n\n/// A list of queued press events. Used for special handling of potentially multiple press events\n/// that occur during a Waiting event.\ntype PressedQueue = ArrayDeque;\n\n/// The maximum number of actions that can be activated concurrently via chord decomposition or\n/// activation of multiple switch cases using fallthrough.\npub const ACTION_QUEUE_LEN: usize = 8;\n\n/// The queue is currently only used for chord decomposition when a longer chord does not result in\n/// an action, but splitting it into smaller chords would. The buffer size of 8 should be more than\n/// enough for real world usage, but if one wanted to be extra safe, this should be ChordKeys::BITS\n/// since that should guarantee that all potentially queueable actions can fit.\ntype ActionQueue<'a, T> =\n ArrayDeque, ACTION_QUEUE_LEN, arraydeque::behavior::Wrapping>;\ntype Delay = u16;\npub(crate) type QueuedAction<'a, T> = Option<(KCoord, Delay, &'a Action<'a, T>, LayerStack)>;\n\npub const REAL_KEY_ROW: u8 = 0;\n\nconst HISTORICAL_EVENT_LEN: usize = 8;\nconst EXTRA_WAITING_LEN: usize = 8;\n#[test]\nfn extra_waiting_size_constraint() {\n assert!(EXTRA_WAITING_LEN < i8::MAX as usize);\n}\n\n/// The layout manager. It takes `Event`s and `tick`s as input, and\n/// generate keyboard reports.\npub struct Layout<'a, const C: usize, const R: usize, T = core::convert::Infallible>\nwhere\n T: 'a + std::fmt::Debug,\n{\n /// Fallback for transparent keys inside actions that are on `default_layer`.\n pub src_keys: &'a [Action<'a, T>; C],\n pub layers: &'a [[[Action<'a, T>; C]; R]],\n pub default_layer: usize,\n /// Key states.\n pub states: Vec, 64>,\n pub waiting: Option>,\n pub extra_waiting:\n ArrayDeque, EXTRA_WAITING_LEN, arraydeque::behavior::Wrapping>,\n pub tap_dance_eager: Option>,\n pub queue: Queue,\n pub oneshot: OneShotState,\n pub keys_to_suppress_for_one_cycle: Vec,\n pub last_press_tracker: LastPressTracker,\n pub active_sequences: ArrayDeque, 4, arraydeque::behavior::Wrapping>,\n pub action_queue: ActionQueue<'a, T>,\n pub rpt_action: Option<&'a Action<'a, T>>,\n pub historical_keys: History,\n pub historical_inputs: History,\n pub quick_tap_hold_timeout: bool,\n /// If a different key was pressed within this many ticks before a HoldTap key,\n /// immediately resolve as tap (typing streak detection). 0 = disabled.\n pub tap_hold_require_prior_idle: u16,\n pub chords_v2: Option>,\n rpt_multikey_key_buffer: MultiKeyBuffer<'a, T>,\n trans_resolution_behavior_v2: bool,\n delegate_to_first_layer: bool,\n contextual_execution: ContextualExecution,\n /// Tracks tap-hold activation events (hold/tap resolved).\n /// Only stores data when the `tap_hold_tracker` feature is enabled;\n /// otherwise this is a zero-sized no-op.\n pub tap_hold_tracker: crate::tap_hold_tracker::TapHoldTracker,\n}\n\npub use crate::tap_hold_tracker::{HoldActivatedInfo, TapActivatedInfo};\n\npub struct History {\n events: ArrayDeque,\n ticks_since_occurrences: ArrayDeque,\n}\n\n#[derive(Copy, Clone)]\npub struct HistoricalEvent {\n pub event: T,\n pub ticks_since_occurrence: u16,\n}\n\nimpl History\nwhere\n T: Copy,\n{\n fn new() -> Self {\n Self {\n ticks_since_occurrences: ArrayDeque::new(),\n events: ArrayDeque::new(),\n }\n }\n\n fn tick_hist(&mut self) {\n let ticks = self.ticks_since_occurrences.as_uninit_slice_mut();\n for tick_count in ticks {\n unsafe {\n *tick_count.assume_init_mut() = tick_count.assume_init().saturating_add(1);\n }\n }\n }\n\n fn push_front(&mut self, event: T) {\n self.ticks_since_occurrences.push_front(0);\n self.events.push_front(event);\n }\n\n pub fn iter_hevents(&self) -> impl Iterator> + '_ + Clone {\n self.events\n .iter()\n .copied()\n .zip(self.ticks_since_occurrences.iter().copied())\n .map(|(event, ticks_since_occurrence)| HistoricalEvent {\n event,\n ticks_since_occurrence,\n })\n }\n}\n\n/// An event on the key matrix.\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\npub enum Event {\n /// Press event with coordinates (i, j).\n Press(u8, u16),\n /// Release event with coordinates (i, j).\n Release(u8, u16),\n}\nimpl Event {\n /// Returns the coordinates (i, j) of the event.\n pub fn coord(self) -> KCoord {\n match self {\n Event::Press(i, j) => (i, j),\n Event::Release(i, j) => (i, j),\n }\n }\n\n /// Transforms the coordinates of the event.\n ///\n /// # Example\n ///\n /// ```\n /// # use kanata_keyberon::layout::Event;\n /// assert_eq!(\n /// Event::Press(3, 10),\n /// Event::Press(3, 1).transform(|i, j| (i, 11 - j)),\n /// );\n /// ```\n pub fn transform(self, f: impl FnOnce(u8, u16) -> KCoord) -> Self {\n match self {\n Event::Press(i, j) => {\n let (i, j) = f(i, j);\n Event::Press(i, j)\n }\n Event::Release(i, j) => {\n let (i, j) = f(i, j);\n Event::Release(i, j)\n }\n }\n }\n\n /// Returns `true` if the event is a key press.\n pub fn is_press(self) -> bool {\n match self {\n Event::Press(..) => true,\n Event::Release(..) => false,\n }\n }\n\n /// Returns `true` if the event is a key release.\n pub fn is_release(self) -> bool {\n match self {\n Event::Release(..) => true,\n Event::Press(..) => false,\n }\n }\n}\n\n/// Event from custom action.\n#[derive(Debug, Default, PartialEq, Eq)]\npub enum CustomEvent<'a, T: 'a> {\n /// No custom action.\n #[default]\n NoEvent,\n /// The given custom action key is pressed.\n Press(&'a T),\n /// The given custom action key is released.\n Release(&'a T),\n}\nimpl CustomEvent<'_, T> {\n /// Update an event according to a new event.\n ///\n ///The event can only be modified in the order `NoEvent < Press <\n /// Release`\n fn update(&mut self, e: Self) {\n use CustomEvent::*;\n match (&e, &self) {\n (Release(_), NoEvent) | (Release(_), Press(_)) => *self = e,\n (Press(_), NoEvent) => *self = e,\n _ => (),\n }\n }\n}\n\n/// Metadata about normal key flags.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]\npub struct NormalKeyFlags(pub u8);\n\npub const NORMAL_KEY_FLAG_CLEAR_ON_NEXT_ACTION: u8 = 0x01;\npub const NORMAL_KEY_FLAG_CLEAR_ON_NEXT_RELEASE: u8 = 0x02;\n\nimpl NormalKeyFlags {\n pub fn nkf_clear_on_next_action(self) -> bool {\n (self.0 & NORMAL_KEY_FLAG_CLEAR_ON_NEXT_ACTION) == NORMAL_KEY_FLAG_CLEAR_ON_NEXT_ACTION\n }\n pub fn nkf_clear_on_next_release(self) -> bool {\n (self.0 & NORMAL_KEY_FLAG_CLEAR_ON_NEXT_RELEASE) == NORMAL_KEY_FLAG_CLEAR_ON_NEXT_RELEASE\n }\n}\n\n#[derive(Debug, Eq, PartialEq)]\npub enum State<'a, T: 'a> {\n NormalKey {\n keycode: KeyCode,\n coord: KCoord,\n flags: NormalKeyFlags,\n },\n LayerModifier {\n value: usize,\n coord: KCoord,\n },\n Custom {\n value: &'a T,\n coord: KCoord,\n },\n FakeKey {\n keycode: KeyCode,\n }, // Fake key event for sequences\n RepeatingSequence {\n sequence: &'a &'a [SequenceEvent<'a, T>],\n coord: KCoord,\n },\n SeqCustomPending(&'a T),\n SeqCustomActive(&'a T),\n Tombstone,\n NoOpInput {\n coord: KCoord,\n },\n}\nimpl Copy for State<'_, T> {}\nimpl Clone for State<'_, T> {\n fn clone(&self) -> Self {\n *self\n }\n}\nimpl<'a, T: 'a> State<'a, T> {\n pub fn keycode(&self) -> Option {\n match self {\n NormalKey { keycode, .. } => Some(*keycode),\n FakeKey { keycode } => Some(*keycode),\n _ => None,\n }\n }\n pub fn coord(&self) -> Option {\n match self {\n NormalKey { coord, .. }\n | LayerModifier { coord, .. }\n | Custom { coord, .. }\n | NoOpInput { coord }\n | RepeatingSequence { coord, .. } => Some(*coord),\n _ => None,\n }\n }\n fn keycode_in_coords(&self, coords: &OneShotCoords) -> Option {\n match self {\n NormalKey { keycode, coord, .. } => {\n if coords.contains(coord) {\n Some(*keycode)\n } else {\n None\n }\n }\n _ => None,\n }\n }\n /// Returns None if the key has been released and Some otherwise.\n pub fn release(&self, c: KCoord, custom: &mut CustomEvent<'a, T>) -> Option {\n match *self {\n NormalKey { coord, .. }\n | LayerModifier { coord, .. }\n | RepeatingSequence { coord, .. }\n | NoOpInput { coord }\n if coord == c =>\n {\n None\n }\n Custom { value, coord } if coord == c => {\n custom.update(CustomEvent::Release(value));\n None\n }\n _ => Some(*self),\n }\n }\n pub fn release_state(&self, s: ReleasableState) -> Option {\n match (*self, s) {\n (\n NormalKey { keycode: k1, .. } | FakeKey { keycode: k1 },\n ReleasableState::KeyCode(k2),\n ) => {\n if k1 == k2 {\n None\n } else {\n Some(*self)\n }\n }\n (LayerModifier { value: l1, .. }, ReleasableState::Layer(l2)) => {\n if l1 == l2 {\n None\n } else {\n Some(*self)\n }\n }\n _ => Some(*self),\n }\n }\n fn seq_release(&self, kc: KeyCode) -> Option {\n match *self {\n FakeKey { keycode, .. } if keycode == kc => None,\n _ => Some(*self),\n }\n }\n fn get_layer(&self) -> Option {\n match self {\n LayerModifier { value, .. } => Some(*value),\n _ => None,\n }\n }\n pub fn clear_on_next_release(&self) -> bool {\n match self {\n NormalKey { flags, .. } => {\n (flags.0 & NORMAL_KEY_FLAG_CLEAR_ON_NEXT_RELEASE)\n == NORMAL_KEY_FLAG_CLEAR_ON_NEXT_RELEASE\n }\n _ => false,\n }\n }\n}\n\n#[derive(Copy, Clone, Debug)]\npub(crate) struct TapDanceState<'a, T: 'a> {\n actions: &'a [&'a Action<'a, T>],\n timeout: u16,\n num_taps: u16,\n}\n\n#[derive(Copy, Clone, Debug)]\npub struct TapDanceEagerState<'a, T: 'a> {\n coord: KCoord,\n actions: &'a [&'a Action<'a, T>],\n timeout: u16,\n orig_timeout: u16,\n num_taps: u16,\n}\n\nimpl TapDanceEagerState<'_, T> {\n fn tick_tde(&mut self) {\n self.timeout = self.timeout.saturating_sub(1);\n }\n\n fn is_expired(&self) -> bool {\n self.timeout == 0 || usize::from(self.num_taps) >= self.actions.len()\n }\n\n fn set_expired(&mut self) {\n self.timeout = 0;\n }\n\n fn incr_taps(&mut self) {\n self.num_taps += 1;\n self.timeout = self.orig_timeout;\n }\n}\n\n#[derive(Debug)]\npub(crate) enum WaitingConfig<'a, T: 'a + std::fmt::Debug> {\n HoldTap(HoldTapConfig<'a>),\n TapDance(TapDanceState<'a, T>),\n Chord(&'a ChordsGroup<'a, T>),\n}\n\n#[derive(Debug)]\npub struct WaitingState<'a, T: 'a + std::fmt::Debug> {\n coord: KCoord,\n timeout: u16,\n on_press_reset_timeout_to: Option,\n delay: u16,\n ticks: u16,\n hold: &'a Action<'a, T>,\n tap: &'a Action<'a, T>,\n timeout_action: &'a Action<'a, T>,\n config: WaitingConfig<'a, T>,\n layer_stack: LayerStack,\n prev_queue_len: QueueLen,\n}\n\n/// Actions that can be triggered for a key configured for HoldTap.\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\npub enum WaitingAction {\n /// Trigger the holding event.\n Hold,\n /// Trigger the tapping event.\n Tap,\n /// Trigger the timeout event.\n Timeout,\n /// Drop this event. It will act as if no key was pressed.\n NoOp,\n}\n\nimpl<'a, T: std::fmt::Debug> WaitingState<'a, T> {\n fn tick_wt(\n &mut self,\n queued: &mut Queue,\n action_queue: &mut ActionQueue<'a, T>,\n ) -> Option<(WaitingAction, Option)> {\n self.timeout = self.timeout.saturating_sub(1);\n self.ticks = self.ticks.saturating_add(1);\n let mut pq = None;\n let (ret, cfg_change) = match self.config {\n WaitingConfig::HoldTap(htc) => (self.handle_hold_tap(htc, queued), None),\n WaitingConfig::TapDance(ref tds) => {\n let (ret, num_taps) =\n self.handle_tap_dance(tds.num_taps, tds.actions.len(), queued);\n self.prev_queue_len = queued.len() as u8;\n // Due to ownership issues, handle_tap_dance can't contain all of the necessary\n // logic.\n if ret.is_some() {\n let idx = core::cmp::min(num_taps.into(), tds.actions.len()).saturating_sub(1);\n self.tap = tds.actions[idx];\n }\n if num_taps > tds.num_taps {\n self.timeout = tds.timeout;\n }\n (\n ret,\n Some(WaitingConfig::TapDance(TapDanceState { num_taps, ..*tds })),\n )\n }\n WaitingConfig::Chord(config) => {\n if let Some((ret, action, cpq)) = self.handle_chord(config, queued, action_queue) {\n self.tap = action;\n pq = Some(cpq);\n (Some(ret), None)\n } else {\n (None, None)\n }\n }\n };\n if let Some(cfg) = cfg_change {\n self.config = cfg;\n }\n ret.map(|v| (v, pq))\n }\n\n fn handle_hold_tap(&mut self, cfg: HoldTapConfig, queued: &Queue) -> Option {\n if queued.len() as u8 == self.prev_queue_len && self.timeout > 0 {\n // Fast path: nothing has changed since last tick and we haven't timed out yet.\n return None;\n }\n if let Some(timeout_reset_val) = self.on_press_reset_timeout_to {\n if let Some(last) = queued.iter().next_back() {\n if last.event.is_press() {\n self.timeout = timeout_reset_val.into();\n }\n }\n }\n self.prev_queue_len = queued.len() as u8;\n let mut skip_timeout = false;\n match cfg {\n HoldTapConfig::Default => (),\n HoldTapConfig::HoldOnOtherKeyPress => {\n if queued.iter().any(|s| s.event.is_press()) {\n return Some(WaitingAction::Hold);\n }\n }\n HoldTapConfig::Order { buffer, .. } => {\n // Like PermissiveHold: if another key was pressed AND released\n // (while modifier is still held), resolve as Hold.\n // If modifier is released first, the fallthrough below handles Tap.\n //\n // Buffer: key presses that occurred within `buffer` ticks of the\n // hold-tap key press are ignored by release-order logic, allowing\n // fast typing to resolve as Tap regardless of release order.\n let mut queued = queued.iter();\n while let Some(q) = queued.next() {\n if q.event.is_press() {\n // Elapsed ticks since this key entered the queue, compared against buffer window.\n let press_tick = self.ticks.saturating_sub(q.since);\n if press_tick < buffer {\n continue;\n }\n let (i, j) = q.event.coord();\n let target = Event::Release(i, j);\n if queued.clone().any(|q| q.event == target) {\n return Some(WaitingAction::Hold);\n }\n }\n }\n }\n HoldTapConfig::PermissiveHold => {\n let mut queued = queued.iter();\n while let Some(q) = queued.next() {\n if q.event.is_press() {\n let (i, j) = q.event.coord();\n let target = Event::Release(i, j);\n if queued.clone().any(|q| q.event == target) {\n return Some(WaitingAction::Hold);\n }\n }\n }\n }\n HoldTapConfig::Custom(func) => {\n let (waiting_action, local_skip) = (func)(QueuedIter(queued.iter()), self.coord);\n if waiting_action.is_some() {\n return waiting_action;\n }\n skip_timeout = local_skip;\n }\n }\n if let Some(&Queued {\n since: since_release,\n ..\n }) = queued\n .iter()\n .find(|s| self.is_corresponding_release(&s.event))\n {\n if self.timeout >= self.delay.saturating_sub(since_release) {\n Some(WaitingAction::Tap)\n } else {\n Some(WaitingAction::Timeout)\n }\n } else if self.timeout == 0 && (!skip_timeout) {\n Some(WaitingAction::Timeout)\n } else {\n None\n }\n }\n\n fn handle_tap_dance(\n &self,\n num_taps: u16,\n max_taps: usize,\n queued: &mut Queue,\n ) -> (Option, u16) {\n if queued.len() as u8 == self.prev_queue_len && self.timeout > 0 {\n // Fast path: nothing has changed since last tick and we haven't timed out yet.\n return (None, num_taps);\n }\n // Evict events with the same coordinates except for the final release. E.g. if 3 taps have\n // occurred, this will remove all `Press` events and 2 `Release` events. This is done so\n // that the state machine processes the entire tap dance sequence as a single press and\n // single release regardless of how many taps were actually done.\n let evict_same_coord_events = |num_taps: u16, queued: &mut Queue| {\n let mut releases_to_remove = num_taps.saturating_sub(1);\n queued.retain(|s| {\n let mut do_retain = true;\n if self.is_corresponding_release(&s.event) {\n if releases_to_remove > 0 {\n do_retain = false;\n releases_to_remove = releases_to_remove.saturating_sub(1)\n }\n } else if self.is_corresponding_press(&s.event) {\n do_retain = false;\n }\n do_retain\n });\n };\n if self.timeout == 0 {\n evict_same_coord_events(num_taps, queued);\n return (Some(WaitingAction::Tap), num_taps);\n }\n // Get the number of sequential taps for this tap-dance key. If a different key was\n // pressed, activate a tap-dance action.\n match queued.iter().try_fold(1, |same_tap_count, s| {\n if self.is_corresponding_press(&s.event) {\n Ok(same_tap_count + 1)\n } else if matches!(s.event, Event::Press(..)) {\n Err((same_tap_count, ()))\n } else {\n Ok(same_tap_count)\n }\n }) {\n Ok(num_taps) if usize::from(num_taps) >= max_taps => {\n evict_same_coord_events(num_taps, queued);\n (Some(WaitingAction::Tap), num_taps)\n }\n Ok(num_taps) => (None, num_taps),\n Err((num_taps, _)) => {\n evict_same_coord_events(num_taps, queued);\n (Some(WaitingAction::Tap), num_taps)\n }\n }\n }\n\n fn handle_chord(\n &mut self,\n config: &'a ChordsGroup<'a, T>,\n queued: &mut Queue,\n action_queue: &mut ActionQueue<'a, T>,\n ) -> Option<(WaitingAction, &'a Action<'a, T>, PressedQueue)> {\n if queued.len() as u8 == self.prev_queue_len && self.timeout.saturating_sub(self.delay) > 0\n {\n // Fast path: nothing has changed since last tick and we haven't timed out yet.\n return None;\n }\n self.prev_queue_len = queued.len() as u8;\n\n // need to keep track of how many Press events we handled so we can filter them out later\n let mut handled_press_events = 0;\n let start_chord_coord = self.coord;\n let mut released_coord = None;\n\n // Compute the set of chord keys that are currently pressed\n // `Ok` when chording mode may continue\n // `Err` when it should end for various reasons\n let active = queued\n .iter()\n .try_fold(config.get_keys(self.coord).unwrap_or(0), |active, s| {\n if self.delay.saturating_sub(s.since) > self.timeout {\n Ok(active)\n } else if let Some(chord_keys) = config.get_keys(s.event.coord()) {\n match s.event {\n Event::Press(_, _) => {\n handled_press_events += 1;\n Ok(active | chord_keys)\n }\n Event::Release(i, j) => {\n // release chord quickly by changing the coordinate to the released\n // key, to be consistent with chord decomposition behaviour.\n released_coord = Some((i, j));\n Err(active)\n }\n }\n } else if matches!(s.event, Event::Press(..)) {\n Err(active) // pressed a non-chord key, abort\n } else {\n Ok(active)\n }\n })\n .and_then(|active| {\n if self.timeout.saturating_sub(self.delay) == 0 {\n Err(active) // timeout expired, abort\n } else {\n Ok(active)\n }\n });\n\n let res = match active {\n Ok(active) => {\n // Chording mode still active, only trigger action if it's unambiguous\n if let Some(action) = config.get_chord_if_unambiguous(active) {\n if let Some(coord) = released_coord {\n self.coord = coord;\n }\n (WaitingAction::Tap, action)\n } else {\n return None; // nothing to do yet, we'll check back later\n }\n }\n Err(active) => {\n // Abort chording mode. Trigger a chord action if there is one.\n if let Some(action) = config.get_chord(active) {\n if let Some(coord) = released_coord {\n self.coord = coord;\n }\n (WaitingAction::Tap, action)\n } else {\n self.decompose_chord_into_action_queue(config, queued, action_queue);\n (WaitingAction::NoOp, &Action::NoOp)\n }\n }\n };\n\n let mut pq = PressedQueue::new();\n let _ = pq.push_back(start_chord_coord);\n\n // Return all press events that were logically handled by this chording event\n queued.retain(|s| {\n if self.delay.saturating_sub(s.since) > self.timeout {\n true\n } else if matches!(s.event, Event::Press(i, j) if config.get_keys((i, j)).is_some())\n && handled_press_events > 0\n {\n handled_press_events -= 1;\n let _ = pq.push_back(s.event().coord());\n false\n } else {\n true\n }\n });\n\n Some((res.0, res.1, pq))\n }\n\n fn decompose_chord_into_action_queue(\n &mut self,\n config: &'a ChordsGroup<'a, T>,\n queued: &Queue,\n action_queue: &mut ActionQueue<'a, T>,\n ) {\n let mut chord_key_order = [0u128; ChordKeys::BITS as usize];\n\n // Default to the initial coordinate. But if a key is released early (before the timeout\n // occurs), use that key for action releases. That way the chord is released as early as\n // possible.\n let mut default_associated_coord = self.coord;\n\n let starting_mask = config.get_keys(self.coord).unwrap_or(0);\n let mut mask_bits_set = 1;\n chord_key_order[0] = starting_mask;\n let _ = queued.iter().try_fold(starting_mask, |active, s| {\n if self.delay.saturating_sub(s.since) > self.timeout {\n Ok(active)\n } else if let Some(chord_keys) = config.get_keys(s.event.coord()) {\n match s.event {\n Event::Press(..) => {\n if active | chord_keys != active {\n chord_key_order[mask_bits_set] = chord_keys;\n mask_bits_set += 1;\n }\n Ok(active | chord_keys)\n }\n Event::Release(i, j) => {\n default_associated_coord = (i, j);\n Err(active) // released a chord key, abort\n }\n }\n } else if matches!(s.event, Event::Press(..)) {\n Err(active) // pressed a non-chord key, abort\n } else {\n Ok(active)\n }\n });\n let len = mask_bits_set;\n let chord_keys = &chord_key_order[0..len];\n\n let get_coord_for_chord = |mask: ChordKeys| -> (u8, u16) {\n if config.get_keys(default_associated_coord).unwrap_or(0) & mask > 0 {\n // This might be a release.\n // If it belongs to the associated action, prefer to use it.\n return default_associated_coord;\n }\n if self.coord != default_associated_coord\n && config.get_keys(self.coord).unwrap_or(0) & mask > 0\n {\n // The first coordinate not in queued\n // so must be explicitly checked if it is not the default coord.\n return self.coord;\n }\n queued\n .iter()\n .find_map(|q| {\n let coord = q.event.coord();\n let qmask = config.get_keys(coord).unwrap_or(0);\n match qmask & mask {\n 0 => None,\n _ => Some(coord),\n }\n })\n .unwrap_or(default_associated_coord)\n };\n\n // Compute actions using the following description:\n //\n // Let's say we have a chord group with keys (h j k l). The full set (h j k l) is not\n // defined with an action, but the user has pressed all of h, j, k, l in the listed order,\n // so now kanata needs to break down the combo. How should it work?\n //\n // Figuratively \"release\" keys in reverse-temporal order until a valid chord is found. So\n // first, l is figuratively released, and if (h j k) is a valid chord, that action will\n // activate. If (l) by itself is valid that then activates after (h j k) is finished.\n //\n // In the case that (h j k) is not a chord, instead activate (h j). If that is a valid\n // chord, then try to activate (k l) together, and if not, evaluate (k), then (l).\n //\n // If (h j) is not a valid chord, try to activate (h). Then try to activate (j k l). If\n // that is invalid, try (j k), then (j). If (j k) is valid, try (l). If (j) is valid, try\n // (k l). If (k l) is invalid, try (k) then (l).\n //\n // The possible executions, listed in descending order of priority (first listed has\n // highest execution priority) are:\n // (h j k l)\n // (h j k) (l)\n // (h j) (k l)\n // (h j) (k) (l)\n // (h) (j k l)\n // (h) (j k) (l)\n // (h) (j) (k l)\n // (h) (j) (k) (l)\n\n let mut start = 0;\n let mut end = len;\n let delay = self.delay + self.ticks;\n while start < len {\n let sub_chord = &chord_keys[start..end];\n let chord_mask = sub_chord\n .iter()\n .copied()\n .reduce(|acc, e| acc | e)\n .unwrap_or(0);\n if let Some(action) = config.get_chord(chord_mask) {\n let coord = get_coord_for_chord(chord_mask);\n // Note on LayerStack being default (empty):\n // A chordv1 allows transparency, so this is broken right now,\n // and could result in an infinite loop, because\n // the queue activating code falls back to top-level resolution order\n // if the stored layer stack is empty.\n let _ = action_queue.push_back(Some((coord, delay, action, Default::default())));\n } else {\n end -= 1;\n // shrink from end until something is found, or have checked up to and including\n // the individual start key.\n while end > start {\n let sub_chord = &chord_keys[start..end];\n let chord_mask = sub_chord\n .iter()\n .copied()\n .reduce(|acc, e| acc | e)\n .unwrap_or(0);\n if let Some(action) = config.get_chord(chord_mask) {\n let coord = get_coord_for_chord(chord_mask);\n let _ = action_queue.push_back(Some((\n coord,\n delay,\n action,\n Default::default(),\n )));\n break;\n }\n end -= 1;\n }\n }\n start = if end <= start { start + 1 } else { end };\n end = len;\n }\n }\n\n fn is_corresponding_release(&self, event: &Event) -> bool {\n matches!(event, Event::Release(i, j) if (*i, *j) == self.coord)\n }\n\n fn is_corresponding_press(&self, event: &Event) -> bool {\n matches!(event, Event::Press(i, j) if (*i, *j) == self.coord)\n }\n}\n\ntype OneShotCoords = ArrayDeque;\n\n#[derive(Debug, Copy, Clone)]\npub struct SequenceState<'a, T: 'a> {\n cur_event: Option>,\n delay: u32, // Keeps track of SequenceEvent::Delay time remaining\n tapped: Option, // Keycode of a key that should be released at the next tick\n remaining_events: &'a [SequenceEvent<'a, T>],\n}\n\ntype ReleasedOneShotKeys = Vec;\n\n// Using a u16 for indices instead of usize.\n// Need to check against this value in code that creates layers.\npub const MAX_LAYERS: usize = 60000;\n\n// Use heapless Vec for perf - avoid pointer indirections.\n// Use u16 for more efficient cache. 12*u16 = 3*u64 = 24 bytes.\n// Then there is a usize for the length, totaling 32 bytes.\n// Cache line is typically 64 bytes, so this takes half a cache line.\n// Above all assumes x86-64.\npub const MAX_ACTIVE_LAYERS: usize = 12;\n\n/// Because we only need a read-only stack and efficient iteration over contained\n/// items, LayerStack items are in reverse order over usual back-to-front order\n/// of items in array-based stack implementations.\ntype LayerStack = Vec;\n\n/// Contains the state of one shot keys that are currently active.\npub struct OneShotState {\n /// KCoordinates of one shot keys that are active\n pub keys: ArrayDeque,\n /// KCoordinates of one shot keys that have been released\n pub released_keys: ArrayDeque,\n /// Fix #1874:\n /// Represents the one-shot state that must not be released on physical key release.\n /// Consider the case `(multi a (one-shot 100 b))`,\n /// when only tracking coordinates (which this used to in the past),\n /// the `a` would not release a even upon releasing the action key\n /// because its state falls on the same coordinate as the oneshot b.\n /// The fix is to explicitly know which key/layer states\n /// — which are the only actions allowed within one-shot —\n /// should be kept, and normally release others.\n pub state_to_retain_on_release:\n ArrayDeque,\n /// Used to keep track of already-pressed keys for the release variants.\n pub other_pressed_keys: ArrayDeque,\n /// Timeout (ms) after which all one shot keys expire\n pub timeout: u16,\n /// Contains the end config of the most recently pressed one shot key\n pub end_config: OneShotEndConfig,\n /// Marks if release of the one shot keys should be done on the next tick\n pub release_on_next_tick: bool,\n /// The number of ticks to delay the release of the one-shot activation\n /// for EndOnFirstPress(OrRepress).\n /// This used to not exist and effectively be 1 (1ms),\n /// but that is too short for some environments.\n /// When too short, applications or desktop environments process\n /// the key release before the next press,\n /// even if temporally the release was sent after.\n pub pause_input_processing_delay: u16,\n /// If pause_input_processing_delay is used, this will be >0,\n /// meaning input processing should be paused to prevent extra presses\n /// from coming in while OneShot has not yet been released.\n ///\n /// May also be reused for other purposes...\n pub pause_input_processing_ticks: u16,\n\n /// Number of ticks to ignore press events for.\n pub ticks_to_ignore_events: u16,\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]\npub enum OneShotRetainableState {\n KeyCode { coord: KCoord, kc: KeyCode },\n Layer { coord: KCoord, layer: u16 },\n}\n\nimpl OneShotRetainableState {\n pub fn coord(&self) -> KCoord {\n match self {\n Self::KeyCode { coord, .. } | Self::Layer { coord, .. } => *coord,\n }\n }\n}\n\n#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]\nenum OneShotHandlePressKey {\n OneShotKey(KCoord),\n Other(KCoord),\n}\n\nimpl OneShotState {\n fn tick_osh(&mut self) -> Option {\n if self.keys.is_empty() {\n return None;\n }\n self.ticks_to_ignore_events = self.ticks_to_ignore_events.saturating_sub(1);\n self.timeout = self.timeout.saturating_sub(1);\n if self.release_on_next_tick || self.timeout == 0 {\n self.release_on_next_tick = false;\n self.timeout = 0;\n self.pause_input_processing_ticks = 0;\n self.ticks_to_ignore_events = 0;\n self.keys.clear();\n self.other_pressed_keys.clear();\n self.state_to_retain_on_release.clear();\n Some(self.released_keys.drain(..).collect())\n } else {\n None\n }\n }\n\n /// Returns the coordinates associated with an active oneshot.\n /// The intended use of this is for `rpt-any` to be able to repeat\n /// the output chord of a one-shot+normal key,\n /// which are two separate actions that users\n /// would likely want to combine under a repeat condition.\n fn handle_press(&mut self, key: OneShotHandlePressKey) -> OneShotCoords {\n let mut oneshot_coords = ArrayDeque::new();\n if self.keys.is_empty() || self.ticks_to_ignore_events > 0 {\n return oneshot_coords;\n }\n match key {\n OneShotHandlePressKey::OneShotKey(pressed_coord) => {\n if matches!(\n self.end_config,\n OneShotEndConfig::EndOnFirstReleaseOrRepress\n | OneShotEndConfig::EndOnFirstPressOrRepress\n ) && self.keys.contains(&pressed_coord)\n {\n self.release_on_next_tick = true;\n oneshot_coords.extend(self.keys.iter().copied());\n }\n\n self.released_keys.retain(|coord| *coord != pressed_coord);\n }\n OneShotHandlePressKey::Other(pressed_coord) => {\n if matches!(\n self.end_config,\n OneShotEndConfig::EndOnFirstPress | OneShotEndConfig::EndOnFirstPressOrRepress\n ) {\n self.timeout = core::cmp::min(self.pause_input_processing_delay, self.timeout);\n self.pause_input_processing_ticks = self.pause_input_processing_delay;\n } else {\n let _ = self.other_pressed_keys.push_back(pressed_coord);\n }\n oneshot_coords.extend(self.keys.iter().copied());\n }\n };\n oneshot_coords\n }\n\n /// Returns true if the caller should handle the release normally and false otherwise.\n /// The second value in the tuple represents an overflow of released one shot keys and should\n /// be released is it is `Some`.\n fn handle_release(&mut self, (i, j): KCoord) -> (bool, Option) {\n if self.keys.is_empty() {\n return (true, None);\n }\n if !self.keys.contains(&(i, j)) {\n if matches!(\n self.end_config,\n OneShotEndConfig::EndOnFirstRelease | OneShotEndConfig::EndOnFirstReleaseOrRepress\n ) && self.other_pressed_keys.contains(&(i, j))\n {\n self.release_on_next_tick = true;\n }\n (true, None)\n } else {\n // delay release for one shot keys\n (false, self.released_keys.push_back((i, j)))\n }\n }\n\n fn add_state_to_retain(&mut self, state: OneShotRetainableState) {\n if !self.state_to_retain_on_release.contains(&state) {\n self.state_to_retain_on_release.push_back(state);\n }\n }\n}\n\n/// An iterator over the currently queued events.\n///\n/// Events can be retrieved by iterating over this struct and calling [Queued::event].\n#[derive(Clone)]\npub struct QueuedIter<'a>(arraydeque::Iter<'a, Queued>);\n\nimpl<'a> Iterator for QueuedIter<'a> {\n type Item = &'a Queued;\n fn next(&mut self) -> Option {\n self.0.next()\n }\n fn size_hint(&self) -> (usize, Option) {\n self.0.size_hint()\n }\n}\n\n/// An event, waiting in a queue to be processed.\n#[derive(Debug, Copy, Clone)]\npub struct Queued {\n pub(crate) event: Event,\n pub(crate) since: u16,\n}\nimpl From for Queued {\n fn from(event: Event) -> Self {\n Queued { event, since: 0 }\n }\n}\nimpl Queued {\n pub(crate) fn new_press(i: u8, j: u16) -> Self {\n Self {\n since: 0,\n event: Event::Press(i, j),\n }\n }\n\n pub(crate) fn new_release(i: u8, j: u16) -> Self {\n Self {\n since: 0,\n event: Event::Release(i, j),\n }\n }\n\n pub(crate) fn tick_qd(&mut self) {\n self.since = self.since.saturating_add(1);\n }\n\n /// Get the [Event] from this object.\n pub fn event(&self) -> Event {\n self.event\n }\n}\n\n#[derive(Default)]\npub struct LastPressTracker {\n pub coord: KCoord,\n pub tap_hold_timeout: u16,\n}\n\nimpl LastPressTracker {\n fn tick_lpt(&mut self) {\n self.tap_hold_timeout = self.tap_hold_timeout.saturating_sub(1);\n }\n fn update_coord(&mut self, coord: KCoord) {\n if coord.0 == REAL_KEY_ROW {\n // Only update if it's a real key press.\n self.coord = coord;\n }\n }\n}\n\nimpl<'a, const C: usize, const R: usize, T: 'a + Copy + std::fmt::Debug> Layout<'a, C, R, T> {\n /// Creates a new `Layout` object.\n fn new(layers: &'a [[[Action; C]; R]]) -> Self {\n assert!(layers.len() < MAX_LAYERS);\n Self {\n src_keys: &[Action::NoOp; C],\n layers,\n default_layer: 0,\n states: Vec::new(),\n waiting: None,\n extra_waiting: ArrayDeque::new(),\n tap_dance_eager: None,\n queue: ArrayDeque::new(),\n oneshot: OneShotState {\n timeout: 0,\n end_config: OneShotEndConfig::EndOnFirstPress,\n keys: ArrayDeque::new(),\n released_keys: ArrayDeque::new(),\n state_to_retain_on_release: ArrayDeque::new(),\n other_pressed_keys: ArrayDeque::new(),\n release_on_next_tick: false,\n pause_input_processing_delay: 0,\n pause_input_processing_ticks: 0,\n ticks_to_ignore_events: 0,\n },\n keys_to_suppress_for_one_cycle: Vec::new(),\n last_press_tracker: Default::default(),\n active_sequences: ArrayDeque::new(),\n action_queue: ArrayDeque::new(),\n rpt_action: None,\n historical_keys: History::new(),\n historical_inputs: History::new(),\n rpt_multikey_key_buffer: unsafe { MultiKeyBuffer::new() },\n quick_tap_hold_timeout: false,\n tap_hold_require_prior_idle: 0,\n trans_resolution_behavior_v2: true,\n delegate_to_first_layer: false,\n chords_v2: None,\n contextual_execution: ContextualExecution::new(),\n tap_hold_tracker: Default::default(),\n }\n }\n pub fn new_with_trans_action_settings(\n src_keys: &'a [Action; C],\n layers: &'a [[[Action; C]; R]],\n trans_resolution_behavior_v2: bool,\n delegate_to_first_layer: bool,\n ) -> Self {\n let mut new = Self::new(layers);\n new.src_keys = src_keys;\n new.trans_resolution_behavior_v2 = trans_resolution_behavior_v2;\n new.delegate_to_first_layer = delegate_to_first_layer;\n new\n }\n\n /// Iterates on the key codes of the current state.\n pub fn keycodes(&self) -> impl Iterator + Clone + '_ {\n let keys_to_suppress_for_one_cycle = self.keys_to_suppress_for_one_cycle.clone();\n self.states\n .iter()\n .filter_map(State::keycode)\n .filter(move |kc| !keys_to_suppress_for_one_cycle.contains(kc))\n }\n fn waiting_into_hold(&mut self, idx: i8) -> CustomEvent<'a, T> {\n let waiting = if idx < 0 {\n self.waiting.as_ref()\n } else {\n self.extra_waiting.get(idx as usize)\n };\n if let Some(w) = waiting {\n let hold = w.hold;\n let coord = w.coord;\n let delay = match w.config {\n WaitingConfig::HoldTap(..) | WaitingConfig::Chord(_) => w.delay + w.ticks,\n WaitingConfig::TapDance(_) => 0,\n };\n let layer_stack = w.layer_stack.clone();\n self.tap_hold_tracker.set_hold_activated(coord, &w.config);\n if idx < 0 {\n self.waiting = None;\n } else {\n self.extra_waiting.remove(idx as usize);\n }\n if coord == self.last_press_tracker.coord {\n self.last_press_tracker.tap_hold_timeout = 0;\n }\n // Similar issue happens for the quick tap-hold tap as with on-press release;\n // the rapidity of the release can cause issues. See pause_input_processing_delay\n // comments for more detail.\n self.oneshot.pause_input_processing_ticks = self.oneshot.pause_input_processing_delay;\n self.do_action(hold, coord, delay, false, &mut layer_stack.into_iter())\n } else {\n CustomEvent::NoEvent\n }\n }\n fn waiting_into_tap(&mut self, pq: Option, idx: i8) -> CustomEvent<'a, T> {\n let waiting = if idx < 0 {\n self.waiting.as_ref()\n } else {\n self.extra_waiting.get(idx as usize)\n };\n if let Some(w) = waiting {\n let tap = w.tap;\n let coord = w.coord;\n let delay = match w.config {\n WaitingConfig::HoldTap(..) | WaitingConfig::Chord(_) => w.delay + w.ticks,\n WaitingConfig::TapDance(_) => 0,\n };\n let layer_stack = w.layer_stack.clone();\n self.tap_hold_tracker.set_tap_activated(coord, &w.config);\n if idx < 0 {\n self.waiting = None;\n } else {\n self.extra_waiting.remove(idx as usize);\n }\n let ret = self.do_action(\n tap,\n coord,\n delay,\n false,\n &mut layer_stack.clone().into_iter(),\n );\n\n if let Some(pq) = pq {\n self.contextual_execution.pause_historical_keys_updates = true;\n match tap {\n Action::KeyCode(_)\n | Action::MultipleKeyCodes(_)\n | Action::OneShot(_)\n | Action::Layer(_) => {\n // The current intent of this block is to ensure that simple actions like\n // key presses or layer-while-held remain pressed as long as a single key from\n // the input chord remains held. The behaviour of these actions is correct in\n // the case of repeating do_action, so there is currently no harm in doing\n // this. Other action types are more problematic though.\n for other_coord in pq.iter().copied() {\n self.do_action(\n tap,\n other_coord,\n delay,\n false,\n &mut layer_stack.clone().into_iter(),\n );\n }\n }\n Action::MultipleActions(acs) => {\n // Like above block, but for the same simple actions within MultipleActions\n for ac in acs.iter() {\n if matches!(\n ac,\n Action::KeyCode(_)\n | Action::MultipleKeyCodes(_)\n | Action::OneShot(_)\n | Action::Layer(_)\n ) {\n for other_coord in pq.iter().copied() {\n self.do_action(\n ac,\n other_coord,\n delay,\n false,\n &mut layer_stack.clone().into_iter(),\n );\n }\n }\n }\n }\n _ => {}\n }\n self.contextual_execution.pause_historical_keys_updates = false;\n }\n\n // Similar issue happens for the quick tap-hold tap as with on-press release;\n // the rapidity of the release can cause issues. See pause_input_processing_delay\n // comments for more detail.\n self.oneshot.pause_input_processing_ticks = self.oneshot.pause_input_processing_delay;\n ret\n } else {\n CustomEvent::NoEvent\n }\n }\n fn waiting_into_timeout(&mut self, idx: i8) -> CustomEvent<'a, T> {\n let waiting = if idx < 0 {\n self.waiting.as_ref()\n } else {\n self.extra_waiting.get(idx as usize)\n };\n if let Some(w) = waiting {\n let timeout_action = w.timeout_action;\n let coord = w.coord;\n let delay = match w.config {\n WaitingConfig::HoldTap(..) | WaitingConfig::Chord(_) => w.delay + w.ticks,\n WaitingConfig::TapDance(_) => 0,\n };\n let layer_stack = w.layer_stack.clone();\n self.tap_hold_tracker.set_hold_activated(coord, &w.config);\n if idx < 0 {\n self.waiting = None;\n } else {\n self.extra_waiting.remove(idx as usize);\n }\n if coord == self.last_press_tracker.coord {\n self.last_press_tracker.tap_hold_timeout = 0;\n }\n self.do_action(\n timeout_action,\n coord,\n delay,\n false,\n &mut layer_stack.into_iter(),\n )\n } else {\n CustomEvent::NoEvent\n }\n }\n fn drop_waiting(&mut self) -> CustomEvent<'a, T> {\n self.waiting = None;\n CustomEvent::NoEvent\n }\n /// A time event.\n ///\n /// This method must be called regularly, typically every millisecond.\n ///\n /// Returns the corresponding `CustomEvent`, allowing to manage\n /// custom actions thanks to the `Action::Custom` variant.\n pub fn tick(&mut self) -> CustomEvent<'a, T> {\n let active_layer = self.current_layer() as u16;\n if let Some(chv2) = self.chords_v2.as_mut() {\n self.queue.extend(chv2.tick_chv2(active_layer).drain(0..));\n if let chord_action @ Some(_) = chv2.get_action_chv2() {\n self.action_queue.push_back(chord_action);\n self.oneshot.pause_input_processing_ticks =\n self.oneshot.pause_input_processing_delay;\n }\n }\n self.keys_to_suppress_for_one_cycle.clear();\n if let Some(Some((coord, delay, action, layer_stack))) = self.action_queue.pop_front() {\n // If there's anything in the action queue, don't process anything else yet - execute\n // everything. Otherwise an action may never be released.\n return self.do_action(action, coord, delay, false, &mut layer_stack.into_iter());\n }\n self.queue.iter_mut().for_each(Queued::tick_qd);\n self.last_press_tracker.tick_lpt();\n if let Some(ref mut tde) = self.tap_dance_eager {\n tde.tick_tde();\n if tde.is_expired() {\n self.tap_dance_eager = None;\n }\n }\n self.process_sequences();\n\n self.historical_keys.tick_hist();\n self.historical_inputs.tick_hist();\n\n let mut custom = CustomEvent::NoEvent;\n if let Some(released_keys) = self.oneshot.tick_osh() {\n for key in released_keys.iter() {\n custom.update(self.dequeue(Queued {\n event: Event::Release(key.0, key.1),\n since: 0,\n }));\n }\n }\n\n custom.update(match &mut self.waiting {\n Some(w) => match w.tick_wt(&mut self.queue, &mut self.action_queue) {\n Some((WaitingAction::Hold, _)) => self.waiting_into_hold(-1),\n Some((WaitingAction::Tap, pq)) => self.waiting_into_tap(pq, -1),\n Some((WaitingAction::Timeout, _)) => self.waiting_into_timeout(-1),\n Some((WaitingAction::NoOp, _)) => self.drop_waiting(),\n None => CustomEvent::NoEvent,\n },\n None => {\n if self.extra_waiting.is_empty() {\n // Due to the possible delay in the key release for EndOnFirstPress\n // because some apps/DEs do not handle it properly if done too quickly,\n // undesirable behaviour of extra presses making it in before\n // the release happens might occur.\n //\n // A mitigation against that is to pause input processing.\n if self.oneshot.pause_input_processing_ticks > 0 {\n self.oneshot.pause_input_processing_ticks =\n self.oneshot.pause_input_processing_ticks.saturating_sub(1);\n CustomEvent::NoEvent\n } else {\n match self.queue.pop_front() {\n Some(s) => self.dequeue(s),\n None => CustomEvent::NoEvent,\n }\n }\n } else {\n CustomEvent::NoEvent\n }\n }\n });\n let custom = self.process_extra_waitings(custom);\n self.process_sequence_custom(custom)\n }\n /// Takes care of draining and populating the `active_sequences` ArrayDeque,\n /// giving us sequences (aka macros) of nearly limitless length!\n fn process_sequences(&mut self) {\n // Iterate over all active sequence events\n for _ in 0..self.active_sequences.len() {\n if let Some(mut seq) = self.active_sequences.pop_front() {\n // If we've encountered a SequenceEvent::Delay we must count\n // that down completely before doing anything else...\n if seq.delay > 0 {\n seq.delay = seq.delay.saturating_sub(1);\n } else if let Some(keycode) = seq.tapped {\n // Clear out the Press() matching this Tap()'s keycode\n self.states.retain(|s| s.seq_release(keycode).is_some());\n seq.tapped = None;\n } else {\n // Pull the next SequenceEvent\n if let [e, tail @ ..] = seq.remaining_events {\n seq.cur_event = Some(*e);\n seq.remaining_events = tail;\n }\n // Process it (SequenceEvent)\n match seq.cur_event {\n Some(SequenceEvent::Complete) => {\n seq.remaining_events = &[];\n }\n Some(SequenceEvent::Press(keycode)) => {\n // Start tracking this fake key Press() event\n let _ = self.states.push(FakeKey { keycode });\n self.contextual_execution\n .push_historical_key(&mut self.historical_keys, keycode);\n // Fine to fake (0, 0). This is sequences anyway. In Kanata, nothing\n // valid should be at (0, 0) that this would interfere with.\n self.oneshot\n .handle_press(OneShotHandlePressKey::Other((0, 0)));\n }\n Some(SequenceEvent::Tap(keycode)) => {\n // Same as Press() except we track it for one tick via seq.tapped:\n let _ = self.states.push(FakeKey { keycode });\n self.contextual_execution\n .push_historical_key(&mut self.historical_keys, keycode);\n self.oneshot\n .handle_press(OneShotHandlePressKey::Other((0, 0)));\n seq.tapped = Some(keycode);\n }\n Some(SequenceEvent::Release(keycode)) => {\n // Nothing valid should be at (0, 0). It's fine to fake this.\n self.oneshot.handle_release((0, 0));\n self.states.retain(|s| s.seq_release(keycode).is_some());\n }\n Some(SequenceEvent::Delay { duration }) => {\n // Setup a delay that will be decremented once per tick until 0\n if duration > 0 {\n // -1 to start since this tick counts\n seq.delay = duration - 1;\n }\n }\n Some(SequenceEvent::Custom(custom)) => {\n let _ = self.states.push(State::SeqCustomPending(custom));\n }\n _ => {} // We'll never get here\n }\n }\n if !seq.remaining_events.is_empty() {\n // Put it back\n self.active_sequences.push_back(seq);\n }\n }\n }\n if self.active_sequences.is_empty() {\n // Push only the latest pressed repeating macro.\n if let Some(State::RepeatingSequence { sequence, .. }) = self\n .states\n .iter()\n .rev()\n .find(|s| matches!(s, State::RepeatingSequence { .. }))\n {\n self.active_sequences.push_back(SequenceState {\n cur_event: None,\n delay: 0,\n tapped: None,\n remaining_events: sequence,\n });\n }\n }\n }\n\n fn process_extra_waitings(&mut self, current_custom: CustomEvent<'a, T>) -> CustomEvent<'a, T> {\n if !matches!(current_custom, CustomEvent::NoEvent) {\n return current_custom;\n }\n let mut waiting_action = (0, None);\n for (i, w) in self.extra_waiting.iter_mut().enumerate() {\n match w.tick_wt(&mut self.queue, &mut self.action_queue) {\n None => {}\n wa => {\n waiting_action = (i as isize, wa);\n // break - only complete one at a time even if potentially multiple have\n // completed, so that only one custom event is returned.\n //\n // Theoretically if we could call the waiting_into_* functions, we could do that\n // here and break only if custom is None, but that runs into mutability\n // problems. I don't expect any perceptible degradation between from not doing\n // the above.\n break;\n }\n }\n }\n let i = waiting_action.0;\n match waiting_action.1 {\n Some((WaitingAction::Hold, _)) => self.waiting_into_hold(i as i8),\n Some((WaitingAction::Tap, pq)) => self.waiting_into_tap(pq, i as i8),\n Some((WaitingAction::Timeout, _)) => self.waiting_into_timeout(i as i8),\n Some((WaitingAction::NoOp, _)) => self.drop_waiting(),\n None => current_custom,\n }\n }\n\n fn process_sequence_custom(\n &mut self,\n mut current_custom: CustomEvent<'a, T>,\n ) -> CustomEvent<'a, T> {\n if self.states.is_empty() || !matches!(current_custom, CustomEvent::NoEvent) {\n return current_custom;\n }\n // It is important to note that this code cannot simply be replaced by `retain_mut`.\n // The `retain_mut` function is not chosen\n // because it is important to break on the first `SeqCustom` that is discovered.\n // Such functionality could be replaced by a marker to ignore processing,\n // but for now that is not necessary.\n self.states.retain(|s| !matches!(s, State::Tombstone));\n for state in self.states.iter_mut() {\n match state {\n State::SeqCustomPending(custom) => {\n current_custom.update(CustomEvent::Press(custom));\n *state = State::SeqCustomActive(custom);\n break;\n }\n State::SeqCustomActive(custom) => {\n current_custom.update(CustomEvent::Release(custom));\n *state = State::Tombstone;\n break;\n }\n _ => continue,\n };\n }\n current_custom\n }\n fn dequeue(&mut self, queue: Queued) -> CustomEvent<'a, T> {\n use Event::*;\n match queue.event {\n Release(i, j) => {\n let mut custom = CustomEvent::NoEvent;\n let (do_release, overflow_key) = self.oneshot.handle_release((i, j));\n if do_release {\n self.states.retain(|s| {\n !s.clear_on_next_release() && s.release((i, j), &mut custom).is_some()\n });\n } else {\n // Fix #1874:\n // Might still need to apply release,\n // but need to check against states on same coordinate\n // that aren't part of a OneShot.\n self.states.retain(|s| {\n match s {\n NormalKey { coord, keycode, .. } => {\n // NormalKey is a valid oneshot state,\n // may need to keep.\n *coord != (i, j)\n || self.oneshot.state_to_retain_on_release.contains(\n &OneShotRetainableState::KeyCode {\n coord: *coord,\n kc: *keycode,\n },\n )\n }\n LayerModifier { coord, value } => {\n // LayerModifier is a valid oneshot state,\n // may need to keep.\n *coord != (i, j)\n || self.oneshot.state_to_retain_on_release.contains(\n &OneShotRetainableState::Layer {\n coord: *coord,\n layer: *value as u16,\n },\n )\n }\n // Everything else is not a valid oneshot state,\n // if it falls on the same coordinate\n // as a oneshot key, it should still be released here.\n _ => {\n !s.clear_on_next_release()\n && s.release((i, j), &mut custom).is_some()\n }\n }\n });\n }\n if let Some((i2, j2)) = overflow_key {\n self.states\n .retain(|s| s.release((i2, j2), &mut custom).is_some());\n }\n custom\n }\n\n Press(i, j) => {\n let mut layer_stack = self.trans_resolution_layer_order().into_iter();\n if let Some(tde) = &mut self.tap_dance_eager {\n if (i, j) == self.last_press_tracker.coord && !tde.is_expired() {\n let tde_action = tde.actions[usize::from(tde.num_taps)];\n tde.incr_taps();\n let custom = self.do_action(\n tde_action,\n (i, j),\n queue.since,\n false,\n &mut layer_stack.skip(1),\n );\n custom\n } else {\n // i == 0 means real key, i == 1 means fake key. Let fake keys do whatever, but\n // interrupt tap-dance-eager if real key.\n if i == REAL_KEY_ROW {\n tde.set_expired();\n }\n self.do_action(&Action::Trans, (i, j), queue.since, false, &mut layer_stack)\n }\n } else {\n self.do_action(&Action::Trans, (i, j), queue.since, false, &mut layer_stack)\n }\n }\n }\n }\n /// Register a key event.\n pub fn event(&mut self, event: Event) {\n if let Event::Press(x, y) = event {\n self.historical_inputs.push_front((x, y));\n }\n if let Some(overflow) = if let Some(ch) = self.chords_v2.as_mut() {\n ch.push_back_chv2(event.into())\n } else {\n self.queue.push_back(event.into())\n } {\n for i in -1..(EXTRA_WAITING_LEN as i8) {\n self.waiting_into_hold(i);\n }\n self.dequeue(overflow);\n }\n }\n\n /// Put a key event at the front instead of back.\n /// These events will not participate in chordsv2.\n pub fn event_to_front(&mut self, event: Event) {\n if let Event::Press(x, y) = event {\n self.historical_inputs.push_front((x, y));\n }\n if let Some(overflow) = self.queue.push_front(event.into()) {\n for i in -1..(EXTRA_WAITING_LEN as i8) {\n self.waiting_into_hold(i);\n }\n self.dequeue(overflow);\n }\n }\n\n /// Resolve coordinate to first non-Trans actions.\n /// Trans on base layer, resolves to key from defsrc.\n fn resolve_coord(\n &self,\n coord: KCoord,\n layer_stack: &mut (impl Iterator + Clone),\n ) -> &'a Action<'a, T> {\n use crate::action::Action::*;\n let x = coord.0 as usize;\n let y = coord.1 as usize;\n assert!(x <= self.layers[0].len());\n assert!(y <= self.layers[0][0].len());\n for layer in layer_stack {\n assert!(usize::from(layer) <= self.layers.len());\n let action = &self.layers[usize::from(layer)][x][y];\n match action {\n Trans => continue,\n action => return action,\n }\n }\n if x == 0 { &self.src_keys[y] } else { &NoOp }\n }\n fn do_action(\n &mut self,\n action: &'a Action<'a, T>,\n coord: KCoord,\n delay: u16,\n is_oneshot: bool,\n layer_stack: &mut (impl Iterator + Clone), // used to resolve Trans action\n ) -> CustomEvent<'a, T> {\n let mut action = action;\n if let Trans = action {\n action = self.resolve_coord(coord, layer_stack);\n }\n let action = action;\n\n if self.last_press_tracker.coord != coord && coord.0 == REAL_KEY_ROW {\n self.last_press_tracker.tap_hold_timeout = 0;\n }\n use Action::*;\n self.states.retain(|s| match s {\n // Need to solve a problem here - if the output chord `S-=` is active, and then a\n // different keypress `=` happens, the `lsft =` states are cleared; but the `=`\n // is immediately re-added again. This means the release is never observed..\n //\n // Bug introduced:\n //\n // If doing something like typing parentheses using output chords,\n // e.g. S-9 followed by S-0,\n // the trivial fix will suppress the shift key for a bit\n // but the `0` still gets output,\n // resulting in an unshifted `0` which is incorrect.\n //\n // Fix added:\n //\n // Do not apply the suppression to modifiers.\n // Modifiers typically don't have a usage pattern similar to\n // the real use case of `S-=` followed by `=` example,\n // such as `S-=` followed by only `lsft`,\n // with a desire for the lone `lsft` to actually activate something.\n NormalKey { flags, keycode, .. } => match flags.nkf_clear_on_next_action() {\n true => {\n self.oneshot.pause_input_processing_ticks += 2;\n if !keycode.is_mod() {\n let _ = self.keys_to_suppress_for_one_cycle.push(*keycode);\n }\n false\n }\n false => true,\n },\n _ => true,\n });\n match action {\n NoOp => {\n // There is an interaction between oneshot and chordsv2 here.\n // chordsv2 sends fake queued press/release events at the coordinate level in order\n // to trigger other \"waiting\" style actions, namely tap-hold. However, these can\n // potentially interfere with oneshot by triggering early oneshot activation. This\n // is resolved by ignoring actions at the coordinate at which the fake events are\n // sent.\n if !is_oneshot && coord != TRIGGER_TAPHOLD_COORD {\n self.oneshot\n .handle_press(OneShotHandlePressKey::Other(coord));\n }\n self.rpt_action = Some(action);\n let _ = self.states.push(NoOpInput { coord });\n }\n Src => {\n let action = &self.src_keys[usize::from(coord.1)];\n // Risk: infinite recursive resulting in stack overflow.\n // In practice this is not expected to happen.\n // The `src_keys` actions are all expected to be `KeyCode` or `NoOp` actions.\n self.do_action(action, coord, delay, is_oneshot, &mut std::iter::empty());\n }\n Trans => {\n // Transparent action should be resolved to non-transparent one near the top\n // of `do_action`.\n unreachable!(\"Trans action should have been resolved earlier\")\n }\n Repeat => {\n // Notes around repeat:\n //\n // Though this action seems conceptually simple, in reality there are a lot of\n // decisions to be made around how exactly actions repeat. For example: in a\n // tap-dance action, would one expect the tap-dance to be repeated or the inner\n // action that was most activated within the tap-dance?\n //\n // Currently the answer to these questions is: what is easy/possible to do? E.g.\n // fork and switch are inconsistent with each other even though the actions are\n // conceptually very similar. This is because switch can potentially activate\n // multiple actions (but not always), so uses the action queue, while fork does\n // not. As another example, tap-dance and tap-hold will repeat the inner action and\n // not the outer (tap-dance|hold) but multi will repeat the entire outer multi\n // action.\n if let Some(ac) = self.rpt_action {\n self.do_action(ac, coord, delay, is_oneshot, &mut std::iter::empty());\n }\n }\n HoldTap(HoldTapAction {\n timeout,\n hold,\n tap,\n timeout_action,\n config,\n tap_hold_interval,\n on_press_reset_timeout_to,\n require_prior_idle,\n }) => {\n // Typing streak detection: if a different physical key was pressed\n // recently, resolve as tap immediately without entering WaitingState.\n // Per-action override takes precedence over the global defcfg value.\n let idle_threshold = require_prior_idle.unwrap_or(self.tap_hold_require_prior_idle);\n if idle_threshold > 0 {\n let prior_idle_tap = self\n .historical_inputs\n .iter_hevents()\n .find(|prior| prior.event.0 == REAL_KEY_ROW && prior.event != coord)\n .is_some_and(|prior| prior.ticks_since_occurrence <= idle_threshold);\n if prior_idle_tap {\n let custom = self.do_action(tap, coord, delay, is_oneshot, layer_stack);\n self.last_press_tracker.update_coord(coord);\n return custom;\n }\n }\n let mut custom = CustomEvent::NoEvent;\n if *tap_hold_interval == 0\n || coord != self.last_press_tracker.coord\n || self.last_press_tracker.tap_hold_timeout == 0\n {\n let ticks = match self.quick_tap_hold_timeout {\n // Leave 1 tick to timeout as it will be consumed in the next processing cycle\n true => delay.min(timeout.saturating_sub(1)),\n false => 0,\n };\n let waiting: WaitingState = WaitingState {\n coord,\n timeout: timeout.saturating_sub(ticks),\n delay: delay.saturating_sub(ticks),\n ticks,\n on_press_reset_timeout_to: *on_press_reset_timeout_to,\n hold,\n tap,\n timeout_action,\n config: WaitingConfig::HoldTap(*config),\n layer_stack: layer_stack.collect(),\n prev_queue_len: QueueLen::MAX,\n };\n if self.waiting.is_some() {\n self.extra_waiting.push_back(waiting);\n } else {\n self.waiting = Some(waiting);\n }\n self.last_press_tracker.tap_hold_timeout = *tap_hold_interval;\n } else {\n self.last_press_tracker.tap_hold_timeout = 0;\n custom.update(self.do_action(tap, coord, delay, is_oneshot, layer_stack));\n }\n // Need to set tap_hold_tracker coord AFTER the checks.\n self.last_press_tracker.update_coord(coord);\n return custom;\n }\n &OneShot(oneshot) => {\n self.last_press_tracker.update_coord(coord);\n let custom =\n self.do_action(oneshot.action, coord, delay, true, &mut std::iter::empty());\n // Note - set rpt_action after doing the inner oneshot action. This means that the\n // whole oneshot will be repeated by rpt-any rather than only the inner action.\n self.rpt_action = Some(action);\n self.oneshot\n .handle_press(OneShotHandlePressKey::OneShotKey(coord));\n self.oneshot.timeout = oneshot.timeout;\n self.oneshot.end_config = oneshot.end_config;\n if let Some(overflow) = self.oneshot.keys.push_back((coord.0, coord.1)) {\n self.event(Event::Release(overflow.0, overflow.1));\n }\n return custom;\n }\n &OneShotIgnoreEventsTicks(ticks) => {\n self.last_press_tracker.update_coord(coord);\n self.rpt_action = Some(action);\n self.oneshot.ticks_to_ignore_events = ticks;\n }\n &TapDance(td) => {\n self.last_press_tracker.update_coord(coord);\n match td.config {\n TapDanceConfig::Lazy => {\n self.waiting = Some(WaitingState {\n coord,\n timeout: td.timeout,\n delay,\n ticks: 0,\n hold: &Action::NoOp,\n tap: &Action::NoOp,\n timeout_action: &Action::NoOp,\n on_press_reset_timeout_to: None,\n config: WaitingConfig::TapDance(TapDanceState {\n actions: td.actions,\n timeout: td.timeout,\n num_taps: 1,\n }),\n layer_stack: layer_stack.collect(),\n prev_queue_len: QueueLen::MAX,\n });\n }\n TapDanceConfig::Eager => {\n match self.tap_dance_eager {\n None => {\n self.tap_dance_eager = Some(TapDanceEagerState {\n coord,\n actions: td.actions,\n timeout: td.timeout,\n orig_timeout: td.timeout,\n num_taps: 1,\n })\n }\n Some(tde) => {\n if tde.coord != coord {\n self.tap_dance_eager = Some(TapDanceEagerState {\n coord,\n actions: td.actions,\n timeout: td.timeout,\n orig_timeout: td.timeout,\n num_taps: 1,\n });\n }\n }\n };\n return self.do_action(td.actions[0], coord, delay, false, layer_stack);\n }\n }\n }\n &Chords(chords) => {\n self.last_press_tracker.update_coord(coord);\n self.waiting = Some(WaitingState {\n coord,\n timeout: chords.timeout,\n delay,\n ticks: 0,\n hold: &Action::NoOp,\n tap: &Action::NoOp,\n timeout_action: &Action::NoOp,\n on_press_reset_timeout_to: None,\n config: WaitingConfig::Chord(chords),\n layer_stack: layer_stack.collect(),\n prev_queue_len: QueueLen::MAX,\n });\n }\n &KeyCode(keycode) => {\n self.last_press_tracker.update_coord(coord);\n // Most-recent-first!\n self.contextual_execution\n .push_historical_key(&mut self.historical_keys, keycode);\n let _ = self.states.push(NormalKey {\n coord,\n keycode,\n flags: NormalKeyFlags(0),\n });\n let mut oneshot_coords = ArrayDeque::new();\n if !is_oneshot {\n oneshot_coords = self\n .oneshot\n .handle_press(OneShotHandlePressKey::Other(coord));\n } else {\n self.oneshot\n .add_state_to_retain(OneShotRetainableState::KeyCode {\n coord,\n kc: keycode,\n });\n }\n if oneshot_coords.is_empty() {\n self.rpt_action = Some(action);\n } else {\n self.rpt_action = None;\n unsafe {\n self.rpt_multikey_key_buffer.clear();\n for kc in self\n .states\n .iter()\n .filter_map(|kc| State::keycode_in_coords(kc, &oneshot_coords))\n {\n self.rpt_multikey_key_buffer.push(kc);\n }\n self.rpt_multikey_key_buffer.push(keycode);\n self.rpt_action = Some(self.rpt_multikey_key_buffer.get_ref());\n }\n }\n }\n &MultipleKeyCodes(v) => {\n self.last_press_tracker.update_coord(coord);\n for &keycode in *v {\n // BUG:\n // In the original implementation, activating an action sequence such as b ->\n // S-b will not type a separate instance of \"B\" because b is already held and\n // wont be re-sent by the outer processing loop.\n //\n // FIX:\n // If `keycode` is not a mod, suppress it for a cycle if it exists in the\n // status. This is not expected to have any negative perceptible effects.\n if !keycode.is_mod() && self.keycodes().any(|kc| kc == keycode) {\n let _ = self.keys_to_suppress_for_one_cycle.push(keycode);\n }\n self.contextual_execution\n .push_historical_key(&mut self.historical_keys, keycode);\n let _ = self.states.push(NormalKey {\n coord,\n keycode,\n // In Kanata, this action is only ever used with output chords. Output\n // chords within a one-shot are ignored because someone might do something\n // like (one-shot C-S-lalt to get 3 modifiers. These are probably intended\n // to remain held. However, other output chords are usually used to type\n // symbols or accented characters, e.g. S-1 or RA-a. Clearing chord keys on\n // the next action allows a subsequent typed key to not have modifiers\n // alongside it. But if the symbol or accented character is held down, key\n // repeat works just fine.\n flags: NormalKeyFlags(if is_oneshot {\n 0\n } else {\n NORMAL_KEY_FLAG_CLEAR_ON_NEXT_ACTION\n }),\n });\n }\n\n let mut oneshot_coords = ArrayDeque::new();\n if !is_oneshot {\n oneshot_coords = self\n .oneshot\n .handle_press(OneShotHandlePressKey::Other(coord));\n } else {\n for &keycode in *v {\n self.oneshot\n .add_state_to_retain(OneShotRetainableState::KeyCode {\n coord,\n kc: keycode,\n });\n }\n }\n if oneshot_coords.is_empty() {\n self.rpt_action = Some(action);\n } else {\n self.rpt_action = None;\n unsafe {\n self.rpt_multikey_key_buffer.clear();\n for kc in self\n .states\n .iter()\n .filter_map(|s| s.keycode_in_coords(&oneshot_coords))\n {\n self.rpt_multikey_key_buffer.push(kc);\n }\n for &keycode in *v {\n self.rpt_multikey_key_buffer.push(keycode);\n }\n self.rpt_action = Some(self.rpt_multikey_key_buffer.get_ref());\n }\n }\n }\n &MultipleActions(v) => {\n self.last_press_tracker.update_coord(coord);\n let mut custom = CustomEvent::NoEvent;\n for action in *v {\n custom.update(self.do_action(\n action,\n coord,\n delay,\n is_oneshot,\n &mut layer_stack.clone(),\n ));\n }\n // Save the whole multi action instead of the final action in multi so that Repeat\n // repeats all of the actions in this multi.\n self.rpt_action = Some(action);\n return custom;\n }\n Sequence { events } => {\n self.active_sequences.push_back(SequenceState {\n cur_event: None,\n delay: 0,\n tapped: None,\n remaining_events: events,\n });\n if !is_oneshot {\n self.oneshot\n .handle_press(OneShotHandlePressKey::Other(coord));\n }\n self.rpt_action = Some(action);\n }\n RepeatableSequence { events } => {\n self.active_sequences.push_back(SequenceState {\n cur_event: None,\n delay: 0,\n tapped: None,\n remaining_events: events,\n });\n let _ = self.states.push(RepeatingSequence {\n sequence: events,\n coord,\n });\n if !is_oneshot {\n self.oneshot\n .handle_press(OneShotHandlePressKey::Other(coord));\n }\n self.rpt_action = Some(action);\n }\n CancelSequences => {\n // Clear any and all running sequences then clean up any leftover FakeKey events\n self.active_sequences.clear();\n for fake_key in self.states.clone().iter() {\n if let FakeKey { keycode } = *fake_key {\n self.states.retain(|s| s.seq_release(keycode).is_some());\n }\n }\n if !is_oneshot {\n self.oneshot\n .handle_press(OneShotHandlePressKey::Other(coord));\n }\n self.rpt_action = Some(action);\n }\n &Layer(value) => {\n self.last_press_tracker.update_coord(coord);\n let _ = self.states.push(LayerModifier { value, coord });\n if !is_oneshot {\n self.oneshot\n .handle_press(OneShotHandlePressKey::Other(coord));\n } else {\n self.oneshot\n .add_state_to_retain(OneShotRetainableState::Layer {\n coord,\n layer: value as u16,\n });\n }\n // Notably missing in Layer and below in DefaultLayer is setting rpt_action. This\n // is so that if the Repeat key is on a different layer than the base, it can still\n // be used to repeat the previous non-layer-changing action.\n }\n DefaultLayer(value) => {\n self.last_press_tracker.update_coord(coord);\n self.set_default_layer(*value);\n if !is_oneshot {\n self.oneshot\n .handle_press(OneShotHandlePressKey::Other(coord));\n }\n }\n Custom(value) => {\n self.last_press_tracker.update_coord(coord);\n if !is_oneshot {\n self.oneshot\n .handle_press(OneShotHandlePressKey::Other(coord));\n }\n self.rpt_action = Some(action);\n if self.states.push(State::Custom { value, coord }).is_ok() {\n return CustomEvent::Press(value);\n }\n }\n ReleaseState(rs) => {\n self.states.retain(|s| s.release_state(*rs).is_some());\n if !is_oneshot {\n self.oneshot\n .handle_press(OneShotHandlePressKey::Other(coord));\n }\n self.rpt_action = Some(action);\n }\n Fork(fcfg) => {\n let ret = match self.states.iter().any(|s| match s {\n NormalKey { keycode, .. } | FakeKey { keycode } => {\n fcfg.right_triggers.contains(keycode)\n }\n _ => false,\n }) {\n false => {\n self.do_action(&fcfg.left, coord, delay, false, &mut layer_stack.clone())\n }\n true => {\n self.do_action(&fcfg.right, coord, delay, false, &mut layer_stack.clone())\n }\n };\n // Repeat the fork rather than the terminal action.\n self.rpt_action = Some(action);\n return ret;\n }\n Switch(sw) => {\n let active_keys = self.states.iter().filter_map(State::keycode);\n let active_coords = self.states.iter().filter_map(State::coord);\n let historical_keys = self.historical_keys.iter_hevents();\n let historical_coords = self.historical_inputs.iter_hevents();\n let layers = self.trans_resolution_layer_order().into_iter();\n let action_queue = &mut self.action_queue;\n for ac in sw.actions(\n active_keys,\n active_coords,\n historical_keys,\n historical_coords,\n layers,\n // Note on truncating cast: I expect default layer to be in range by other\n // assertions.\n self.default_layer as u16,\n ) {\n action_queue.push_back(Some((coord, 0, ac, layer_stack.collect())));\n }\n // Switch is not properly repeatable. This has to use the action queue for the\n // purpose of proper Custom action handling, because a single switch action can\n // activate multiple inner actions. But because of the use of the action queue,\n // switch has no way to set `rpt_action` after the queue is depleted. I suppose\n // that can be fixable, but for now will keep it as-is.\n }\n }\n CustomEvent::NoEvent\n }\n\n /// Obtain the index of the current active layer\n pub fn current_layer(&self) -> usize {\n self.states\n .iter()\n .rev()\n .find_map(State::get_layer)\n .unwrap_or(self.default_layer)\n }\n\n pub fn active_held_layers(&self) -> impl Iterator + Clone + '_ {\n self.states\n .iter()\n .filter_map(|s| State::get_layer(s).map(|l| l as u16))\n .rev()\n }\n\n /// Returns a list indices of layers that should be used for [`Action::Trans`] resolution.\n pub fn trans_resolution_layer_order(&self) -> LayerStack {\n let current_layer = self.current_layer();\n if self.trans_resolution_behavior_v2 {\n let mut v = self.active_held_layers().collect::();\n let _ = v.push(self.default_layer as u16);\n if self.delegate_to_first_layer && current_layer != 0 && self.default_layer != 0 {\n let _ = v.push(0);\n }\n v\n } else {\n let mut v = Vec::new();\n let _ = v.push(current_layer as u16);\n if self.delegate_to_first_layer && current_layer != 0 {\n let _ = v.push(0);\n }\n v\n }\n }\n\n /// Sets the default layer for the layout\n pub fn set_default_layer(&mut self, value: usize) {\n if value < self.layers.len() {\n self.default_layer = value\n }\n }\n}\n\n#[cfg(test)]\nmod test {\n extern crate std;\n use super::{Event::*, Layout, *};\n use crate::action::Action::*;\n use crate::action::HoldTapConfig;\n use crate::action::{k, l};\n use crate::key_code::KeyCode;\n use crate::key_code::KeyCode::*;\n use std::collections::BTreeSet;\n\n #[track_caller]\n fn assert_keys(expected: &[KeyCode], iter: impl Iterator) {\n let expected: BTreeSet<_> = expected.iter().copied().collect();\n let tested = iter.collect();\n assert_eq!(expected, tested);\n }\n\n #[test]\n fn basic_hold_tap() {\n static LAYERS: Layers<2, 1> = &[\n [[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: l(1),\n tap: k(Space),\n timeout_action: k(RShift),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n }),\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(LCtrl),\n timeout_action: k(LShift),\n tap: k(Enter),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n }),\n ]],\n [[Trans, MultipleKeyCodes(&[LCtrl, Enter].as_slice())]],\n ];\n let mut layout = Layout::new(LAYERS);\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 0));\n for _ in 0..197 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn basic_hold_tap_repress_timeout() {\n static LAYERS: Layers<2, 1> = &[\n [[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: l(1),\n tap: k(Space),\n timeout_action: l(1),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n }),\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(LCtrl),\n timeout_action: k(LCtrl),\n tap: k(Enter),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n }),\n ]],\n [[Trans, MultipleKeyCodes(&[LCtrl, Enter].as_slice())]],\n ];\n let mut layout = Layout::new(LAYERS);\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 0));\n for _ in 0..197 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LCtrl], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LCtrl], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LCtrl, Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LCtrl], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn hold_tap_interleaved_timeout() {\n static LAYERS: Layers<2, 1> = &[[[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n }),\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 20,\n hold: k(LCtrl),\n timeout_action: k(LCtrl),\n tap: k(Enter),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n }),\n ]]];\n let mut layout = Layout::new(LAYERS);\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n for _ in 0..15 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n for _ in 0..10 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n }\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space, LCtrl], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LCtrl], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn hold_on_press() {\n static LAYERS: Layers<2, 1> = &[[[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::HoldOnOtherKeyPress,\n tap_hold_interval: 0,\n }),\n k(Enter),\n ]]];\n let mut layout = Layout::new(LAYERS);\n\n // Press another key before timeout\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt, Enter], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Enter], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Press another key after timeout\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n for _ in 0..200 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt, Enter], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Enter], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn order_clean_tap() {\n // Press and release modifier with no other keys → Tap.\n static LAYERS: Layers<2, 1> = &[[[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n timeout: u16::MAX,\n hold: k(LAlt),\n timeout_action: k(Space),\n tap: k(Space),\n config: HoldTapConfig::Order { buffer: 0 },\n tap_hold_interval: 0,\n require_prior_idle: None,\n }),\n k(Enter),\n ]]];\n let mut layout = Layout::new(LAYERS);\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn order_hold() {\n // Modifier down → other down → other up first → Hold.\n static LAYERS: Layers<2, 1> = &[[[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n timeout: u16::MAX,\n hold: k(LAlt),\n timeout_action: k(Space),\n tap: k(Space),\n config: HoldTapConfig::Order { buffer: 0 },\n tap_hold_interval: 0,\n require_prior_idle: None,\n }),\n k(Enter),\n ]]];\n let mut layout = Layout::new(LAYERS);\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n // Other key releases first → Hold\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt, Enter], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n // Release modifier\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn order_tap() {\n // Modifier down → other down → modifier up first → Tap.\n static LAYERS: Layers<2, 1> = &[[[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n timeout: u16::MAX,\n hold: k(LAlt),\n timeout_action: k(Space),\n tap: k(Space),\n config: HoldTapConfig::Order { buffer: 0 },\n tap_hold_interval: 0,\n require_prior_idle: None,\n }),\n k(Enter),\n ]]];\n let mut layout = Layout::new(LAYERS);\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n // Modifier releases first → Tap\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space, Enter], layout.keycodes());\n }\n\n #[test]\n fn order_multi_key_hold() {\n // TH down → A down → B down → A up (while B still held) → TH up.\n // A's press+release cycle completes while TH is held → Hold.\n static LAYERS: Layers<3, 1> = &[[[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n timeout: u16::MAX,\n hold: k(LAlt),\n timeout_action: k(Space),\n tap: k(Space),\n config: HoldTapConfig::Order { buffer: 0 },\n tap_hold_interval: 0,\n require_prior_idle: None,\n }),\n k(Enter),\n k(Tab),\n ]]];\n let mut layout = Layout::new(LAYERS);\n\n // TH down\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n // A down\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n // B down\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n // A up — A's press+release cycle is complete → Hold resolves\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n // Queued keys replay: Enter press, Tab press, Enter release\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt, Enter], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt, Enter, Tab], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt, Tab], layout.keycodes());\n // Release B\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n // Release TH\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn order_buffer_ignores_press_within_window() {\n // TH down (buffer=50) → other key pressed+released within 50 ticks.\n // Without buffer this would be Hold (other key's press+release cycle\n // completes while TH held). With buffer=50, the press is ignored by\n // release-order logic, so TH remains unresolved. Releasing TH → Tap.\n static LAYERS: Layers<2, 1> = &[[[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: u16::MAX,\n hold: k(LAlt),\n timeout_action: k(Space),\n tap: k(Space),\n config: HoldTapConfig::Order { buffer: 50 },\n tap_hold_interval: 0,\n }),\n k(Enter),\n ]]];\n let mut layout = Layout::new(LAYERS);\n\n // TH down\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n // Other key pressed at tick ~1 (well within 50-tick buffer)\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n // Other key released — would normally trigger Hold, but press is buffered\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n // TH released → Tap (buffered press was ignored).\n // Space activates, then queued Enter press+release replays.\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space, Enter], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn permissive_hold() {\n static LAYERS: Layers<2, 1> = &[[[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::PermissiveHold,\n tap_hold_interval: 0,\n }),\n k(Enter),\n ]]];\n let mut layout = Layout::new(LAYERS);\n\n // Press and release another key before timeout\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt, Enter], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn simultaneous_hold() {\n static LAYERS: Layers<3, 1> = &[[[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n }),\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(RAlt),\n timeout_action: k(RAlt),\n tap: k(A),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n }),\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(LCtrl),\n timeout_action: k(LCtrl),\n tap: k(A),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n }),\n ]]];\n let mut layout = Layout::new(LAYERS);\n layout.quick_tap_hold_timeout = true;\n\n // Press and release another key before timeout\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n for _ in 0..196 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt, RAlt], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt, RAlt], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt, RAlt, LCtrl], layout.keycodes());\n }\n\n #[test]\n fn multiple_actions() {\n static LAYERS: Layers<2, 1> = &[\n [[MultipleActions(&[l(1), k(LShift)].as_slice()), k(F)]],\n [[Trans, k(E)]],\n ];\n let mut layout = Layout::new(LAYERS);\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, E], layout.keycodes());\n layout.event(Release(0, 1));\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn custom() {\n static LAYERS: Layers<1, 1, i32> = &[[[Action::Custom(42)]]];\n let mut layout = Layout::new(LAYERS);\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Custom event\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::Press(&42), layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // nothing more\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // release custom\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::Release(&42), layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn multiple_layers() {\n static LAYERS: Layers<2, 1> = &[\n [[l(1), l(2)]],\n [[k(A), l(3)]],\n [[l(0), k(B)]],\n [[k(C), k(D)]],\n ];\n let mut layout = Layout::new(LAYERS);\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_eq!(0, layout.current_layer());\n assert_keys(&[], layout.keycodes());\n\n // press L1\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_eq!(1, layout.current_layer());\n assert_keys(&[], layout.keycodes());\n // press L3 on L1\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_eq!(3, layout.current_layer());\n assert_keys(&[], layout.keycodes());\n // release L1, still on l3\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_eq!(3, layout.current_layer());\n assert_keys(&[], layout.keycodes());\n // press and release C on L3\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[C], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n // release L3, back to L0\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_eq!(0, layout.current_layer());\n assert_keys(&[], layout.keycodes());\n\n // back to empty, going to L2\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_eq!(2, layout.current_layer());\n assert_keys(&[], layout.keycodes());\n // and press the L0 key on L2\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_eq!(0, layout.current_layer());\n assert_keys(&[], layout.keycodes());\n // release the L0, back to L2\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_eq!(2, layout.current_layer());\n assert_keys(&[], layout.keycodes());\n // release the L2, back to L0\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_eq!(0, layout.current_layer());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn custom_handler() {\n fn always_tap(_: QueuedIter, _: KCoord) -> (Option, bool) {\n (Some(WaitingAction::Tap), false)\n }\n fn always_hold(_: QueuedIter, _: KCoord) -> (Option, bool) {\n (Some(WaitingAction::Hold), false)\n }\n fn always_nop(_: QueuedIter, _: KCoord) -> (Option, bool) {\n (Some(WaitingAction::NoOp), false)\n }\n fn always_none(_: QueuedIter, _: KCoord) -> (Option, bool) {\n (None, false)\n }\n static LAYERS: Layers<4, 1> = &[[[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(Kb1),\n timeout_action: k(Kb1),\n tap: k(Kb0),\n config: HoldTapConfig::Custom(&always_tap),\n tap_hold_interval: 0,\n }),\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(Kb3),\n timeout_action: k(Kb3),\n tap: k(Kb2),\n config: HoldTapConfig::Custom(&always_hold),\n tap_hold_interval: 0,\n }),\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(Kb5),\n timeout_action: k(Kb5),\n tap: k(Kb4),\n config: HoldTapConfig::Custom(&always_nop),\n tap_hold_interval: 0,\n }),\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(Kb7),\n timeout_action: k(Kb7),\n tap: k(Kb6),\n config: HoldTapConfig::Custom(&always_none),\n tap_hold_interval: 0,\n }),\n ]]];\n let mut layout = Layout::new(LAYERS);\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Custom handler always taps\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb0], layout.keycodes());\n\n // nothing more\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Custom handler always holds\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb3], layout.keycodes());\n\n // nothing more\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Custom handler always prevents any event\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // even timeout does not trigger\n for _ in 0..200 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // nothing more\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Custom handler timeout fallback\n layout.event(Press(0, 3));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n for _ in 0..199 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb7], layout.keycodes());\n }\n\n #[test]\n fn tap_hold_interval() {\n static LAYERS: Layers<2, 1> = &[[[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::Default,\n tap_hold_interval: 200,\n }),\n k(Enter),\n ]]];\n let mut layout = Layout::new(LAYERS);\n\n // press and release the HT key, expect tap action\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // press again within tap_hold_interval, tap action should be in keycode immediately\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n\n // tap action should continue to be in keycodes even after timeout\n for _ in 0..300 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n }\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Press again. This is outside the tap_hold_interval window, so should result in hold\n // action.\n layout.event(Press(0, 0));\n for _ in 0..200 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn tap_hold_interval_interleave() {\n static LAYERS: Layers<3, 1> = &[[[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::Default,\n tap_hold_interval: 200,\n }),\n k(Enter),\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Enter),\n config: HoldTapConfig::Default,\n tap_hold_interval: 200,\n }),\n ]]];\n let mut layout = Layout::new(LAYERS);\n\n // press and release the HT key, expect tap action\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // press a different key in between\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Enter], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // press HT key again, should result in hold action\n layout.event(Press(0, 0));\n for _ in 0..200 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // press HT key, press+release diff key, release HT key\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Enter, Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // press HT key again, should result in hold action\n layout.event(Press(0, 0));\n for _ in 0..200 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // press HT key, press+release diff (HT) key, release HT key\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Enter, Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // press HT key again, should result in hold action\n layout.event(Press(0, 0));\n for _ in 0..200 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n }\n\n #[test]\n fn tap_hold_interval_short_hold() {\n static LAYERS: Layers<1, 1> = &[[[HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 50,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::Default,\n tap_hold_interval: 200,\n })]]];\n let mut layout = Layout::new(LAYERS);\n\n // press and hold the HT key, expect hold action\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // press and hold the HT key, expect hold action, even though it's within the\n // tap_hold_interval\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn tap_hold_interval_different_hold() {\n static LAYERS: Layers<2, 1> = &[[[\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 50,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::Default,\n tap_hold_interval: 200,\n }),\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 200,\n hold: k(RAlt),\n timeout_action: k(RAlt),\n tap: k(Enter),\n config: HoldTapConfig::Default,\n tap_hold_interval: 200,\n }),\n ]]];\n let mut layout = Layout::new(LAYERS);\n\n // press HT1, press HT2, release HT1 after hold timeout, release HT2, press HT2\n layout.event(Press(0, 0));\n layout.event(Press(0, 1));\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt, Enter], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Enter], layout.keycodes());\n // press HT2 again, should result in tap action\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n for _ in 0..300 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Enter], layout.keycodes());\n }\n }\n\n #[test]\n fn one_shot() {\n static LAYERS: Layers<3, 1> = &[[[\n OneShot(&crate::action::OneShot {\n timeout: 100,\n action: &k(LShift),\n end_config: OneShotEndConfig::EndOnFirstPress,\n }),\n k(A),\n k(B),\n ]]];\n let mut layout = Layout::new(LAYERS);\n layout.oneshot.pause_input_processing_delay = 1;\n\n // Test:\n // 1. press one-shot\n // 2. release one-shot\n // 3. press A within timeout\n // 4. press B within timeout\n // 5. release A, B\n layout.event(Press(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Release(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Press(0, 1));\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A, LShift], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A, B], layout.keycodes());\n layout.event(Release(0, 1));\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test:\n // 1. press one-shot\n // 2. release one-shot\n // 3. press A after timeout\n // 4. release A\n layout.event(Press(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Release(0, 0));\n for _ in 0..75 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test:\n // 1. press one-shot\n // 2. press A\n // 3. release A\n // 4. release one-shot\n layout.event(Press(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, A], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test:\n // 1. press one-shot\n // 2. press A after timeout\n // 3. release A\n // 4. release one-shot\n layout.event(Press(0, 0));\n for _ in 0..200 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, A], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn one_shot_end_press_or_repress() {\n static LAYERS: Layers<3, 1> = &[[[\n OneShot(&crate::action::OneShot {\n timeout: 100,\n action: &k(LShift),\n end_config: OneShotEndConfig::EndOnFirstPressOrRepress,\n }),\n k(A),\n k(B),\n ]]];\n let mut layout = Layout::new(LAYERS);\n layout.oneshot.pause_input_processing_delay = 1;\n\n // Test:\n // 1. press one-shot\n // 2. release one-shot\n // 3. press A within timeout\n // 4. press B within timeout\n // 5. release A, B\n layout.event(Press(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Release(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Press(0, 1));\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A, LShift], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A, B], layout.keycodes());\n layout.event(Release(0, 1));\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test:\n // 1. press one-shot\n // 2. release one-shot\n // 3. press A after timeout\n // 4. release A\n layout.event(Press(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Release(0, 0));\n for _ in 0..75 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test:\n // 1. press one-shot\n // 2. press A\n // 3. release A\n // 4. release one-shot\n layout.event(Press(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, A], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test:\n // 1. press one-shot\n // 2. press A after timeout\n // 3. release A\n // 4. release one-shot\n layout.event(Press(0, 0));\n for _ in 0..200 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, A], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test:\n // 1. press one-shot\n // 2. release one-shot\n // 3. press one-shot within timeout\n // 4. release one-shot quickly - should end\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test:\n // 1. press one-shot\n // 2. release one-shot\n // 3. press one-shot within timeout\n // 4. release one-shot after timeout\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n for _ in 0..200 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn one_shot_end_on_release() {\n static LAYERS: Layers<3, 1> = &[[[\n OneShot(&crate::action::OneShot {\n timeout: 100,\n action: &k(LShift),\n end_config: OneShotEndConfig::EndOnFirstRelease,\n }),\n k(A),\n k(B),\n ]]];\n let mut layout = Layout::new(LAYERS);\n\n // Test:\n // 1. press one-shot\n // 2. release one-shot\n // 3. press A within timeout\n // 4. press B within timeout\n // 5. release A, B\n layout.event(Press(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Release(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Press(0, 1));\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A, LShift], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A, B, LShift], layout.keycodes());\n layout.event(Release(0, 1));\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B, LShift], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test:\n // 1. press one-shot\n // 2. release one-shot\n // 3. press A after timeout\n // 4. release A\n layout.event(Press(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Release(0, 0));\n for _ in 0..75 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test:\n // 1. press one-shot\n // 2. press A\n // 3. release A\n // 4. release one-shot\n layout.event(Press(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, A], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test:\n // 1. press one-shot\n // 2. press A after timeout\n // 3. release A\n // 4. release one-shot\n layout.event(Press(0, 0));\n for _ in 0..200 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, A], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test:\n // 3. press A\n // 1. press one-shot\n // 2. release one-shot\n // 3. release A\n // 4. press B within timeout\n // 5. release B\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A], layout.keycodes());\n layout.event(Press(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A, LShift], layout.keycodes());\n }\n layout.event(Release(0, 0));\n for _ in 0..25 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A, LShift], layout.keycodes());\n }\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B, LShift], layout.keycodes());\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn one_shot_multi() {\n static LAYERS: Layers<4, 1> = &[\n [[\n OneShot(&crate::action::OneShot {\n timeout: 100,\n action: &k(LShift),\n end_config: OneShotEndConfig::EndOnFirstPress,\n }),\n OneShot(&crate::action::OneShot {\n timeout: 100,\n action: &k(LCtrl),\n end_config: OneShotEndConfig::EndOnFirstPress,\n }),\n OneShot(&crate::action::OneShot {\n timeout: 100,\n action: &Layer(1),\n end_config: OneShotEndConfig::EndOnFirstPress,\n }),\n NoOp,\n ]],\n [[k(A), k(B), k(C), k(D)]],\n ];\n let mut layout = Layout::new(LAYERS);\n layout.oneshot.pause_input_processing_delay = 1;\n\n layout.event(Press(0, 0));\n layout.event(Release(0, 0));\n for _ in 0..90 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Press(0, 1));\n for _ in 0..90 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, LCtrl], layout.keycodes());\n }\n assert_eq!(layout.current_layer(), 0);\n layout.event(Press(0, 2));\n layout.event(Release(0, 2));\n for _ in 0..90 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, LCtrl], layout.keycodes());\n assert_eq!(layout.current_layer(), 1);\n }\n layout.event(Press(0, 3));\n layout.event(Release(0, 3));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, LCtrl, D], layout.keycodes());\n assert_eq!(layout.current_layer(), 1);\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LCtrl], layout.keycodes());\n assert_eq!(layout.current_layer(), 0);\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn one_shot_tap_hold() {\n static LAYERS: Layers<3, 1> = &[\n [[\n OneShot(&crate::action::OneShot {\n timeout: 200,\n action: &k(LShift),\n end_config: OneShotEndConfig::EndOnFirstPress,\n }),\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 100,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n }),\n NoOp,\n ]],\n [[k(A), k(B), k(C)]],\n ];\n let mut layout = Layout::new(LAYERS);\n layout.oneshot.pause_input_processing_delay = 1;\n\n layout.event(Press(0, 0));\n layout.event(Release(0, 0));\n for _ in 0..90 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Press(0, 1));\n for _ in 0..90 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n layout.event(Press(0, 0));\n layout.event(Release(0, 0));\n for _ in 0..90 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n layout.event(Press(0, 1));\n for _ in 0..100 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, LAlt], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn tap_dance_uneager() {\n static LAYERS: Layers<2, 2> = &[[\n [\n TapDance(&crate::action::TapDance {\n timeout: 100,\n actions: &[\n &k(LShift),\n &OneShot(&crate::action::OneShot {\n timeout: 100,\n action: &k(LCtrl),\n end_config: OneShotEndConfig::EndOnFirstPress,\n }),\n &HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 100,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n }),\n ],\n config: TapDanceConfig::Lazy,\n }),\n k(A),\n ],\n [k(B), k(C)],\n ]];\n let mut layout = Layout::new(LAYERS);\n\n // Test: tap-dance first key, timeout\n layout.event(Press(0, 0));\n for _ in 0..100 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test: tap-dance first key, press another key\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Release(0, 0));\n assert_keys(&[LShift], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, A], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test: tap-dance second key, timeout\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 0));\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 0));\n for _ in 0..99 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n for _ in 0..100 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LCtrl], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test: tap-dance third key, timeout, tap\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 0));\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 0));\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test: tap-dance third key, timeout, hold\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 0));\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 0));\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 0));\n for _ in 0..100 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n for _ in 0..200 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n }\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn tap_dance_eager() {\n static LAYERS: Layers<2, 2> = &[[\n [\n TapDance(&crate::action::TapDance {\n timeout: 100,\n actions: &[&k(Kb1), &k(Kb2), &k(Kb3)],\n config: TapDanceConfig::Eager,\n }),\n k(A),\n ],\n [k(B), k(C)],\n ]];\n let mut layout = Layout::new(LAYERS);\n\n // Test: tap-dance-eager first key\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb1], layout.keycodes());\n for _ in 0..200 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb1], layout.keycodes());\n }\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test: tap-dance-eager first key, press another key\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb1], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb1, A], layout.keycodes());\n layout.event(Release(0, 0));\n assert_keys(&[Kb1, A], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test: tap-dance second key\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb1], layout.keycodes());\n layout.event(Release(0, 0));\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb2], layout.keycodes());\n layout.event(Release(0, 0));\n for _ in 0..99 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Test: tap-dance third key\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb1], layout.keycodes());\n layout.event(Release(0, 0));\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb2], layout.keycodes());\n layout.event(Release(0, 0));\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb3], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn release_state() {\n static LAYERS: Layers<2, 1> = &[\n [[\n MultipleActions(&(&[KeyCode(LCtrl), Layer(1)] as _)),\n MultipleActions(&(&[KeyCode(LAlt), Layer(1)] as _)),\n ]],\n [[\n MultipleActions(\n &(&[ReleaseState(ReleasableState::KeyCode(LAlt)), KeyCode(Space)] as _),\n ),\n ReleaseState(ReleasableState::Layer(1)),\n ]],\n ];\n\n let mut layout = Layout::new(LAYERS);\n\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LAlt], layout.keycodes());\n assert_eq!(1, layout.current_layer());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LCtrl], layout.keycodes());\n assert_eq!(1, layout.current_layer());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_eq!(0, layout.current_layer());\n assert_keys(&[LCtrl], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LCtrl], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_chord() {\n const GROUP: ChordsGroup = ChordsGroup {\n coords: &[((0, 2), 1), ((0, 3), 2), ((0, 4), 4), ((0, 5), 8)],\n chords: &[\n (1, &KeyCode(Kb1)),\n (2, &KeyCode(Kb2)),\n (4, &KeyCode(Kb3)),\n (8, &KeyCode(Kb4)),\n (3, &KeyCode(Kb5)),\n (11, &KeyCode(Kb6)),\n ],\n timeout: 100,\n };\n static LAYERS: Layers<6, 1> = &[[[\n NoOp,\n NoOp,\n Chords(&GROUP),\n Chords(&GROUP),\n Chords(&GROUP),\n Chords(&GROUP),\n ]]];\n\n let mut layout = Layout::new(LAYERS);\n layout.event(Press(0, 2));\n // timeout on non-terminal chord\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 3));\n for _ in 0..49 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb5], layout.keycodes());\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb5], layout.keycodes());\n layout.event(Release(0, 3));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // timeout on terminal chord with no action associated\n // combo like (h j k) -> (h j) (k)\n layout.event(Press(0, 2));\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 3));\n for _ in 0..30 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 4));\n for _ in 0..20 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb5], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb5, Kb3], layout.keycodes());\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb3], layout.keycodes());\n layout.event(Release(0, 3));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb3], layout.keycodes());\n layout.event(Release(0, 4));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // release terminal chord with no action associated\n // combo like (h j k) -> (h j) (k)\n layout.event(Press(0, 2));\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 3));\n for _ in 0..30 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 4));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 4));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb5], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb5, Kb3], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb5], layout.keycodes());\n layout.event(Release(0, 2));\n layout.event(Release(0, 3));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // release terminal chord with no action associated\n // Test combo like (h j k l) -> (h) (j k l)\n layout.event(Press(0, 4));\n layout.event(Press(0, 2));\n layout.event(Press(0, 3));\n layout.event(Press(0, 5));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n for _ in 0..30 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb3], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb3, Kb6], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb3], layout.keycodes());\n }\n\n #[test]\n fn test_chord_normalkey_order() {\n const GROUP: ChordsGroup = ChordsGroup {\n coords: &[((0, 2), 1), ((0, 3), 2), ((0, 4), 4), ((0, 5), 8)],\n chords: &[\n (1, &KeyCode(Kb1)),\n (2, &KeyCode(Kb2)),\n (4, &KeyCode(Kb3)),\n (8, &KeyCode(Kb4)),\n (3, &KeyCode(Kb5)),\n (11, &KeyCode(Kb6)),\n ],\n timeout: 100,\n };\n static LAYERS: Layers<6, 1> = &[[[\n NoOp,\n k(A),\n Chords(&GROUP),\n Chords(&GROUP),\n Chords(&GROUP),\n Chords(&GROUP),\n ]]];\n\n let mut layout = Layout::new(LAYERS);\n layout.event(Press(0, 2));\n // timeout on non-terminal chord\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb1], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb1, A], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb1], layout.keycodes());\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_chord_multi_waiting_decomposition() {\n const GROUP: ChordsGroup = ChordsGroup {\n coords: &[((0, 0), 1), ((0, 1), 2)],\n chords: &[\n (\n 1,\n &HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 100,\n hold: k(A),\n timeout_action: k(A),\n tap: k(Kb1),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n }),\n ),\n (\n 2,\n &HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 100,\n hold: k(B),\n timeout_action: k(B),\n tap: k(Kb2),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n }),\n ),\n ],\n timeout: 100,\n };\n static LAYERS: Layers<2, 1> = &[[[Chords(&GROUP), Chords(&GROUP)]]];\n\n let mut layout = Layout::new(LAYERS);\n layout.quick_tap_hold_timeout = true;\n layout.event(Press(0, 0));\n layout.event(Press(0, 1));\n // Why does this take 103 ticks?\n // 0: chord begin\n // 1: chord decompose\n // 2: action queue dequeue\n // 3: action queue dequeue\n // 4-103: timeout ticks\n for _ in 0..102 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A, B], layout.keycodes());\n layout.event(Release(0, 0));\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_fork() {\n static LAYERS: Layers<2, 1> = &[[[\n Fork(&ForkConfig {\n left: k(Kb1),\n right: k(Kb2),\n right_triggers: &[Space],\n }),\n k(Space),\n ]]];\n let mut layout = Layout::new(LAYERS);\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb1], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n layout.event(Press(0, 1));\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Space, Kb2], layout.keycodes());\n layout.event(Release(0, 1));\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[Kb2], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_repeat() {\n static LAYERS: Layers<5, 1> = &[\n [[\n k(A),\n MultipleKeyCodes(&[LShift, B].as_slice()),\n Repeat,\n MultipleActions(&[k(C), k(D)].as_slice()),\n Layer(1),\n ]],\n [[\n k(E),\n MultipleKeyCodes(&[LShift, F].as_slice()),\n Repeat,\n MultipleActions(&[k(G), k(H)].as_slice()),\n Layer(1),\n ]],\n ];\n let mut layout = Layout::new(LAYERS);\n\n // Press a key\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Repeat it, should be the same\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A], layout.keycodes());\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Press a chord\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, B], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Repeat it, should be the same\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LShift, B], layout.keycodes());\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Press a multiple action\n layout.event(Press(0, 3));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[C, D], layout.keycodes());\n layout.event(Release(0, 3));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Repeat it, should be the same\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[C, D], layout.keycodes());\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Go to a different layer and press a key\n layout.event(Press(0, 4));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[E], layout.keycodes());\n layout.event(Release(0, 4));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[E], layout.keycodes());\n layout.event(Release(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Repeat, should be the same as the other layer\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[E], layout.keycodes());\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n // Activate the layer action and press repeat there, should still be the same action\n layout.event(Press(0, 4));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[E], layout.keycodes());\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 4));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_clear_multiple_keycodes() {\n static LAYERS: Layers<2, 1> = &[[[k(A), MultipleKeyCodes(&[LCtrl, Enter].as_slice())]]];\n let mut layout = Layout::new(LAYERS);\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[LCtrl, Enter], layout.keycodes());\n // Cancel chord keys on next keypress.\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A], layout.keycodes());\n }\n\n // Tests the new Trans behavior.\n // https://github.com/jtroo/kanata/issues/738\n #[test]\n fn test_trans_in_stacked_held_layers() {\n static LAYERS: Layers<4, 1> = &[\n [[Layer(1), NoOp, NoOp, k(A)]],\n [[NoOp, Layer(2), NoOp, k(B)]],\n [[NoOp, NoOp, Layer(3), Trans]],\n [[NoOp, NoOp, NoOp, Trans]],\n ];\n let mut layout = Layout::new(LAYERS);\n\n // change to layer 2\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n // change to layer 3\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n // change to layer 4\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n // pressing Trans should press a key in layer 2, compared to previous behavior,\n // where a key in layer 1 would be pressed\n layout.event(Press(0, 3));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B], layout.keycodes());\n layout.event(Release(0, 3));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_trans_in_action_on_first_layer() {\n static DEFSRC_LAYER: [Action; 2] = [NoOp, k(X)];\n static LAYERS: Layers<2, 1> = &[\n [[Layer(1), Trans]],\n [[NoOp, MultipleActions(&[Trans].as_slice())]],\n ];\n let mut layout = Layout::new_with_trans_action_settings(&DEFSRC_LAYER, LAYERS, true, true);\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[X], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_trans_in_taphold_tap() {\n static LAYERS: Layers<3, 1> = &[\n [[Layer(1), NoOp, k(A)]],\n [[NoOp, Layer(2), k(B)]],\n [[\n NoOp,\n NoOp,\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 50,\n hold: k(Space),\n timeout_action: k(Space),\n tap: Trans,\n config: HoldTapConfig::Default,\n tap_hold_interval: 200,\n }),\n ]],\n ];\n let mut layout = Layout::new(LAYERS);\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 2)); // press th\n for _ in 0..10 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Release(0, 2)); // release th\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B], layout.keycodes()); // B is resolved from Trans\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n // test tap action repeat\n layout.event(Press(0, 2));\n for _ in 0..30 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B], layout.keycodes());\n }\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_trans_in_taphold_hold() {\n static LAYERS: Layers<3, 1> = &[\n [[Layer(1), NoOp, k(A)]],\n [[NoOp, Layer(2), k(B)]],\n [[\n NoOp,\n NoOp,\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 50,\n hold: Trans,\n timeout_action: Trans,\n tap: k(Space),\n config: HoldTapConfig::Default,\n tap_hold_interval: 200,\n }),\n ]],\n ];\n let mut layout = Layout::new(LAYERS);\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 2)); // press th\n for _ in 0..50 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n for _ in 0..70 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B], layout.keycodes()); // B is resolved from Trans\n }\n layout.event(Release(0, 2)); // release th\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_trans_in_tapdance_lazy() {\n static LAYERS: Layers<3, 1> = &[\n [[Layer(1), NoOp, k(A)]],\n [[NoOp, Layer(2), k(B)]],\n [[\n NoOp,\n NoOp,\n TapDance(&crate::action::TapDance {\n timeout: 100,\n actions: &[&Trans, &k(X)],\n config: TapDanceConfig::Lazy,\n }),\n ]],\n ];\n let mut layout = Layout::new(LAYERS);\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 2));\n for _ in 0..10 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Release(0, 2));\n for _ in 0..90 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_trans_in_tapdance_eager() {\n static LAYERS: Layers<3, 1> = &[\n [[Layer(1), NoOp, k(A)]],\n [[NoOp, Layer(2), k(B)]],\n [[\n NoOp,\n NoOp,\n TapDance(&crate::action::TapDance {\n timeout: 100,\n actions: &[&Trans, &k(X)],\n config: TapDanceConfig::Eager,\n }),\n ]],\n ];\n let mut layout = Layout::new(LAYERS);\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 2));\n for _ in 0..10 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B], layout.keycodes());\n }\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_trans_in_multi() {\n static LAYERS: Layers<3, 1> = &[\n [[Layer(1), NoOp, k(A)]],\n [[NoOp, Layer(2), k(B)]],\n [[NoOp, NoOp, MultipleActions(&[Trans, k(X)].as_slice())]],\n ];\n let mut layout = Layout::new(LAYERS);\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 2));\n for _ in 0..10 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B, X], layout.keycodes());\n }\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_trans_in_chords() {\n const GROUP: ChordsGroup = ChordsGroup {\n coords: &[((0, 2), 1), ((0, 3), 2)],\n chords: &[(1, &Trans), (2, &Trans), (3, &KeyCode(X))],\n timeout: 100,\n };\n static LAYERS: Layers<4, 1> = &[\n [[Layer(1), NoOp, k(A), k(B)]],\n [[NoOp, Layer(2), k(C), k(D)]],\n [[NoOp, NoOp, Chords(&GROUP), Chords(&GROUP)]],\n ];\n let mut layout = Layout::new(LAYERS);\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 2));\n for _ in 0..10 {\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[C], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_trans_in_fork() {\n static LAYERS: Layers<3, 1> = &[\n [[Layer(1), NoOp, k(A)]],\n [[NoOp, Layer(2), k(B)]],\n [[\n NoOp,\n NoOp,\n Fork(&ForkConfig {\n left: Trans,\n right: Trans,\n right_triggers: &[Space],\n }),\n ]],\n ];\n let mut layout = Layout::new(LAYERS);\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B], layout.keycodes());\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_trans_in_switch() {\n static LAYERS: Layers<3, 1> = &[\n [[Layer(1), NoOp, k(A)]],\n [[NoOp, Layer(2), k(B)]],\n [[\n NoOp,\n NoOp,\n Switch(&switch::Switch {\n cases: &[(&[], &Trans, BreakOrFallthrough::Break)],\n }),\n ]],\n ];\n let mut layout = Layout::new(LAYERS);\n layout.trans_resolution_behavior_v2 = true;\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n layout.event(Press(0, 2));\n // No idea why we have to wait 2 ticks here. Is this a bug in switch?\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B], layout.keycodes());\n\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n #[test]\n fn test_multiple_taphold_trans() {\n static LAYERS: Layers<4, 1> = &[\n [[Layer(1), NoOp, NoOp, k(A)]],\n [[\n NoOp,\n Layer(2),\n NoOp,\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 50,\n hold: k(B),\n timeout_action: k(B),\n tap: Trans,\n config: HoldTapConfig::Default,\n tap_hold_interval: 200,\n }),\n ]],\n [[\n NoOp,\n NoOp,\n Layer(3),\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 50,\n hold: k(C),\n timeout_action: k(C),\n tap: Trans,\n config: HoldTapConfig::Default,\n tap_hold_interval: 200,\n }),\n ]],\n [[\n NoOp,\n NoOp,\n NoOp,\n HoldTap(&HoldTapAction {\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n timeout: 50,\n hold: k(D),\n timeout_action: k(D),\n tap: Trans,\n config: HoldTapConfig::Default,\n tap_hold_interval: 200,\n }),\n ]],\n ];\n let mut layout = Layout::new(LAYERS);\n\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 3));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 3));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 3));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[A], layout.keycodes());\n }\n\n #[test]\n fn trans_in_multi_works_with_all_trans_settings() {\n let permutations: &[(bool, bool)] =\n &[(false, false), (false, true), (true, false), (true, true)];\n\n for &(trans_v2, delegate_to_1st) in permutations {\n static DEFSRC_LAYER: [Action; 3] = [NoOp, NoOp, k(X)];\n static LAYERS: Layers<3, 1> = &[\n [[\n Layer(1),\n DefaultLayer(1),\n MultipleActions(&[Trans, k(Y)].as_slice()),\n ]],\n [[NoOp, Layer(2), k(B)]],\n [[NoOp, NoOp, Trans]],\n ];\n for &do_layer_switch in &[false, true] {\n let mut layout = Layout::new_with_trans_action_settings(\n &DEFSRC_LAYER,\n LAYERS,\n trans_v2,\n delegate_to_1st,\n );\n\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[X, Y], layout.keycodes());\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n if do_layer_switch {\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Release(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n assert_eq!(layout.default_layer, 1);\n } else {\n layout.event(Press(0, 0));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[B], layout.keycodes());\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n\n layout.event(Press(0, 1));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n layout.event(Press(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(\n match (trans_v2, delegate_to_1st) {\n (false, false) => &[X],\n (false, true) => &[X, Y],\n (true, _) => &[B],\n },\n layout.keycodes(),\n );\n layout.event(Release(0, 2));\n assert_eq!(CustomEvent::NoEvent, layout.tick());\n assert_keys(&[], layout.keycodes());\n }\n }\n }\n\n #[cfg(feature = \"tap_hold_tracker\")]\n #[test]\n fn hold_activated_is_set_on_hold_timeout() {\n static LAYERS: Layers<1, 1> = &[[[HoldTap(&HoldTapAction {\n timeout: 5,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n })]]];\n let mut layout = Layout::new(LAYERS);\n // Nothing set initially.\n assert!(layout.tap_hold_tracker.take_hold_activated().is_none());\n\n layout.event(Press(0, 0));\n for _ in 0..6 {\n let _ = layout.tick();\n }\n // Hold action should be active.\n assert_keys(&[LAlt], layout.keycodes());\n\n // Flag should be set exactly once.\n let info = layout\n .tap_hold_tracker\n .take_hold_activated()\n .expect(\"hold_activated should be set\");\n assert_eq!(info.coord, (0, 0));\n assert!(layout.tap_hold_tracker.take_hold_activated().is_none());\n }\n\n #[cfg(feature = \"tap_hold_tracker\")]\n #[test]\n fn tap_activated_is_set_on_tap_release() {\n static LAYERS: Layers<2, 1> = &[[[\n HoldTap(&HoldTapAction {\n timeout: 200,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::Default,\n tap_hold_interval: 0,\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n }),\n k(A),\n ]]];\n let mut layout = Layout::new(LAYERS);\n assert!(layout.tap_hold_tracker.take_tap_activated().is_none());\n\n // Quick press and release triggers tap.\n layout.event(Press(0, 0));\n let _ = layout.tick();\n layout.event(Release(0, 0));\n let _ = layout.tick();\n\n assert_keys(&[Space], layout.keycodes());\n let info = layout\n .tap_hold_tracker\n .take_tap_activated()\n .expect(\"tap_activated should be set\");\n assert_eq!(info.coord, (0, 0));\n assert!(layout.tap_hold_tracker.take_tap_activated().is_none());\n }\n\n #[cfg(feature = \"tap_hold_tracker\")]\n #[test]\n fn hold_activated_is_set_on_permissive_hold() {\n static LAYERS: Layers<2, 1> = &[[[\n HoldTap(&HoldTapAction {\n timeout: 200,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::PermissiveHold,\n tap_hold_interval: 0,\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n }),\n k(A),\n ]]];\n let mut layout = Layout::new(LAYERS);\n assert!(layout.tap_hold_tracker.take_hold_activated().is_none());\n\n // PermissiveHold: press hold-tap key, press another key, release it => hold.\n layout.event(Press(0, 0));\n let _ = layout.tick();\n layout.event(Press(0, 1));\n let _ = layout.tick();\n layout.event(Release(0, 1));\n let _ = layout.tick();\n\n assert_keys(&[LAlt], layout.keycodes());\n let info = layout\n .tap_hold_tracker\n .take_hold_activated()\n .expect(\"hold_activated should be set via waiting_into_hold\");\n assert_eq!(info.coord, (0, 0));\n assert!(layout.tap_hold_tracker.take_tap_activated().is_none());\n }\n\n #[cfg(feature = \"tap_hold_tracker\")]\n #[test]\n fn hold_activated_is_set_on_hold_on_other_key_press() {\n static LAYERS: Layers<2, 1> = &[[[\n HoldTap(&HoldTapAction {\n timeout: 200,\n hold: k(LAlt),\n timeout_action: k(LAlt),\n tap: k(Space),\n config: HoldTapConfig::HoldOnOtherKeyPress,\n tap_hold_interval: 0,\n on_press_reset_timeout_to: None,\n require_prior_idle: None,\n }),\n k(A),\n ]]];\n let mut layout = Layout::new(LAYERS);\n assert!(layout.tap_hold_tracker.take_hold_activated().is_none());\n\n // HoldOnOtherKeyPress: press hold-tap key, then press another key => hold.\n layout.event(Press(0, 0));\n let _ = layout.tick();\n layout.event(Press(0, 1));\n let _ = layout.tick();\n\n assert_keys(&[LAlt], layout.keycodes());\n let info = layout\n .tap_hold_tracker\n .take_hold_activated()\n .expect(\"hold_activated should be set via waiting_into_hold\");\n assert_eq!(info.coord, (0, 0));\n assert!(layout.tap_hold_tracker.take_tap_activated().is_none());\n }\n\n #[test]\n fn chord_does_not_set_tap_hold_activated() {\n const GROUP: ChordsGroup = ChordsGroup {\n coords: &[((0, 0), 1), ((0, 1), 2)],\n chords: &[(3, &KeyCode(Kb5))],\n timeout: 100,\n };\n static LAYERS: Layers<2, 1> = &[[[Chords(&GROUP), Chords(&GROUP)]]];\n\n let mut layout = Layout::new(LAYERS);\n layout.event(Press(0, 0));\n for _ in 0..50 {\n let _ = layout.tick();\n }\n layout.event(Press(0, 1));\n for _ in 0..50 {\n let _ = layout.tick();\n }\n assert_keys(&[Kb5], layout.keycodes());\n // Chord resolution must not set tap or hold activated flags.\n assert!(layout.tap_hold_tracker.take_hold_activated().is_none());\n assert!(layout.tap_hold_tracker.take_tap_activated().is_none());\n }\n\n #[test]\n fn tap_dance_does_not_set_tap_hold_activated() {\n static LAYERS: Layers<2, 1> = &[[[\n TapDance(&crate::action::TapDance {\n timeout: 100,\n actions: &[&k(LShift), &k(LCtrl)],\n config: TapDanceConfig::Lazy,\n }),\n k(A),\n ]]];\n\n let mut layout = Layout::new(LAYERS);\n // Single tap, wait for timeout.\n layout.event(Press(0, 0));\n for _ in 0..101 {\n let _ = layout.tick();\n }\n assert_keys(&[LShift], layout.keycodes());\n // Tap-dance resolution must not set tap or hold activated flags.\n assert!(layout.tap_hold_tracker.take_hold_activated().is_none());\n assert!(layout.tap_hold_tracker.take_tap_activated().is_none());\n }\n}\n" }, { "path": "keyberon/src/lib.rs", "content": "//! This is a fork intended for use by the [kanata keyboard remapper software](https://github.com/jtroo/kanata).\n//! Please make contributions to the original project.\n\npub mod action;\npub mod chord;\npub mod key_code;\npub mod layout;\nmod multikey_buffer;\npub mod tap_hold_tracker;\n" }, { "path": "keyberon/src/multikey_buffer.rs", "content": "//! Module for `MultiKeyBuffer`.\n\nuse std::{array, slice};\n\nuse crate::action::{Action, ONE_SHOT_MAX_ACTIVE};\nuse crate::key_code::KeyCode;\n\n// Presumably this should be plenty.\n// ONE_SHOT_MAX_ACTIVE is already likely unreasonably large enough.\n// This buffer capacity adds more onto that,\n// just in case somebody finds a way to use all of the one-shot capacity.\nconst BUFCAP: usize = ONE_SHOT_MAX_ACTIVE + 4;\n\n/// This is an unsafe container that enables a mutable Action::MultipleKeyCodes.\npub(crate) struct MultiKeyBuffer<'a, T> {\n buf: [KeyCode; BUFCAP],\n size: usize,\n ptr: *mut &'static [KeyCode],\n ac: *mut Action<'a, T>,\n}\n\nunsafe impl Send for MultiKeyBuffer<'_, T> {}\n\nimpl<'a, T> MultiKeyBuffer<'a, T> {\n /// Create a new instance of `MultiKeyBuffer`.\n ///\n /// # Safety\n ///\n /// The program should not have any references to the inner buffer when the struct is dropped.\n pub(crate) unsafe fn new() -> Self {\n Self {\n buf: array::from_fn(|_| KeyCode::Escape),\n size: 0,\n ptr: Box::leak(Box::new(slice::from_raw_parts(\n core::ptr::NonNull::dangling().as_ptr(),\n 0,\n ))),\n ac: Box::leak(Box::new(Action::NoOp)),\n }\n }\n\n /// Set the current size of the buffer to zero.\n ///\n /// # Safety\n ///\n /// The program should not have any references to the inner buffer.\n pub(crate) unsafe fn clear(&mut self) {\n self.size = 0;\n }\n\n /// Push to the end of the buffer. If the buffer is full, this silently fails.\n ///\n /// # Safety\n ///\n /// The program should not have any references to the inner buffer.\n pub(crate) unsafe fn push(&mut self, kc: KeyCode) {\n if self.size < BUFCAP {\n self.buf[self.size] = kc;\n self.size += 1;\n }\n }\n\n /// Get a reference to the inner buffer in the form of an `Action`.\n /// The `Action` will be the variant `MultipleKeyCodes`,\n /// containing all keys that have been pushed.\n ///\n /// # Safety\n ///\n /// The program should not have any references to the inner buffer before calling.\n /// The program should not mutate the buffer after calling this function until after the\n /// returned reference is dropped.\n pub(crate) unsafe fn get_ref(&self) -> &'a Action<'a, T> {\n *self.ac = Action::NoOp;\n *self.ptr = slice::from_raw_parts(self.buf.as_ptr(), self.size);\n *self.ac = Action::MultipleKeyCodes(&*self.ptr);\n &*self.ac\n }\n}\n\nimpl Drop for MultiKeyBuffer<'_, T> {\n fn drop(&mut self) {\n unsafe {\n drop(Box::from_raw(self.ac));\n drop(Box::from_raw(self.ptr));\n }\n }\n}\n" }, { "path": "keyberon/src/tap_hold_tracker.rs", "content": "//! Tracks tap-hold activation events for external consumers (e.g. TCP broadcast).\n//!\n//! When the `tap_hold_tracker` feature is enabled, this module stores the\n//! coordinate of the most recent hold/tap activation so that higher-level code\n//! can relay it over the network. When the feature is disabled the tracker is\n//! a zero-sized no-op — all setters are empty and all getters return `None`.\n//!\n//! The `config` parameter on the setters accepts a `&WaitingConfig` reference;\n//! the `matches!` guard lives inside the method body so that the no-op stub's\n//! empty body causes the compiler to eliminate the call entirely.\n\n#[cfg(feature = \"tap_hold_tracker\")]\nmod inner {\n use crate::layout::{KCoord, WaitingConfig};\n\n /// Information about a tap-hold key that just transitioned to hold state.\n #[derive(Debug, Clone, Copy)]\n pub struct HoldActivatedInfo {\n /// The key coordinate (row, column).\n pub coord: KCoord,\n }\n\n /// Information about a tap-hold key that just triggered its tap action.\n #[derive(Debug, Clone, Copy)]\n pub struct TapActivatedInfo {\n /// The key coordinate (row, column).\n pub coord: KCoord,\n }\n\n /// Records the most recent tap-hold activation event.\n #[derive(Debug, Default)]\n pub struct TapHoldTracker {\n hold_activated: Option,\n tap_activated: Option,\n }\n\n impl TapHoldTracker {\n pub(crate) fn set_hold_activated<'a, T: std::fmt::Debug>(\n &mut self,\n coord: KCoord,\n config: &WaitingConfig<'a, T>,\n ) {\n if matches!(config, WaitingConfig::HoldTap(..)) {\n self.hold_activated = Some(HoldActivatedInfo { coord });\n }\n }\n\n pub(crate) fn set_tap_activated<'a, T: std::fmt::Debug>(\n &mut self,\n coord: KCoord,\n config: &WaitingConfig<'a, T>,\n ) {\n if matches!(config, WaitingConfig::HoldTap(..)) {\n self.tap_activated = Some(TapActivatedInfo { coord });\n }\n }\n\n pub fn take_hold_activated(&mut self) -> Option {\n self.hold_activated.take()\n }\n\n pub fn take_tap_activated(&mut self) -> Option {\n self.tap_activated.take()\n }\n }\n}\n\n#[cfg(not(feature = \"tap_hold_tracker\"))]\nmod inner {\n use crate::layout::{KCoord, WaitingConfig};\n\n /// Stub: no coordinate data stored when the feature is disabled.\n #[derive(Debug, Clone, Copy)]\n pub struct HoldActivatedInfo {\n /// The key coordinate (row, column).\n pub coord: KCoord,\n }\n\n /// Stub: no coordinate data stored when the feature is disabled.\n #[derive(Debug, Clone, Copy)]\n pub struct TapActivatedInfo {\n /// The key coordinate (row, column).\n pub coord: KCoord,\n }\n\n /// Zero-sized no-op tracker when the feature is disabled.\n #[derive(Debug, Default)]\n pub struct TapHoldTracker;\n\n impl TapHoldTracker {\n #[inline(always)]\n pub(crate) fn set_hold_activated<'a, T: std::fmt::Debug>(\n &mut self,\n _coord: KCoord,\n _config: &WaitingConfig<'a, T>,\n ) {\n }\n\n #[inline(always)]\n pub(crate) fn set_tap_activated<'a, T: std::fmt::Debug>(\n &mut self,\n _coord: KCoord,\n _config: &WaitingConfig<'a, T>,\n ) {\n }\n\n #[inline(always)]\n pub fn take_hold_activated(&mut self) -> Option {\n None\n }\n\n #[inline(always)]\n pub fn take_tap_activated(&mut self) -> Option {\n None\n }\n }\n}\n\npub use inner::*;\n" }, { "path": "parser/.gitignore", "content": "# Ignore Cargo.lock since this is a library crate\nCargo.lock\ntarget" }, { "path": "parser/Cargo.toml", "content": "[package]\nname = \"kanata-parser\"\nversion = \"0.1110.0\"\nauthors = [\"jtroo \"]\ndescription = \"A parser for configuration language of kanata, a keyboard remapper.\"\nkeywords = [\"kanata\", \"parser\"]\nhomepage = \"https://github.com/jtroo/kanata\"\nrepository = \"https://github.com/jtroo/kanata\"\nreadme = \"README.md\"\nlicense = \"LGPL-3.0-only\"\nedition = \"2021\"\n\n[dependencies]\nanyhow = \"1\"\nbitflags = \"2.5.0\"\nbytemuck = \"1.15.0\"\nitertools = \"0.12\"\nlog = { version = \"0.4.8\", default-features = false }\nmiette = { version = \"5.7.0\", features = [\"fancy\"] }\nonce_cell = \"1\"\nordered-float = \"5.1.0\"\nparking_lot = \"0.12\"\npatricia_tree = \"0.8\"\nrustc-hash = \"1.1.0\"\nthiserror = \"1.0.38\"\n\nkanata-keyberon = { path = \"../keyberon\", version = \"0.1110.0\" }\n\n[dev-dependencies]\nsimplelog = \"0.12.0\"\n\n[features]\ncmd = []\ninterception_driver = []\ngui = []\nlsp = []\nwin_llhook_read_scancodes = []\nwin_sendinput_send_scancodes = []\nzippychord = []\n" }, { "path": "parser/LICENSE", "content": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007 Free Software Foundation, Inc. \n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n\n This version of the GNU Lesser General Public License incorporates\nthe terms and conditions of version 3 of the GNU General Public\nLicense, supplemented by the additional permissions listed below.\n\n 0. Additional Definitions.\n\n As used herein, \"this License\" refers to version 3 of the GNU Lesser\nGeneral Public License, and the \"GNU GPL\" refers to version 3 of the GNU\nGeneral Public License.\n\n \"The Library\" refers to a covered work governed by this License,\nother than an Application or a Combined Work as defined below.\n\n An \"Application\" is any work that makes use of an interface provided\nby the Library, but which is not otherwise based on the Library.\nDefining a subclass of a class defined by the Library is deemed a mode\nof using an interface provided by the Library.\n\n A \"Combined Work\" is a work produced by combining or linking an\nApplication with the Library. The particular version of the Library\nwith which the Combined Work was made is also called the \"Linked\nVersion\".\n\n The \"Minimal Corresponding Source\" for a Combined Work means the\nCorresponding Source for the Combined Work, excluding any source code\nfor portions of the Combined Work that, considered in isolation, are\nbased on the Application, and not on the Linked Version.\n\n The \"Corresponding Application Code\" for a Combined Work means the\nobject code and/or source code for the Application, including any data\nand utility programs needed for reproducing the Combined Work from the\nApplication, but excluding the System Libraries of the Combined Work.\n\n 1. Exception to Section 3 of the GNU GPL.\n\n You may convey a covered work under sections 3 and 4 of this License\nwithout being bound by section 3 of the GNU GPL.\n\n 2. Conveying Modified Versions.\n\n If you modify a copy of the Library, and, in your modifications, a\nfacility refers to a function or data to be supplied by an Application\nthat uses the facility (other than as an argument passed when the\nfacility is invoked), then you may convey a copy of the modified\nversion:\n\n a) under this License, provided that you make a good faith effort to\n ensure that, in the event an Application does not supply the\n function or data, the facility still operates, and performs\n whatever part of its purpose remains meaningful, or\n\n b) under the GNU GPL, with none of the additional permissions of\n this License applicable to that copy.\n\n 3. Object Code Incorporating Material from Library Header Files.\n\n The object code form of an Application may incorporate material from\na header file that is part of the Library. You may convey such object\ncode under terms of your choice, provided that, if the incorporated\nmaterial is not limited to numerical parameters, data structure\nlayouts and accessors, or small macros, inline functions and templates\n(ten or fewer lines in length), you do both of the following:\n\n a) Give prominent notice with each copy of the object code that the\n Library is used in it and that the Library and its use are\n covered by this License.\n\n b) Accompany the object code with a copy of the GNU GPL and this license\n document.\n\n 4. Combined Works.\n\n You may convey a Combined Work under terms of your choice that,\ntaken together, effectively do not restrict modification of the\nportions of the Library contained in the Combined Work and reverse\nengineering for debugging such modifications, if you also do each of\nthe following:\n\n a) Give prominent notice with each copy of the Combined Work that\n the Library is used in it and that the Library and its use are\n covered by this License.\n\n b) Accompany the Combined Work with a copy of the GNU GPL and this license\n document.\n\n c) For a Combined Work that displays copyright notices during\n execution, include the copyright notice for the Library among\n these notices, as well as a reference directing the user to the\n copies of the GNU GPL and this license document.\n\n d) Do one of the following:\n\n 0) Convey the Minimal Corresponding Source under the terms of this\n License, and the Corresponding Application Code in a form\n suitable for, and under terms that permit, the user to\n recombine or relink the Application with a modified version of\n the Linked Version to produce a modified Combined Work, in the\n manner specified by section 6 of the GNU GPL for conveying\n Corresponding Source.\n\n 1) Use a suitable shared library mechanism for linking with the\n Library. A suitable mechanism is one that (a) uses at run time\n a copy of the Library already present on the user's computer\n system, and (b) will operate properly with a modified version\n of the Library that is interface-compatible with the Linked\n Version.\n\n e) Provide Installation Information, but only if you would otherwise\n be required to provide such information under section 6 of the\n GNU GPL, and only to the extent that such information is\n necessary to install and execute a modified version of the\n Combined Work produced by recombining or relinking the\n Application with a modified version of the Linked Version. (If\n you use option 4d0, the Installation Information must accompany\n the Minimal Corresponding Source and Corresponding Application\n Code. If you use option 4d1, you must provide the Installation\n Information in the manner specified by section 6 of the GNU GPL\n for conveying Corresponding Source.)\n\n 5. Combined Libraries.\n\n You may place library facilities that are a work based on the\nLibrary side by side in a single library together with other library\nfacilities that are not Applications and are not covered by this\nLicense, and convey such a combined library under terms of your\nchoice, if you do both of the following:\n\n a) Accompany the combined library with a copy of the same work based\n on the Library, uncombined with any other library facilities,\n conveyed under the terms of this License.\n\n b) Give prominent notice with the combined library that part of it\n is a work based on the Library, and explaining where to find the\n accompanying uncombined form of the same work.\n\n 6. Revised Versions of the GNU Lesser General Public License.\n\n The Free Software Foundation may publish revised and/or new versions\nof the GNU Lesser General Public License from time to time. Such new\nversions will be similar in spirit to the present version, but may\ndiffer in detail to address new problems or concerns.\n\n Each version is given a distinguishing version number. If the\nLibrary as you received it specifies that a certain numbered version\nof the GNU Lesser General Public License \"or any later version\"\napplies to it, you have the option of following the terms and\nconditions either of that published version or of any later version\npublished by the Free Software Foundation. If the Library as you\nreceived it does not specify a version number of the GNU Lesser\nGeneral Public License, you may choose any version of the GNU Lesser\nGeneral Public License ever published by the Free Software Foundation.\n\n If the Library as you received it specifies that a proxy can decide\nwhether future versions of the GNU Lesser General Public License shall\napply, that proxy's public statement of acceptance of any version is\npermanent authorization for you to choose that version for the\nLibrary." }, { "path": "parser/README.md", "content": "# kanata-parser\n\nA parser for configuration language of [kanata](https://github.com/jtroo/kanata).\n\nThis crate does not follow semver. It tracks the version of kanata.\n" }, { "path": "parser/src/cfg/alloc.rs", "content": "//! This module contains a helper struct for generating 'static lifetime allocations while still\n//! keeping track of them so that they can be freed later.\n\nuse parking_lot::Mutex;\nuse std::sync::Arc;\n\n/// This struct tracks the allocations that are leaked by its provided methods and frees them when\n/// dropped. The `new` function is unsafe because dropping the struct can create dangling\n/// references. Care must be taken to ensure that all allocations made by this struct's methods are\n/// no longer referenced when the struct gets dropped.\n///\n/// In practice, this is not difficult to do in the `cfg` module which only exposes a single public\n/// method.\n///\n/// To avoid leaks, types transformed to &'static by this struct\n/// should not contain nested allocations,\n/// or if they do, the nested allocations should also\n/// be managed by this struct.\npub(crate) struct Allocations {\n allocations: Mutex>,\n}\n\n#[derive(Debug, Copy, Clone)]\npub(crate) struct Allocation {\n ptr: usize,\n len: usize,\n}\n\nimpl std::fmt::Debug for Allocations {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n f.debug_struct(\"Allocations\").finish()\n }\n}\n\nimpl Drop for Allocations {\n fn drop(&mut self) {\n log::debug!(\n \"freeing allocations of length {}\",\n self.allocations.lock().len()\n );\n for a in self.allocations.lock().iter().rev().copied() {\n log::debug!(\"freeing ptr 0x{:x} len{}\", a.ptr, a.len);\n unsafe {\n drop(Box::<[u8]>::from_raw(std::ptr::slice_from_raw_parts_mut(\n a.ptr as *mut u8,\n a.len,\n )))\n };\n }\n }\n}\n\nimpl Allocations {\n /// Create a new allocations group.\n ///\n /// # Safety\n ///\n /// Ensure that all associated allocations are no longer referenced before dropping all\n /// clones of the `Arc`.\n pub(crate) unsafe fn new() -> Arc {\n Arc::new(Self {\n allocations: Mutex::new(vec![]),\n })\n }\n\n /// Returns a `&'static T` by leaking a newly created Box of `v`.\n pub(crate) fn sref(&self, v: T) -> &'static T {\n let p = Box::into_raw(Box::new(v));\n if (p as usize) < 16 {\n panic!(\"sref bad ptr\");\n }\n log::debug!(\n \"sref type: {}, ptr:{p:?} sz:{}\",\n std::any::type_name::(),\n std::mem::size_of::()\n );\n self.allocations.lock().push(Allocation {\n ptr: p as usize,\n len: std::mem::size_of::(),\n });\n Box::leak(unsafe { Box::from_raw(p) })\n }\n\n pub(crate) fn bref_slice(&self, v: Box<[T]>) -> &'static [T] {\n // An empty slice has no backing allocation. `Box<[T]>` is a fat pointer so the leaked return\n // will contain a length of 0 and an invalid pointer.\n if !v.is_empty() {\n let p = v.as_ptr();\n log::debug!(\n \"bref_slice type: {}, ptr:{p:?} sz:{}\",\n std::any::type_name::(),\n std::mem::size_of::()\n );\n self.allocations.lock().push(Allocation {\n ptr: p as usize,\n len: std::mem::size_of::() * v.len(),\n });\n }\n Box::leak(v)\n }\n\n /// Returns a &'static [&'static T] from a `Vec` by converting to a boxed slice and leaking it.\n pub(crate) fn sref_vec(&self, v: Vec) -> &'static [T] {\n log::debug!(\"sref_vec {}\", std::any::type_name::());\n self.bref_slice(v.into_boxed_slice())\n }\n\n /// Returns a `&'static [&'static T]` by leaking a newly created box and boxed slice of `v`.\n pub(crate) fn sref_slice(&self, v: T) -> &'static [&'static T] {\n log::debug!(\"sref_slice {}\", std::any::type_name::());\n self.bref_slice(vec![self.sref(v)].into_boxed_slice())\n }\n\n /// Returns a `&'static str` by leaking a String.\n pub(crate) fn sref_str(&self, v: String) -> &'static str {\n if !v.capacity() == 0 {\n \"\"\n } else {\n let len = v.len();\n let s = v.leak();\n self.allocations.lock().push(Allocation {\n ptr: s.as_ptr() as usize,\n len,\n });\n s\n }\n }\n}\n" }, { "path": "parser/src/cfg/arbitrary_code.rs", "content": "use super::*;\n\nuse crate::bail;\nuse anyhow::anyhow;\n\npub(crate) fn parse_arbitrary_code(\n ac_params: &[SExpr],\n s: &ParserState,\n) -> Result<&'static KanataAction> {\n const ERR_MSG: &str = \"arbitrary code expects one parameter: \";\n if ac_params.len() != 1 {\n bail!(\"{ERR_MSG}\");\n }\n let code = ac_params[0]\n .atom(s.vars())\n .map(str::parse::)\n .and_then(|c| c.ok())\n .ok_or_else(|| anyhow!(\"{ERR_MSG}: got {:?}\", ac_params[0]))?;\n Ok(s.a.sref(Action::Custom(\n s.a.sref(s.a.sref_slice(CustomAction::SendArbitraryCode(code))),\n )))\n}\n" }, { "path": "parser/src/cfg/caps_word.rs", "content": "use super::*;\n\nuse crate::bail;\n\npub(crate) fn parse_caps_word(\n ac_params: &[SExpr],\n repress_behaviour: CapsWordRepressBehaviour,\n s: &ParserState,\n) -> Result<&'static KanataAction> {\n const ERR_STR: &str = \"caps-word expects 1 param: \";\n if ac_params.len() != 1 {\n bail!(\"{ERR_STR}\\nFound {} params instead of 1\", ac_params.len());\n }\n let timeout = parse_non_zero_u16(&ac_params[0], s, \"timeout\")?;\n Ok(s.a.sref(Action::Custom(s.a.sref(s.a.sref_slice(\n CustomAction::CapsWord(CapsWordCfg {\n repress_behaviour,\n keys_to_capitalize: &[\n KeyCode::A,\n KeyCode::B,\n KeyCode::C,\n KeyCode::D,\n KeyCode::E,\n KeyCode::F,\n KeyCode::G,\n KeyCode::H,\n KeyCode::I,\n KeyCode::J,\n KeyCode::K,\n KeyCode::L,\n KeyCode::M,\n KeyCode::N,\n KeyCode::O,\n KeyCode::P,\n KeyCode::Q,\n KeyCode::R,\n KeyCode::S,\n KeyCode::T,\n KeyCode::U,\n KeyCode::V,\n KeyCode::W,\n KeyCode::X,\n KeyCode::Y,\n KeyCode::Z,\n KeyCode::Minus,\n ],\n keys_nonterminal: &[\n KeyCode::Kb0,\n KeyCode::Kb1,\n KeyCode::Kb2,\n KeyCode::Kb3,\n KeyCode::Kb4,\n KeyCode::Kb5,\n KeyCode::Kb6,\n KeyCode::Kb7,\n KeyCode::Kb8,\n KeyCode::Kb9,\n KeyCode::Kp0,\n KeyCode::Kp1,\n KeyCode::Kp2,\n KeyCode::Kp3,\n KeyCode::Kp4,\n KeyCode::Kp5,\n KeyCode::Kp6,\n KeyCode::Kp7,\n KeyCode::Kp8,\n KeyCode::Kp9,\n KeyCode::BSpace,\n KeyCode::Delete,\n KeyCode::Up,\n KeyCode::Down,\n KeyCode::Left,\n KeyCode::Right,\n ],\n timeout,\n }),\n )))))\n}\n\npub(crate) fn parse_caps_word_custom(\n ac_params: &[SExpr],\n repress_behaviour: CapsWordRepressBehaviour,\n s: &ParserState,\n) -> Result<&'static KanataAction> {\n const ERR_STR: &str = \"caps-word-custom expects 3 param: \";\n if ac_params.len() != 3 {\n bail!(\"{ERR_STR}\\nFound {} params instead of 3\", ac_params.len());\n }\n let timeout = parse_non_zero_u16(&ac_params[0], s, \"timeout\")?;\n Ok(s.a.sref(Action::Custom(\n s.a.sref(\n s.a.sref_slice(CustomAction::CapsWord(CapsWordCfg {\n repress_behaviour,\n keys_to_capitalize: s.a.sref_vec(\n parse_key_list(&ac_params[1], s, \"keys-to-capitalize\")?\n .into_iter()\n .map(KeyCode::from)\n .collect(),\n ),\n keys_nonterminal: s.a.sref_vec(\n parse_key_list(&ac_params[2], s, \"extra-non-terminal-keys\")?\n .into_iter()\n .map(KeyCode::from)\n .collect(),\n ),\n timeout,\n })),\n ),\n )))\n}\n" }, { "path": "parser/src/cfg/chord.rs", "content": "use itertools::Itertools;\nuse kanata_keyberon::chord::{ChordV2, ChordsForKey, ChordsForKeys, ReleaseBehaviour};\nuse rustc_hash::{FxHashMap, FxHashSet};\n\nuse std::fs;\n\nuse crate::{anyhow_expr, bail_expr};\n\nuse super::*;\n\npub(crate) fn parse_defchordv2(\n exprs: &[SExpr],\n s: &ParserState,\n) -> Result> {\n if exprs[0].atom(None).expect(\"should be atom\") == \"defchordsv2-experimental\" {\n log::warn!(\n \"You should replace defchordsv2-experimental with defchordsv2.\\n\\\n Using -experimental will be invalid in the future.\"\n );\n }\n\n let mut chunks = exprs[1..].chunks_exact(5);\n let mut chords_container = ChordsForKeys::<'static, KanataCustom> {\n mapping: FxHashMap::default(),\n };\n\n let mut all_participating_key_sets = FxHashSet::default();\n\n let all_chords = chunks\n .by_ref()\n .flat_map(|chunk| match chunk[0] {\n // Match a line like\n // (include filename.txt) () 100 all-released (layer1 layer2)\n SExpr::List(Spanned {\n t: ref exprs,\n span: _,\n }) if matches!(exprs.first(), Some(SExpr::Atom(a)) if a.t == \"include\") => {\n let file_name = exprs[1].atom(s.vars()).unwrap();\n let chord_translation = ChordTranslation::create(\n file_name,\n &chunk[2],\n &chunk[3],\n &chunk[4],\n &s.layers[0][0],\n );\n let chord_definitions = parse_chord_file(file_name).unwrap();\n let processed = chord_definitions.iter().map(|chord_def| {\n let chunk = chord_translation.translate_chord(chord_def);\n parse_single_chord(&chunk, s, &mut all_participating_key_sets)\n });\n Ok::<_, ParseError>(processed.collect_vec())\n }\n _ => Ok(vec![parse_single_chord(\n chunk,\n s,\n &mut all_participating_key_sets,\n )]),\n })\n .flat_map(|vec_result| vec_result.into_iter())\n .collect::>>();\n let unsuccessful = all_chords\n .iter()\n .filter_map(|r| r.as_ref().err())\n .collect::>();\n if let Some(e) = unsuccessful.first() {\n return Err((*e).clone());\n }\n\n let successful = all_chords.into_iter().filter_map(Result::ok).collect_vec();\n for chord in successful {\n for pkey in chord.participating_keys.iter().copied() {\n //log::trace!(\"chord for key:{pkey:?} > {chord:?}\");\n chords_container\n .mapping\n .entry(pkey)\n .or_insert(ChordsForKey { chords: vec![] })\n .chords\n .push(s.a.sref(chord.clone()));\n }\n }\n let rem = chunks.remainder();\n if !rem.is_empty() {\n bail_expr!(\n rem.last().unwrap(),\n \"Incomplete chord entry. Each chord entry must have 5 items:\\n\\\n participating-keys, action, timeout, release-type, disabled-layers\"\n );\n }\n Ok(chords_container)\n}\n\nfn parse_single_chord(\n chunk: &[SExpr],\n s: &ParserState,\n all_participating_key_sets: &mut FxHashSet>,\n) -> Result> {\n let participants = parse_participating_keys(&chunk[0], s)?;\n if !all_participating_key_sets.insert(participants.clone()) {\n bail_expr!(\n &chunk[0],\n \"Duplicate participating-keys, key sets may be used only once.\"\n );\n }\n let action = parse_action(&chunk[1], s)?;\n let timeout = parse_timeout(&chunk[2], s)?;\n let release_behaviour = parse_release_behaviour(&chunk[3], s)?;\n let disabled_layers = parse_disabled_layers(&chunk[4], s)?;\n let chord: ChordV2<'static, KanataCustom> = ChordV2 {\n action,\n participating_keys: s.a.sref_vec(participants.clone()),\n pending_duration: timeout,\n disabled_layers: s.a.sref_vec(disabled_layers),\n release_behaviour,\n };\n Ok(s.a.sref(chord).clone())\n}\n\nfn parse_participating_keys(keys: &SExpr, s: &ParserState) -> Result> {\n let mut participants = keys\n .list(s.vars())\n .map(|l| {\n l.iter()\n .try_fold(vec![], |mut keys, key| -> Result> {\n let k = key.atom(s.vars()).and_then(str_to_oscode).ok_or_else(|| {\n anyhow_expr!(\n key,\n \"The first chord item must be a list of keys.\\nInvalid key name.\"\n )\n })?;\n keys.push(k.into());\n Ok(keys)\n })\n })\n .ok_or_else(|| anyhow_expr!(keys, \"The first chord item must be a list of keys.\"))??;\n if participants.len() < 2 {\n bail_expr!(keys, \"The minimum number of participating chord keys is 2\");\n }\n participants.sort();\n Ok(participants)\n}\n\nfn parse_timeout(chunk: &SExpr, s: &ParserState) -> Result {\n let timeout = parse_non_zero_u16(chunk, s, \"chord timeout\")?;\n Ok(timeout)\n}\n\nfn parse_release_behaviour(\n release_behaviour_string: &SExpr,\n s: &ParserState,\n) -> Result {\n let release_behaviour = release_behaviour_string\n .atom(s.vars())\n .and_then(|r| {\n Some(match r {\n \"first-release\" => ReleaseBehaviour::OnFirstRelease,\n \"all-released\" => ReleaseBehaviour::OnLastRelease,\n _ => return None,\n })\n })\n .ok_or_else(|| {\n anyhow_expr!(\n release_behaviour_string,\n \"Chord release behaviour must be one of:\\n\\\n first-release | all-released\"\n )\n })?;\n Ok(release_behaviour)\n}\n\nfn parse_disabled_layers(disabled_layers: &SExpr, s: &ParserState) -> Result> {\n let disabled_layers = disabled_layers\n .list(s.vars())\n .map(|dl| {\n dl.iter()\n .try_fold(vec![], |mut layers, layer| -> Result> {\n let l_idx = layer\n .atom(s.vars())\n .and_then(|l| s.layer_idxs.get(l))\n .ok_or_else(|| anyhow_expr!(layer, \"Not a known layer name.\"))?;\n layers.push((*l_idx) as u16);\n Ok(layers)\n })\n })\n .ok_or_else(|| {\n anyhow_expr!(\n disabled_layers,\n \"Disabled layers must be a list of layer names\"\n )\n })??;\n Ok(disabled_layers)\n}\n\nfn parse_chord_file(file_name: &str) -> Result> {\n let input_data =\n fs::read_to_string(file_name).unwrap_or_else(|_| panic!(\"Unable to read file {file_name}\"));\n let parsed_chords = parse_input(&input_data).unwrap();\n Ok(parsed_chords)\n}\n\nfn parse_input(input: &str) -> Result> {\n input\n .lines()\n .filter(|line| !line.trim().is_empty() && !line.trim().starts_with(\"//\"))\n .map(|line| {\n let mut caps = line.split('\\t');\n let error_message = format!(\n \"Each line needs to have an action separated by a tab character, got '{line}'\"\n );\n let keys = caps.next().expect(&error_message);\n let action = caps.next().expect(&error_message);\n Ok(ChordDefinition {\n keys: keys.to_string(),\n action: action.to_string(),\n })\n })\n .collect()\n}\n\n#[derive(Debug)]\nstruct ChordDefinition {\n keys: String,\n action: String,\n}\n\nstruct ChordTranslation<'a> {\n file_name: &'a str,\n target_map: FxHashMap,\n postprocess_map: FxHashMap,\n timeout: &'a SExpr,\n release_behaviour: &'a SExpr,\n disabled_layers: &'a SExpr,\n}\n\nimpl<'a> ChordTranslation<'a> {\n fn create(\n file_name: &'a str,\n timeout: &'a SExpr,\n release_behaviour: &'a SExpr,\n disabled_layers: &'a SExpr,\n first_layer: &[Action<'static, &&[&CustomAction]>],\n ) -> Self {\n let postprocess_map: FxHashMap = [\n (\"semicolon\", \";\"),\n (\"colon\", \"S-.\"),\n (\"slash\", \"/\"),\n (\"apostrophe\", \"'\"),\n (\"dot\", \".\"),\n (\" \", \"spc\"),\n ]\n .iter()\n .cloned()\n .map(|(k, v)| (k.to_string(), v.to_string()))\n .collect();\n let target_map = first_layer\n .iter()\n .enumerate()\n .filter_map(|(idx, layout)| {\n layout\n .key_codes()\n .next()\n .map(|kc| kc.to_string().to_lowercase())\n .zip(\n idx.try_into()\n .ok()\n .and_then(OsCode::from_u16)\n .map(|osc| osc.to_string().to_lowercase()),\n )\n })\n .collect::>()\n .into_iter()\n .chain(vec![(\" \".to_string(), \"spc\".to_string())])\n .collect::>();\n ChordTranslation {\n file_name,\n target_map,\n postprocess_map,\n timeout,\n release_behaviour,\n disabled_layers,\n }\n }\n\n fn post_process(&self, converted: &str) -> String {\n self.postprocess_map\n .get(converted)\n .map(|c| c.to_string())\n .unwrap_or_else(|| {\n if converted.chars().all(|c| c.is_uppercase()) {\n format!(\"S-{}\", converted.to_lowercase())\n } else {\n converted.to_string()\n }\n })\n }\n\n fn participant_keys(&self, keys: &str) -> Vec {\n keys.chars()\n .map(|key| {\n self.target_map\n .get(key.to_string().to_lowercase().as_str())\n .map(|c| self.postprocess_map.get(c).unwrap_or(c).to_string())\n .unwrap_or_else(|| key.to_string())\n })\n .collect::>()\n }\n\n fn action(&self, action: &str) -> Vec {\n let mut action_strings = action\n .chars()\n .map(|c| self.post_process(&c.to_string()))\n .collect_vec();\n // Wait 50ms for one-shot Shift to release\n // TODO: This would be better handled by a (multi (release-key lsft)(release-key rsft))\n // but I haven't gotten that to work yet.\n action_strings.insert(1, \"50\".to_string());\n action_strings.extend_from_slice(&[\n \"sldr\".to_string(),\n \"spc\".to_string(),\n \"nop0\".to_string(),\n ]);\n action_strings\n }\n\n fn translate_chord(&self, chord_def: &ChordDefinition) -> Vec {\n let sexpr_string = format!(\n \"(({}) (macro {}))\",\n self.participant_keys(&chord_def.keys).join(\" \"),\n self.action(&chord_def.action).join(\" \")\n );\n let mut participant_action = sexpr::parse(&sexpr_string, self.file_name).unwrap()[0]\n .t\n .clone();\n participant_action.extend_from_slice(&[\n self.timeout.clone(),\n self.release_behaviour.clone(),\n self.disabled_layers.clone(),\n ]);\n participant_action\n }\n}\n" }, { "path": "parser/src/cfg/chord_v1.rs", "content": "use super::*;\n\nuse crate::anyhow_expr;\nuse crate::anyhow_span;\nuse crate::bail;\nuse crate::bail_expr;\nuse crate::bail_span;\nuse crate::err_expr;\n\n#[derive(Debug, Clone)]\npub(crate) struct ChordGroup {\n id: u16,\n name: String,\n keys: Vec,\n coords: Vec<((u8, u16), ChordKeys)>,\n chords: HashMap,\n timeout: u16,\n}\n\npub(crate) fn parse_chord(ac_params: &[SExpr], s: &ParserState) -> Result<&'static KanataAction> {\n const ERR_MSG: &str = \"Action chord expects a chords group name followed by an identifier\";\n if ac_params.len() != 2 {\n bail!(ERR_MSG);\n }\n\n let name = ac_params[0]\n .atom(s.vars())\n .ok_or_else(|| anyhow_expr!(&ac_params[0], \"{ERR_MSG}\"))?;\n let group = match s.chord_groups.get(name) {\n Some(t) => t,\n None => bail_expr!(&ac_params[0], \"Referenced unknown chord group: {}.\", name),\n };\n let chord_key_index = ac_params[1]\n .atom(s.vars())\n .map(|s| match group.keys.iter().position(|e| e == s) {\n Some(i) => Ok(i),\n None => err_expr!(\n &ac_params[1],\n r#\"Identifier \"{}\" is not used in chord group \"{}\".\"#,\n &s,\n name,\n ),\n })\n .ok_or_else(|| anyhow_expr!(&ac_params[0], \"{ERR_MSG}\"))??;\n let chord_keys: u128 = 1 << chord_key_index;\n\n // We don't yet know at this point what the entire chords group will look like nor at which\n // coords this action will end up. So instead we store a dummy action which will be properly\n // resolved in `resolve_chord_groups`.\n Ok(s.a.sref(Action::Chords(s.a.sref(ChordsGroup {\n timeout: group.timeout,\n coords: s.a.sref_vec(vec![((0, group.id), chord_keys)]),\n chords: s.a.sref_vec(vec![]),\n }))))\n}\n\npub(crate) fn parse_chord_groups(\n exprs: &[&Spanned>],\n s: &mut ParserState,\n) -> Result<()> {\n const MSG: &str = \"Incorrect number of elements found in defchords.\\nThere should be the group name, followed by timeout, followed by keys-action pairs\";\n for expr in exprs {\n let mut subexprs = check_first_expr(expr.t.iter(), \"defchords\")?;\n let name = subexprs\n .next()\n .and_then(|e| e.atom(s.vars()))\n .ok_or_else(|| anyhow_span!(expr, \"{MSG}\"))?\n .to_owned();\n let timeout = match subexprs.next() {\n Some(e) => parse_non_zero_u16(e, s, \"timeout\")?,\n None => bail_span!(expr, \"{MSG}\"),\n };\n let id = match s.chord_groups.len().try_into() {\n Ok(id) => id,\n Err(_) => bail_span!(expr, \"Maximum number of chord groups exceeded.\"),\n };\n let mut group = ChordGroup {\n id,\n name: name.clone(),\n keys: Vec::new(),\n coords: Vec::new(),\n chords: HashMap::default(),\n timeout,\n };\n // Read k-v pairs from the configuration\n while let Some(keys_expr) = subexprs.next() {\n let action = match subexprs.next() {\n Some(v) => v,\n None => bail_expr!(\n keys_expr,\n \"Key list found without action - add an action for this chord\"\n ),\n };\n let mut keys = keys_expr\n .list(s.vars())\n .map(|keys| {\n keys.iter().map(|key| {\n key.atom(s.vars()).ok_or_else(|| {\n anyhow_expr!(\n key,\n \"Chord keys cannot be lists. Invalid key name: {:?}\",\n key\n )\n })\n })\n })\n .ok_or_else(|| anyhow_expr!(keys_expr, \"Chord must be a list/set of keys\"))?;\n let mask: u128 = keys.try_fold(0, |mask, key| {\n let key = key?;\n let index = match group.keys.iter().position(|k| k == key) {\n Some(i) => i,\n None => {\n let i = group.keys.len();\n if i + 1 > MAX_CHORD_KEYS {\n bail_expr!(keys_expr, \"Maximum number of keys in a chords group ({MAX_CHORD_KEYS}) exceeded - found {}\", i + 1);\n }\n group.keys.push(key.to_owned());\n i\n }\n };\n Ok(mask | (1 << index))\n })?;\n if group.chords.insert(mask, action.clone()).is_some() {\n bail_expr!(keys_expr, \"Duplicate chord in group {name}\");\n }\n }\n if s.chord_groups.insert(name.to_owned(), group).is_some() {\n bail_span!(expr, \"Duplicate chords group: {}\", name);\n }\n }\n Ok(())\n}\n\npub(crate) fn resolve_chord_groups(layers: &mut IntermediateLayers, s: &ParserState) -> Result<()> {\n let mut chord_groups = s.chord_groups.values().cloned().collect::>();\n chord_groups.sort_by_key(|group| group.id);\n\n for layer in layers.iter() {\n for (i, row) in layer.iter().enumerate() {\n for (j, cell) in row.iter().enumerate() {\n find_chords_coords(&mut chord_groups, (i as u8, j as u16), cell);\n }\n }\n }\n\n let chord_groups = chord_groups.into_iter().map(|group| {\n // Check that all keys in the chord group have been assigned to some coordinate\n for (key_index, key) in group.keys.iter().enumerate() {\n let key_mask = 1 << key_index;\n if !group.coords.iter().any(|(_, keys)| keys & key_mask != 0) {\n bail!(\"coord group `{0}` defines unused key `{1}`, did you forget to bind `(chord {0} {1})`?\", group.name, key)\n }\n }\n\n let chords = group.chords.iter().map(|(mask, action)| {\n Ok((*mask, parse_action(action, s)?))\n }).collect::>>()?;\n\n Ok(s.a.sref(ChordsGroup {\n coords: s.a.sref_vec(group.coords),\n chords: s.a.sref_vec(chords),\n timeout: group.timeout,\n }))\n }).collect::>>()?;\n\n for layer in layers.iter_mut() {\n for row in layer.iter_mut() {\n for cell in row.iter_mut() {\n if let Some(action) = fill_chords(&chord_groups, cell, s) {\n *cell = action;\n }\n }\n }\n }\n\n Ok(())\n}\n\npub(crate) fn find_chords_coords(\n chord_groups: &mut [ChordGroup],\n coord: (u8, u16),\n action: &KanataAction,\n) {\n match action {\n Action::Chords(ChordsGroup { coords, .. }) => {\n for ((_, group_id), chord_keys) in coords.iter() {\n let group = &mut chord_groups[*group_id as usize];\n group.coords.push((coord, *chord_keys));\n }\n }\n Action::NoOp\n | Action::Trans\n | Action::Src\n | Action::Repeat\n | Action::KeyCode(_)\n | Action::MultipleKeyCodes(_)\n | Action::Layer(_)\n | Action::DefaultLayer(_)\n | Action::Sequence { .. }\n | Action::RepeatableSequence { .. }\n | Action::CancelSequences\n | Action::ReleaseState(_)\n | Action::OneShotIgnoreEventsTicks(_)\n | Action::Custom(_) => {}\n Action::HoldTap(HoldTapAction { tap, hold, .. }) => {\n find_chords_coords(chord_groups, coord, tap);\n find_chords_coords(chord_groups, coord, hold);\n }\n Action::OneShot(OneShot { action: ac, .. }) => {\n find_chords_coords(chord_groups, coord, ac);\n }\n Action::MultipleActions(actions) => {\n for ac in actions.iter() {\n find_chords_coords(chord_groups, coord, ac);\n }\n }\n Action::TapDance(TapDance { actions, .. }) => {\n for ac in actions.iter() {\n find_chords_coords(chord_groups, coord, ac);\n }\n }\n Action::Fork(ForkConfig { left, right, .. }) => {\n find_chords_coords(chord_groups, coord, left);\n find_chords_coords(chord_groups, coord, right);\n }\n Action::Switch(Switch { cases }) => {\n for case in cases.iter() {\n find_chords_coords(chord_groups, coord, case.1);\n }\n }\n }\n}\n\npub(crate) fn fill_chords(\n chord_groups: &[&'static ChordsGroup<&&[&CustomAction]>],\n action: &KanataAction,\n s: &ParserState,\n) -> Option {\n match action {\n Action::Chords(ChordsGroup { coords, .. }) => {\n let ((_, group_id), _) = coords\n .iter()\n .next()\n .expect(\"unresolved chords should have exactly one entry\");\n Some(Action::Chords(chord_groups[*group_id as usize]))\n }\n Action::NoOp\n | Action::Trans\n | Action::Repeat\n | Action::Src\n | Action::KeyCode(_)\n | Action::MultipleKeyCodes(_)\n | Action::Layer(_)\n | Action::DefaultLayer(_)\n | Action::Sequence { .. }\n | Action::RepeatableSequence { .. }\n | Action::CancelSequences\n | Action::ReleaseState(_)\n | Action::OneShotIgnoreEventsTicks(_)\n | Action::Custom(_) => None,\n Action::HoldTap(&hta @ HoldTapAction { tap, hold, .. }) => {\n let new_tap = fill_chords(chord_groups, &tap, s);\n let new_hold = fill_chords(chord_groups, &hold, s);\n if new_tap.is_some() || new_hold.is_some() {\n Some(Action::HoldTap(s.a.sref(HoldTapAction {\n hold: new_hold.unwrap_or(hold),\n tap: new_tap.unwrap_or(tap),\n ..hta\n })))\n } else {\n None\n }\n }\n Action::OneShot(&os @ OneShot { action: ac, .. }) => {\n fill_chords(chord_groups, ac, s).map(|ac| {\n Action::OneShot(s.a.sref(OneShot {\n action: s.a.sref(ac),\n ..os\n }))\n })\n }\n Action::MultipleActions(actions) => {\n let new_actions = actions\n .iter()\n .map(|ac| fill_chords(chord_groups, ac, s))\n .collect::>();\n if new_actions.iter().any(|it| it.is_some()) {\n let new_actions = new_actions\n .iter()\n .zip(**actions)\n .map(|(new_ac, ac)| new_ac.unwrap_or(*ac))\n .collect::>();\n Some(Action::MultipleActions(s.a.sref(s.a.sref_vec(new_actions))))\n } else {\n None\n }\n }\n Action::TapDance(&td @ TapDance { actions, .. }) => {\n let new_actions = actions\n .iter()\n .map(|ac| fill_chords(chord_groups, ac, s))\n .collect::>();\n if new_actions.iter().any(|it| it.is_some()) {\n let new_actions = new_actions\n .iter()\n .zip(actions)\n .map(|(new_ac, ac)| new_ac.map(|v| s.a.sref(v)).unwrap_or(*ac))\n .collect::>();\n Some(Action::TapDance(s.a.sref(TapDance {\n actions: s.a.sref_vec(new_actions),\n ..td\n })))\n } else {\n None\n }\n }\n Action::Fork(&fcfg @ ForkConfig { left, right, .. }) => {\n let new_left = fill_chords(chord_groups, &left, s);\n let new_right = fill_chords(chord_groups, &right, s);\n if new_left.is_some() || new_right.is_some() {\n Some(Action::Fork(s.a.sref(ForkConfig {\n left: new_left.unwrap_or(left),\n right: new_right.unwrap_or(right),\n ..fcfg\n })))\n } else {\n None\n }\n }\n Action::Switch(Switch { cases }) => {\n let mut new_cases = vec![];\n for case in cases.iter() {\n new_cases.push((\n case.0,\n fill_chords(chord_groups, case.1, s)\n .map(|ac| s.a.sref(ac))\n .unwrap_or(case.1),\n case.2,\n ));\n }\n Some(Action::Switch(s.a.sref(Switch {\n cases: s.a.sref_vec(new_cases),\n })))\n }\n }\n}\n" }, { "path": "parser/src/cfg/clipboard.rs", "content": "use super::*;\n\nuse crate::anyhow_expr;\nuse crate::bail;\nuse crate::bail_expr;\n\npub(crate) fn parse_clipboard_set(\n ac_params: &[SExpr],\n s: &ParserState,\n) -> Result<&'static KanataAction> {\n const ERR_MSG: &str = \"expects 1 parameter: \";\n if ac_params.len() != 1 {\n bail!(\"{CLIPBOARD_SET} {ERR_MSG}, found {}\", ac_params.len());\n }\n let expr = &ac_params[0];\n let clip_string = match expr {\n SExpr::Atom(filepath) => filepath,\n SExpr::List(_) => {\n bail_expr!(&expr, \"Clipboard string cannot be a list\")\n }\n };\n let clip_string = clip_string.t.trim_atom_quotes();\n Ok(s.a.sref(Action::Custom(s.a.sref(s.a.sref_slice(\n CustomAction::ClipboardSet(s.a.sref_str(clip_string.to_string())),\n )))))\n}\n\npub(crate) fn parse_clipboard_save(\n ac_params: &[SExpr],\n s: &ParserState,\n) -> Result<&'static KanataAction> {\n const ERR_MSG: &str = \"expects 1 parameter: \";\n if ac_params.len() != 1 {\n bail!(\"{CLIPBOARD_SAVE} {ERR_MSG}, found {}\", ac_params.len());\n }\n let id = parse_u16(&ac_params[0], s, \"clipboard save ID\")?;\n Ok(s.a.sref(Action::Custom(\n s.a.sref(s.a.sref_slice(CustomAction::ClipboardSave(id))),\n )))\n}\n\npub(crate) fn parse_clipboard_restore(\n ac_params: &[SExpr],\n s: &ParserState,\n) -> Result<&'static KanataAction> {\n const ERR_MSG: &str = \"expects 1 parameter: \";\n if ac_params.len() != 1 {\n bail!(\"{CLIPBOARD_RESTORE} {ERR_MSG}, found {}\", ac_params.len());\n }\n let id = parse_u16(&ac_params[0], s, \"clipboard save ID\")?;\n Ok(s.a.sref(Action::Custom(\n s.a.sref(s.a.sref_slice(CustomAction::ClipboardRestore(id))),\n )))\n}\n\npub(crate) fn parse_clipboard_save_swap(\n ac_params: &[SExpr],\n s: &ParserState,\n) -> Result<&'static KanataAction> {\n const ERR_MSG: &str =\n \"expects 2 parameters: \";\n if ac_params.len() != 2 {\n bail!(\"{CLIPBOARD_SAVE_SWAP} {ERR_MSG}, found {}\", ac_params.len());\n }\n let id1 = parse_u16(&ac_params[0], s, \"clipboard save ID\")?;\n let id2 = parse_u16(&ac_params[1], s, \"clipboard save ID\")?;\n Ok(s.a.sref(Action::Custom(\n s.a.sref(s.a.sref_slice(CustomAction::ClipboardSaveSwap(id1, id2))),\n )))\n}\n\npub(crate) fn parse_clipboard_save_set(\n ac_params: &[SExpr],\n s: &ParserState,\n) -> Result<&'static KanataAction> {\n const ERR_MSG: &str = \"expects 2 parameters: \";\n if ac_params.len() != 2 {\n bail!(\"{CLIPBOARD_SAVE_SET} {ERR_MSG}, found {}\", ac_params.len());\n }\n let id = parse_u16(&ac_params[0], s, \"clipboard save ID\")?;\n let save_content = ac_params[1]\n .atom(s.vars())\n .ok_or_else(|| anyhow_expr!(&ac_params[1], \"save content must be a string\"))?;\n Ok(s.a.sref(Action::Custom(s.a.sref(s.a.sref_slice(\n CustomAction::ClipboardSaveSet(id, s.a.sref_str(save_content.into())),\n )))))\n}\n" }, { "path": "parser/src/cfg/cmd.rs", "content": "use super::*;\n\nuse crate::bail;\nuse crate::bail_expr;\n\npub(crate) enum CmdType {\n /// Execute command in own thread.\n Standard,\n /// Execute command synchronously and output stdout as macro-like SExpr.\n OutputKeys,\n /// Execute command and set clipboard to output. Clipboard content is passed as stdin to the\n /// command.\n ClipboardSet,\n /// Execute command and set clipboard save id to output.\n /// Clipboard save id content is passed as stdin to the command.\n ClipboardSaveSet,\n}\n\n// Parse cmd, but there are 2 arguments before specifying normal log and error log\npub(crate) fn parse_cmd_log(ac_params: &[SExpr], s: &ParserState) -> Result<&'static KanataAction> {\n const ERR_STR: &str =\n \"cmd-log expects at least 3 strings, \";\n if !s.is_cmd_enabled {\n bail!(\n \"cmd is not enabled for this kanata executable (did you use 'cmd_allowed' variants?), but is set in the configuration\"\n );\n }\n if ac_params.len() < 3 {\n bail!(ERR_STR);\n }\n let mut cmd = vec![];\n let log_level =\n if let Some(Ok(input_mode)) = ac_params[0].atom(s.vars()).map(LogLevel::try_from_str) {\n input_mode\n } else {\n bail_expr!(&ac_params[0], \"{ERR_STR}\\n{}\", LogLevel::err_msg());\n };\n let error_log_level =\n if let Some(Ok(input_mode)) = ac_params[1].atom(s.vars()).map(LogLevel::try_from_str) {\n input_mode\n } else {\n bail_expr!(&ac_params[1], \"{ERR_STR}\\n{}\", LogLevel::err_msg());\n };\n collect_strings(&ac_params[2..], &mut cmd, s);\n if cmd.is_empty() {\n bail!(ERR_STR);\n }\n let cmds = cmd.into_iter().map(|v| s.a.sref_str(v)).collect();\n Ok(s.a.sref(Action::Custom(s.a.sref(s.a.sref_slice(\n CustomAction::CmdLog(log_level, error_log_level, s.a.sref_vec(cmds)),\n )))))\n}\n\n#[allow(unused_variables)]\npub(crate) fn parse_cmd(\n ac_params: &[SExpr],\n s: &ParserState,\n cmd_type: CmdType,\n) -> Result<&'static KanataAction> {\n #[cfg(not(feature = \"cmd\"))]\n {\n bail!(\n \"cmd is not enabled for this kanata executable. Use a cmd_allowed prebuilt executable or compile with the feature: cmd.\"\n );\n }\n #[cfg(feature = \"cmd\")]\n {\n if matches!(cmd_type, CmdType::ClipboardSaveSet) {\n const ERR_STR: &str = \"expects a save ID and at least one string\";\n if !s.is_cmd_enabled {\n bail!(\"To use cmd you must put in defcfg: danger-enable-cmd yes.\");\n }\n if ac_params.len() < 2 {\n bail!(\"{CLIPBOARD_SAVE_CMD_SET} {ERR_STR}\");\n }\n let mut cmd = vec![];\n let save_id = parse_u16(&ac_params[0], s, \"clipboard save ID\")?;\n collect_strings(&ac_params[1..], &mut cmd, s);\n if cmd.is_empty() {\n bail_expr!(&ac_params[1], \"{CLIPBOARD_SAVE_CMD_SET} {ERR_STR}\");\n }\n let cmds = cmd.into_iter().map(|v| s.a.sref_str(v)).collect();\n return Ok(s.a.sref(Action::Custom(s.a.sref(s.a.sref_slice(\n CustomAction::ClipboardSaveCmdSet(save_id, s.a.sref_vec(cmds)),\n )))));\n }\n\n const ERR_STR: &str = \"cmd expects at least one string\";\n if !s.is_cmd_enabled {\n bail!(\"To use cmd you must put in defcfg: danger-enable-cmd yes.\");\n }\n let mut cmd = vec![];\n collect_strings(ac_params, &mut cmd, s);\n if cmd.is_empty() {\n bail!(ERR_STR);\n }\n let cmds = cmd.into_iter().map(|v| s.a.sref_str(v)).collect();\n let cmds = s.a.sref_vec(cmds);\n Ok(s.a\n .sref(Action::Custom(s.a.sref(s.a.sref_slice(match cmd_type {\n CmdType::Standard => CustomAction::Cmd(cmds),\n CmdType::OutputKeys => CustomAction::CmdOutputKeys(cmds),\n CmdType::ClipboardSet => CustomAction::ClipboardCmdSet(cmds),\n CmdType::ClipboardSaveSet => unreachable!(),\n })))))\n }\n}\n\n/// Recurse through all levels of list nesting and collect into a flat list of strings.\n/// Recursion is DFS, which matches left-to-right reading of the strings as they appear,\n/// if everything was on a single line.\npub(crate) fn collect_strings(params: &[SExpr], strings: &mut Vec, s: &ParserState) {\n for param in params {\n if let Some(a) = param.atom(s.vars()) {\n strings.push(a.trim_atom_quotes().to_owned());\n } else {\n // unwrap: this must be a list, since it's not an atom.\n let l = param.list(s.vars()).unwrap();\n collect_strings(l, strings, s);\n }\n }\n}\n\n#[test]\npub(crate) fn test_collect_strings() {\n let params = r#\"(gah (squish \"squash\" (splish splosh) \"bah mah\") dah)\"#;\n let params = sexpr::parse(params, \"noexist\").unwrap();\n let mut strings = vec![];\n collect_strings(¶ms[0].t, &mut strings, &ParserState::default());\n assert_eq!(\n &strings,\n &[\n \"gah\", \"squish\", \"squash\", \"splish\", \"splosh\", \"bah mah\", \"dah\"\n ]\n );\n}\n" }, { "path": "parser/src/cfg/custom_tap_hold.rs", "content": "use kanata_keyberon::layout::{Event, KCoord, QueuedIter, REAL_KEY_ROW, WaitingAction};\n\nuse crate::keys::OsCode;\n\nuse super::alloc::Allocations;\n\n#[derive(Clone, Copy, PartialEq, Eq, Debug)]\npub(crate) enum Hand {\n Left,\n Right,\n Neutral,\n}\n\n/// Compact mapping from key codes to hand assignments.\n/// Stores only keys that have an explicit left/right assignment;\n/// any key not present is treated as `Hand::Neutral`.\n#[derive(Clone, Copy, Debug)]\npub(crate) struct HandMap {\n pub(crate) keys: &'static [u16],\n pub(crate) hands: &'static [Hand],\n}\n\nimpl HandMap {\n pub(crate) fn get(&self, key_code: u16) -> Hand {\n self.keys\n .iter()\n .position(|&k| k == key_code)\n .map(|i| self.hands[i])\n .unwrap_or(Hand::Neutral)\n }\n}\n\n#[derive(Clone, Copy, Debug)]\npub(crate) enum DecisionBehavior {\n Tap,\n Hold,\n Ignore,\n}\n\n/// The function-trait object stored inside `HoldTapConfig::Custom`.\npub(crate) type CustomTapHoldFn =\n dyn Fn(QueuedIter, KCoord) -> (Option, bool) + Send + Sync;\n\n/// Returns a closure that can be used in `HoldTapConfig::Custom`, which will return early with a\n/// Tap action in the case that any of `keys` are pressed. Otherwise it behaves as\n/// `HoldTapConfig::PermissiveHold` would.\npub(crate) fn custom_tap_hold_release(\n keys: &[OsCode],\n a: &Allocations,\n) -> &'static CustomTapHoldFn {\n let keys = a.sref_vec(Vec::from_iter(keys.iter().copied()));\n a.sref(\n move |mut queued: QueuedIter, _coord: KCoord| -> (Option, bool) {\n while let Some(q) = queued.next() {\n if q.event().is_press() {\n let (i, j) = q.event().coord();\n // If any key matches the input, do a tap right away.\n if i == REAL_KEY_ROW && keys.iter().copied().map(u16::from).any(|j2| j2 == j) {\n return (Some(WaitingAction::Tap), false);\n }\n // Otherwise do the PermissiveHold algorithm.\n let target = Event::Release(i, j);\n if queued.clone().copied().any(|q| q.event() == target) {\n return (Some(WaitingAction::Hold), false);\n }\n }\n }\n (None, false)\n },\n )\n}\n\n/// Returns a closure that can be used in `HoldTapConfig::Custom`, which will return early with a\n/// Tap action in the case that any of `keys_press_then_release_trigger_tap` are pressed and\n/// released, or if any in `keys_press_trigger_tap` are pressed (no release needed). Otherwise it\n/// behaves as `HoldTapConfig::PermissiveHold` would.\npub(crate) fn custom_tap_hold_release_trigger_tap_release(\n keys_press_trigger_tap: &[OsCode],\n keys_press_then_release_trigger_tap: &[OsCode],\n a: &Allocations,\n) -> &'static CustomTapHoldFn {\n let keys_press_then_release_trigger_tap = a.sref_vec(Vec::from_iter(\n keys_press_then_release_trigger_tap\n .iter()\n .copied()\n .map(u16::from),\n ));\n let keys_press_trigger_tap = a.sref_vec(Vec::from_iter(\n keys_press_trigger_tap.iter().copied().map(u16::from),\n ));\n a.sref(\n move |mut queued: QueuedIter, _coord: KCoord| -> (Option, bool) {\n while let Some(q) = queued.next() {\n if q.event().is_press() {\n let (i, j) = q.event().coord();\n if i != REAL_KEY_ROW {\n continue;\n }\n // If any pressed key matches the press list and has been released, do\n // a tap right away.\n if keys_press_trigger_tap.iter().copied().any(|j2| j2 == j) {\n return (Some(WaitingAction::Tap), false);\n }\n // If any pressed key matches the press-release list and has been released, do\n // a tap right away.\n if keys_press_then_release_trigger_tap\n .iter()\n .copied()\n .any(|j2| j2 == j)\n {\n let target = Event::Release(i, j);\n if queued.clone().copied().any(|q| q.event() == target) {\n return (Some(WaitingAction::Tap), false);\n }\n }\n // Otherwise do the PermissiveHold algorithm.\n let target = Event::Release(i, j);\n if queued.clone().copied().any(|q| q.event() == target) {\n return (Some(WaitingAction::Hold), false);\n }\n }\n }\n (None, false)\n },\n )\n}\n\npub(crate) fn custom_tap_hold_except(keys: &[OsCode], a: &Allocations) -> &'static CustomTapHoldFn {\n let keys = a.sref_vec(Vec::from_iter(keys.iter().copied()));\n a.sref(\n move |mut queued: QueuedIter, _coord: KCoord| -> (Option, bool) {\n for q in queued.by_ref() {\n if q.event().is_press() {\n let (_i, j) = q.event().coord();\n // If any key matches the input, do a tap.\n if keys.iter().copied().map(u16::from).any(|j2| j2 == j) {\n return (Some(WaitingAction::Tap), false);\n }\n // Otherwise continue with default behavior\n return (None, false);\n }\n }\n // Otherwise skip timeout\n (None, true)\n },\n )\n}\n\n/// Returns a closure that can be used in `HoldTapConfig::Custom`, which will return early with a\n/// Tap action in the case that any of `keys` are pressed. Unlike `custom_tap_hold_except`, if no\n/// matching key is pressed, this waits for timeout instead of skipping it.\npub(crate) fn custom_tap_hold_tap_keys(\n keys: &[OsCode],\n a: &Allocations,\n) -> &'static CustomTapHoldFn {\n let keys = a.sref_vec(Vec::from_iter(keys.iter().copied()));\n a.sref(\n move |mut queued: QueuedIter, _coord: KCoord| -> (Option, bool) {\n for q in queued.by_ref() {\n if q.event().is_press() {\n let (_i, j) = q.event().coord();\n // If any key matches the input, do a tap.\n if keys.iter().copied().map(u16::from).any(|j2| j2 == j) {\n return (Some(WaitingAction::Tap), false);\n }\n // Otherwise continue with default behavior (no early hold activation)\n }\n }\n // Wait for timeout (key difference from custom_tap_hold_except which returns true)\n (None, false)\n },\n )\n}\n\npub(crate) fn custom_tap_hold_opposite_hand(\n hand_map: &'static HandMap,\n same_hand: DecisionBehavior,\n neutral_behavior: DecisionBehavior,\n unknown_hand: DecisionBehavior,\n neutral_keys: &'static [OsCode],\n a: &Allocations,\n) -> &'static CustomTapHoldFn {\n a.sref(\n move |queued: QueuedIter, coord: KCoord| -> (Option, bool) {\n let (_row, col) = coord;\n let waiting_hand = hand_map.get(col);\n\n for q in queued {\n if !q.event().is_press() {\n continue;\n }\n let (i, j) = q.event().coord();\n if i != REAL_KEY_ROW {\n continue;\n }\n\n // Check neutral-keys first (takes precedence over defhands)\n if let Some(osc) = OsCode::from_u16(j) {\n if neutral_keys.contains(&osc) {\n match neutral_behavior {\n DecisionBehavior::Tap => return (Some(WaitingAction::Tap), false),\n DecisionBehavior::Hold => return (Some(WaitingAction::Hold), false),\n DecisionBehavior::Ignore => continue,\n }\n }\n }\n\n let pressed_hand = hand_map.get(j);\n\n match (waiting_hand, pressed_hand) {\n (Hand::Left, Hand::Right) | (Hand::Right, Hand::Left) => {\n return (Some(WaitingAction::Hold), false);\n }\n (Hand::Left, Hand::Left) | (Hand::Right, Hand::Right) => match same_hand {\n DecisionBehavior::Tap => return (Some(WaitingAction::Tap), false),\n DecisionBehavior::Hold => return (Some(WaitingAction::Hold), false),\n DecisionBehavior::Ignore => continue,\n },\n _ => {\n // At least one key is Neutral (not in defhands)\n match unknown_hand {\n DecisionBehavior::Tap => return (Some(WaitingAction::Tap), false),\n DecisionBehavior::Hold => return (Some(WaitingAction::Hold), false),\n DecisionBehavior::Ignore => continue,\n }\n }\n }\n }\n (None, false)\n },\n )\n}\n" }, { "path": "parser/src/cfg/defcfg.rs", "content": "use super::HashSet;\nuse super::sexpr::SExpr;\nuse super::{TrimAtomQuotes, error::*};\nuse crate::cfg::check_first_expr;\nuse crate::custom_action::*;\nuse crate::keys::*;\n#[allow(unused)]\nuse crate::{anyhow_expr, anyhow_span, bail, bail_expr, bail_span};\n\n#[cfg(any(target_os = \"linux\", target_os = \"android\", target_os = \"unknown\"))]\n#[derive(Copy, Clone, Debug, PartialEq, Eq)]\npub enum DeviceDetectMode {\n KeyboardOnly,\n KeyboardMice,\n Any,\n}\n#[cfg(any(target_os = \"linux\", target_os = \"android\", target_os = \"unknown\"))]\nimpl std::fmt::Display for DeviceDetectMode {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n write!(f, \"{self:?}\")\n }\n}\n\n#[cfg(any(target_os = \"linux\", target_os = \"android\", target_os = \"unknown\"))]\n#[derive(Debug, Clone)]\npub struct CfgLinuxOptions {\n pub linux_dev: Vec,\n pub linux_dev_names_include: Option>,\n pub linux_dev_names_exclude: Option>,\n pub linux_continue_if_no_devs_found: bool,\n pub linux_unicode_u_code: crate::keys::OsCode,\n pub linux_unicode_termination: UnicodeTermination,\n pub linux_x11_repeat_delay_rate: Option,\n pub linux_use_trackpoint_property: bool,\n pub linux_output_name: String,\n pub linux_output_bus_type: LinuxCfgOutputBusType,\n pub linux_device_detect_mode: Option,\n}\n#[cfg(any(target_os = \"linux\", target_os = \"android\", target_os = \"unknown\"))]\nimpl Default for CfgLinuxOptions {\n fn default() -> Self {\n Self {\n linux_dev: vec![],\n linux_dev_names_include: None,\n linux_dev_names_exclude: None,\n linux_continue_if_no_devs_found: false,\n // historically was the only option, so make KEY_U the default\n linux_unicode_u_code: crate::keys::OsCode::KEY_U,\n // historically was the only option, so make Enter the default\n linux_unicode_termination: UnicodeTermination::Enter,\n linux_x11_repeat_delay_rate: None,\n linux_use_trackpoint_property: false,\n linux_output_name: \"kanata\".to_owned(),\n linux_output_bus_type: LinuxCfgOutputBusType::BusI8042,\n linux_device_detect_mode: None,\n }\n }\n}\n#[cfg(any(target_os = \"linux\", target_os = \"android\", target_os = \"unknown\"))]\n#[derive(Debug, Clone, Copy)]\npub enum LinuxCfgOutputBusType {\n BusUsb,\n BusI8042,\n BusVirtual,\n}\n\n#[cfg(any(target_os = \"macos\", target_os = \"unknown\"))]\n#[derive(Debug, Default, Clone)]\npub struct CfgMacosOptions {\n pub macos_dev_names_include: Option>,\n pub macos_dev_names_exclude: Option>,\n}\n\n#[cfg(any(\n all(feature = \"interception_driver\", target_os = \"windows\"),\n target_os = \"unknown\"\n))]\n#[derive(Debug, Clone, Default)]\npub struct CfgWinterceptOptions {\n pub windows_interception_mouse_hwids: Option>,\n pub windows_interception_mouse_hwids_exclude: Option>,\n pub windows_interception_keyboard_hwids: Option>,\n pub windows_interception_keyboard_hwids_exclude: Option>,\n}\n\n#[cfg(any(target_os = \"windows\", target_os = \"unknown\"))]\n#[derive(Debug, Clone, Default)]\npub struct CfgWindowsOptions {\n pub windows_altgr: AltGrBehaviour,\n pub sync_keystates: bool,\n}\n\n#[cfg(all(any(target_os = \"windows\", target_os = \"unknown\"), feature = \"gui\"))]\n#[derive(Debug, Clone)]\npub struct CfgOptionsGui {\n /// File name / path to the tray icon file.\n pub tray_icon: Option,\n /// Whether to match layer names to icon files without an explicit 'icon' field\n pub icon_match_layer_name: bool,\n /// Show tooltip on layer changes showing layer icons\n pub tooltip_layer_changes: bool,\n /// Show tooltip on layer changes for the default/base layer\n pub tooltip_no_base: bool,\n /// Show tooltip on layer changes even for layers without an icon\n pub tooltip_show_blank: bool,\n /// Show tooltip on layer changes for this duration (ms)\n pub tooltip_duration: u16,\n /// Show system notification message on config reload\n pub notify_cfg_reload: bool,\n /// Disable sound for the system notification message on config reload\n pub notify_cfg_reload_silent: bool,\n /// Show system notification message on errors\n pub notify_error: bool,\n /// Set tooltip size (width, height)\n pub tooltip_size: (u16, u16),\n}\n#[cfg(all(any(target_os = \"windows\", target_os = \"unknown\"), feature = \"gui\"))]\nimpl Default for CfgOptionsGui {\n fn default() -> Self {\n Self {\n tray_icon: None,\n icon_match_layer_name: true,\n tooltip_layer_changes: false,\n tooltip_show_blank: false,\n tooltip_no_base: true,\n tooltip_duration: 500,\n notify_cfg_reload: true,\n notify_cfg_reload_silent: false,\n notify_error: true,\n tooltip_size: (24, 24),\n }\n }\n}\n\n#[derive(Debug)]\npub struct CfgOptions {\n pub process_unmapped_keys: bool,\n pub process_unmapped_keys_exceptions: Option>,\n pub block_unmapped_keys: bool,\n pub allow_hardware_repeat: bool,\n pub start_alias: Option,\n pub enable_cmd: bool,\n pub sequence_timeout: u16,\n pub sequence_input_mode: SequenceInputMode,\n pub sequence_backtrack_modcancel: bool,\n pub sequence_always_on: bool,\n pub log_layer_changes: bool,\n pub delegate_to_first_layer: bool,\n pub movemouse_inherit_accel_state: bool,\n pub movemouse_smooth_diagonals: bool,\n pub override_release_on_activation: bool,\n pub dynamic_macro_max_presses: u16,\n pub dynamic_macro_replay_delay_behaviour: ReplayDelayBehaviour,\n pub concurrent_tap_hold: bool,\n pub rapid_event_delay: u16,\n pub trans_resolution_behavior_v2: bool,\n pub chords_v2_min_idle: u16,\n pub tap_hold_require_prior_idle: u16,\n #[cfg(any(\n all(target_os = \"windows\", feature = \"interception_driver\"),\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n pub mouse_movement_key: Option,\n #[cfg(any(target_os = \"linux\", target_os = \"android\", target_os = \"unknown\"))]\n pub linux_opts: CfgLinuxOptions,\n #[cfg(any(target_os = \"macos\", target_os = \"unknown\"))]\n pub macos_opts: CfgMacosOptions,\n #[cfg(any(target_os = \"windows\", target_os = \"unknown\"))]\n pub windows_opts: CfgWindowsOptions,\n #[cfg(any(\n all(feature = \"interception_driver\", target_os = \"windows\"),\n target_os = \"unknown\"\n ))]\n pub wintercept_opts: CfgWinterceptOptions,\n #[cfg(all(any(target_os = \"windows\", target_os = \"unknown\"), feature = \"gui\"))]\n pub gui_opts: CfgOptionsGui,\n}\n\nimpl Default for CfgOptions {\n fn default() -> Self {\n Self {\n process_unmapped_keys: false,\n process_unmapped_keys_exceptions: None,\n block_unmapped_keys: false,\n allow_hardware_repeat: true,\n start_alias: None,\n enable_cmd: false,\n sequence_timeout: 1000,\n sequence_input_mode: SequenceInputMode::HiddenSuppressed,\n sequence_backtrack_modcancel: true,\n sequence_always_on: false,\n log_layer_changes: true,\n delegate_to_first_layer: false,\n movemouse_inherit_accel_state: false,\n movemouse_smooth_diagonals: false,\n override_release_on_activation: false,\n dynamic_macro_max_presses: 128,\n dynamic_macro_replay_delay_behaviour: ReplayDelayBehaviour::Recorded,\n concurrent_tap_hold: false,\n rapid_event_delay: 5,\n trans_resolution_behavior_v2: true,\n chords_v2_min_idle: 5,\n tap_hold_require_prior_idle: 0,\n #[cfg(any(\n all(target_os = \"windows\", feature = \"interception_driver\"),\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n mouse_movement_key: None,\n #[cfg(any(target_os = \"linux\", target_os = \"android\", target_os = \"unknown\"))]\n linux_opts: Default::default(),\n #[cfg(any(target_os = \"windows\", target_os = \"unknown\"))]\n windows_opts: Default::default(),\n #[cfg(any(\n all(feature = \"interception_driver\", target_os = \"windows\"),\n target_os = \"unknown\"\n ))]\n wintercept_opts: Default::default(),\n #[cfg(any(target_os = \"macos\", target_os = \"unknown\"))]\n macos_opts: Default::default(),\n #[cfg(all(any(target_os = \"windows\", target_os = \"unknown\"), feature = \"gui\"))]\n gui_opts: Default::default(),\n }\n }\n}\n\n/// Parse configuration entries from an expression starting with defcfg.\npub fn parse_defcfg(expr: &[SExpr]) -> Result {\n let mut seen_keys = HashSet::default();\n let mut cfg = CfgOptions::default();\n let mut exprs = check_first_expr(expr.iter(), \"defcfg\")?;\n let mut is_process_unmapped_keys_defined = false;\n // Read k-v pairs from the configuration\n loop {\n let key = match exprs.next() {\n Some(k) => k,\n None => {\n if !is_process_unmapped_keys_defined {\n log::warn!(\n \"The item process-unmapped-keys is not defined in defcfg. Consider whether process-unmapped-keys should be yes vs. no.\"\n );\n }\n return Ok(cfg);\n }\n };\n let val = match exprs.next() {\n Some(v) => v,\n None => bail_expr!(key, \"Found a defcfg option missing a value\"),\n };\n match key {\n SExpr::Atom(k) => {\n let label = k.t.as_str();\n if !seen_keys.insert(label) {\n bail_expr!(key, \"Duplicate defcfg option {}\", label);\n }\n match label {\n \"sequence-timeout\" => {\n cfg.sequence_timeout = parse_cfg_val_u16(val, label, true)?;\n }\n \"sequence-input-mode\" => {\n let v = sexpr_to_str_or_err(val, label)?;\n cfg.sequence_input_mode = SequenceInputMode::try_from_str(v)\n .map_err(|e| anyhow_expr!(val, \"{}\", e.to_string()))?;\n }\n \"sequence-always-on\" => {\n cfg.sequence_always_on = parse_defcfg_val_bool(val, label)?\n }\n \"dynamic-macro-max-presses\" => {\n cfg.dynamic_macro_max_presses = parse_cfg_val_u16(val, label, false)?;\n }\n \"dynamic-macro-replay-delay-behaviour\" => {\n cfg.dynamic_macro_replay_delay_behaviour = val\n .atom(None)\n .map(|v| match v {\n \"constant\" => Ok(ReplayDelayBehaviour::Constant),\n \"recorded\" => Ok(ReplayDelayBehaviour::Recorded),\n _ => bail_expr!(\n val,\n \"this option must be one of: constant | recorded\"\n ),\n })\n .ok_or_else(|| {\n anyhow_expr!(val, \"this option must be one of: constant | recorded\")\n })??;\n }\n \"linux-dev\" => {\n #[cfg(any(\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n {\n cfg.linux_opts.linux_dev = parse_dev(val)?;\n if cfg.linux_opts.linux_dev.is_empty() {\n bail_expr!(\n val,\n \"device list is empty, no devices will be intercepted\"\n );\n }\n }\n }\n \"linux-dev-names-include\" => {\n #[cfg(any(\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n {\n let dev_names = parse_dev(val)?;\n if dev_names.is_empty() {\n log::warn!(\"linux-dev-names-include is empty\");\n }\n cfg.linux_opts.linux_dev_names_include = Some(dev_names);\n }\n }\n \"linux-dev-names-exclude\" => {\n #[cfg(any(\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n {\n cfg.linux_opts.linux_dev_names_exclude = Some(parse_dev(val)?);\n }\n }\n \"linux-unicode-u-code\" => {\n #[cfg(any(\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n {\n let v = sexpr_to_str_or_err(val, label)?;\n cfg.linux_opts.linux_unicode_u_code = crate::keys::str_to_oscode(v)\n .ok_or_else(|| {\n anyhow_expr!(val, \"unknown code for {label}: {}\", v)\n })?;\n }\n }\n \"linux-unicode-termination\" => {\n #[cfg(any(\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n {\n let v = sexpr_to_str_or_err(val, label)?;\n cfg.linux_opts.linux_unicode_termination = match v {\n \"enter\" => UnicodeTermination::Enter,\n \"space\" => UnicodeTermination::Space,\n \"enter-space\" => UnicodeTermination::EnterSpace,\n \"space-enter\" => UnicodeTermination::SpaceEnter,\n _ => bail_expr!(\n val,\n \"{label} got {}. It accepts: enter|space|enter-space|space-enter\",\n v\n ),\n }\n }\n }\n \"linux-x11-repeat-delay-rate\" => {\n #[cfg(any(\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n {\n let v = sexpr_to_str_or_err(val, label)?;\n let delay_rate = v.split(',').collect::>();\n const ERRMSG: &str = \"Invalid value for linux-x11-repeat-delay-rate.\\nExpected two numbers 0-65535 separated by a comma, e.g. 200,25\";\n if delay_rate.len() != 2 {\n bail_expr!(val, \"{}\", ERRMSG)\n }\n cfg.linux_opts.linux_x11_repeat_delay_rate = Some(KeyRepeatSettings {\n delay: match str::parse::(delay_rate[0]) {\n Ok(delay) => delay,\n Err(_) => bail_expr!(val, \"{}\", ERRMSG),\n },\n rate: match str::parse::(delay_rate[1]) {\n Ok(rate) => rate,\n Err(_) => bail_expr!(val, \"{}\", ERRMSG),\n },\n });\n }\n }\n \"linux-use-trackpoint-property\" => {\n #[cfg(any(\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n {\n cfg.linux_opts.linux_use_trackpoint_property =\n parse_defcfg_val_bool(val, label)?\n }\n }\n \"linux-output-device-name\" => {\n #[cfg(any(\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n {\n let device_name = sexpr_to_str_or_err(val, label)?;\n if device_name.is_empty() {\n log::warn!(\n \"linux-output-device-name is empty, using kanata as default value\"\n );\n } else {\n cfg.linux_opts.linux_output_name = device_name.to_owned();\n }\n }\n }\n \"linux-output-device-bus-type\" => {\n let bus_type = sexpr_to_str_or_err(val, label)?;\n match bus_type {\n \"USB\" | \"I8042\" | \"virtual\" => {}\n _ => bail_expr!(\n val,\n \"Invalid value for linux-output-device-bus-type.\\nExpected one of: USB | I8042 | virtual\"\n ),\n };\n #[cfg(any(\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n {\n let bus_type = match bus_type {\n \"USB\" => LinuxCfgOutputBusType::BusUsb,\n \"I8042\" => LinuxCfgOutputBusType::BusI8042,\n \"virtual\" => LinuxCfgOutputBusType::BusVirtual,\n _ => unreachable!(\"validated earlier\"),\n };\n cfg.linux_opts.linux_output_bus_type = bus_type;\n }\n }\n \"linux-device-detect-mode\" => {\n let detect_mode = sexpr_to_str_or_err(val, label)?;\n match detect_mode {\n \"any\" | \"keyboard-only\" | \"keyboard-mice\" => {}\n _ => bail_expr!(\n val,\n \"Invalid value for linux-device-detect-mode.\\nExpected one of: any | keyboard-only | keyboard-mice\"\n ),\n };\n #[cfg(any(\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n {\n let detect_mode = Some(match detect_mode {\n \"any\" => DeviceDetectMode::Any,\n \"keyboard-only\" => DeviceDetectMode::KeyboardOnly,\n \"keyboard-mice\" => DeviceDetectMode::KeyboardMice,\n _ => unreachable!(\"validated earlier\"),\n });\n cfg.linux_opts.linux_device_detect_mode = detect_mode;\n }\n }\n \"windows-altgr\" => {\n #[cfg(any(target_os = \"windows\", target_os = \"unknown\"))]\n {\n const CANCEL: &str = \"cancel-lctl-press\";\n const ADD: &str = \"add-lctl-release\";\n let v = sexpr_to_str_or_err(val, label)?;\n cfg.windows_opts.windows_altgr = match v {\n CANCEL => AltGrBehaviour::CancelLctlPress,\n ADD => AltGrBehaviour::AddLctlRelease,\n _ => bail_expr!(\n val,\n \"Invalid value for {label}: {}. Valid values are {},{}\",\n v,\n CANCEL,\n ADD\n ),\n }\n }\n }\n \"windows-sync-keystates\" => {\n #[cfg(any(target_os = \"windows\", target_os = \"unknown\"))]\n {\n cfg.windows_opts.sync_keystates = parse_defcfg_val_bool(val, label)?;\n }\n }\n \"windows-interception-mouse-hwid\" => {\n #[cfg(any(\n all(feature = \"interception_driver\", target_os = \"windows\"),\n target_os = \"unknown\"\n ))]\n {\n if cfg\n .wintercept_opts\n .windows_interception_mouse_hwids_exclude\n .is_some()\n {\n bail_expr!(\n val,\n \"{label} and windows-interception-mouse-hwid-exclude cannot both be included\"\n );\n }\n let v = sexpr_to_str_or_err(val, label)?;\n let hwid = v;\n log::trace!(\"win hwid: {hwid}\");\n let hwid_vec = hwid\n .split(',')\n .try_fold(vec![], |mut hwid_bytes, hwid_byte| {\n hwid_byte.trim_matches(' ').parse::().map(|b| {\n hwid_bytes.push(b);\n hwid_bytes\n })\n }).map_err(|_| anyhow_expr!(val, \"{label} format is invalid. It should consist of numbers [0,255] separated by commas\"))?;\n let hwid_slice = hwid_vec.iter().copied().enumerate()\n .try_fold([0u8; HWID_ARR_SZ], |mut hwid, idx_byte| {\n let (i, b) = idx_byte;\n if i > HWID_ARR_SZ {\n bail_expr!(val, \"{label} is too long; it should be up to {HWID_ARR_SZ} numbers [0,255]\")\n }\n hwid[i] = b;\n Ok(hwid)\n })?;\n match cfg\n .wintercept_opts\n .windows_interception_mouse_hwids\n .as_mut()\n {\n Some(v) => {\n v.push(hwid_slice);\n }\n None => {\n cfg.wintercept_opts.windows_interception_mouse_hwids =\n Some(vec![hwid_slice]);\n }\n }\n cfg.wintercept_opts\n .windows_interception_mouse_hwids\n .as_mut()\n .unwrap()\n .shrink_to_fit();\n }\n }\n \"windows-interception-mouse-hwids\" => {\n #[cfg(any(\n all(feature = \"interception_driver\", target_os = \"windows\"),\n target_os = \"unknown\"\n ))]\n {\n if cfg\n .wintercept_opts\n .windows_interception_mouse_hwids_exclude\n .is_some()\n {\n bail_expr!(\n val,\n \"{label} and windows-interception-mouse-hwid-exclude cannot both be included\"\n );\n }\n let parsed_hwids = sexpr_to_hwids_vec(\n val,\n label,\n \"entry in windows-interception-mouse-hwids\",\n )?;\n match cfg\n .wintercept_opts\n .windows_interception_mouse_hwids\n .as_mut()\n {\n Some(v) => {\n v.extend(parsed_hwids);\n }\n None => {\n cfg.wintercept_opts.windows_interception_mouse_hwids =\n Some(parsed_hwids);\n }\n }\n cfg.wintercept_opts\n .windows_interception_mouse_hwids\n .as_mut()\n .unwrap()\n .shrink_to_fit();\n }\n }\n \"windows-interception-mouse-hwids-exclude\" => {\n #[cfg(any(\n all(feature = \"interception_driver\", target_os = \"windows\"),\n target_os = \"unknown\"\n ))]\n {\n if cfg\n .wintercept_opts\n .windows_interception_mouse_hwids\n .is_some()\n {\n bail_expr!(\n val,\n \"{label} and windows-interception-mouse-hwid(s) cannot both be used\"\n );\n }\n let parsed_hwids = sexpr_to_hwids_vec(\n val,\n label,\n \"entry in windows-interception-mouse-hwids-exclude\",\n )?;\n cfg.wintercept_opts.windows_interception_mouse_hwids_exclude =\n Some(parsed_hwids);\n }\n }\n \"windows-interception-keyboard-hwids\" => {\n #[cfg(any(\n all(feature = \"interception_driver\", target_os = \"windows\"),\n target_os = \"unknown\"\n ))]\n {\n if cfg\n .wintercept_opts\n .windows_interception_keyboard_hwids_exclude\n .is_some()\n {\n bail_expr!(\n val,\n \"{label} and windows-interception-keyboard-hwid-exclude cannot both be used\"\n );\n }\n let parsed_hwids = sexpr_to_hwids_vec(\n val,\n label,\n \"entry in windows-interception-keyboard-hwids\",\n )?;\n cfg.wintercept_opts.windows_interception_keyboard_hwids =\n Some(parsed_hwids);\n }\n }\n \"windows-interception-keyboard-hwids-exclude\" => {\n #[cfg(any(\n all(feature = \"interception_driver\", target_os = \"windows\"),\n target_os = \"unknown\"\n ))]\n {\n if cfg\n .wintercept_opts\n .windows_interception_keyboard_hwids\n .is_some()\n {\n bail_expr!(\n val,\n \"{label} and windows-interception-keyboard-hwid cannot both be used\"\n );\n }\n let parsed_hwids = sexpr_to_hwids_vec(\n val,\n label,\n \"entry in windows-interception-keyboard-hwids-exclude\",\n )?;\n cfg.wintercept_opts\n .windows_interception_keyboard_hwids_exclude = Some(parsed_hwids);\n }\n }\n \"macos-dev-names-include\" => {\n #[cfg(any(target_os = \"macos\", target_os = \"unknown\"))]\n {\n let dev_names = parse_dev(val)?;\n if dev_names.is_empty() {\n log::warn!(\"macos-dev-names-include is empty\");\n }\n cfg.macos_opts.macos_dev_names_include = Some(dev_names);\n }\n }\n \"macos-dev-names-exclude\" => {\n #[cfg(any(target_os = \"macos\", target_os = \"unknown\"))]\n {\n let dev_names = parse_dev(val)?;\n if dev_names.is_empty() {\n log::warn!(\"macos-dev-names-exclude is empty\");\n }\n cfg.macos_opts.macos_dev_names_exclude = Some(dev_names);\n }\n }\n \"tray-icon\" => {\n #[cfg(all(\n any(target_os = \"windows\", target_os = \"unknown\"),\n feature = \"gui\"\n ))]\n {\n let icon_path = sexpr_to_str_or_err(val, label)?;\n if icon_path.is_empty() {\n log::warn!(\"tray-icon is empty\");\n }\n cfg.gui_opts.tray_icon = Some(icon_path.to_string());\n }\n }\n \"icon-match-layer-name\" => {\n #[cfg(all(\n any(target_os = \"windows\", target_os = \"unknown\"),\n feature = \"gui\"\n ))]\n {\n cfg.gui_opts.icon_match_layer_name = parse_defcfg_val_bool(val, label)?\n }\n }\n \"tooltip-layer-changes\" => {\n #[cfg(all(\n any(target_os = \"windows\", target_os = \"unknown\"),\n feature = \"gui\"\n ))]\n {\n cfg.gui_opts.tooltip_layer_changes = parse_defcfg_val_bool(val, label)?\n }\n }\n \"tooltip-show-blank\" => {\n #[cfg(all(\n any(target_os = \"windows\", target_os = \"unknown\"),\n feature = \"gui\"\n ))]\n {\n cfg.gui_opts.tooltip_show_blank = parse_defcfg_val_bool(val, label)?\n }\n }\n \"tooltip-no-base\" => {\n #[cfg(all(\n any(target_os = \"windows\", target_os = \"unknown\"),\n feature = \"gui\"\n ))]\n {\n cfg.gui_opts.tooltip_no_base = parse_defcfg_val_bool(val, label)?\n }\n }\n \"tooltip-duration\" => {\n #[cfg(all(\n any(target_os = \"windows\", target_os = \"unknown\"),\n feature = \"gui\"\n ))]\n {\n cfg.gui_opts.tooltip_duration = parse_cfg_val_u16(val, label, false)?\n }\n }\n \"notify-cfg-reload\" => {\n #[cfg(all(\n any(target_os = \"windows\", target_os = \"unknown\"),\n feature = \"gui\"\n ))]\n {\n cfg.gui_opts.notify_cfg_reload = parse_defcfg_val_bool(val, label)?\n }\n }\n \"notify-cfg-reload-silent\" => {\n #[cfg(all(\n any(target_os = \"windows\", target_os = \"unknown\"),\n feature = \"gui\"\n ))]\n {\n cfg.gui_opts.notify_cfg_reload_silent =\n parse_defcfg_val_bool(val, label)?\n }\n }\n \"notify-error\" => {\n #[cfg(all(\n any(target_os = \"windows\", target_os = \"unknown\"),\n feature = \"gui\"\n ))]\n {\n cfg.gui_opts.notify_error = parse_defcfg_val_bool(val, label)?\n }\n }\n \"tooltip-size\" => {\n #[cfg(all(\n any(target_os = \"windows\", target_os = \"unknown\"),\n feature = \"gui\"\n ))]\n {\n let v = sexpr_to_str_or_err(val, label)?;\n let tooltip_size = v.split(',').collect::>();\n const ERRMSG: &str = \"Invalid value for tooltip-size.\\nExpected two numbers 0-65535 separated by a comma, e.g. 24,24\";\n if tooltip_size.len() != 2 {\n bail_expr!(val, \"{}\", ERRMSG)\n }\n cfg.gui_opts.tooltip_size = (\n match str::parse::(tooltip_size[0]) {\n Ok(w) => w,\n Err(_) => bail_expr!(val, \"{}\", ERRMSG),\n },\n match str::parse::(tooltip_size[1]) {\n Ok(h) => h,\n Err(_) => bail_expr!(val, \"{}\", ERRMSG),\n },\n );\n }\n }\n\n \"process-unmapped-keys\" => {\n is_process_unmapped_keys_defined = true;\n if let Some(list) = val.list(None) {\n let err = \"Expected (all-except key1 ... keyN).\";\n if list.len() < 2 {\n bail_expr!(val, \"{err}\");\n }\n match list[0].atom(None) {\n Some(\"all-except\") => {}\n _ => {\n bail_expr!(val, \"{err}\");\n }\n };\n // Note: deflocalkeys should already be parsed when parsing defcfg,\n // so can use safely use str_to_oscode here; it will include user\n // configurations already.\n let mut key_exceptions: Vec<(OsCode, SExpr)> = vec![];\n for key_expr in list[1..].iter() {\n let key = key_expr.atom(None).and_then(str_to_oscode).ok_or_else(\n || anyhow_expr!(key_expr, \"Expected a known key name.\"),\n )?;\n if key_exceptions.iter().any(|k_exc| k_exc.0 == key) {\n bail_expr!(key_expr, \"Duplicate key name is not allowed.\");\n }\n key_exceptions.push((key, key_expr.clone()));\n }\n cfg.process_unmapped_keys = true;\n cfg.process_unmapped_keys_exceptions = Some(key_exceptions);\n } else {\n cfg.process_unmapped_keys = parse_defcfg_val_bool(val, label)?\n }\n }\n\n \"block-unmapped-keys\" => {\n cfg.block_unmapped_keys = parse_defcfg_val_bool(val, label)?\n }\n \"allow-hardware-repeat\" => {\n cfg.allow_hardware_repeat = parse_defcfg_val_bool(val, label)?\n }\n \"alias-to-trigger-on-load\" => {\n cfg.start_alias = parse_defcfg_val_string(val, label)?\n }\n \"danger-enable-cmd\" => cfg.enable_cmd = parse_defcfg_val_bool(val, label)?,\n \"sequence-backtrack-modcancel\" => {\n cfg.sequence_backtrack_modcancel = parse_defcfg_val_bool(val, label)?\n }\n \"log-layer-changes\" => {\n cfg.log_layer_changes = parse_defcfg_val_bool(val, label)?\n }\n \"delegate-to-first-layer\" => {\n cfg.delegate_to_first_layer = parse_defcfg_val_bool(val, label)?;\n if cfg.delegate_to_first_layer {\n log::info!(\n \"delegating transparent keys on other layers to first defined layer\"\n );\n }\n }\n \"linux-continue-if-no-devs-found\" => {\n #[cfg(any(\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n {\n cfg.linux_opts.linux_continue_if_no_devs_found =\n parse_defcfg_val_bool(val, label)?\n }\n }\n \"movemouse-smooth-diagonals\" => {\n cfg.movemouse_smooth_diagonals = parse_defcfg_val_bool(val, label)?\n }\n \"movemouse-inherit-accel-state\" => {\n cfg.movemouse_inherit_accel_state = parse_defcfg_val_bool(val, label)?\n }\n \"override-release-on-activation\" => {\n cfg.override_release_on_activation = parse_defcfg_val_bool(val, label)?\n }\n \"concurrent-tap-hold\" => {\n cfg.concurrent_tap_hold = parse_defcfg_val_bool(val, label)?\n }\n \"rapid-event-delay\" => {\n cfg.rapid_event_delay = parse_cfg_val_u16(val, label, false)?\n }\n \"transparent-key-resolution\" => {\n let v = sexpr_to_str_or_err(val, label)?;\n cfg.trans_resolution_behavior_v2 = match v {\n \"to-base-layer\" => false,\n \"layer-stack\" => true,\n _ => bail_expr!(\n val,\n \"{label} got {}. It accepts: 'to-base-layer' or 'layer-stack'\",\n v\n ),\n };\n }\n \"chords-v2-min-idle\" | \"chords-v2-min-idle-experimental\" => {\n if label == \"chords-v2-min-idle-experimental\" {\n log::warn!(\n \"You should replace chords-v2-min-idle-experimental with chords-v2-min-idle\\n\\\n Using -experimental will be invalid in the future.\"\n )\n }\n let min_idle = parse_cfg_val_u16(val, label, true)?;\n if min_idle < 5 {\n bail_expr!(val, \"{label} must be 5-65535\");\n }\n cfg.chords_v2_min_idle = min_idle;\n }\n \"tap-hold-require-prior-idle\" => {\n cfg.tap_hold_require_prior_idle = parse_cfg_val_u16(val, label, false)?;\n }\n \"mouse-movement-key\" => {\n #[cfg(any(\n all(target_os = \"windows\", feature = \"interception_driver\"),\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"unknown\"\n ))]\n {\n if let Some(keystr) = parse_defcfg_val_string(val, label)? {\n if let Some(key) = str_to_oscode(&keystr) {\n cfg.mouse_movement_key = Some(key);\n } else {\n bail_expr!(val, \"{label} not a recognised key code\");\n }\n } else {\n bail_expr!(val, \"{label} not a string for a key code\");\n }\n }\n }\n _ => bail_expr!(key, \"Unknown defcfg option {}\", label),\n };\n }\n SExpr::List(_) => {\n bail_expr!(key, \"Lists are not allowed in as keys in defcfg\");\n }\n }\n }\n}\n\nfn parse_defcfg_val_string(expr: &SExpr, _label: &str) -> Result> {\n match expr {\n SExpr::Atom(v) => Ok(Some(v.t.clone())),\n _ => Ok(None),\n }\n}\n\npub const FALSE_VALUES: [&str; 3] = [\"no\", \"false\", \"0\"];\npub const TRUE_VALUES: [&str; 3] = [\"yes\", \"true\", \"1\"];\npub const BOOLEAN_VALUES: [&str; 6] = [\"yes\", \"true\", \"1\", \"no\", \"false\", \"0\"];\n\nfn parse_defcfg_val_bool(expr: &SExpr, label: &str) -> Result {\n match &expr {\n SExpr::Atom(v) => {\n let val = v.t.trim_atom_quotes().to_ascii_lowercase();\n if TRUE_VALUES.contains(&val.as_str()) {\n Ok(true)\n } else if FALSE_VALUES.contains(&val.as_str()) {\n Ok(false)\n } else {\n bail_expr!(\n expr,\n \"The value for {label} must be one of: {}\",\n BOOLEAN_VALUES.join(\", \")\n );\n }\n }\n SExpr::List(_) => {\n bail_expr!(\n expr,\n \"The value for {label} cannot be a list, it must be one of: {}\",\n BOOLEAN_VALUES.join(\", \"),\n )\n }\n }\n}\n\nfn parse_cfg_val_u16(expr: &SExpr, label: &str, exclude_zero: bool) -> Result {\n let start = if exclude_zero { 1 } else { 0 };\n match &expr {\n SExpr::Atom(v) => Ok(str::parse::(v.t.trim_atom_quotes())\n .ok()\n .and_then(|u| {\n if exclude_zero && u == 0 {\n None\n } else {\n Some(u)\n }\n })\n .ok_or_else(|| anyhow_expr!(expr, \"{label} must be {start}-65535\"))?),\n SExpr::List(_) => {\n bail_expr!(\n expr,\n \"The value for {label} cannot be a list, it must be a number {start}-65535\",\n )\n }\n }\n}\n\npub fn parse_colon_separated_text(paths: &str) -> Vec {\n let mut all_paths = vec![];\n let mut full_dev_path = String::new();\n let mut dev_path_iter = paths.split(':').peekable();\n while let Some(dev_path) = dev_path_iter.next() {\n if dev_path.ends_with('\\\\') && dev_path_iter.peek().is_some() {\n full_dev_path.push_str(dev_path.trim_end_matches('\\\\'));\n full_dev_path.push(':');\n continue;\n } else {\n full_dev_path.push_str(dev_path);\n }\n all_paths.push(full_dev_path.clone());\n full_dev_path.clear();\n }\n all_paths.shrink_to_fit();\n all_paths\n}\n\n#[cfg(any(\n target_os = \"linux\",\n target_os = \"android\",\n target_os = \"macos\",\n target_os = \"unknown\"\n))]\npub fn parse_dev(val: &SExpr) -> Result> {\n Ok(match val {\n SExpr::Atom(a) => {\n let devs = parse_colon_separated_text(a.t.trim_atom_quotes());\n if devs.len() == 1 && devs[0].is_empty() {\n bail_expr!(val, \"an empty string is not a valid device name or path\")\n }\n devs\n }\n SExpr::List(l) => {\n let r: Result> =\n l.t.iter()\n .try_fold(Vec::with_capacity(l.t.len()), |mut acc, expr| match expr {\n SExpr::Atom(path) => {\n let trimmed_path = path.t.trim_atom_quotes().to_string();\n if trimmed_path.is_empty() {\n bail_span!(\n path,\n \"an empty string is not a valid device name or path\"\n )\n }\n acc.push(trimmed_path);\n Ok(acc)\n }\n SExpr::List(inner_list) => {\n bail_span!(inner_list, \"expected strings, found a list\")\n }\n });\n\n r?\n }\n })\n}\n\nfn sexpr_to_str_or_err<'a>(expr: &'a SExpr, label: &str) -> Result<&'a str> {\n match expr {\n SExpr::Atom(a) => Ok(a.t.trim_atom_quotes()),\n SExpr::List(_) => bail_expr!(expr, \"The value for {label} can't be a list\"),\n }\n}\n\n#[cfg(any(\n all(feature = \"interception_driver\", target_os = \"windows\"),\n target_os = \"unknown\"\n))]\nfn sexpr_to_list_or_err<'a>(expr: &'a SExpr, label: &str) -> Result<&'a [SExpr]> {\n match expr {\n SExpr::Atom(_) => bail_expr!(expr, \"The value for {label} must be a list\"),\n SExpr::List(l) => Ok(&l.t),\n }\n}\n\n#[cfg(any(\n all(feature = \"interception_driver\", target_os = \"windows\"),\n target_os = \"unknown\"\n))]\nfn sexpr_to_hwids_vec(\n val: &SExpr,\n label: &str,\n entry_label: &str,\n) -> Result> {\n let hwids = sexpr_to_list_or_err(val, label)?;\n let mut parsed_hwids = vec![];\n for hwid_expr in hwids.iter() {\n let hwid = sexpr_to_str_or_err(hwid_expr, entry_label)?;\n log::trace!(\"win hwid: {hwid}\");\n let hwid_vec = hwid\n .split(',')\n .try_fold(vec![], |mut hwid_bytes, hwid_byte| {\n hwid_byte.trim_matches(' ').parse::().map(|b| {\n hwid_bytes.push(b);\n hwid_bytes\n })\n }).map_err(|_| anyhow_expr!(hwid_expr, \"Entry in {label} is invalid. Entries should be numbers [0,255] separated by commas\"))?;\n let hwid_slice = hwid_vec.iter().copied().enumerate()\n .try_fold([0u8; HWID_ARR_SZ], |mut hwid, idx_byte| {\n let (i, b) = idx_byte;\n if i > HWID_ARR_SZ {\n bail_expr!(hwid_expr, \"entry in {label} is too long; it should be up to {HWID_ARR_SZ} 8-bit unsigned integers\")\n }\n hwid[i] = b;\n Ok(hwid)\n });\n parsed_hwids.push(hwid_slice?);\n }\n parsed_hwids.shrink_to_fit();\n Ok(parsed_hwids)\n}\n\n#[cfg(any(target_os = \"linux\", target_os = \"android\", target_os = \"unknown\"))]\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\npub struct KeyRepeatSettings {\n pub delay: u16,\n pub rate: u16,\n}\n\n#[cfg(any(target_os = \"linux\", target_os = \"android\", target_os = \"unknown\"))]\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\npub enum UnicodeTermination {\n Enter,\n Space,\n SpaceEnter,\n EnterSpace,\n}\n\n#[cfg(any(target_os = \"windows\", target_os = \"unknown\"))]\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]\npub enum AltGrBehaviour {\n #[default]\n DoNothing,\n CancelLctlPress,\n AddLctlRelease,\n}\n\n#[cfg(any(target_os = \"windows\", target_os = \"unknown\"))]\n#[cfg(any(\n all(feature = \"interception_driver\", target_os = \"windows\"),\n target_os = \"unknown\"\n))]\npub const HWID_ARR_SZ: usize = 1024;\n\n#[derive(Clone, Copy, Debug, PartialEq, Eq)]\npub enum ReplayDelayBehaviour {\n /// Always use a fixed number of ticks between presses and releases.\n /// This is the original kanata behaviour.\n /// This means that held action activations like in tap-hold do not behave as intended.\n Constant,\n /// Use the recorded number of ticks between presses and releases.\n /// This is newer behaviour.\n Recorded,\n}\n" }, { "path": "parser/src/cfg/defhands.rs", "content": "use super::sexpr::*;\nuse super::*;\nuse crate::{anyhow_expr, bail, bail_expr};\n\npub(super) fn parse_defhands(expr: &[SExpr], s: &ParserState) -> Result {\n use custom_tap_hold::Hand;\n\n let exprs_iter = check_first_expr(expr.iter(), \"defhands\")?;\n let mut keys: Vec = Vec::new();\n let mut hands: Vec = Vec::new();\n let mut seen_left = false;\n let mut seen_right = false;\n\n for group_expr in exprs_iter {\n let group = group_expr\n .list(s.vars())\n .ok_or_else(|| anyhow_expr!(group_expr, \"expected (left ...) or (right ...)\"))?;\n if group.is_empty() {\n bail_expr!(group_expr, \"expected (left ...) or (right ...)\");\n }\n let hand_name = group[0]\n .atom(s.vars())\n .ok_or_else(|| anyhow_expr!(&group[0], \"expected 'left' or 'right'\"))?;\n let hand = match hand_name {\n \"left\" => {\n if seen_left {\n bail_expr!(&group[0], \"duplicate 'left' group in defhands\");\n }\n seen_left = true;\n Hand::Left\n }\n \"right\" => {\n if seen_right {\n bail_expr!(&group[0], \"duplicate 'right' group in defhands\");\n }\n seen_right = true;\n Hand::Right\n }\n _ => bail_expr!(&group[0], \"expected 'left' or 'right', got '{}'\", hand_name),\n };\n for key_expr in &group[1..] {\n let key_name = key_expr\n .atom(s.vars())\n .ok_or_else(|| anyhow_expr!(key_expr, \"expected a key name, found list\"))?;\n let osc = str_to_oscode(key_name)\n .ok_or_else(|| anyhow_expr!(key_expr, \"unknown key '{}'\", key_name))?;\n let code = u16::from(osc);\n if let Some(pos) = keys.iter().position(|&k| k == code) {\n let existing_name = if hands[pos] == Hand::Left {\n \"left\"\n } else {\n \"right\"\n };\n bail_expr!(\n key_expr,\n \"Key already assigned to '{}' hand, cannot also be in '{}'\",\n existing_name,\n hand_name\n );\n }\n keys.push(code);\n hands.push(hand);\n }\n }\n\n let keys_static = s.a.sref_vec(keys);\n let hands_static = s.a.sref_vec(hands);\n Ok(custom_tap_hold::HandMap {\n keys: keys_static,\n hands: hands_static,\n })\n}\n\npub(super) fn parse_tap_hold_opposite_hand(\n ac_params: &[SExpr],\n s: &ParserState,\n) -> Result<&'static KanataAction> {\n use custom_tap_hold::{DecisionBehavior, custom_tap_hold_opposite_hand};\n\n const ARITY_MSG: &str = \"tap-hold-opposite-hand expects at least 3 items: \\\n [options...]\";\n if ac_params.is_empty() {\n bail!(ARITY_MSG);\n }\n if ac_params.len() < 3 {\n bail_expr!(&ac_params[0], \"{}\", ARITY_MSG);\n }\n let hand_map = s.hand_map.ok_or_else(|| {\n anyhow_expr!(\n &ac_params[0],\n \"tap-hold-opposite-hand requires defhands to be defined\"\n )\n })?;\n\n let hold_timeout = parse_non_zero_u16(&ac_params[0], s, \"timeout\")?;\n let tap_action = parse_action(&ac_params[1], s)?;\n let hold_action = parse_action(&ac_params[2], s)?;\n if matches!(tap_action, Action::HoldTap { .. }) {\n bail_expr!(\n &ac_params[1],\n \"tap-hold does not work in the tap-action of tap-hold\"\n );\n }\n\n let mut timeout_behavior = DecisionBehavior::Tap;\n let mut same_hand = DecisionBehavior::Tap;\n let mut neutral_behavior = DecisionBehavior::Ignore;\n let mut unknown_hand = DecisionBehavior::Ignore;\n let mut neutral_keys: Vec = Vec::new();\n let mut require_prior_idle: Option = None;\n let mut seen_options: HashSet<&str> = HashSet::default();\n\n for option_expr in &ac_params[3..] {\n let Some(option) = option_expr.list(s.vars()) else {\n bail_expr!(\n option_expr,\n \"expected option list, e.g. `(timeout hold)` or `(neutral-keys spc tab)`\"\n );\n };\n if option.is_empty() {\n bail_expr!(option_expr, \"option list cannot be empty\");\n }\n let kw = option[0]\n .atom(s.vars())\n .ok_or_else(|| anyhow_expr!(&option[0], \"option name must be a string\"))?;\n if !seen_options.insert(kw) {\n bail_expr!(\n &option[0],\n \"duplicate option '{}' in tap-hold-opposite-hand\",\n kw\n );\n }\n match kw {\n \"timeout\" => {\n if option.len() != 2 {\n bail_expr!(\n option_expr,\n \"option must contain exactly 2 items: `(name value)`\"\n );\n }\n timeout_behavior = parse_decision_behavior_tap_hold(&option[1], s)?;\n }\n \"same-hand\" => {\n if option.len() != 2 {\n bail_expr!(\n option_expr,\n \"option must contain exactly 2 items: `(name value)`\"\n );\n }\n same_hand = parse_decision_behavior(&option[1], s)?;\n }\n \"neutral\" => {\n if option.len() != 2 {\n bail_expr!(\n option_expr,\n \"option must contain exactly 2 items: `(name value)`\"\n );\n }\n neutral_behavior = parse_decision_behavior(&option[1], s)?;\n }\n \"unknown-hand\" => {\n if option.len() != 2 {\n bail_expr!(\n option_expr,\n \"option must contain exactly 2 items: `(name value)`\"\n );\n }\n unknown_hand = parse_decision_behavior(&option[1], s)?;\n }\n \"neutral-keys\" => {\n if option.len() < 2 {\n bail_expr!(\n option_expr,\n \"neutral-keys expects one or more key atoms, e.g. `(neutral-keys spc tab)`\"\n );\n }\n neutral_keys = parse_key_atoms(&option[1..], s, \"neutral-keys\")?;\n }\n \"require-prior-idle\" => {\n require_prior_idle = Some(tap_hold::parse_require_prior_idle_option(\n option,\n option_expr,\n s,\n )?);\n }\n _ => bail_expr!(\n &option[0],\n \"unknown option '{}' for tap-hold-opposite-hand. \\\n Valid options: timeout, same-hand, neutral, unknown-hand, neutral-keys, require-prior-idle\",\n kw\n ),\n }\n }\n\n let timeout_action = match timeout_behavior {\n DecisionBehavior::Tap => tap_action,\n DecisionBehavior::Hold => hold_action,\n DecisionBehavior::Ignore => unreachable!(),\n };\n\n let neutral_keys_static = s.a.sref_vec(neutral_keys);\n\n Ok(s.a.sref(Action::HoldTap(s.a.sref(HoldTapAction {\n config: HoldTapConfig::Custom(custom_tap_hold_opposite_hand(\n hand_map,\n same_hand,\n neutral_behavior,\n unknown_hand,\n neutral_keys_static,\n &s.a,\n )),\n tap_hold_interval: 0,\n timeout: hold_timeout,\n tap: *tap_action,\n hold: *hold_action,\n timeout_action: *timeout_action,\n on_press_reset_timeout_to: None,\n require_prior_idle,\n }))))\n}\n\nfn parse_key_atoms(exprs: &[SExpr], s: &ParserState, label: &str) -> Result> {\n exprs\n .iter()\n .map(|key_expr| {\n let key_name = key_expr\n .atom(s.vars())\n .ok_or_else(|| anyhow_expr!(key_expr, \"{label} expects key atoms, found list\"))?;\n str_to_oscode(key_name)\n .ok_or_else(|| anyhow_expr!(key_expr, \"unknown key '{key_name}'\"))\n })\n .collect()\n}\n\nfn parse_decision_behavior(\n expr: &SExpr,\n s: &ParserState,\n) -> Result {\n use custom_tap_hold::DecisionBehavior;\n\n match expr\n .atom(s.vars())\n .ok_or_else(|| anyhow_expr!(expr, \"expected tap, hold, or ignore\"))?\n {\n \"tap\" => Ok(DecisionBehavior::Tap),\n \"hold\" => Ok(DecisionBehavior::Hold),\n \"ignore\" => Ok(DecisionBehavior::Ignore),\n v => bail_expr!(expr, \"expected tap, hold, or ignore; got '{}'\", v),\n }\n}\n\nfn parse_decision_behavior_tap_hold(\n expr: &SExpr,\n s: &ParserState,\n) -> Result {\n use custom_tap_hold::DecisionBehavior;\n\n match expr\n .atom(s.vars())\n .ok_or_else(|| anyhow_expr!(expr, \"expected tap or hold\"))?\n {\n \"tap\" => Ok(DecisionBehavior::Tap),\n \"hold\" => Ok(DecisionBehavior::Hold),\n v => bail_expr!(expr, \"expected tap or hold for timeout; got '{}'\", v),\n }\n}\n" }, { "path": "parser/src/cfg/deflayer.rs", "content": "use super::*;\n\nuse crate::anyhow_expr;\nuse crate::anyhow_span;\nuse crate::bail;\nuse crate::bail_expr;\nuse crate::bail_span;\n\npub(crate) type LayerIndexes = HashMap;\n\npub(crate) const DEFLAYER: &str = \"deflayer\";\npub(crate) const DEFLAYER_MAPPED: &str = \"deflayermap\";\n\n/// Returns layer names and their indexes into the keyberon layout. This also checks that:\n/// - All layers have the same number of items as the defsrc,\n/// - There are no duplicate layer names\n/// - Parentheses weren't used directly or kmonad-style escapes for parentheses weren't used.\npub(crate) fn parse_layer_indexes(\n exprs: &[SpannedLayerExprs],\n expected_len: usize,\n vars: &HashMap,\n _lsp_hints: &mut LspHints,\n) -> Result<(LayerIndexes, LayerIcons)> {\n let mut layer_indexes = HashMap::default();\n let mut layer_icons = HashMap::default();\n for (i, expr_type) in exprs.iter().enumerate() {\n let (mut subexprs, expr, do_element_count_check, deflayer_keyword) = match expr_type {\n SpannedLayerExprs::DefsrcMapping(e) => {\n (check_first_expr(e.t.iter(), DEFLAYER)?, e, true, DEFLAYER)\n }\n SpannedLayerExprs::CustomMapping(e) => (\n check_first_expr(e.t.iter(), DEFLAYER_MAPPED)?,\n e,\n false,\n DEFLAYER_MAPPED,\n ),\n };\n let layer_expr = subexprs.next().ok_or_else(|| {\n anyhow_span!(\n expr,\n \"{deflayer_keyword} requires a layer name after `{deflayer_keyword}` token\"\n )\n })?;\n let (layer_name, _layer_name_span, icon) = {\n let name = layer_expr.atom(Some(vars));\n match name {\n Some(name) => (name.to_owned(), layer_expr.span(), None),\n None => {\n // unwrap: this **must** be a list due to atom() call above.\n let list = layer_expr.list(Some(vars)).unwrap();\n let first = list.first().ok_or_else(|| anyhow_expr!(\n layer_expr,\n \"{deflayer_keyword} requires a string name within this pair of parentheses (or a string name without any)\"\n ))?;\n let name = first.atom(Some(vars)).ok_or_else(|| anyhow_expr!(\n layer_expr,\n \"layer name after {deflayer_keyword} must be a string when enclosed within one pair of parentheses\"\n ))?;\n let layer_opts = parse_layer_opts(&list[1..])?;\n let icon = layer_opts\n .get(DEFLAYER_ICON[0])\n .map(|icon_s| icon_s.trim_atom_quotes().to_owned());\n (name.to_owned(), first.span(), icon)\n }\n }\n };\n if layer_indexes.contains_key(&layer_name) {\n bail_expr!(layer_expr, \"duplicate layer name: {}\", layer_name);\n }\n // Check if user tried to use parentheses directly - `(` and `)`\n // or escaped them like in kmonad - `\\(` and `\\)`.\n for subexpr in subexprs {\n if let Some(list) = subexpr.list(None) {\n if list.is_empty() {\n bail_expr!(\n subexpr,\n \"You can't put parentheses in deflayer directly, because they are special characters for delimiting lists.\\n\\\n To get `(` and `)` in US layout, you should use `S-9` and `S-0` respectively.\\n\\\n For more context, see: https://github.com/jtroo/kanata/issues/459\"\n )\n }\n if list.len() == 1\n && list\n .first()\n .is_some_and(|s| s.atom(None).is_some_and(|atom| atom == \"\\\\\"))\n {\n bail_expr!(\n subexpr,\n \"Escaping shifted characters with `\\\\` is currently not supported in kanata.\\n\\\n To get `(` and `)` in US layout, you should use `S-9` and `S-0` respectively.\\n\\\n For more context, see: https://github.com/jtroo/kanata/issues/163\"\n )\n }\n }\n }\n if do_element_count_check {\n let num_actions = expr.t.len() - 2;\n if num_actions != expected_len {\n bail_span!(\n expr,\n \"Layer {} has {} item(s), but requires {} to match defsrc\",\n layer_name,\n num_actions,\n expected_len\n )\n }\n }\n\n #[cfg(feature = \"lsp\")]\n _lsp_hints\n .definition_locations\n .layer\n .insert(layer_name.clone(), _layer_name_span.clone());\n\n layer_indexes.insert(layer_name.clone(), i);\n layer_icons.insert(layer_name, icon);\n }\n\n Ok((layer_indexes, layer_icons))\n}\n\npub(crate) fn parse_layers(\n s: &ParserState,\n mapped_keys: &mut MappedKeys,\n defcfg: &CfgOptions,\n) -> Result {\n let mut layers_cfg = new_layers(s.layer_exprs.len());\n if s.layer_exprs.len() > MAX_LAYERS {\n bail!(\"Maximum number of layers ({}) exceeded.\", MAX_LAYERS);\n }\n let mut defsrc_layer = s.defsrc_layer;\n for (layer_level, layer) in s.layer_exprs.iter().enumerate() {\n match layer {\n // The skip is done to skip the `deflayer` and layer name tokens.\n LayerExprs::DefsrcMapping(layer) => {\n // Parse actions in the layer and place them appropriately according\n // to defsrc mapping order.\n for (i, ac) in layer.iter().skip(2).enumerate() {\n let ac = parse_action(ac, s)?;\n layers_cfg[layer_level][0][s.mapping_order[i]] = *ac;\n }\n }\n LayerExprs::CustomMapping(layer) => {\n // Parse actions as input output pairs\n let mut pairs = layer[2..].chunks_exact(2);\n let mut layer_mapped_keys = HashSet::default();\n let mut defsrc_anykey_used = false;\n let mut unmapped_anykey_used = false;\n let mut both_anykey_used = false;\n for pair in pairs.by_ref() {\n let input = &pair[0];\n let action = &pair[1];\n\n let action = parse_action(action, s)?;\n if input.atom(s.vars()).is_some_and(|x| x == \"_\") {\n if defsrc_anykey_used {\n bail_expr!(input, \"must have only one use of _ within a layer\")\n }\n if both_anykey_used {\n bail_expr!(input, \"must either use _ or ___ within a layer, not both\")\n }\n for i in 0..s.mapping_order.len() {\n if layers_cfg[layer_level][0][s.mapping_order[i]] == DEFAULT_ACTION {\n layers_cfg[layer_level][0][s.mapping_order[i]] = *action;\n }\n }\n defsrc_anykey_used = true;\n } else if input.atom(s.vars()).is_some_and(|x| x == \"__\") {\n if unmapped_anykey_used {\n bail_expr!(input, \"must have only one use of __ within a layer\")\n }\n if !defcfg.process_unmapped_keys {\n bail_expr!(\n input,\n \"must set process-unmapped-keys to yes to use __ to map unmapped keys\"\n );\n }\n if both_anykey_used {\n bail_expr!(input, \"must either use __ or ___ within a layer, not both\")\n }\n for i in 0..layers_cfg[0][0].len() {\n if layers_cfg[layer_level][0][i] == DEFAULT_ACTION\n && !s.mapping_order.contains(&i)\n {\n layers_cfg[layer_level][0][i] = *action;\n }\n }\n unmapped_anykey_used = true;\n } else if input.atom(s.vars()).is_some_and(|x| x == \"___\") {\n if both_anykey_used {\n bail_expr!(input, \"must have only one use of ___ within a layer\")\n }\n if defsrc_anykey_used {\n bail_expr!(input, \"must either use _ or ___ within a layer, not both\")\n }\n if unmapped_anykey_used {\n bail_expr!(input, \"must either use __ or ___ within a layer, not both\")\n }\n if !defcfg.process_unmapped_keys {\n bail_expr!(\n input,\n \"must set process-unmapped-keys to yes to use ___ to also map unmapped keys\"\n );\n }\n for i in 0..layers_cfg[0][0].len() {\n if layers_cfg[layer_level][0][i] == DEFAULT_ACTION {\n layers_cfg[layer_level][0][i] = *action;\n }\n }\n both_anykey_used = true;\n } else {\n let input_key = input\n .atom(s.vars())\n .and_then(str_to_oscode)\n .ok_or_else(|| anyhow_expr!(input, \"input must be a key name\"))?;\n mapped_keys.insert(input_key);\n if !layer_mapped_keys.insert(input_key) {\n bail_expr!(input, \"input key must not be repeated within a layer\")\n }\n layers_cfg[layer_level][0][usize::from(input_key)] = *action;\n }\n }\n let rem = pairs.remainder();\n if !rem.is_empty() {\n bail_expr!(&rem[0], \"input must by followed by an action\");\n }\n }\n }\n for (osc, layer_action) in layers_cfg[layer_level][0].iter_mut().enumerate() {\n if *layer_action == DEFAULT_ACTION {\n *layer_action = match s.block_unmapped_keys && !is_a_button(osc as u16) {\n true => Action::NoOp,\n false => Action::Trans,\n };\n }\n }\n\n // Set fake keys on every layer.\n for (y, action) in s.virtual_keys.values() {\n let (x, y) = get_fake_key_coords(*y);\n layers_cfg[layer_level][x as usize][y as usize] = **action;\n }\n\n // If the user has configured delegation to the first (default) layer for transparent keys,\n // (as opposed to delegation to defsrc), replace the defsrc actions with the actions from\n // the first layer.\n if layer_level == 0 && s.delegate_to_first_layer {\n for (defsrc_ac, default_layer_ac) in defsrc_layer.iter_mut().zip(layers_cfg[0][0]) {\n if default_layer_ac != Action::Trans {\n *defsrc_ac = default_layer_ac;\n }\n }\n }\n\n // Very last thing - ensure index 0 is always no-op. This shouldn't have any way to be\n // physically activated. This enable other code to rely on there always being a no-op key.\n layers_cfg[layer_level][0][0] = Action::NoOp;\n }\n Ok(layers_cfg)\n}\n\npub(crate) fn parse_layer_base(\n ac_params: &[SExpr],\n s: &ParserState,\n) -> Result<&'static KanataAction> {\n let idx = layer_idx(ac_params, &s.layer_idxs, s)?;\n set_layer_change_lsp_hint(&ac_params[0], &mut s.lsp_hints.borrow_mut());\n Ok(s.a.sref(Action::DefaultLayer(idx)))\n}\n\npub(crate) fn parse_layer_toggle(\n ac_params: &[SExpr],\n s: &ParserState,\n) -> Result<&'static KanataAction> {\n let idx = layer_idx(ac_params, &s.layer_idxs, s)?;\n set_layer_change_lsp_hint(&ac_params[0], &mut s.lsp_hints.borrow_mut());\n Ok(s.a.sref(Action::Layer(idx)))\n}\n" }, { "path": "parser/src/cfg/deflocalkeys.rs", "content": "use super::*;\n\nuse crate::anyhow_expr;\nuse crate::bail_expr;\n\n#[cfg(all(\n not(feature = \"interception_driver\"),\n any(\n not(feature = \"win_llhook_read_scancodes\"),\n not(feature = \"win_sendinput_send_scancodes\")\n ),\n target_os = \"windows\"\n))]\npub(crate) const DEF_LOCAL_KEYS: &str = \"deflocalkeys-win\";\n#[cfg(all(\n feature = \"win_llhook_read_scancodes\",\n feature = \"win_sendinput_send_scancodes\",\n not(feature = \"interception_driver\"),\n target_os = \"windows\"\n))]\npub(crate) const DEF_LOCAL_KEYS: &str = \"deflocalkeys-winiov2\";\n#[cfg(all(feature = \"interception_driver\", target_os = \"windows\"))]\npub(crate) const DEF_LOCAL_KEYS: &str = \"deflocalkeys-wintercept\";\n#[cfg(target_os = \"macos\")]\npub(crate) const DEF_LOCAL_KEYS: &str = \"deflocalkeys-macos\";\n#[cfg(any(target_os = \"linux\", target_os = \"android\", target_os = \"unknown\"))]\npub(crate) const DEF_LOCAL_KEYS: &str = \"deflocalkeys-linux\";\n\npub(crate) fn deflocalkeys_variant_applies_to_current_os(variant: &str) -> bool {\n variant == DEF_LOCAL_KEYS\n}\n\npub(crate) const DEFLOCALKEYS_VARIANTS: &[&str] = &[\n \"deflocalkeys-win\",\n \"deflocalkeys-winiov2\",\n \"deflocalkeys-wintercept\",\n \"deflocalkeys-linux\",\n \"deflocalkeys-macos\",\n];\n\n/// Parse custom keys from an expression starting with deflocalkeys.\npub(crate) fn parse_deflocalkeys(\n def_local_keys_variant: &str,\n expr: &[SExpr],\n) -> Result> {\n let mut localkeys = HashMap::default();\n let mut exprs = check_first_expr(expr.iter(), def_local_keys_variant)?;\n // Read k-v pairs from the configuration\n while let Some(key_expr) = exprs.next() {\n let key = key_expr.atom(None).ok_or_else(|| {\n anyhow_expr!(key_expr, \"No lists are allowed in {def_local_keys_variant}\")\n })?;\n if localkeys.contains_key(key) {\n bail_expr!(\n key_expr,\n \"Duplicate {key} found in {def_local_keys_variant}\"\n );\n }\n\n // Bug:\n // Trying to convert a number to OsCode is OS-dependent and is fallible.\n // A valid number for Linux could throw an error on Windows.\n //\n // Fix:\n // When the deflocalkeys variant does not apply to the current OS,\n // use a dummy OsCode to keep the \"same name\" validation\n // while avoiding the u16->OsCode conversion attempt.\n if !deflocalkeys_variant_applies_to_current_os(def_local_keys_variant) {\n localkeys.insert(key.to_owned(), OsCode::KEY_RESERVED);\n continue;\n }\n\n let osc = match exprs.next() {\n Some(v) => v\n .atom(None)\n .ok_or_else(|| anyhow_expr!(v, \"No lists are allowed in {def_local_keys_variant}\"))\n .and_then(|osc| {\n osc.parse::().map_err(|_| {\n anyhow_expr!(v, \"Unknown number in {def_local_keys_variant}: {osc}\")\n })\n })\n .and_then(|osc| {\n OsCode::from_u16(osc).ok_or_else(|| {\n anyhow_expr!(v, \"Unknown number in {def_local_keys_variant}: {osc}\")\n })\n })?,\n None => bail_expr!(key_expr, \"Key without a number in {def_local_keys_variant}\"),\n };\n log::debug!(\"custom mapping: {key} {}\", osc.as_u16());\n localkeys.insert(key.to_owned(), osc);\n }\n Ok(localkeys)\n}\n" }, { "path": "parser/src/cfg/defsrc.rs", "content": "use super::*;\n\nuse crate::anyhow_expr;\nuse crate::bail_expr;\n\n/// Parse mapped keys from an expression starting with defsrc. Returns the key mapping as well as\n/// a vec of the indexes in order. The length of the returned vec should be matched by the length\n/// of all layer declarations.\npub(crate) fn parse_defsrc(\n expr: &[SExpr],\n defcfg: &CfgOptions,\n) -> Result<(MappedKeys, Vec, MouseInDefsrc)> {\n let exprs = check_first_expr(expr.iter(), \"defsrc\")?;\n let mut mkeys = MappedKeys::default();\n let mut ordered_codes = Vec::new();\n let mut is_mouse_used = MouseInDefsrc::NoMouse;\n for expr in exprs {\n let s = match expr {\n SExpr::Atom(a) => &a.t,\n _ => bail_expr!(expr, \"No lists allowed in defsrc\"),\n };\n let oscode = str_to_oscode(s)\n .ok_or_else(|| anyhow_expr!(expr, \"Unknown key in defsrc: \\\"{}\\\"\", s))?;\n is_mouse_used = match (is_mouse_used, oscode) {\n (\n MouseInDefsrc::NoMouse,\n OsCode::BTN_LEFT\n | OsCode::BTN_RIGHT\n | OsCode::BTN_MIDDLE\n | OsCode::BTN_SIDE\n | OsCode::BTN_EXTRA\n | OsCode::MouseWheelUp\n | OsCode::MouseWheelDown\n | OsCode::MouseWheelLeft\n | OsCode::MouseWheelRight,\n ) => MouseInDefsrc::MouseUsed,\n _ => is_mouse_used,\n };\n\n if mkeys.contains(&oscode) {\n bail_expr!(expr, \"Repeat declaration of key in defsrc: \\\"{}\\\"\", s)\n }\n mkeys.insert(oscode);\n ordered_codes.push(oscode.into());\n }\n\n let mapped_exceptions = match &defcfg.process_unmapped_keys_exceptions {\n Some(excluded_keys) => {\n for excluded_key in excluded_keys.iter() {\n log::debug!(\"process unmapped keys exception: {:?}\", excluded_key);\n if mkeys.contains(&excluded_key.0) {\n bail_expr!(\n &excluded_key.1,\n \"Keys cannot be included in defsrc and also excepted in process-unmapped-keys.\"\n );\n }\n }\n\n excluded_keys\n .iter()\n .map(|excluded_key| excluded_key.0)\n .collect()\n }\n None => vec![],\n };\n\n log::info!(\"process unmapped keys: {}\", defcfg.process_unmapped_keys);\n if defcfg.process_unmapped_keys {\n for osc in 0..KEYS_IN_ROW as u16 {\n if let Some(osc) = OsCode::from_u16(osc) {\n if osc.is_mouse_code() {\n // Bugfix #1879:\n // Auto-including mouse activity in mapped keys\n // seems strictly incorrect to do, so never do it.\n // Users can still choose to opt in if they want.\n // Auto-including mouse activity breaks many scenarios.\n continue;\n }\n match KeyCode::from(osc) {\n KeyCode::No => {}\n _ => {\n if !mapped_exceptions.contains(&osc) {\n mkeys.insert(osc);\n }\n }\n }\n }\n }\n }\n\n mkeys.shrink_to_fit();\n Ok((mkeys, ordered_codes, is_mouse_used))\n}\n\npub(crate) fn create_defsrc_layer() -> [KanataAction; KEYS_IN_ROW] {\n let mut layer = [KanataAction::NoOp; KEYS_IN_ROW];\n\n for (i, ac) in layer.iter_mut().enumerate() {\n *ac = OsCode::from_u16(i as u16)\n .map(|osc| Action::KeyCode(osc.into()))\n .unwrap_or(Action::NoOp);\n }\n // Ensure 0-index is no-op.\n layer[0] = KanataAction::NoOp;\n layer\n}\n" }, { "path": "parser/src/cfg/deftemplate.rs", "content": "//! This file is responsible for template expansion.\n//! For simplicity of implementation, there is performance left off the table.\n//! This code runs at parse time and not in runtime\n//! so it is not performance critical.\n//!\n//! The known performance left off the table is:\n//!\n//! - Creating the expanded template recurses through all SExprs every time.\n//! Instead the code could pre-compute the paths to access every variable\n//! that needs substition. (perf_1)\n//!\n//! - Replacing the `template-expand|if-equal` items with the appropriate values\n//! recreates the Vec for every replacement that happens at that recursion depth.\n//! Instead the code could do recreate the vec only once\n//! and insert SExprs at the proper places. (perf_2)\n\nuse crate::anyhow_expr;\nuse crate::anyhow_span;\nuse crate::bail_expr;\nuse crate::bail_span;\nuse crate::err_expr;\nuse crate::err_span;\n\nuse super::error::*;\nuse super::sexpr::*;\nuse super::*;\n\n#[derive(Debug)]\nstruct Template {\n name: String,\n vars: Vec,\n // Same as vars above but all names are prefixed with '$'.\n vars_substitute_names: Vec,\n content: Vec,\n}\n\n/// Parse `deftemplate`s and expand `template-expand`s.\n///\n/// Syntax of `deftemplate` is:\n///\n/// `(deftemplate