Trying the Zsa-Voyager With Ergo-L

KEYMAP="${KEYMAP_TAR%%\?*}" nix build --impure ~/.cache/voyager-ergol \
    --print-out-paths --no-link

https://ipfs.konubinix.eu/p/bafkreidzesuuaq5euzfoffuhzij6ulwseq5jurnrdpbkfvtr34oon4tkfe?ms57294nywbf16kj40kr7hwhbrr4kpd1_zsa_voyager_konubinix.bin

lsusb -d 3297:0791 > /dev/null || {
    echo "not in bootloader: press the boot key of L2,"
    echo "or plug it back in holding esc, which erases what it remembers too"
    exit 1
}

dfu-util --device 3297:0791 --alt 0 \
    --dfuse-address 0x08002000:leave \
    --download "${firmware%%\?*}" | sed '/\r/d'

dfu-util 0.11

Copyright 2005-2009 Weston Schmidt, Harald Welte and OpenMoko Inc.
Copyright 2010-2021 Tormod Volden and Stefan Schmidt
This program is Free Software and has ABSOLUTELY NO WARRANTY
Please report bugs to http://sourceforge.net/p/dfu-util/tickets/

Opening DFU capable USB device...
Device ID 3297:0791
Device DFU version 011a
Claiming USB DFU Interface...
Setting Alternate Interface #0 ...
Determining device status...
DFU state(2) = dfuIDLE, status(0) = No error condition is present
DFU mode device DFU version 011a
Device returned transfer size 2048
DfuSe interface name: "Internal Flash   "
Downloading element to address = 0x08002000, size = 56868
Erase    done.
Download done.
File downloaded successfully
Submitting leave request...
Transitioning to dfuMANIFEST state

from keymap_drawer.config import ParseConfig
from xkbcommon import xkb

# The alphanumeric keys. Above them the keypad repeats the same glyphs.
SPACE = 65
MAIN_BLOCK = [*range(9, 62), SPACE]

# The spaces ergol puts on that key are invisible, so name them.
VISIBLE = {" ": "␣", " ": "⍽", " ": "⎵"}

# ergol reaches its accented letters through the ★ dead key, which is level 5.
ONE_DEAD_KEY = 4

# Level 4: the maths and the superscripts, plus the non-breaking space.
ALTGR_SHIFT = 3

context = xkb.Context()


def glyphs(layout, variant, held):
    """What each key of the main block produces, with `held` down."""
    keymap = context.keymap_new_from_names(layout=layout, variant=variant)
    state = keymap.state_new()
    if held:
        state.update_key(keymap.key_by_name(held), xkb.XKB_KEY_DOWN)
    return {code: state.key_get_string(code) for code in MAIN_BLOCK}


def level(layout, variant, index):
    """What each key produces at that level, for levels no modifier reaches."""
    keymap = context.keymap_new_from_names(layout=layout, variant=variant)
    out = {}
    for code in MAIN_BLOCK:
        syms = []
        if keymap.num_levels_for_key(code, 0) > index:
            syms = keymap.key_get_syms_by_level(code, 0, index)
        out[code] = (xkb.keysym_to_string(syms[0]) or "") if syms else ""
    return out


def ergol_levels():
    """Every key of ergol, as (base, shifted, altgr, dead key, altgr+shift)."""
    base = glyphs("fr", "ergol", None)
    shifted = glyphs("fr", "ergol", "LFSH")
    altgr = glyphs("fr", "ergol", "RALT")
    dead = level("fr", "ergol", ONE_DEAD_KEY)
    hard = level("fr", "ergol", ALTGR_SHIFT)
    return {
        code: (base[code] or "★", shifted[code], altgr[code], dead[code], hard[code])
        for code in MAIN_BLOCK
    }


def keycode_map():
    """keymap-drawer's qmk_keycode_map, with the ergol levels of that same key."""
    plain = glyphs("us", None, None)
    caps = glyphs("us", None, "LFSH")
    ergol = ergol_levels()

    # A keycode that already means "shift + something" lands on one glyph only.
    unshifted = {plain[code]: ergol[code] for code in MAIN_BLOCK if plain[code]}
    shifted = {
        caps[code]: (ergol[code][1], "", "", "", "")
        for code in MAIN_BLOCK
        if caps[code]
    }

    # Letters are absent from that map: it falls back to the keycode name.
    out = {glyph.upper(): levels for glyph, levels in unshifted.items() if glyph.isalnum()}

    for keycode, glyph in ParseConfig().qmk_keycode_map.items():
        out[keycode] = unshifted.get(glyph) or shifted.get(glyph) or (glyph, "", "", "", "")

    out["SPACE"] = out["SPC"] = ergol[SPACE]
    return out


