refactor: Rework repository structure

Using this structure, only the keymap itself is bound to a specific
board. Everything else (configuration, rules) can be shared across
multiple boards.

chzerv.c

@@ -0,0 +1,134 @@
+// vim: tabstop=2:softtabstop=2:shiftwidth=2
+
+/**
+ * Feature libraries
+ */
+#include "features/layer_lock.h"
+
+/**
+ * Layers
+ */
+enum custom_layers {
+  _BASE,
+  _NAV,
+  _SYM,
+  _FUN,
+};
+
+/**
+ * Custom keys
+ */
+enum custom_keycodes {
+  LLOCK = SAFE_RANGE,
+  SELLINE,
+  UPDIR,
+  USRNAME,
+  LITERAL,
+  ARROW,
+  ARROW_RE,
+};
+
+/**
+ * Key aliases to improve readability
+ */
+
+#define CTL_ESC LCTL_T(KC_ESC)   // 'Escape' when tapped, 'Control' when held
+#define CTL_ENT LCTL_T(KC_ENT)   // 'Enter' when tapped, 'Control' when held
+#define ENT_SFT LSFT_T(KC_ENT)   // 'Space' when tapped, 'Shift' when held
+#define BS_NAV LT(_NAV, KC_BSPC) // 'Backspace' when tapped, 'MO(_NAV)' when held
+
+#define MO_SYM MO(_SYM)
+
+#define REDO C(S(KC_Z))
+
+// One Shot Modifiers
+#define OSM_LS OSM(MOD_LSFT)
+#define OSM_RS OSM(MOD_RSFT)
+#define OSM_A OSM(MOD_LALT)
+#define OSM_G OSM(MOD_LGUI)
+#define OSM_C OSM(MOD_LCTL)
+#define OSM_CS OSM(MOD_LCTL | MOD_LSFT)
+
+// Selecting/extending words
+#define WORD_PR C(KC_LEFT)
+#define WORD_NX C(KC_RGHT)
+#define SELALL C(KC_A)
+
+// Navigating browser tabs
+#define TAB_PR C(KC_PGUP)
+#define TAB_NX C(KC_PGDN)
+#define TAB_CL C(KC_W)
+#define TAB_RE C(S(KC_T))
+
+/**
+ * Caps Word (https://docs.qmk.fm/features/caps_word)
+ */
+#ifdef CAPS_WORD_ENABLE
+bool caps_word_press_user(uint16_t keycode) {
+  switch (keycode) {
+    // Keycodes that continue Caps Word, with shift applied
+    case KC_A ... KC_Z:
+      add_weak_mods(MOD_BIT(KC_LSFT));
+      return true;
+
+      // Keycodes that continue Caps Word, without shifting
+    case KC_1 ... KC_0:
+    case KC_BSPC:
+    case KC_DEL:
+    case KC_UNDS:
+      return true;
+
+    default:
+      return false;  // Deactivate Caps Word
+  }
+}
+#endif
+
+layer_state_t layer_state_set_user(layer_state_t state) {
+  return update_tri_layer_state(state, _SYM, _NAV, _FUN);
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t* record) {
+  if (!process_layer_lock(keycode, record, LLOCK)) { return false; }
+
+  // Macros
+  if (record->event.pressed) {
+    const uint8_t mods = get_mods();
+    const uint8_t oneshot_mods = get_oneshot_mods();
+
+    switch (keycode) {
+      case UPDIR:
+        SEND_STRING("../");
+        return false;
+
+      case USRNAME:
+        SEND_STRING("chzerv");
+        return false;
+
+      case LITERAL:
+        SEND_STRING("\"${}\""SS_TAP(X_LEFT)SS_TAP(X_LEFT));
+        return false;
+
+      case SELLINE:
+        SEND_STRING(SS_TAP(X_HOME) SS_LSFT(SS_TAP(X_END)));
+        return false;
+
+      case ARROW:
+        if ((mods | oneshot_mods) & MOD_MASK_SHIFT) {
+          del_oneshot_mods(MOD_MASK_SHIFT);
+          unregister_mods(MOD_MASK_SHIFT);
+          SEND_STRING("=>");
+          register_mods(mods);
+        } else {
+          SEND_STRING("->");
+        }
+        return false;
+
+      case ARROW_RE:
+        SEND_STRING("<-");
+        return false;
+    }
+  }
+
+  return true;
+}

chzerv_config.h

