ficd/zmk
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Update nodefree repo

Browse source
This commit is contained in:
urob 2022-07-16 14:51:27 -04:00
parent 8197248640
commit 39c3e5f982
6 changed files with 153 additions and 133 deletions
Download patch file Download diff file Expand all files Collapse all files

194
zmk-nodefree-config/README.md
View file

@ -11,22 +11,21 @@ streamlined syntax. Check out [example.keymap](example.keymap) to see it in acti
## Overview ## Overview
The following convenience macros are provided: The following convenience macros are provided:
1. `ZMK_BEHAVIOR` can be used to create new behaviors such as hold-taps, tap-dances or 1. `ZMK_BEHAVIOR` creates behaviors such as hold-taps, tap-dances or
ZMK macros [\[doc\]](#zmk_behavior) ZMK macros [\[doc\]](#zmk_behavior)
2. `ZMK_LAYER` adds new layers to your keymap [\[doc\]](#zmk_layer) 2. `ZMK_LAYER` adds layers to the keymap [\[doc\]](#zmk_layer)
3. `ZMK_COMBO` defines new combos [\[doc\]](#zmk_combo) 3. `ZMK_COMBO` defines combos [\[doc\]](#zmk_combo)
4. `ZMK_CONDITIONAL_LAYERS` sets up "tri-layer" conditions [\[doc\]](#zmk_conditional_layers) 4. `ZMK_CONDITIONAL_LAYER` sets up "tri-layer" conditions [\[doc\]](#zmk_conditional_layer)
5. `ZMK_UNICODE_SINGLE` and `ZMK_UNICODE_PAIR` create unicode characters [\[doc\]](#zmk_unicode) 5. `ZMK_UNICODE_SINGLE` and `ZMK_UNICODE_PAIR` create unicode characters [\[doc\]](#zmk_unicode)
6. optional `international_chars` source files define a number of international character such 6. `international_chars` provides character definitions for some non-English languages
as <kbd>ä</kbd>/<kbd>Ä</kbd> or <kbd>δ</kbd>/<kbd>Δ</kbd> that can be added to the keymap
[\[doc\]](#international-characters) [\[doc\]](#international-characters)
7. optional `keypos_def` source files define human-readable key position shortcuts for some popular 7. `keypos_def` provides human-readable key position shortcuts for some popular
keyboards that simplify the configuration of combos and positional hold-taps keyboards that simplify the configuration of combos and positional hold-taps
[\[doc\]](#key-position-shortcuts) [\[doc\]](#key-position-helpers)
## Quickstart ## Quickstart
1. Copy this repository into the root folder of your private zmk-config repository. The 1. Copy this repository into the root folder of your zmk-config. The
folder structure should look as follows: folder structure should look as follows:
``` ```
zmk-config zmk-config
@ -55,7 +54,7 @@ hold-tap, key-repeat, macro, mod-morph, sticky-key or tap-dance
**Syntax:** `ZMK_BEHAVIOR(name, type, specification)` **Syntax:** `ZMK_BEHAVIOR(name, type, specification)`
* `name`: a unique string chosen by the user (e.g., `my_behavior`). The new behavior can * `name`: a unique string chosen by the user (e.g., `my_behavior`). The new behavior can
be added to the keymap using `&name` (e.g., `&my_behavior`) be added to the keymap using `&name` (e.g., `&my_behavior`).
* `type`: the behavior to be created. It must be one of the following: * `type`: the behavior to be created. It must be one of the following:
`caps_word`, `hold_tap`, `key_repeat`, `macro`, `mod_morph`, `sticky_key` or `caps_word`, `hold_tap`, `key_repeat`, `macro`, `mod_morph`, `sticky_key` or
`tap_dance`. Note that two-word types are separated by underscores (`_`). `tap_dance`. Note that two-word types are separated by underscores (`_`).
@ -76,9 +75,8 @@ ZMK_BEHAVIOR(hrm, hold_tap,
) )
``` ```
The new behavior can be added to the keymap-layout using `&hrm` (e.g., `&hrm LSHIFT T` This creates a custom "homerow mod" that can be added to the keymap using `&hrm`. For example,
creates a key that yields `T` on tap and `LSHIFT` on hold, using the custom `&hrm LSHIFT T` creates a key that yields `T` on tap and `LSHIFT` on hold.
configuration above).
#### Example 2: Creating a custom tap-dance key #### Example 2: Creating a custom tap-dance key
@ -88,9 +86,8 @@ ZMK_BEHAVIOR(ss_cw, tap_dance,
bindings = <&sk LSHFT>, <&caps_word>; bindings = <&sk LSHFT>, <&caps_word>;
) )
``` ```
This behavior yields sticky-shift on tap and caps-word on double tap. It can be added to
The new behavior can be added to the keymap-layout using `&ss_cw`. The key yields the keymap using `&ss_cw`.
sticky-shift on tap and caps-word on double tap;
#### Example 3: Creating a custom "win-sleep" macro #### Example 3: Creating a custom "win-sleep" macro
@ -102,15 +99,14 @@ ZMK_BEHAVIOR(win_sleep, macro,
) )
``` ```
This creates a "Windows sleep key" that can be added to the keymap-layout using This creates a "Windows sleep macro" that can be added to the keymap using `&win_sleep`.
`&win_sleep`.
### ZMK\_LAYER ### ZMK\_LAYER
`ZMK_LAYER` adds new keymap layers to the configuration. `ZMK_LAYER` adds new keymap layers to the configuration.
**Syntax:** `ZMK_LAYER(name, layout)` **Syntax:** `ZMK_LAYER(name, layout)`
* `name`: a unique identifier string chosen by the user (usually this isn't referenced elsewhere) * `name`: a unique identifier string chosen by the user (usually there is no reason to reference this elsewhere)
* `layout`: the layout specification using the same syntax as the `bindings` * `layout`: the layout specification using the same syntax as the `bindings`
property of the [ZMK keymap configuration](https://zmk.dev/docs/config/keymap) property of the [ZMK keymap configuration](https://zmk.dev/docs/config/keymap)
@ -139,18 +135,18 @@ ZMK_KEYMAP(default_layer,
`ZMK_COMBO` defines new combos. `ZMK_COMBO` defines new combos.
**Syntax:** `ZMK_COMBO(name, bindings, keypos, layers)` **Syntax:** `ZMK_COMBO(name, bindings, keypos, layers)`
* `name`: a unique identifier string chosen by the user (usually this isn't referenced elsewhere) * `name`: a unique identifier string chosen by the user (usually there is not reason to reference this elsewhere)
* `binding`: the binding triggered by the combo (this can be any stock or previously defined behavior) * `binding`: the binding triggered by the combo (this can be any stock or previously defined behavior)
* `keypos`: a list of 2 or more key positions that trigger the combo (e.g., `12 * `keypos`: a list of 2 or more key positions that trigger the combo (e.g., `12
13`). Note that the mapping from key positions to keys depends on your keyboard. To facilitate 13`). Note that the mapping from key positions to keys depends on your keyboard. To facilitate
the combo set-up and increase portability, this repository provides shortcuts for some popular keyboards. the combo setup and increase portability, one can use key-position helpers instead.
See [below](#key-position-shortcuts) on how to use them. See [below](#key-position-helpers) on how to use them.
* `layers`: a list of layers for which the combo is active (e.g., `0 1` for the first * `layers`: a list of layers for which the combo is active (e.g., `0 1` for the first
two layers). If set to `ALL` the combo is active on all layers. two layers). If set to `ALL` the combo is active on all layers.
By default, the timeout for combos created with `ZMK_COMBO` is 30ms. If `COMBO_TERM` is By default, the timeout for combos created with `ZMK_COMBO` is 30ms. If `COMBO_TERM` is
set prior to calling `ZMK_COMBO`, the value of `COMBO_TERM` is used instead. Note: while set prior to calling `ZMK_COMBO`, the value of `COMBO_TERM` is used instead. Note: while
it is possible to set different timeout for different combos, this is known to cause it is possible to set different timeouts for different combos, this is known to cause
[issues](https://github.com/zmkfirmware/zmk/issues/905) with overlapping combos and should be avoided. [issues](https://github.com/zmkfirmware/zmk/issues/905) with overlapping combos and should be avoided.
#### Example: copy and paste combos #### Example: copy and paste combos
@ -161,16 +157,16 @@ ZMK_COMBO(copy, &kp LC(C), 12 13, ALL)
ZMK_COMBO(paste, &kp LC(V), 13 14, ALL) ZMK_COMBO(paste, &kp LC(V), 13 14, ALL)
``` ```
This sets the combo timeout to 50ms, and then creates two combos which both are This sets the combo timeout to 50ms, and then creates two combos which both are
active all layers. The first combo is triggered when the active on all layers. The first combo is triggered when the
12th and 13th keys are pressed jointly within the `COMBO_TERM`, sending <kbd>Ctrl</kbd> + <kbd>C</kbd>. The 12th and 13th keys are pressed jointly within the `COMBO_TERM`, sending <kbd>Ctrl</kbd> + <kbd>C</kbd>. The
second combo is triggered when the 13th and 14th keys are pressed jointly, sending second combo is triggered when the 13th and 14th keys are pressed jointly, sending
<kbd>Ctrl</kbd> + <kbd>V</kbd>. <kbd>Ctrl</kbd> + <kbd>V</kbd>.
### ZMK\_CONDITIONAL\_LAYERS ### ZMK\_CONDITIONAL\_LAYER
This sets up tri-layer conditions. This sets up tri-layer conditions.
**Syntax:** `ZMK_CONDITIONAL_LAYERS(if_layers, then_layers)` **Syntax:** `ZMK_CONDITIONAL_LAYER(if_layers, then_layers)`
* `if_layers`: a list of layers which trigger the `then_layer` if simultaneously active * `if_layers`: a list of layers which trigger the `then_layer` if simultaneously active
* `then_layer`: the layer which is activated when the if-condition is met. Due to ZMK's * `then_layer`: the layer which is activated when the if-condition is met. Due to ZMK's
layering model, it should generally have a higher number than the `if_layers` layering model, it should generally have a higher number than the `if_layers`
@ -178,38 +174,19 @@ This sets up tri-layer conditions.
For instance, this triggers "layer 3" if layers "1" and "2" are For instance, this triggers "layer 3" if layers "1" and "2" are
simultaneously active. simultaneously active.
```C++ ```C++
ZMK_CONDITIONAL_LAYERS(1 2, 3) ZMK_CONDITIONAL_LAYER(1 2, 3)
``` ```
Mind that ZMK's layer numbering starts at 0! In general, it is recommended to use layer Mind that ZMK's layer numbering starts at 0. One can use layer
definitions, as demonstrated in [example.keymap](example.keymap), to simplify life. definitions, as demonstrated in [example.keymap](example.keymap), to simplify life.
### ZMK\_UNICODE ### ZMK\_UNICODE
There are two macros that simplify creating new unicode characters that There are two macros that create new unicode characters that
can be added to the keymap. `ZMK_UNICODE_SINGLE` creates single unicode characters such can be added to the keymap. `ZMK_UNICODE_SINGLE` creates single unicode characters such
as <kbd>€</kbd>, whereas `ZMK_UNICODE_PAIR` creates pairs of shifted/unshifted unicode as <kbd>€</kbd>, and `ZMK_UNICODE_PAIR` creates pairs of shifted/unshifted unicode
characters that are useful for specifying international characters such as characters that are useful for specifying international characters such as
<kbd>ä</kbd>/<kbd>Ä</kbd> or <kbd>δ</kbd>/<kbd>Δ</kbd>. <kbd>ä</kbd>/<kbd>Ä</kbd> or <kbd>δ</kbd>/<kbd>Δ</kbd>.
Note that the input of unicode characters differs across operation systems. By default,
`ZMK_UNICODE` is configured for Windows (using WinCompose). The easiest way to set up unicode
characters for other operation systems is to set the variable `HOST_OS` **before**
sourcing `helper.h`.
For Linux use:
```C++
#define HOST_OS 1 // set to 1 for Linux, default is 0 (Windows)
#include helper.h
```
For macOS use:
```C++
#define HOST_OS 2 // set to 2 for macOS, default is 0 (Windows)
#include helper.h
```
This will send unicode characters using the OS's default input channels.
For non-default input channels or for other operation systems, one can instead set the
variables `OS_UNICODE_LEAD` and `OS_UNICODE_TRAIL` to the character sequences that
initialize/terminate the unicode input.
**Syntax:** `ZMK_UNICODE_SINGLE(name, L0, L1, L2, L3)` **Syntax:** `ZMK_UNICODE_SINGLE(name, L0, L1, L2, L3)`
* `name:` a unique string chosen by the user (e.g., `my_char`). The unicode character can * `name:` a unique string chosen by the user (e.g., `my_char`). The unicode character can
@ -224,35 +201,36 @@ initialize/terminate the unicode input.
* `U0` to `U3`: a 4-digit sequence defining the shifted unicode string (which is send when * `U0` to `U3`: a 4-digit sequence defining the shifted unicode string (which is send when
holding <kbd>Shift</kbd> while pressing <kbd>&name</kbd>) holding <kbd>Shift</kbd> while pressing <kbd>&name</kbd>)
Note: 5-digit unicode characters are currently not supported. Note: 5-digit unicode characters are currently not supported (but would be easy to add
if there is interest).
#### Example 1: Euro sign (U+20AC) #### Example 1: Euro sign (€)
```C++ ```C++
ZMK_UNICODE_SINGLE(euro_sign, N2, N0, A, C) ZMK_UNICODE_SINGLE(euro_sign, N2, N0, A, C)
``` ```
The Euro character can be added to the keymap using `&euro_sign`. This creates a Euro character that can be added to the keymap using `&euro_sign`.
#### Example 2: German umlauts (ä/Ä, ö/Ö, ü/Ü) #### Example 2: German umlauts (ä/Ä, ö/Ö, ü/Ü)
```C++ ```C++
// name unshifted shifted // name unshifted shifted
ZMK_UNICODE_PAIR( ae, N0, N0, E, N4, N0, N0, C, N4 ) ZMK_UNICODE_PAIR( de_ae, N0, N0, E, N4, N0, N0, C, N4 )
ZMK_UNICODE_PAIR( oe, N0, N0, F, N6, N0, N0, D, N6 ) ZMK_UNICODE_PAIR( de_oe, N0, N0, F, N6, N0, N0, D, N6 )
ZMK_UNICODE_PAIR( ue, N0, N0, F, C, N0, N0, D, C ) ZMK_UNICODE_PAIR( de_ue, N0, N0, F, C, N0, N0, D, C )
``` ```
The "umlaut"-pairs can be added to the keymap using `&ae`, `&oe` and `&ue`. The creates "umlaut" pairs that can be added to the keymap using `&de_ae`, `&de_oe` and `&de_ue`.
#### Dependencies for unicodes #### Dependencies for unicode
* `ZMK_UNICODE_PAIR` requires a ZMK version patched with
[PR#1114](https://github.com/zmkfirmware/zmk/pull/1114) (not needed for * `ZMK_UNICODE_PAIR` requires ZMK patched with a modified version of the "masked-mods"
`ZMK_UNICODE_SINGLE`). If you don't want to maintain PR, available from [https://github.com/urob/zmk/tree/masked-mods](https://github.com/urob/zmk/tree/masked-mods).[^1] If you don't want
your own ZMK repository, you can use ZMK's [beta to maintain your own ZMK repository, you can use ZMK's [beta
testing](https://zmk.dev/docs/features/beta-testing) feature to configure Github testing](https://zmk.dev/docs/features/beta-testing) feature to configure Github
Actions to build against a patched remote branch of ZMK. To do so, replace the Actions to build against a patched remote branch of ZMK. To do so, replace the
contents of `west.yml` in your local `zmk-config/config` directory with the following contents of `west.yml` in your `zmk-config/config` directory with the following
contents: contents, which adds the required patch:
``` ```
manifest: manifest:
remotes: remotes:
@ -266,36 +244,58 @@ The "umlaut"-pairs can be added to the keymap using `&ae`, `&oe` and `&ue`.
self: self:
path: config path: config
``` ```
* Depending on the operation system there are addition requirements for unicode input to * The input of unicode characters differs across operating systems. By
work. On Windows, one must install default, `ZMK_UNICODE` is configured for Windows (using WinCompose). To set it up
[WinCompose](https://github.com/samhocevar/wincompose). On macOS one must enable for another OS, set the variable
unicode input in the system preferences. `HOST_OS` **before** sourcing `helper.h`.
For Linux use:
```C++
#define HOST_OS 1 // set to 1 for Linux, default is 0 (Windows)
#include helper.h
```
For macOS use:
```C++
#define HOST_OS 2 // set to 2 for macOS, default is 0 (Windows)
#include helper.h
```
This will send unicode characters using the OS's default input channels.
For non-default input channels or for other operating systems, one can instead set the
variables `OS_UNICODE_LEAD` and `OS_UNICODE_TRAIL` to the character sequences that
initialize/terminate the unicode input.[^2]
* On Windows and macOS there are additional requirements for unicode input to work. On
Windows, one must install [WinCompose](https://github.com/samhocevar/wincompose). On
macOS one must enable unicode input in the system preferences.
### International characters ### International characters
There are pre-defined definitions for international characters for a few There are pre-defined definitions for international characters for a few
languages (currently German and Greek --- contributions are welcome!). These can be languages --- currently German, Greek and Swedish (contributions are welcome)[^3]. These can be
loaded by sourcing the corresponding files. loaded by sourcing the corresponding files; e.g.:
```C++ ```C++
#include "../zmk-nodefree-config/international_chars/greek.dtsi"
#include "../zmk-nodefree-config/international_chars/german.dtsi" #include "../zmk-nodefree-config/international_chars/german.dtsi"
#include "../zmk-nodefree-config/international_chars/greek.dtsi"
#include "../zmk-nodefree-config/international_chars/swedish.dtsi"
``` ```
These definitions make use of unicode in the background, please see the unicode documentation Once sourced, international characters can be added to the
above for prerequisites. Once sourced, Greek and German characters can be added to the keymap using, e.g., `&de_ae`, `&el_alpha` or `&sv_ao`
keymap using, e.g., `&alpha`, `&upsilon`, `&tau` or `&omikron` (see the language files for (each language has its own prefix; see the language files for a complete list of available characters).
a complete list of available characters).
### Key position shortcuts **Dependencies:** These definitions make use of unicode in the background,
see the unicode section above for [prerequisites](#dependencies-for-unicode).
Certain configuration options such as combos and positional hold-taps are based on the ### Key-position helpers
physical position of keys on your keyboard. This reduces portability of configuration
files across keyboards with different layouts.
To increase portability, this repository comes with key position definitions for some Certain configuration options such as combos and positional hold-taps are based on the
popular keyboard layouts (48-key boards such as Planck, 42-key boards such as Corne, physical position of keys on the keyboard. This can be cumbersome and reduces
36-key boards and 34-key boards). portability of configuration files across keyboards with different layouts.
These layouts provide a map from the physical key positions to human-readable shortcuts. To increase portability and ease of use, this repo provides optional key-position
helpers for some popular keyboard layouts (48-key boards such as Planck, 42-key
boards such as Corne, 36-key boards and 34-key boards).
These key-position helpers provide a map from the physical key positions to human-readable shortcuts.
All shortcuts are of the following form: All shortcuts are of the following form:
* `L/R` for **L**eft/**R**ight hand * `L/R` for **L**eft/**R**ight hand
* `T/M/B/H` for **T**op/**M**iddle/**B**ottom and t**H**umb row. * `T/M/B/H` for **T**op/**M**iddle/**B**ottom and t**H**umb row.
@ -312,16 +312,16 @@ For instance, the shortcuts layout for a 36-key board looks as follows:
╰───────╮ LH2 LH1 LH0 │ RH0 RH1 RH2 ╭───────╯ ╰───────╮ LH2 LH1 LH0 │ RH0 RH1 RH2 ╭───────╯
╰─────────────┴─────────────╯ ╰─────────────┴─────────────╯
``` ```
Schematics for all existing layout files can be found at the top of the corresponding Schematics for all supported keyboards can be found in the corresponding
definition files. definition files in the `keypos_def` folder.
To use these shortcut definitions, source the definition file for your keyboard To use these key-position helpers, source the definition file for your keyboard
into your `.keymap` file. E.g., for a 36-key board, use: into your `.keymap` file. E.g., for a 36-key board, use:
```C++ ```C++
#include "../zmk-nodefree-config/keypos_def/keypos_36keys.h" #include "../zmk-nodefree-config/keypos_def/keypos_36keys.h"
``` ```
#### Example 1: Defining combos using key position shortcuts #### Example 1: Defining combos using key-position helpers
```C++ ```C++
ZMK_COMBO(copy, &kp LC(C), LB2 LB3, ALL) ZMK_COMBO(copy, &kp LC(C), LB2 LB3, ALL)
@ -335,8 +335,8 @@ This defines a "copy"-combo for the middle + ring finger on the left bottom row,
Here we use ZMK's [positional Here we use ZMK's [positional
hold-tap](https://zmk.dev/docs/behaviors/hold-tap#positional-hold-tap-and-hold-trigger-key-positions) hold-tap](https://zmk.dev/docs/behaviors/hold-tap#positional-hold-tap-and-hold-trigger-key-positions)
feature to make home-row mods only trigger with "opposite hand" keys.[^1] Using our feature to make home-row mods only trigger with "opposite hand" keys.[^4] Using
positional shortcuts makes this straightforward: key-position helpers makes this straightforward:
```C++ ```C++
#define HRM_LT LM1 LM2 LM3 LM4 // left-hand HRMs #define HRM_LT LM1 LM2 LM3 LM4 // left-hand HRMs
@ -363,5 +363,19 @@ ZMK_BEHAVIOR(hmr, hold_tap, // right-hand HRMs
hold-trigger-key-positions = <KEYS_LT THUMBS HRM_RT>; // include right-hand HRMs for chording hold-trigger-key-positions = <KEYS_LT THUMBS HRM_RT>; // include right-hand HRMs for chording
) )
``` ```
[^1]: The original "masked-mods" PR is available [here](https://github.com/zmkfirmware/zmk/pull/1114).
It works well when using the standard unicode configuration with Windows or macOS,
but leads to garbled unicode sequences under Linux. Using the patched version from
https://github.com/urob/zmk/tree/masked-mods makes it work under all three
operating systems and for non-standard configurations.
[^1]: We also whitelist same-hand HRMs so that we can combine them to chord mods. [^2]: The default for Windows is `OS_UNICODE_LEAD` set to tap <kbd>Right Alt</kbd>
followed by <kbd>U</kbd> and `OS_UNICODE_TRAIL` set to tap <kbd>Return</kbd>.
The default for Linux is `OS_UNICODE_LEAD` set to tap <kbd>Shift</kbd> +
<kbd>Ctrl</kbd> + <kbd>U</kbd> and `OS_UNICODE_TRAIL` set to tap <kbd>Space</kbd>.
The default for macOS is `OS_UNICODE_LEAD` set to hold <kbd>Left Alt</kbd>
and `OS_UNICODE_TRAIL` set to release <kbd>Left Alt</kbd>.
[^3]: Swedish language support was added by discord user "captainwoot".
[^4]: We also whitelist same-hand HRMs so that we can combine them to chord mods.

17
zmk-nodefree-config/example.keymap
View file

@ -9,7 +9,7 @@
#define ___ &trans #define ___ &trans
#define DEF 0 #define DEF 0 // layer shortcuts, must match order in which they are defined below
#define NAV 1 #define NAV 1
#define NUM 2 #define NUM 2
#define GER 3 #define GER 3
@ -44,17 +44,18 @@ ZMK_BEHAVIOR(win_sleep, macro,
bindings = <&kp LG(X) &kp U &kp S>; bindings = <&kp LG(X) &kp U &kp S>;
) )
/* combos */ // euro sign
ZMK_UNICODE_SINGLE(euro_sign, N2, N0, A, C) // €
// replace a/o/u/s with German umlauts when NAV and NUM are held jointly
ZMK_CONDITIONAL_LAYER(NAV NUM, GER)
// combos
#define COMBO_TERM 40 // timeout of 40ms (default is 30ms if omitted) #define COMBO_TERM 40 // timeout of 40ms (default is 30ms if omitted)
ZMK_COMBO(combo_sleep, &win_sleep, RT3 RT4, NAV) // custom sleep macro, only active on NAV layer ZMK_COMBO(combo_sleep, &win_sleep, RT3 RT4, NAV) // custom sleep macro, only active on NAV layer
ZMK_COMBO(combo_copy, &kp LC(C), LB2 LB3, ALL) // Ctrl + C, active on all layers ZMK_COMBO(combo_copy, &kp LC(C), LB2 LB3, ALL) // Ctrl + C, active on all layers
ZMK_COMBO(combo_paste, &kp LC(V), LB1 LB2, ALL) // Ctrl + V, active on all layers ZMK_COMBO(combo_paste, &kp LC(V), LB1 LB2, ALL) // Ctrl + V, active on all layers
/* conditional layer */
ZMK_CONDITIONAL_LAYERS(NAV NUM, GER) // replace A/O/U/S with umlauts when NAV and NUM are held jointly
/* keymap */ /* keymap */
ZMK_LAYER(default_layer, ZMK_LAYER(default_layer,
@ -95,9 +96,9 @@ ZMK_LAYER(num_layer,
ZMK_LAYER(german_layer, ZMK_LAYER(german_layer,
// ╭─────────────┬─────────────┬─────────────┬─────────────┬─────────────╮ ╭─────────────┬─────────────┬─────────────┬─────────────┬─────────────╮ // ╭─────────────┬─────────────┬─────────────┬─────────────┬─────────────╮ ╭─────────────┬─────────────┬─────────────┬─────────────┬─────────────╮
___ ___ ___ ___ ___ ___ ___ &ue ___ ___ ___ ___ ___ ___ ___ ___ ___ &de_ue ___ ___
// ├─────────────┼─────────────┼─────────────┼─────────────┼─────────────┤ ├─────────────┼─────────────┼─────────────┼─────────────┼─────────────┤ // ├─────────────┼─────────────┼─────────────┼─────────────┼─────────────┤ ├─────────────┼─────────────┼─────────────┼─────────────┼─────────────┤
&ae ___ &eszett ___ ___ ___ ___ ___ ___ &oe &de_ae ___ &de_eszett ___ ___ ___ ___ &euro_sign ___ &de_oe
// ├─────────────┼─────────────┼─────────────┼─────────────┼─────────────┤ ├─────────────┼─────────────┼─────────────┼─────────────┼─────────────┤ // ├─────────────┼─────────────┼─────────────┼─────────────┼─────────────┤ ├─────────────┼─────────────┼─────────────┼─────────────┼─────────────┤
___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___
// ╰─────────────┼─────────────┼─────────────┼─────────────┼─────────────┤ ├─────────────┼─────────────┼─────────────┼─────────────┼─────────────┤ // ╰─────────────┼─────────────┼─────────────┼─────────────┼─────────────┤ ├─────────────┼─────────────┼─────────────┼─────────────┼─────────────┤

14
zmk-nodefree-config/helper.h
View file

@ -62,9 +62,9 @@
}; \ }; \
}; };
/* ZMK_CONDITIONAL_LAYERS */ /* ZMK_CONDITIONAL_LAYER */
#define ZMK_CONDITIONAL_LAYERS(if_layers, then_layer) \ #define ZMK_CONDITIONAL_LAYER(if_layers, then_layer) \
/ { \ / { \
conditional_layers { \ conditional_layers { \
compatible = "zmk,conditional-layers"; \ compatible = "zmk,conditional-layers"; \
@ -125,11 +125,11 @@
}; };
#define ZMK_UNICODE_SINGLE(name, L0, L1, L2, L3) \ #define ZMK_UNICODE_SINGLE(name, L0, L1, L2, L3) \
UC_MACRO(uc_lower_ ## name, &kp L0 &kp L1 &kp L2 &kp L3) \ UC_MACRO(name ## _lower, &kp L0 &kp L1 &kp L2 &kp L3) \
UC_MODMORPH(uc_ ## name, &uc_lower_ ## name, &none) UC_MODMORPH(name, &name ## _lower, &none)
#define ZMK_UNICODE_PAIR(name, L0, L1, L2, L3, U0, U1, U2, U3) \ #define ZMK_UNICODE_PAIR(name, L0, L1, L2, L3, U0, U1, U2, U3) \
UC_MACRO(uc_lower_ ## name, &kp L0 &kp L1 &kp L2 &kp L3) \ UC_MACRO(name ## _lower, &kp L0 &kp L1 &kp L2 &kp L3) \
UC_MACRO(uc_upper_ ## name, &kp U0 &kp U1 &kp U2 &kp U3) \ UC_MACRO(name ## _upper, &kp U0 &kp U1 &kp U2 &kp U3) \
UC_MODMORPH(uc_ ## name, &uc_lower_ ## name, &uc_upper_ ## name) UC_MODMORPH(name, &name ## _lower, &name ## _upper)

8
zmk-nodefree-config/international_chars/german.dtsi
View file

@ -1,6 +1,6 @@
/* German umlauts */ /* German umlauts */
ZMK_UNICODE_PAIR( ae, N0, N0, E, N4, N0, N0, C, N4) ZMK_UNICODE_PAIR( de_ae, N0, N0, E, N4, N0, N0, C, N4)
ZMK_UNICODE_PAIR( oe, N0, N0, F, N6, N0, N0, D, N6) ZMK_UNICODE_PAIR( de_oe, N0, N0, F, N6, N0, N0, D, N6)
ZMK_UNICODE_PAIR( ue, N0, N0, F, C, N0, N0, D, C) ZMK_UNICODE_PAIR( de_ue, N0, N0, F, C, N0, N0, D, C)
ZMK_UNICODE_SINGLE( eszett, N0, N0, D, F) ZMK_UNICODE_SINGLE( de_eszett, N0, N0, D, F)

48
zmk-nodefree-config/international_chars/greek.dtsi
View file

@ -1,26 +1,26 @@
/* Greek letters */ /* Greek letters */
ZMK_UNICODE_PAIR( alpha, N0, N3, B, N1, N0, N3, N9, N1) ZMK_UNICODE_PAIR(el_alpha, N0, N3, B, N1, N0, N3, N9, N1)
ZMK_UNICODE_PAIR( beta, N0, N3, B, N2, N0, N3, N9, N2) ZMK_UNICODE_PAIR(el_beta, N0, N3, B, N2, N0, N3, N9, N2)
ZMK_UNICODE_PAIR( gamma, N0, N3, B, N3, N0, N3, N9, N3) ZMK_UNICODE_PAIR(el_gamma, N0, N3, B, N3, N0, N3, N9, N3)
ZMK_UNICODE_PAIR( delta, N0, N3, B, N4, N0, N3, N9, N4) ZMK_UNICODE_PAIR(el_delta, N0, N3, B, N4, N0, N3, N9, N4)
ZMK_UNICODE_PAIR( epsilon, N0, N3, F, N5, N0, N3, N9, N5) // varepsilon = 03B5 ZMK_UNICODE_PAIR(el_epsilon, N0, N3, F, N5, N0, N3, N9, N5) // varepsilon = 03B5
ZMK_UNICODE_PAIR( zeta, N0, N3, B, N6, N0, N3, N9, N6) ZMK_UNICODE_PAIR(el_zeta, N0, N3, B, N6, N0, N3, N9, N6)
ZMK_UNICODE_PAIR( eta, N0, N3, B, N7, N0, N3, N9, N7) ZMK_UNICODE_PAIR(el_eta, N0, N3, B, N7, N0, N3, N9, N7)
ZMK_UNICODE_PAIR( theta, N0, N3, B, N8, N0, N3, N9, N8) ZMK_UNICODE_PAIR(el_theta, N0, N3, B, N8, N0, N3, N9, N8)
ZMK_UNICODE_PAIR( iota, N0, N3, B, N9, N0, N3, N9, N9) ZMK_UNICODE_PAIR(el_iota, N0, N3, B, N9, N0, N3, N9, N9)
ZMK_UNICODE_PAIR( kappa, N0, N3, B, A, N0, N3, N9, A) ZMK_UNICODE_PAIR(el_kappa, N0, N3, B, A, N0, N3, N9, A)
ZMK_UNICODE_PAIR( lambda, N0, N3, B, B, N0, N3, N9, B) ZMK_UNICODE_PAIR(el_lambda, N0, N3, B, B, N0, N3, N9, B)
ZMK_UNICODE_PAIR( mu, N0, N3, B, C, N0, N3, N9, C) ZMK_UNICODE_PAIR(el_mu, N0, N3, B, C, N0, N3, N9, C)
ZMK_UNICODE_PAIR( nu, N0, N3, B, D, N0, N3, N9, D) ZMK_UNICODE_PAIR(el_nu, N0, N3, B, D, N0, N3, N9, D)
ZMK_UNICODE_PAIR( xi, N0, N3, B, E, N0, N3, N9, E) ZMK_UNICODE_PAIR(el_xi, N0, N3, B, E, N0, N3, N9, E)
ZMK_UNICODE_PAIR( omikron, N0, N3, B, F, N0, N3, N9, F) ZMK_UNICODE_PAIR(el_omikron, N0, N3, B, F, N0, N3, N9, F)
ZMK_UNICODE_PAIR( pi, N0, N3, C, N0, N0, N3, A, N0) ZMK_UNICODE_PAIR(el_pi, N0, N3, C, N0, N0, N3, A, N0)
ZMK_UNICODE_PAIR( rho, N0, N3, C, N1, N0, N3, A, N1) ZMK_UNICODE_PAIR(el_rho, N0, N3, C, N1, N0, N3, A, N1)
ZMK_UNICODE_PAIR( sigma, N0, N3, C, N3, N0, N3, A, N3) ZMK_UNICODE_PAIR(el_sigma, N0, N3, C, N3, N0, N3, A, N3)
ZMK_UNICODE_PAIR( tau, N0, N3, C, N4, N0, N3, A, N4) ZMK_UNICODE_PAIR(el_tau, N0, N3, C, N4, N0, N3, A, N4)
ZMK_UNICODE_PAIR( upsilon, N0, N3, C, N5, N0, N3, A, N5) ZMK_UNICODE_PAIR(el_upsilon, N0, N3, C, N5, N0, N3, A, N5)
ZMK_UNICODE_PAIR( phi, N0, N3, C, N6, N0, N3, A, N6) // varphi = 03C6 ZMK_UNICODE_PAIR(el_phi, N0, N3, C, N6, N0, N3, A, N6) // varphi = 03C6
ZMK_UNICODE_PAIR( chi, N0, N3, C, N7, N0, N3, A, N7) ZMK_UNICODE_PAIR(el_chi, N0, N3, C, N7, N0, N3, A, N7)
ZMK_UNICODE_PAIR( psi, N0, N3, C, N8, N0, N3, A, N8) ZMK_UNICODE_PAIR(el_psi, N0, N3, C, N8, N0, N3, A, N8)
ZMK_UNICODE_PAIR( omega, N0, N3, C, N9, N0, N3, A, N9) ZMK_UNICODE_PAIR(el_omega, N0, N3, C, N9, N0, N3, A, N9)

5
zmk-nodefree-config/international_chars/swedish.dtsi Normal file
View file

@ -0,0 +1,5 @@
/* Swedish letters */
ZMK_UNICODE_PAIR(sv_ae, N0, N0, E, N4, N0, N0, C, N4)
ZMK_UNICODE_PAIR(sv_ao, N0, N0, E, N5, N0, N0, C, N5)
ZMK_UNICODE_PAIR(sv_oe, N0, N0, F, N6, N0, N0, D, N6)