for keycode, (base, shifted, altgr, dead, hard) in keycode_map().items():
    # Showing "q Q" on every letter is noise.
    shifted = "" if shifted == base.upper() else shifted
    # Keycaps are printed in majuscule.
    base = base.upper() if base.isalpha() else base
    # A cell cannot hold a bare pipe.
    cells = [
        VISIBLE.get(cell, cell).replace("|", r"\vert")
        for cell in (base, shifted, altgr, dead, hard)
    ]
    print("%s|%s|%s|%s|%s|%s" % (keycode, *cells))

# noweb lays the python out under the line it stands on, hence the dedent.
DEDENT='import sys, textwrap; exec(textwrap.dedent(sys.stdin.read()))'
nix shell --impure --expr 'with import <nixpkgs> {};
    python3.withPackages (ps: [ ps.xkbcommon ps.keymap-drawer ])' \
    --command python3 -c "$DEDENT" <<'GLYPHS' # the ergol levels
<<ergol_glyphs_py>>
GLYPHS

import json
import os
import subprocess
import sys
import tempfile

<<board_py>>

qmk_source(os.path.expanduser("~/.cache/voyager-ergol"))
from qmk.keycodes import load_spec

# Keycodes keymap-drawer leaves as their raw name.
RENAMES = {
    # Shift+backspace is a key override, absent from the keymaps array.
    "BSPC": {"t": "DEL", "s": "suppr"},
    "LEFT_GUI": "super",
    "RIGHT_GUI": "super",
    "CW_TOGG": "caps word",
    "QK_BOOT": "boot",
    "PGUP": "PAGE UP",
    "PGDN": "PAGE DOWN",
    "VOLD": "vol -",
    "VOLU": "vol +",
    "MUTE": "mute",
    "MPRV": "prev",
    "MNXT": "next",
    "MSTP": "stop",
    "MPLY": "play",
    "RM_TOGG": "rgb",
    "RM_NEXT": "rgb anim",
    "RGB_M_P": "rgb solid",
    "RM_VALD": "dimmer",
    "RM_VALU": "brighter",
    "LAYER_COLORS_ON": "layer colors",
    # rgb_matrix_sethsv with those hues, per process_record_user.
    "HUE_RED": "red",
    "HUE_GREEN": "green",
    "HUE_BLUE": "blue",
}

# What a glyph is coloured by is the modifier that reaches it.
INKS = {
    "shift": "#b03a2e",
    "altgr": "#1a5fb4",
    "both": "#7d3c98",
    "dead": "#1e7d32",
    # The modifiers that select no layout level.
    "ctrl": "#c98200",
    "alt": "#0e8a8a",
    "super": "#c0399f",
    "plain": "#6b6f76",
}

STYLE = """
rect.homerow { fill: #d7e3f2; }
rect.thumbrest { fill: #eaf0f8; }
/* Restated last: the thumb that reaches the layer stays the held pink. */
rect.held { fill: #fdd; }
text.glyph.tl { font-size: 24px; }
text.tr, text.left, text.right { font-size: 18px; }
text.glyph.tap { font-size: 15px; }
text.hold { font-size: 12px; }
text.left, text.right { dominant-baseline: alphabetic; }
text.left, text.right { transform: translateY(14px); }
text.hold { transform: translateY(11px); }
text.glyph.tap { transform: translateY(9px); }
text.tr, text.shifted, text.shiftmod.hold { fill: %(shift)s; }
text.right, text.altgrmod.hold { fill: %(altgr)s; }
text.glyph.tap { fill: %(both)s; }
text.left, text.deadkeymod.tl { fill: %(dead)s; }
text.plainmod.hold, text.modkey.tap { fill: %(plain)s; }
text.ctrlmod.hold { fill: %(ctrl)s; }
text.altmod.hold { fill: %(alt)s; }
text.supermod.hold { fill: %(super)s; }
""" % INKS