@@ -0,0 +1,16 @@
+// vim: tabstop=2:softtabstop=2:shiftwidth=2
+#pragma once
+
+// Tap hold configuration
+#define TAPPING_TERM 170
+
+// Tapping a One Shot key 2 times will hold the key until tapped once again.
+// When combined with one-shot Shifts, it is a nice alternative for Caps Lock
+#define ONESHOT_TAP_TOGGLE 2
+
+#ifdef CAPS_WORD_ENABLE
+// Pressing Shift with caps word active will invert the state, allowing us to uncapitalize a single letter
+#define CAPS_WORD_INVERT_ON_SHIFT
+// Turn caps word off if no keys have been pressed after 3s
+#define CAPS_WORD_IDLE_TIMEOUT 3000
+#endif

features/layer_lock.c

@@ -0,0 +1,147 @@
+// Copyright 2022-2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @file layer_lock.c
+ * @brief Layer Lock implementation
+ *
+ * For full documentation, see
+ * <https://getreuer.info/posts/keyboards/layer-lock>
+ */
+
+#include "layer_lock.h"
+
+// The current lock state. The kth bit is on if layer k is locked.
+static layer_state_t locked_layers = 0;
+
+// Layer Lock timer to disable layer lock after X seconds inactivity
+#if LAYER_LOCK_IDLE_TIMEOUT > 0
+static uint32_t layer_lock_timer = 0;
+
+void layer_lock_task(void) {
+  if (locked_layers &&
+      timer_elapsed32(layer_lock_timer) > LAYER_LOCK_IDLE_TIMEOUT) {
+    layer_lock_all_off();
+    layer_lock_timer = timer_read32();
+  }
+}
+#endif  // LAYER_LOCK_IDLE_TIMEOUT > 0
+
+// Handles an event on an `MO` or `TT` layer switch key.
+static bool handle_mo_or_tt(uint8_t layer, keyrecord_t* record) {
+  if (is_layer_locked(layer)) {
+    if (record->event.pressed) {  // On press, unlock the layer.
+      layer_lock_invert(layer);
+    }
+    return false;  // Skip default handling.
+  }
+  return true;
+}
+
+bool process_layer_lock(uint16_t keycode, keyrecord_t* record,
+                        uint16_t lock_keycode) {
+#if LAYER_LOCK_IDLE_TIMEOUT > 0
+  layer_lock_timer = timer_read32();
+#endif  // LAYER_LOCK_IDLE_TIMEOUT > 0
+
+  // The intention is that locked layers remain on. If something outside of
+  // this feature turned any locked layers off, unlock them.
+  if ((locked_layers & ~layer_state) != 0) {
+    layer_lock_set_user(locked_layers &= layer_state);
+  }
+
+  if (keycode == lock_keycode) {
+    if (record->event.pressed) {  // The layer lock key was pressed.
+      layer_lock_invert(get_highest_layer(layer_state));
+    }
+    return false;
+  }
+
+  switch (keycode) {
+    case QK_MOMENTARY ... QK_MOMENTARY_MAX:  // `MO(layer)` keys.
+      return handle_mo_or_tt(QK_MOMENTARY_GET_LAYER(keycode), record);
+
+    case QK_LAYER_TAP_TOGGLE ... QK_LAYER_TAP_TOGGLE_MAX:  // `TT(layer)`.
+      return handle_mo_or_tt(QK_LAYER_TAP_TOGGLE_GET_LAYER(keycode), record);
+
+    case QK_LAYER_MOD ... QK_LAYER_MOD_MAX: {  // `LM(layer, mod)`.
+      uint8_t layer = QK_LAYER_MOD_GET_LAYER(keycode);
+      if (is_layer_locked(layer)) {
+        if (record->event.pressed) {  // On press, unlock the layer.
+          layer_lock_invert(layer);
+        } else {  // On release, clear the mods.
+          clear_mods();
+          send_keyboard_report();
+        }
+        return false;  // Skip default handling.
+      }
+    } break;
+
+#ifndef NO_ACTION_TAPPING
+    case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:  // `LT(layer, key)` keys.
+      if (record->tap.count == 0 && !record->event.pressed &&
+          is_layer_locked(QK_LAYER_TAP_GET_LAYER(keycode))) {
+        // Release event on a held layer-tap key where the layer is locked.
+        return false;  // Skip default handling so that layer stays on.
+      }
+      break;
+#endif  // NO_ACTION_TAPPING
+  }
+
+  return true;
+}
+
+bool is_layer_locked(uint8_t layer) {
+  return locked_layers & ((layer_state_t)1 << layer);
+}
+
+void layer_lock_invert(uint8_t layer) {
+  const layer_state_t mask = (layer_state_t)1 << layer;
+  if ((locked_layers & mask) == 0) {  // Layer is being locked.
+#ifndef NO_ACTION_ONESHOT
+    if (layer == get_oneshot_layer()) {
+      reset_oneshot_layer();  // Reset so that OSL doesn't turn layer off.
+    }
+#endif  // NO_ACTION_ONESHOT
+    layer_on(layer);
+#if LAYER_LOCK_IDLE_TIMEOUT > 0
+    layer_lock_timer = timer_read32();
+#endif  // LAYER_LOCK_IDLE_TIMEOUT > 0
+  } else {  // Layer is being unlocked.
+    layer_off(layer);
+  }
+  layer_lock_set_user(locked_layers ^= mask);
+}
+
+// Implement layer_lock_on/off by deferring to layer_lock_invert.
+void layer_lock_on(uint8_t layer) {
+  if (!is_layer_locked(layer)) {
+    layer_lock_invert(layer);
+  }
+}
+
+void layer_lock_off(uint8_t layer) {
+  if (is_layer_locked(layer)) {
+    layer_lock_invert(layer);
+  }
+}
+
+void layer_lock_all_off(void) {
+  layer_and(~locked_layers);
+  locked_layers = 0;
+  layer_lock_set_user(locked_layers);
+}
+
+__attribute__((weak)) void layer_lock_set_user(layer_state_t locked_layers) {}
+