# footer_text lands raw inside a <text>, so it can carry its own colours.
LEGEND = (
    'base' +
    ' · <tspan fill="%(shift)s">shift</tspan>' +
    ' · <tspan fill="%(altgr)s">altgr</tspan>' +
    ' · <tspan fill="%(both)s">altgr+shift</tspan>' +
    ' · <tspan fill="%(dead)s">★ then key</tspan>'
) % INKS

# The config leaves as its own file, which the drawing block is handed.
OUT = tempfile.mkdtemp()

with open(os.path.join(OUT, "ergol.json"), "w") as f:
    keycode_map = {}
    for keycode, base, shifted, altgr, dead, hard in glyphs:
        spec = {"t": base, "s": shifted, "right": altgr, "left": dead, "br": hard}
        keycode_map[str(keycode)] = {
            field: str(value).replace(r"\vert", "|")
            for field, value in spec.items()
            if value != ""
        }
    keycode_map.update(RENAMES)
    # keymap-drawer shows the name it is given, where the sdk knows the aliases.
    for keycode in load_spec("latest")["keycodes"].values():
        name = keycode["key"].split("KC_")[-1]
        for alias in keycode.get("aliases", []):
            keycode_map.setdefault(alias.split("KC_")[-1], name)
    json.dump(
        {
            "parse_config": {"qmk_keycode_map": keycode_map},
            "draw_config": {
                "svg_extra_style": STYLE,
                "footer_text": LEGEND,
                "shrink_wide_legends": 5,
                "key_w": 76,
                "key_h": 72,
                # Clearance between a corner legend and the key border.
                "small_pad": 15,
            },
        },
        f,
    )

print(os.path.join(OUT, "ergol.json"))

https://ipfs.konubinix.eu/p/bafkreig65fjfdkuz57na67wfr25oxs4mahbyxvlycexn2erk672lffzpqy?ergol.json

import json
import sys

import yaml

<<modifiers_py>>

# A key that is only a modifier, rather than a modifier held on a letter.
MOD_NAMES = set(MODIFIERS.values())

# Third of the four rows, minus the outer pinky column and the inner index
# column, which are stretches: four fingers per hand actually rest here.
HOME_ROW = (25, 26, 27, 28, 31, 32, 33, 34)

# Of the two keys per thumb, the layer-tap is the one under the thumb at rest.
THUMBS = (48, 51)

path, config_path = sys.argv[1], sys.argv[2]
keymap = yaml.safe_load(open(path, encoding="utf-8"))
config = json.load(open(config_path, encoding="utf-8"))

# keymap-drawer builds mod-taps as tap/hold/shifted only, dropping left and
# right, which is exactly where the accents and the symbols live.
levels = {
    spec["t"]: spec
    for spec in config["parse_config"]["qmk_keycode_map"].values()
    if isinstance(spec, dict) and "t" in spec
}

for layer in keymap["layers"].values():
    for index, key in enumerate(layer):
        # A key with nothing but a tap is a bare string, and cannot carry a class.
        if isinstance(key, str):
            key = layer[index] = {"t": key}
        if not isinstance(key, dict):
            continue
        # keymap-drawer already typed the thumb that reaches the layer as
        # held, and the transparent keys as trans. Keep what it found.
        classes = key.get("type", "").split()
        if index in HOME_ROW:
            classes.append("homerow")
        elif index in THUMBS:
            classes.append("thumbrest")
        if key.get("h") in MODIFIERS:
            key["h"] = MODIFIERS[key["h"]]
            classes.append(key["h"] + "mod")
        # The altgr backspace is left out of the override, to keep its level.
        if key.get("t") == "DEL" and key.get("h") == "altgr":
            key.pop("s", None)
        if key.get("t") == "★":
            classes.append("deadkeymod")
        if key.get("t") in MOD_NAMES:
            classes.append("modkey")
        for side in ("left", "right", "br"):
            if side not in key and side in levels.get(key.get("t"), {}):
                key[side] = levels[key["t"]][side]

        # A layout glyph goes to the top corners, leaving the sides for the
        # other levels and the bottom middle for the modifier name. A word
        # label needs the whole key and stays in the middle.
        if len(str(key.get("t", ""))) == 1:
            classes.append("glyph")
            key["tl"] = key.pop("t")
            if "s" in key:
                key["tr"] = key.pop("s")
                # The middle is free once the letter moved to the corner, and it is
                # the only spot altgr+shift does not land on the altgr glyph.
            if "br" in key:
                key["t"] = key.pop("br")
        if classes:
            key["type"] = " ".join(classes)