features/layer_lock.h

@@ -0,0 +1,137 @@
+// Copyright 2022-2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @file layer_lock.h
+ * @brief Layer Lock, a key to stay in the current layer.
+ *
+ * Overview
+ * --------
+ *
+ * Layers are often accessed by holding a button, e.g. with a momentary layer
+ * switch `MO(layer)` or layer tap `LT(layer, key)` key. But you may sometimes
+ * want to "lock" or "toggle" the layer so that it stays on without having to
+ * hold down a button. One way to do that is with a tap-toggle `TT` layer key,
+ * but here is an alternative.
+ *
+ * This library implements a "Layer Lock key". When tapped, it "locks" the
+ * highest layer to stay active, assuming the layer was activated by one of the
+ * following keys:
+ *
+ *  * `MO(layer)` momentary layer switch
+ *  * `LT(layer, key)` layer tap
+ *  * `OSL(layer)` one-shot layer
+ *  * `TT(layer)` layer tap toggle
+ *  * `LM(layer, mod)` layer-mod key (the layer is locked, but not the mods)
+ *
+ * Tapping the Layer Lock key again unlocks and turns off the layer.
+ *
+ * @note When a layer is "locked", other layer keys such as `TO(layer)` or
+ * manually calling `layer_off(layer)` will override and unlock the layer.
+ *
+ * Configuration
+ * -------------
+ *
+ * Optionally, a timeout may be defined so that Layer Lock disables
+ * automatically if not keys are pressed for `LAYER_LOCK_IDLE_TIMEOUT`
+ * milliseconds. Define `LAYER_LOCK_IDLE_TIMEOUT` in your config.h, for instance
+ *
+ *     #define LAYER_LOCK_IDLE_TIMEOUT 60000  // Turn off after 60 seconds.
+ *
+ * and call `layer_lock_task()` from your `matrix_scan_user()` in keymap.c:
+ *
+ *     void matrix_scan_user(void) {
+ *       layer_lock_task();
+ *       // Other tasks...
+ *     }
+ *
+ * For full documentation, see
+ * <https://getreuer.info/posts/keyboards/layer-lock>
+ */
+
+#pragma once
+
+#include "quantum.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Handler function for Layer Lock.
+ *
+ * In your keymap, define a custom keycode to use for Layer Lock. Then handle
+ * Layer Lock from your `process_record_user` function by calling
+ * `process_layer_lock`, passing your custom keycode for the `lock_keycode` arg:
+ *
+ *     #include "features/layer_lock.h"
+ *
+ *     bool process_record_user(uint16_t keycode, keyrecord_t* record) {
+ *       if (!process_layer_lock(keycode, record, LLOCK)) { return false; }
+ *       // Your macros ...
+ *
+ *       return true;
+ *     }
+ */
+bool process_layer_lock(uint16_t keycode, keyrecord_t* record,
+                        uint16_t lock_keycode);
+
+/** Returns true if `layer` is currently locked. */
+bool is_layer_locked(uint8_t layer);
+
+/** Locks and turns on `layer`. */
+void layer_lock_on(uint8_t layer);
+
+/** Unlocks and turns off `layer`. */
+void layer_lock_off(uint8_t layer);
+
+/** Unlocks and turns off all locked layers. */
+void layer_lock_all_off(void);
+
+/** Toggles whether `layer` is locked. */
+void layer_lock_invert(uint8_t layer);
+
+/**
+ * Optional callback that gets called when a layer is locked or unlocked.
+ *
+ * This is useful to represent the current lock state, e.g. by setting an LED or
+ * playing a sound. In your keymap, define
+ *
+ *     void layer_lock_set_user(layer_state_t locked_layers) {
+ *       // Do something like `set_led(is_layer_locked(NAV));`
+ *     }
+ *
+ * @param locked_layers Bitfield in which the kth bit represents whether the
+ *                      kth layer is on.
+ */
+void layer_lock_set_user(layer_state_t locked_layers);
+
+/**
+ * @fn layer_lock_task(void)
+ * Matrix task function for Layer Lock.
+ *
+ * If using `LAYER_LOCK_IDLE_TIMEOUT`, call this function from your
+ * `matrix_scan_user()` function in keymap.c. (If no timeout is set, calling
+ * `layer_lock_task()` has no effect.)
+ */
+#if LAYER_LOCK_IDLE_TIMEOUT > 0
+void layer_lock_task(void);
+#else
+static inline void layer_lock_task(void) {}
+#endif  // LAYER_LOCK_IDLE_TIMEOUT > 0
+
+#ifdef __cplusplus
+}
+#endif
+