with open(path, "w", encoding="utf-8") as f:
    yaml.safe_dump(keymap, f, allow_unicode=True, sort_keys=False)

ergol="${ERGOL%%\?*}"
keymap=$(KEYMAP="${KEYMAP_TAR%%\?*}" nix build --impure \
    ~/.cache/voyager-ergol#keymap-json --print-out-paths --no-link)

# noweb lays the python out under the line it stands on, hence the dedent.
DEDENT='import sys, textwrap; exec(textwrap.dedent(sys.stdin.read()))'
# The drawing is made in a scratch, only its last file being kept.
cd "$(mktemp -d)"
nix shell nixpkgs#keymap-drawer --command \
    keymap -c "$ergol" parse -q "$keymap" -o voyager.yaml
nix shell nixpkgs#python3Packages.pyyaml --command \
    python3 -c "$DEDENT" voyager.yaml "$ergol" <<'MARKS' # the mod marks
<<mark_mods_py>>
MARKS
nix shell nixpkgs#keymap-drawer --command \
    keymap -c "$ergol" draw voyager.yaml -o cheatsheet.svg
nix shell nixpkgs#librsvg --command \
    rsvg-convert -z 1.5 -b white cheatsheet.svg -o cheatsheet.png
printf '%s' "$PWD/cheatsheet.png"

{ ... }:
{
  services.xserver.inputClassSections = [
    ''
      Identifier "voyager-ergol"
      MatchIsKeyboard "on"
      MatchUSBID "3297:1977"
      Option "XkbLayout" "fr"
      Option "XkbVariant" "ergol"
    ''
  ];
}

<<imports_py>>

<<board_py>>

<<layers_py>>

qmk_home = qmk_source(FLAKE)
from qmk.keymap import generate_json

default = default_of(qmk_home)
out = os.path.join(tempfile.mkdtemp(), "default.json")
with open(out, "w") as f:
    json.dump(generate_json(
        keymap="default",
        keyboard="zsa/voyager",
        layout=default[0]["layout"],
        layers=[layer["keycodes"] for layer in default],
    ), f)

print(out)

import sys

import yaml

path = sys.argv[1]
keymap = yaml.safe_load(open(path, encoding="utf-8"))

one = next(iter(keymap["layers"]))
keymap["layers"] = {
    "positions": [{"t": str(index)}
                  for index, _ in enumerate(keymap["layers"][one])]
}
# The levels of ergol are not what this one is about.
keymap["draw_config"] = {"footer_text": ""}

with open(path, "w", encoding="utf-8") as f:
    yaml.safe_dump(keymap, f, allow_unicode=True, sort_keys=False)

HOME_ROW = {
    24: "MOD_RALT", 25: "MOD_LGUI", 26: "MOD_LALT",
    27: "MOD_LCTL", 28: "MOD_LSFT",
    31: "MOD_RSFT", 32: "MOD_RCTL", 33: "MOD_LALT",
    34: "MOD_RGUI", 35: "MOD_RALT",
}

PLAIN = (37, 46, 49, 50)
FREED = (36, 47)

CHANGES = {
    1: {21: "KC_C", 22: "KC_MINS", 45: "KC_N"},
    2: {1: "LAYER_COLORS_ON",
        39: "HUE_RED", 40: "HUE_GREEN", 41: "HUE_BLUE"},
}

def tap_of(keycode):
    held = re.match(r"\w+_T\((.*)\)$", keycode)
    return held.group(1) if held else keycode


def default_of(qmk_home):
    from qmk.keymap import parse_keymap_c

    return parse_keymap_c(os.path.join(
        qmk_home, "keyboards/zsa/voyager/keymaps/default/keymap.c"
    ))["layers"]


def layers_of(qmk_home):
    default = [layer["keycodes"] for layer in default_of(qmk_home)]

    base = default[0]
    for index, modifier in HOME_ROW.items():
        base[index] = "MT(%s, %s)" % (modifier, tap_of(base[index]))
    for index in PLAIN:
        base[index] = tap_of(base[index])
    for index in FREED:
        base[index] = "KC_TRNS"

    for layer, changes in CHANGES.items():
        for index, keycode in changes.items():
            default[layer][index] = keycode
    return default

def modules_json():
    return json.dumps({"modules": ["zsa/defaults", "zsa/oryx"]}, indent=2) + "\n"

def keymap_c(layers):
    from qmk.keymap import generate_c, generate_json

    # The sdk writes the array, out of the format it owns.
    written = generate_c(generate_json(
        keymap="konubinix",
        keyboard="zsa/voyager",
        layout="LAYOUT_voyager",
        layers=layers,
    ))

    keycodes = ["enum custom_keycodes {"]
    for index, name in enumerate(OWN):
        seed = " = QK_USER" if index == 0 else ""
        keycodes.append("    %s%s," % (name, seed))
    keycodes += ["};", ""]

    # The declarations have to stand before the array that names them.
    head, rest = written.split("\n", 1)
    # qmk compiles this file and includes it too, so it guards itself.
    out = ["#pragma once", "", head, "", '#include "ledmap.h"', ""]
    out += keycodes + [rest]
    return "\n".join(out) + "\n" + handlers_c()

def handlers_c():
    out = [
        "const key_override_t shift_backspace =",
        "    ko_make_basic(MOD_MASK_SHIFT, KC_BSPC, KC_DEL);",
        "",
        "const key_override_t *key_overrides[] = {",
        "    &shift_backspace,",
        "    NULL,",
        "};",
        "",
        "bool process_record_user(uint16_t keycode, keyrecord_t *record) {",
        "    if (!record->event.pressed) {",
        "        return true;",
        "    }",
        "    switch (keycode) {",
    ]
    for name, body in OWN.items():
        out.append("        case %s:" % name)
        out.append("            %s" % body)
        out.append("            return false;")
    out += ["    }", "    return true;", "}", ""]
    return "\n".join(out)

def board_of(flake):
    board = subprocess.run(
        ["nix", "build", flake + "#board", "--print-out-paths", "--no-link"],
        capture_output=True, text=True, check=True,
    ).stdout.strip()
    board = json.load(open(board))
    return ([tuple(m) for m in board["keys"]],
            [tuple(m) for m in board["leds"]])


def qmk_source(flake):
    qmk_home = subprocess.run(
        ["nix", "eval", "--raw", flake + "#qmk_source"],
        capture_output=True, text=True, check=True,
    ).stdout.strip()
    # The sdk reads its own data out of the tree it is standing in.
    os.environ["QMK_HOME"] = qmk_home
    os.environ["ORIG_CWD"] = os.getcwd()
    sys.path.insert(0, os.path.join(qmk_home, "lib", "python"))
    os.chdir(qmk_home)
    return qmk_home

def folder(layers, levels, keys, leds, effect):
    return {
        "keymap.json": modules_json(),
        "keymap.c": keymap_c(layers),
        "ledmap.h": ledmap_h(layers, levels, keys, leds),
        "rgb_matrix_user.inc": effect,
        "rules.mk": "\n".join(FEATURES) + "\n",
    }

def tarred(written):
    scratch = tempfile.mkdtemp()
    for name, body in written.items():
        with open(os.path.join(scratch, name), "w") as f:
            f.write(body)

    keymap = os.path.join(tempfile.mkdtemp(), "keymap.tar")
    with tarfile.open(keymap, "w") as tar:
        for name in written:
            tar.add(os.path.join(scratch, name), arcname=name)
    return keymap

<<imports_py>>

<<colours_py>>
<<modifiers_py>>
<<families_py>>
<<own_py>>
<<home_row_py>>
<<changes_py>>
<<layers_py>>
<<emit_modules_py>>
<<emit_handlers_py>>
<<emit_keymap_py>>
<<classify_py>>
<<emit_ledmap_py>>
<<board_py>>
<<written_py>>
<<tar_py>>

EFFECT = """
<<effect_c>>
"""

keys, leds = board_of(FLAKE)
qmk_home = qmk_source(FLAKE)
levels = {str(row[0]): str(row[1]) for row in glyphs}

print(tarred(folder(
    layers_of(qmk_home), levels, keys, leds, EFFECT.lstrip("\n"))))

https://ipfs.konubinix.eu/p/bafkreiftez3lqzkzib57cvsvhdb3k74gexrmhcnxljwtj6kg762ieemp74?keymap.tar

{
  inputs = {
    nixpkgs.url = "nixpkgs";
    qmk_firmware = {
      url = "git+https://github.com/zsa/qmk_firmware?submodules=1&shallow=1";
      flake = false;
    };
  };

  outputs =
    { nixpkgs, qmk_firmware, ... }:
    let
      pkgs = nixpkgs.legacyPackages.x86_64-linux;
      board = "${qmk_firmware}/keyboards/zsa/voyager/keyboard.json";
    in
    {
      <<flake_serves>>

      <<flake_bin>>

      <<flake_keymap_json>>
    };
}

qmk_source = qmk_firmware;

packages.x86_64-linux.python =
  pkgs.python3.withPackages (ps: pkgs.qmk.propagatedBuildInputs);

packages.x86_64-linux.board = pkgs.runCommand "board.json" { } ''${pkgs.jq}/bin/jq '
  {keys: [.layouts.LAYOUT.layout[].matrix],
   leds: [.rgb_matrix.layout[].matrix]}
' ${board} > $out
'';

packages.x86_64-linux.default = pkgs.stdenv.mkDerivation {
  name = "zsa_voyager_konubinix.bin";
  # The keymap arrives as one file, named by the block that wrote it.
  src = /. + (builtins.getEnv "KEYMAP");
  unpackCmd = "tar xf $curSrc";
  sourceRoot = ".";

  # qmk propagates gcc-arm-embedded, gnumake and dfu-util.
  nativeBuildInputs = [ pkgs.qmk ];

  buildPhase = ''export HOME=$TMPDIR QMK_HOME=$TMPDIR/qmk
    cp -r ${qmk_firmware} $QMK_HOME
    chmod -R u+w $QMK_HOME
    keymap=$QMK_HOME/keyboards/zsa/voyager/keymaps/konubinix
    mkdir -p $keymap && cp *.c *.h *.inc *.json *.mk $keymap
    # version.h is stamped from git describe, the store copy has no .git
    qmk compile -e SKIP_VERSION=yes -kb zsa/voyager -km konubinix
  '';

  installPhase = "cp $QMK_HOME/*.bin $out";
};

packages.x86_64-linux.keymap-json = pkgs.stdenv.mkDerivation {
  name = "voyager.json";
  src = /. + (builtins.getEnv "KEYMAP");
  unpackCmd = "tar xf $curSrc";
  sourceRoot = ".";
  nativeBuildInputs = [
    pkgs.qmk
    pkgs.jq
  ];

  buildPhase = ''export HOME=$TMPDIR QMK_HOME=${qmk_firmware}
    qmk c2json -kb zsa/voyager -km konubinix --no-cpp keymap.c -o keymap.json
    jq 'del(.layout)' keymap.json > $out
  '';

  dontInstall = true;
};

COLOURS = {
    "shift": "0xff, 0x17, 0x00",
    "altgr": "0x00, 0x73, 0xff",
    "layer": "0xb2, 0x00, 0xff",
    "command": "0x00, 0xff, 0x37",
    "function": "0xff, 0xf0, 0x00",
    "led": "0xff, 0xff, 0xff",
    "ctrl": "0xff, 0xa5, 0x00",
    "alt": "0x00, 0xff, 0xff",
    "super": "0xff, 0x00, 0xc1",
    "letter": "0x10, 0x14, 0x18",
    "punctuation": "0xb0, 0xb0, 0xb0",
    "off": "0x00, 0x00, 0x00",
}

MODIFIERS = {
    "MOD_LSFT": "shift",
    "MOD_RSFT": "shift",
    "MOD_RALT": "altgr",
    "MOD_LALT": "alt",
    "MOD_LCTL": "ctrl",
    "MOD_RCTL": "ctrl",
    "MOD_LGUI": "super",
    "MOD_RGUI": "super",
}

FAMILIES = (
    (r"KC_F\d+$", "function"),
    (r"(RM_|RGB_|HUE_|LAYER_COLORS_ON)", "led"),
    (r"KC_(VOLD|VOLU|MUTE|MPRV|MNXT|MSTP|MPLY)$", "command"),
    (r"KC_(UP|DOWN|LEFT|RGHT|HOME|END|PGUP|PGDN)$", "altgr"),
    (r"C\(", "punctuation"),
    (r"QK_BOOT$", "shift"),
)

OWN = {
    "LAYER_COLORS_ON": "rgb_matrix_mode(RGB_MATRIX_CUSTOM_LAYER_COLORS);",
    "HUE_RED": "rgb_matrix_sethsv(0, 255, 255);",
    "HUE_GREEN": "rgb_matrix_sethsv(74, 255, 255);",
    "HUE_BLUE": "rgb_matrix_sethsv(169, 255, 255);",
}

FEATURES = (
    "CAPS_WORD_ENABLE = yes",
    "KEY_OVERRIDE_ENABLE = yes",
    "RGB_MATRIX_CUSTOM_USER = yes",
    "RGB_MATRIX_CUSTOM_KB = yes",
)

def classify(keycode, base, levels):
    held = re.match(r"MT\((MOD_\w+),", keycode)
    if held:
        return MODIFIERS[held.group(1)]
    if keycode.startswith("LT("):
        return "layer"
    for pattern, name in FAMILIES:
        if re.match(pattern, keycode):
            return name
    glyph = levels.get(keycode.split("KC_")[-1].rstrip(")"), "")
    if len(glyph) != 1:
        return "command" if keycode == "CW_TOGG" else "off"
    if glyph.isdigit():
        return "off" if base else "altgr"
    return "letter" if glyph.isalpha() else "punctuation"

def ledmap_h(layers, levels, keys, leds):
    to_led = {keys.index(m): i for i, m in enumerate(leds)}
    out = ["const uint8_t PROGMEM ledmap[][RGB_MATRIX_LED_COUNT][3] = {"]
    for index, layer in enumerate(layers):
        paint = ["off"] * len(leds)
        for position, keycode in enumerate(layer):
            paint[to_led[position]] = classify(keycode, index == 0, levels)
        out.append("    [%d] = {" % index)
        for name in paint:
            out.append("        {%s}," % COLOURS[name])
        out.append("    },")
    out += ["};", ""]
    return "\n".join(out)

RGB_MATRIX_EFFECT(LAYER_COLORS)

#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS

extern const uint8_t PROGMEM ledmap[][RGB_MATRIX_LED_COUNT][3];

static bool LAYER_COLORS(effect_params_t *params) {
    RGB_MATRIX_USE_LIMITS(led_min, led_max);
    uint8_t layer = get_highest_layer(layer_state);

    for (uint8_t i = led_min; i < led_max; i++) {
        RGB_MATRIX_TEST_LED_FLAGS();
        uint8_t v = rgb_matrix_config.hsv.v;
        rgb_matrix_set_color(i,
            scale8(pgm_read_byte(&ledmap[layer][i][0]), v),
            scale8(pgm_read_byte(&ledmap[layer][i][1]), v),
            scale8(pgm_read_byte(&ledmap[layer][i][2]), v));
    }
    return rgb_matrix_check_finished_leds(led_max);
}

#endif

set -eu

source "_clk.sh"

clk_usage () {
    cat<<EOF
$0

Light the voyager leds up, or put them out
--
F:--on/--off:Give the leds back to the firmware, or put them out:{"default": true}
EOF
}

clk_help_handler "$@"

if clk_true on
then
    voyager-disco reset
else
    voyager-disco set-color 000000
fi

{ pkgs, ... }:
{
  environment.systemPackages = [
    (pkgs.rustPlatform.buildRustPackage {
      pname = "voyager-disco";
      version = "1753694";
      src = pkgs.fetchFromGitHub {
        owner = "monorkin";
        repo = "voyager-disco";
        rev = "1753694a0d9d43b4bfb56ad5ae362d47beb8538b";
        hash = "sha256-odtKWWb6cfkCCZma/Vpt+o2yuVLFgH2rto3TitnDWqM=";
      };
      cargoHash = "sha256-+AOUfeOvfNzQjqdJjxwHvLgSn4deddaHnEPB5WGCWrY=";
      postPatch = ''
        substituteInPlace src/device.rs \
          --replace-fail "EXPECTED_PROTOCOL_VERSION: u8 = 0x04" "EXPECTED_PROTOCOL_VERSION: u8 = 0x05"
      '';
      nativeBuildInputs = [ pkgs.pkg-config ];
      buildInputs = [ pkgs.udev ];
    })
  ];
}