keyboards/keebio/iris_ce/keymaps/chzerv/config.h

@@ -1,24 +1,4 @@
+// vim: tabstop=2:softtabstop=2:shiftwidth=2
 #pragma once
 
-// Many settings are taken from https://github.com/getreuer/qmk-keymap/
+#include "chzerv_config.h"
-
-#define TAPPING_TOGGLE 2
-#define SELECT_WORD_TIMEOUT 2000  // When idle, clear state after 2 seconds.
-
-//
-// Tap/hold configuration for home row mods
-//
-#define TAPPING_TERM 170
-#define TAPPING_TERM_PER_KEY
-#define PERMISSIVE_HOLD
-#define QUICK_TAP_TERM_PER_KEY
-
-//
-// RGB
-//
-
-// Turn RGB off when PC goes on sleep
-#define RGBLIGHT_SLEEP
-
-// the modes we do use for lights
-#define RGBLIGHT_EFFECT_BREATHING

keyboards/keebio/iris_ce/keymaps/chzerv/rules.mk

@@ -1,15 +1,3 @@
-LTO_ENABLE = yes
+# Include keyboard independent rules from the root directory
-# VIA_ENABLE = yes
+ROOT_DIR := $(dir $(realpath $(lastword $(MAKEFILE_LIST))))
-
+include ${ROOT_DIR}../../../../../rules.mk
-TRI_LAYER_ENABLE = yes
-CAPS_WORD_ENABLE = yes
-DYNAMIC_TAPPING_TERM_ENABLE = yes
-
-SRC += features/select_word.c
-
-# Diasble features we don't use to reduce firmware size
-COMMAND_ENABLE = no
-MAGIC_ENABLE = no
-AUDIO_ENABLE = no
-BLUETOOTH_ENABLE = no
-CONSOLE_ENABLE = no

rules.mk

@@ -0,0 +1,20 @@
+# Disable features we don't use
+COMMAND_ENABLE = no
+CONSOLE_ENABLE = no
+GRAVE_ESC_ENABLE = no
+MAGIC_ENABLE = no
+SPACE_CADET_ENABLE = no
+BLUETOOTH_ENABLE = no
+
+# Compile with `flto` for smaller firmware size
+LTO_ENABLE = yes
+
+# Enable N-Key Rollover
+NKRO_ENABLE = yes
+TRI_LAYER_ENABLE = yes
+
+# https://docs.qmk.fm/features/caps_word
+CAPS_WORD_ENABLE = yes
+
+# Feature libraries
+SRC += features/layer_lock.c