From 1a25d368ad2cdff0b2e1ea97cb4e540889bf29fb Mon Sep 17 00:00:00 2001 From: Drew Whitney Date: Sun, 9 Nov 2025 00:38:39 -0700 Subject: [PATCH] Started mapping out the iris --- flash.sh | 1 + keyboards/keebio/iris_lm/keymaps/drew/alias.h | 45 ++ .../keymaps/drew/caps_word/caps_word.c | 29 ++ .../keymaps/drew/caps_word/caps_word.h | 4 + .../drew/chordal_hold/chordal_options.c | 15 + .../drew/chordal_hold/chordal_options.h | 9 + .../keebio/iris_lm/keymaps/drew/config.h | 19 + .../keymaps/drew/flow_tap/flow_tap_options.c | 35 ++ .../keebio/iris_lm/keymaps/drew/keyboard.json | 257 ++++++++++ .../keebio/iris_lm/keymaps/drew/keymap.c | 439 ++++++++++++++++++ .../keebio/iris_lm/keymaps/drew/layers.h | 8 + .../keebio/iris_lm/keymaps/drew/rules.mk | 17 + .../keymaps/drew/tap_dance/tap_dance.c | 23 + .../keymaps/drew/tap_dance/tap_dance.h | 5 + .../keymaps/drew/taphold/taphold_options.c | 139 ++++++ .../keebio/iris_lm/keymaps/drew/utils/utils.c | 60 +++ .../keebio/iris_lm/keymaps/drew/utils/utils.h | 54 +++ qmk.json | 5 +- 18 files changed, 1160 insertions(+), 4 deletions(-) create mode 100644 flash.sh create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/alias.h create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/caps_word/caps_word.c create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/caps_word/caps_word.h create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/chordal_hold/chordal_options.c create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/chordal_hold/chordal_options.h create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/config.h create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/flow_tap/flow_tap_options.c create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/keyboard.json create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/keymap.c create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/layers.h create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/rules.mk create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/tap_dance/tap_dance.c create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/tap_dance/tap_dance.h create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/taphold/taphold_options.c create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/utils/utils.c create mode 100644 keyboards/keebio/iris_lm/keymaps/drew/utils/utils.h diff --git a/flash.sh b/flash.sh new file mode 100644 index 00000000..63ce5f44 --- /dev/null +++ b/flash.sh @@ -0,0 +1 @@ +qmk flash -kb keebio/iris_lm/g1 -km drew -j 0 \ No newline at end of file diff --git a/keyboards/keebio/iris_lm/keymaps/drew/alias.h b/keyboards/keebio/iris_lm/keymaps/drew/alias.h new file mode 100644 index 00000000..7e9f8d86 --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/alias.h @@ -0,0 +1,45 @@ +#pragma once + +#include QMK_KEYBOARD_H +#include "./layers.h" + +/// @brief Custom keycodes. +enum CustomKeycodes { + DOWN = SAFE_RANGE, + UP, + + LOW_6, + LOW_7, + LOW_8, + LOW_9, + LOW_0, + + MULT, // avoids a conflict with KC_ASTR +}; + +#define TD_CLS TD(TD_CAD_LOCK_SLEEP) +#define COMPOSE KC_SCRL +// keys +#define CAD C(A(KC_DEL)) +#define LAUNCH A(KC_SPC) +#define MENU S(KC_F10) +#define TAB_RIGHT C(KC_TAB) +#define TAB_LEFT (C(S(KC_TAB))) + +// layers +// #define NUM_SPC LT(_NUM, KC_SPC) +// #define NAV_ENT LT(_NAV, KC_ENT) +// #define FUNC_PLAY LT(_FUNC, KC_MPLY) + +// #define NAV_SPC LT(_NAV, KC_SPC) +#define NUM_SPC LT(_NUM, KC_SPC) +#define NAV MO(_NAV) +#define NUM MO(_NUM) +#define SYM MO(_SYM) + +// mod-taps (not homerow mods) +// #define GUI_LAUNCH GUI_T(LAUNCH) + +// trigger mods +#define TABBING_TRIGGER_MODS MOD_MASK_ALT +#define OBLITERATE_TRIGGER_MODS MOD_MASK_GUI diff --git a/keyboards/keebio/iris_lm/keymaps/drew/caps_word/caps_word.c b/keyboards/keebio/iris_lm/keymaps/drew/caps_word/caps_word.c new file mode 100644 index 00000000..f0989a0a --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/caps_word/caps_word.c @@ -0,0 +1,29 @@ +#include QMK_KEYBOARD_H +#include "caps_word.h" +#include "../alias.h" +#include "../tap_dance/tap_dance.h" + +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)); // Apply shift to next key + return true; + break; + // Keycodes that continue Caps Word, without shifting + case KC_1 ... KC_0: + case LOW_6 ... LOW_0: + case KC_BSPC: + case KC_DEL: + case KC_LEFT: + case KC_RGHT: + case KC_MINS: + case KC_UNDS: + case KC_SLSH: + return true; + break; + default: + return false; // Deactivate Caps Word + break; + } +} diff --git a/keyboards/keebio/iris_lm/keymaps/drew/caps_word/caps_word.h b/keyboards/keebio/iris_lm/keymaps/drew/caps_word/caps_word.h new file mode 100644 index 00000000..228a94ad --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/caps_word/caps_word.h @@ -0,0 +1,4 @@ +#pragma once +#include "stdint.h" + +bool caps_word_press_user(uint16_t keycode); diff --git a/keyboards/keebio/iris_lm/keymaps/drew/chordal_hold/chordal_options.c b/keyboards/keebio/iris_lm/keymaps/drew/chordal_hold/chordal_options.c new file mode 100644 index 00000000..1d03d38e --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/chordal_hold/chordal_options.c @@ -0,0 +1,15 @@ +// TODO: possibly remove + +#include "../alias.h" + +bool get_chordal_hold( + uint16_t tap_hold_keycode, keyrecord_t* tap_hold_record, uint16_t other_keycode, + keyrecord_t* other_record +) { + switch (tap_hold_keycode) { + case SFT_D: + case SFT_K: // no same hand stuff for shift + return get_chordal_hold_default(tap_hold_record, other_record); + } + return true; // allow same hand stuff for everything else +} \ No newline at end of file diff --git a/keyboards/keebio/iris_lm/keymaps/drew/chordal_hold/chordal_options.h b/keyboards/keebio/iris_lm/keymaps/drew/chordal_hold/chordal_options.h new file mode 100644 index 00000000..e4cdc9b3 --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/chordal_hold/chordal_options.h @@ -0,0 +1,9 @@ +#pragma once + +#include QMK_KEYBOARD_H +#include "stdint.h" + +bool get_chordal_hold( + uint16_t tap_hold_keycode, keyrecord_t* tap_hold_record, uint16_t other_keycode, + keyrecord_t* other_record +); \ No newline at end of file diff --git a/keyboards/keebio/iris_lm/keymaps/drew/config.h b/keyboards/keebio/iris_lm/keymaps/drew/config.h new file mode 100644 index 00000000..0e59b003 --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/config.h @@ -0,0 +1,19 @@ +#pragma once + +#include "./layers.h" + +#define TAPPING_TERM 200 + +#define QUICK_TAP_TERM_PER_KEY + +#define HOLD_ON_OTHER_KEY_PRESS_PER_KEY +#define PERMISSIVE_HOLD_PER_KEY +#define TAPPING_TERM_PER_KEY +// #define FLOW_TAP_TERM 150 +// #define CHORDAL_HOLD + +#define CAPS_WORD_IDLE_TIMEOUT 0 + +#define DUMMY_MOD_NEUTRALIZER_KEYCODE KC_RCTL +#define MODS_TO_NEUTRALIZE {MOD_BIT(KC_LALT), MOD_BIT(KC_RALT), MOD_BIT(KC_LGUI), MOD_BIT(KC_RGUI)} + diff --git a/keyboards/keebio/iris_lm/keymaps/drew/flow_tap/flow_tap_options.c b/keyboards/keebio/iris_lm/keymaps/drew/flow_tap/flow_tap_options.c new file mode 100644 index 00000000..206ace4b --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/flow_tap/flow_tap_options.c @@ -0,0 +1,35 @@ +#include QMK_KEYBOARD_H +#include "../alias.h" + +uint16_t get_flow_tap_term(uint16_t keycode, keyrecord_t* record, uint16_t previous_keycode) { + switch (get_tap_keycode(previous_keycode)) { + case KC_A ... KC_Z: + case KC_DOT: + case KC_COMM: + case KC_SCLN: + case KC_SLSH: + case KC_QUOT: // enable flow-tap for these keys + break; + + default: // disable otherwise + return 0; + } + + switch (keycode) { + case CTL_D: + case CTL_K: + case CTL_3: + case CTL_8: + case CTL_RBRC: + case CTL_DOWN: // control should always be allowed to hold + + case GUI_LAUNCH: // same with non-homerow mod taps + + case NUM_SPC: + case NAV_ENT: + case FUNC_PLAY: // same with layer-taps + return 0; + break; + } + return FLOW_TAP_TERM; // enable flow-tap +} diff --git a/keyboards/keebio/iris_lm/keymaps/drew/keyboard.json b/keyboards/keebio/iris_lm/keymaps/drew/keyboard.json new file mode 100644 index 00000000..34a3ab59 --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/keyboard.json @@ -0,0 +1,257 @@ +{ + "keyboard_name": "Iris LM-G Rev. 1", + "bootloader": "stm32-dfu", + "diode_direction": "COL2ROW", + "features": { + "bootmagic": true, + "encoder": false, + "extrakey": false, + "mousekey": false, + "rgb_matrix": true + }, + "encoder": { + "rotary": [ + {"pin_a": "A15", "pin_b": "C10"}, + {"pin_a": "B13", "pin_b": "B12"} + ] + }, + "ws2812": { + "driver": "pwm", + "pin": "B7" + }, + "matrix_pins": { + "cols": ["C4", "B2", "A5", "C11", "C13", "C14"], + "rows": ["A4", "A3", "B14", "B5", "F1"] + }, + "split": { + "enabled": true, + "encoder": { + "right": { + "rotary": [ + {"pin_a": "A5", "pin_b": "A6"}, + {"pin_a": "A15", "pin_b": "C10"} + ] + } + }, + "matrix_pins": { + "right": { + "cols": ["C11", "C13", "B6", "B9", "B12", "B2"], + "rows": ["C4", "A7", "B14", "B5", "F1"] + } + }, + "serial": { + "driver": "usart" + }, + "transport": { + "sync" :{ + "matrix_state": true + } + } + }, + "processor": "STM32G431", + "usb": { + "device_version": "1.0.0", + "pid": "0x1656" + }, + "layouts": { + "LAYOUT": { + "layout": [ + {"matrix": [0, 0], "x": 0, "y": 0.375}, + {"matrix": [0, 1], "x": 1, "y": 0.375}, + {"matrix": [0, 2], "x": 2, "y": 0.125}, + {"matrix": [0, 3], "x": 3, "y": 0}, + {"matrix": [0, 4], "x": 4, "y": 0.125}, + {"matrix": [0, 5], "x": 5, "y": 0.25}, + + {"matrix": [5, 5], "x": 9, "y": 0.25}, + {"matrix": [5, 4], "x": 10, "y": 0.125}, + {"matrix": [5, 3], "x": 11, "y": 0}, + {"matrix": [5, 2], "x": 12, "y": 0.125}, + {"matrix": [5, 1], "x": 13, "y": 0.375}, + {"matrix": [5, 0], "x": 14, "y": 0.375}, + + {"matrix": [1, 0], "x": 0, "y": 1.375}, + {"matrix": [1, 1], "x": 1, "y": 1.375}, + {"matrix": [1, 2], "x": 2, "y": 1.125}, + {"matrix": [1, 3], "x": 3, "y": 1}, + {"matrix": [1, 4], "x": 4, "y": 1.125}, + {"matrix": [1, 5], "x": 5, "y": 1.25}, + + {"matrix": [6, 5], "x": 9, "y": 1.25}, + {"matrix": [6, 4], "x": 10, "y": 1.125}, + {"matrix": [6, 3], "x": 11, "y": 1}, + {"matrix": [6, 2], "x": 12, "y": 1.125}, + {"matrix": [6, 1], "x": 13, "y": 1.375}, + {"matrix": [6, 0], "x": 14, "y": 1.375}, + + {"matrix": [2, 0], "x": 0, "y": 2.375}, + {"matrix": [2, 1], "x": 1, "y": 2.375}, + {"matrix": [2, 2], "x": 2, "y": 2.125}, + {"matrix": [2, 3], "x": 3, "y": 2}, + {"matrix": [2, 4], "x": 4, "y": 2.125}, + {"matrix": [2, 5], "x": 5, "y": 2.25}, + + {"matrix": [7, 5], "x": 9, "y": 2.25}, + {"matrix": [7, 4], "x": 10, "y": 2.125}, + {"matrix": [7, 3], "x": 11, "y": 2}, + {"matrix": [7, 2], "x": 12, "y": 2.125}, + {"matrix": [7, 1], "x": 13, "y": 2.375}, + {"matrix": [7, 0], "x": 14, "y": 2.375}, + + {"matrix": [3, 0], "x": 0, "y": 3.375}, + {"matrix": [3, 1], "x": 1, "y": 3.375}, + {"matrix": [3, 2], "x": 2, "y": 3.125}, + {"matrix": [3, 3], "x": 3, "y": 3}, + {"matrix": [3, 4], "x": 4, "y": 3.125}, + {"matrix": [3, 5], "x": 5, "y": 3.25}, + {"matrix": [4, 5], "x": 6.15, "y": 3.75}, + + {"matrix": [9, 5], "x": 7.85, "y": 3.75}, + {"matrix": [8, 5], "x": 9, "y": 3.25}, + {"matrix": [8, 4], "x": 10, "y": 3.125}, + {"matrix": [8, 3], "x": 11, "y": 3}, + {"matrix": [8, 2], "x": 12, "y": 3.125}, + {"matrix": [8, 1], "x": 13, "y": 3.375}, + {"matrix": [8, 0], "x": 14, "y": 3.375}, + + {"matrix": [4, 2], "x": 3.5, "y": 4.25}, + {"matrix": [4, 3], "x": 4.5, "y": 4.375}, + {"matrix": [4, 4], "x": 5.6, "y": 4.75}, + + {"matrix": [9, 4], "x": 8.4, "y": 4.75}, + {"matrix": [9, 3], "x": 9.5, "y": 4.375}, + {"matrix": [9, 2], "x": 10.5, "y": 4.25} + ] + } + }, + "rgb_matrix": { + "animations": { + "alphas_mods": true, + "gradient_up_down": true, + "gradient_left_right": true, + "breathing": true, + "band_sat": true, + "band_val": true, + "band_pinwheel_sat": true, + "band_pinwheel_val": true, + "band_spiral_sat": true, + "band_spiral_val": true, + "cycle_all": true, + "cycle_left_right": true, + "cycle_up_down": true, + "cycle_out_in": true, + "cycle_out_in_dual": true, + "rainbow_moving_chevron": true, + "cycle_pinwheel": true, + "cycle_spiral": true, + "dual_beacon": true, + "rainbow_beacon": true, + "rainbow_pinwheels": true, + "raindrops": true, + "jellybean_raindrops": true, + "hue_breathing": true, + "hue_pendulum": true, + "hue_wave": true, + "pixel_fractal": true, + "pixel_flow": true, + "pixel_rain": true, + "typing_heatmap": true, + "digital_rain": true, + "solid_reactive_simple": true, + "solid_reactive": true, + "solid_reactive_wide": true, + "solid_reactive_multiwide": true, + "solid_reactive_cross": true, + "solid_reactive_multicross": true, + "solid_reactive_nexus": true, + "solid_reactive_multinexus": true, + "splash": true, + "multisplash": true, + "solid_splash": true, + "solid_multisplash": true + }, + "driver": "ws2812", + "split_count": [34, 34], + "max_brightness": 120, + "layout": [ + {"matrix": [0,0], "flags":4, "x":0, "y":5}, + {"flags":2, "x":8, "y":5}, + {"matrix": [0,1], "flags":4, "x":16, "y":5}, + {"matrix": [0,2], "flags":4, "x":32, "y":2}, + {"flags":2, "x":40, "y":1}, + {"matrix": [0,3], "flags":4, "x":48, "y":0}, + {"matrix": [0,4], "flags":4, "x":64, "y":5}, + {"flags":2, "x":72, "y":3}, + {"matrix": [0,5], "flags":4, "x":80, "y":3}, + + {"matrix": [1,5], "flags":4, "x":80, "y":17}, + {"matrix": [1,4], "flags":4, "x":64, "y":15}, + {"matrix": [1,3], "flags":4, "x":48, "y":13}, + {"matrix": [1,2], "flags":4, "x":32, "y":15}, + {"matrix": [1,1], "flags":4, "x":16, "y":18}, + {"matrix": [1,0], "flags":4, "x":0, "y":18}, + + {"matrix": [2,0], "flags":4, "x":0, "y":32}, + {"matrix": [2,1], "flags":4, "x":16, "y":32}, + {"matrix": [2,2], "flags":4, "x":32, "y":28}, + {"matrix": [2,3], "flags":4, "x":48, "y":27}, + {"matrix": [2,4], "flags":4, "x":64, "y":28}, + {"matrix": [2,5], "flags":4, "x":80, "y":30}, + + {"matrix": [3,5], "flags":4, "x":80, "y":43}, + {"matrix": [3,4], "flags":4, "x":64, "y":42}, + {"matrix": [3,3], "flags":4, "x":48, "y":40}, + {"flags":2, "x":40, "y":50}, + {"matrix": [3,2], "flags":4, "x":32, "y":42}, + {"matrix": [3,1], "flags":4, "x":16, "y":45}, + {"flags":2, "x":8, "y":43}, + {"matrix": [3,0], "flags":4, "x":0, "y":45}, + + {"matrix": [4,5], "flags":4, "x":98, "y":52}, + {"matrix": [4,4], "flags":4, "x":90, "y":64}, + {"flags":2, "x":80, "y":58}, + {"matrix": [4,3], "flags":4, "x":72, "y":58}, + {"matrix": [4,2], "flags":4, "x":56, "y":47}, + + {"matrix": [5,0], "flags":4, "x":224, "y":5}, + {"flags":2, "x":216, "y":5}, + {"matrix": [5,1], "flags":4, "x":208, "y":5}, + {"matrix": [5,2], "flags":4, "x":192, "y":2}, + {"flags":2, "x":184, "y":1}, + {"matrix": [5,3], "flags":4, "x":176, "y":0}, + {"matrix": [5,4], "flags":4, "x":160, "y":5}, + {"flags":2, "x":152, "y":3}, + {"matrix": [5,5], "flags":4, "x":144, "y":3}, + + {"matrix": [6,5], "flags":4, "x":144, "y":17}, + {"matrix": [6,4], "flags":4, "x":160, "y":15}, + {"matrix": [6,3], "flags":4, "x":176, "y":13}, + {"matrix": [6,2], "flags":4, "x":192, "y":15}, + {"matrix": [6,1], "flags":4, "x":208, "y":18}, + {"matrix": [6,0], "flags":4, "x":224, "y":18}, + + {"matrix": [7,0], "flags":4, "x":224, "y":32}, + {"matrix": [7,1], "flags":4, "x":208, "y":32}, + {"matrix": [7,2], "flags":4, "x":192, "y":28}, + {"matrix": [7,3], "flags":4, "x":176, "y":27}, + {"matrix": [7,4], "flags":4, "x":160, "y":28}, + {"matrix": [7,5], "flags":4, "x":144, "y":30}, + + {"matrix": [8,5], "flags":4, "x":144, "y":43}, + {"matrix": [8,4], "flags":4, "x":160, "y":42}, + {"matrix": [8,3], "flags":4, "x":176, "y":40}, + {"flags":2, "x":184, "y":50}, + {"matrix": [8,2], "flags":4, "x":192, "y":42}, + {"matrix": [8,1], "flags":4, "x":208, "y":45}, + {"flags":2, "x":216, "y":43}, + {"matrix": [8,0], "flags":4, "x":224, "y":45}, + + {"matrix": [9,2], "flags":4, "x":168, "y":47}, + {"matrix": [9,3], "flags":4, "x":152, "y":58}, + {"flags":2, "x":144, "y":58}, + {"matrix": [9,4], "flags":4, "x":134, "y":64}, + {"matrix": [9,5], "flags":4, "x":126, "y":52} + ], + "sleep": true + } +} diff --git a/keyboards/keebio/iris_lm/keymaps/drew/keymap.c b/keyboards/keebio/iris_lm/keymaps/drew/keymap.c new file mode 100644 index 00000000..c8ff6088 --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/keymap.c @@ -0,0 +1,439 @@ +#include QMK_KEYBOARD_H +#include "./caps_word/caps_word.h" +#include "./layers.h" +#include "./tap_dance/tap_dance.c" +#include "./tap_dance/tap_dance.h" +#include "./utils/utils.h" +#include "stdbool.h" +#include "stdint.h" + +bool NAV_enabled = false; + +// clang-format off +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { +[_BASE] = LAYOUT( +//┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ + TD_CLS, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, COMPOSE, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_ESC, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_TAB, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┼───────────┐ ┌───────────┼───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + CW_TOGG, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_NO, QK_BOOT, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_DEL, +//└───────────┴───────────┴───────────┴─────┬─────┴─────┬─────┴─────┬─────┴────┬──────┘ └─────┬─────┴─────┬─────┴─────┬─────┴─────┬─────┴───────────┴───────────┴───────────┘ + KC_LALT, NAV, NUM_SPC, KC_ENT, SYM, KC_NO +// └───────────┴───────────┴──────────┘ └───────────┴───────────┴───────────┘ +), + +[_GAME] = LAYOUT( +//┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ + KC_TAB, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_LCTL, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┼───────────┐ ┌───────────┼───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_LSFT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, +//└───────────┴───────────┴───────────┴─────┬─────┴─────┬─────┴─────┬─────┴────┬──────┘ └─────┬─────┴─────┬─────┴─────┬─────┴─────┬─────┴───────────┴───────────┴───────────┘ + KC_TRNS, KC_SPC, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS +// └───────────┴───────────┴──────────┘ └───────────┴───────────┴───────────┘ +), + +[_NAV] = LAYOUT( +//┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ + TD_CLS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_TRNS, KC_NO, TAB_LEFT, LAUNCH, TAB_RIGHT, KC_NO, KC_NO, KC_HOME, KC_UP, KC_END, KC_NO, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_TAB, OS_LGUI, OS_LALT, OS_LCTL, OS_LSFT, KC_MPLY, KC_NO, KC_LEFT, KC_DOWN, KC_RGHT, KC_TRNS, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┼───────────┐ ┌───────────┼───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_CAPS, KC_MUTE, KC_MPRV, KC_VOLD, KC_VOLU, KC_MNXT, KC_TRNS, KC_TRNS, KC_NO, KC_F2, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, +//└───────────┴───────────┴───────────┴─────┬─────┴─────┬─────┴─────┬─────┴────┬──────┘ └─────┬─────┴─────┬─────┴─────┬─────┴─────┬─────┴───────────┴───────────┴───────────┘ + KC_TRNS, NUM, KC_TRNS, KC_ENT, SYM, KC_NO +// └───────────┴───────────┴──────────┘ └───────────┴───────────┴───────────┘ +), + +[_SYM] = LAYOUT( +//┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ + TD_CLS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_TRNS, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_TAB, KC_BSLS, KC_LBRC, KC_RBRC, KC_MINS, KC_EQL, KC_GRV, OS_RSFT, OS_RCTL, OS_RALT, OS_RGUI, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┼───────────┐ ┌───────────┼───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_CAPS, KC_PIPE, KC_LCBR, KC_RCBR, KC_UNDS, KC_PLUS, KC_TRNS, KC_TRNS, KC_TILD, KC_F2, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, +//└───────────┴───────────┴───────────┴─────┬─────┴─────┬─────┴─────┬─────┴────┬──────┘ └─────┬─────┴─────┬─────┴─────┬─────┴─────┬─────┴───────────┴───────────┴───────────┘ + KC_TRNS, NUM, KC_TRNS, KC_NO, SYM, KC_NO +// └───────────┴───────────┴──────────┘ └───────────┴───────────┴───────────┘ +), + +[_NUM] = LAYOUT( +//┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ + TD_CLS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_TRNS, KC_SLSH, KC_AT, MULT, KC_MINS, KC_PLUS, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_DOT, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┼───────────┐ ┌───────────┼───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_COMM, KC_6, KC_7, KC_8, KC_9, KC_0, KC_TRNS, KC_TRNS, KC_SCLN, KC_COLN, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, +//└───────────┴───────────┴───────────┴─────┬─────┴─────┬─────┴─────┬─────┴────┬──────┘ └─────┬─────┴─────┬─────┴─────┬─────┴─────┬─────┴───────────┴───────────┴───────────┘ + KC_TRNS, NUM, KC_TRNS, KC_ENT, SYM, KC_NO +// └───────────┴───────────┴──────────┘ └───────────┴───────────┴───────────┘ +), + +[_FUNC] = LAYOUT( +//┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ + TD_CLS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_F1, KC_F2, TAB_LEFT, LAUNCH, TAB_RIGHT, KC_NO, KC_NO, KC_HOME, KC_UP, KC_END, KC_NO, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ ├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_TAB, OS_LGUI, OS_LALT, OS_LCTL, OS_LSFT, KC_MPLY, KC_NO, KC_LEFT, KC_DOWN, KC_RGHT, KC_TRNS, KC_TRNS, +//├───────────┼───────────┼───────────┼───────────┼───────────┼───────────┼───────────┐ ┌───────────┼───────────┼───────────┼───────────┼───────────┼───────────┼───────────┤ + KC_CAPS, KC_MUTE, KC_MPRV, KC_VOLD, KC_VOLU, KC_MNXT, KC_TRNS, KC_TRNS, KC_NO, KC_F2, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, +//└───────────┴───────────┴───────────┴─────┬─────┴─────┬─────┴─────┬─────┴────┬──────┘ └─────┬─────┴─────┬─────┴─────┬─────┴─────┬─────┴───────────┴───────────┴───────────┘ + KC_TRNS, NUM, KC_TRNS, KC_ENT, SYM, KC_NO +// └───────────┴───────────┴──────────┘ └───────────┴───────────┴───────────┘ +), +}; +// clang-format on + +layer_state_t layer_state_set_user(layer_state_t state) { + static bool + if (layer_state_cmp(state, _NAV) && layer_state_cmp(state, _SYM)) { + layer_on(_NUM); + } else { + layer_off(_NUM); + } + return state; +} + + + +// bool process_record_user(uint16_t keycode, keyrecord_t* record) { +// switch (keycode) { +// case GUI_TD_CLS: // make this keycode work (16-bit mod-tap) +// if (record->tap.count) { +// if (record->event.pressed) { +// tap_code16(TD_CLS); +// } +// return false; +// } +// break; + +// // make it possible to go from layer 3 to layer 2 +// case NUM_SPC: +// if (!record->tap.count) { +// if (NAV_enabled) { +// record->event.pressed ? layer_off(_NAV) : layer_on(_NAV); +// } +// } else { +// if (record->event.pressed) { +// uint8_t mods = get_mods(); +// if (mods & MOD_MASK_CTRL) { +// del_mods(MOD_MASK_CTRL); +// tap_code16(MENU); +// set_mods(mods); +// return false; +// } +// } +// } +// break; + +// case NAV_ENT: +// if (!record->tap.count) { +// NAV_enabled = record->event.pressed; +// } +// break; + +// // noshift homerow mods with control overrides +// case GUI_1: +// return unshift_register_or_ctrl_fallthrough(keycode, KC_A, record); +// break; +// case ALT_2: +// return unshift_register_or_ctrl_fallthrough(keycode, KC_S, record); +// break; +// case SFT_4: +// return unshift_register_or_ctrl_fallthrough(keycode, KC_F, record); +// break; +// case SFT_7: +// return unshift_register_or_ctrl_fallthrough(keycode, KC_J, record); +// break; +// case GUI_BSLS: +// return unshift_register_or_ctrl_fallthrough(keycode, KC_A, record); +// break; +// case ALT_LBRC: +// return unshift_register_or_ctrl_fallthrough(keycode, KC_S, record); +// break; +// case SFT_MINS: +// return unshift_register_or_ctrl_fallthrough(keycode, KC_F, record); +// break; + +// case CTL_3: +// case GUI_0: +// case CTL_8: +// case ALT_9: +// case CTL_RBRC: // no control override, just unshift +// return unshift_register(keycode, record); +// break; + +// // make arrow key homerow mods trigger the tap action when held and the hold time expires +// case ALT_UP: +// case CTL_DOWN: +// if (!record->tap.count && !record->tap.interrupted) { +// if (record->event.pressed) { +// register_code(keycode); +// return false; +// } else { +// unregister_code(keycode); +// } +// } else { +// uint8_t mods = get_mods(); +// if (record->event.pressed) { +// if (mods == MOD_BIT(KC_LCTL)) { // remove control +// del_mods(MOD_BIT(KC_LCTL)); +// register_code(keycode); +// set_mods(mods); +// return false; +// } +// } +// } +// case SFT_LEFT: +// case GUI_RGHT: +// // if this is a hold action and it occurred naturally +// if (!record->tap.count && !record->tap.interrupted) { +// if (record->event.pressed) { +// register_code(keycode); +// return false; +// } else { +// unregister_code(keycode); +// } +// } +// break; + +// // make it so only the opposite-side shift key works +// case KC_Q: +// case KC_W: +// case KC_E: +// case KC_R: +// case KC_T: +// case KC_G: +// case KC_Z: +// case KC_X: +// case KC_C: +// case KC_V: +// case KC_B: // left-side +// if (record->event.pressed && get_mods() == MOD_BIT(KC_LSFT)) { +// return false; // do nothing +// } +// break; + +// case GUI_A: +// case ALT_S: +// case CTL_D: +// case SFT_F: +// if (record->event.pressed && record->tap.count && get_mods() == MOD_BIT(KC_LSFT)) { +// return false; // do nothing +// } +// break; + +// case KC_Y: +// case KC_U: +// case KC_I: +// case KC_O: +// case KC_P: +// case KC_H: +// case KC_QUOT: +// case KC_N: +// case KC_M: +// case KC_COMM: +// case KC_DOT: +// case KC_SLSH: +// if (IS_LAYER_ON(_BASE) && record->event.pressed && get_mods() == MOD_BIT(KC_RSFT)) { +// return false; // do nothing +// } +// break; +// case GUI_SCLN: +// case ALT_L: +// case CTL_K: +// case SFT_J: +// if (IS_LAYER_ON(_BASE) && record->event.pressed && record->tap.count && +// get_mods() == MOD_BIT(KC_RSFT)) { +// return false; // do nothing +// } +// break; +// } +// return true; +// } + +// const key_override_t CW_CL_TO_TAB_BACKWARDS = +// ko_make_basic(TABBING_TRIGGER_MODS, TD(TD_CW_CL), TAB_BACKWARD); + +// const key_override_t Q_TO_KILL = ko_make_with_layers(MOD_MASK_GUI, KC_Q, A(KC_F4), 1 << _BASE); + +// const key_override_t COMM_TO_TAB_BACKWARDS = +// ko_make_with_layers(TABBING_TRIGGER_MODS, KC_COMM, TAB_BACKWARD, 1 << _NUM); +// const key_override_t TILDE_TO_TAB_BACKWARDS = +// ko_make_with_layers(TABBING_TRIGGER_MODS, KC_TILDE, TAB_BACKWARD, 1 << _NAV); + +// const key_override_t BSPC_TO_OBLITERATE = { +// .trigger = KC_BSPC, +// .trigger_mods = OBLITERATE_TRIGGER_MODS, +// .layers = 0xFF, +// .custom_action = obliterate_line_backwards, +// .suppressed_mods = OBLITERATE_TRIGGER_MODS, +// }; +// const key_override_t DEL_TO_OBLITERATE = { +// .trigger = KC_DEL, +// .trigger_mods = OBLITERATE_TRIGGER_MODS, +// .layers = 0xFF, +// .custom_action = obliterate_line_forwards, +// .suppressed_mods = OBLITERATE_TRIGGER_MODS, +// }; + +// const key_override_t HOME_NOCTRL = ko_make_basic(MOD_MASK_CTRL, KC_HOME, KC_HOME); +// const key_override_t HOME_TO_MEGA_HOME = ko_make_basic(MOD_MASK_GUI, KC_HOME, C(KC_HOME)); + +// const key_override_t END_NO_CTRL = ko_make_basic(MOD_MASK_CTRL, KC_END, KC_END); +// const key_override_t END_TO_META_END = ko_make_basic(MOD_MASK_GUI, KC_END, C(KC_END)); + +// const key_override_t ESC_TO_TAB_FORWARD = ko_make_basic(TABBING_TRIGGER_MODS, KC_ESC, +// TAB_FORWARD); + +// const key_override_t GRV_TO_TAB_FORWARD = ko_make_basic(TABBING_TRIGGER_MODS, KC_GRV, +// TAB_FORWARD); const key_override_t GRV_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_GRV, KC_GRV); + +// const key_override_t DOWN_TO_ZOOM_OUT = ko_make_basic(MOD_MASK_CTRL, DOWN, C(KC_MINS)); +// const key_override_t DOWN_DEFAULT = ko_make_basic(0, DOWN, KC_DOWN); +// const key_override_t UP_TO_ZOOM_IN = ko_make_basic(MOD_MASK_CTRL, UP, C(KC_EQL)); +// const key_override_t UP_DEFAULT = ko_make_basic(0, UP, KC_UP); + +// // NUM layer +// const key_override_t FIVE_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_5, KC_5); +// const key_override_t SIX_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_6, KC_6); + +// const key_override_t LOW_6_TO_Z = ko_make_basic(MOD_MASK_CTRL, LOW_6, C(KC_Z)); +// const key_override_t LOW_6_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, LOW_6, KC_6); +// const key_override_t LOW_6_DEFAULT = ko_make_basic(0, LOW_6, KC_6); + +// const key_override_t LOW_7_TO_X = ko_make_basic(MOD_MASK_CTRL, LOW_7, C(KC_X)); +// const key_override_t LOW_7_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, LOW_7, KC_7); +// const key_override_t LOW_7_DEFAULT = ko_make_basic(0, LOW_7, KC_7); + +// const key_override_t LOW_8_TO_C = ko_make_basic(MOD_MASK_CTRL, LOW_8, C(KC_C)); +// const key_override_t LOW_8_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, LOW_8, KC_8); +// const key_override_t LOW_8_DEFAULT = ko_make_basic(0, LOW_8, KC_8); + +// const key_override_t LOW_9_TO_V = ko_make_basic(MOD_MASK_CTRL, LOW_9, C(KC_V)); +// const key_override_t LOW_9_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, LOW_9, KC_9); +// const key_override_t LOW_9_DEFAULT = ko_make_basic(0, LOW_9, KC_9); + +// const key_override_t LOW_0_TO_B = ko_make_basic(MOD_MASK_CTRL, LOW_0, C(KC_B)); +// const key_override_t LOW_0_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, LOW_0, KC_0); +// const key_override_t LOW_0_DEFAULT = ko_make_basic(0, LOW_0, KC_0); + +// // minus - +// const key_override_t MINUS_TO_R = ko_make_with_layers(MOD_MASK_CTRL, KC_MINS, C(KC_R), 1 << +// _NUM); const key_override_t MINUS_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_MINS, KC_MINS); +// // multiply symbol (prevents conflict with ASTR) * +// const key_override_t MULT_DEFAULT = ko_make_basic(0, MULT, KC_ASTR); +// // circ ^ +// const key_override_t CIRC_TO_Y = ko_make_basic(MOD_MASK_CTRL, KC_CIRC, C(KC_Y)); +// // ampr & +// const key_override_t AMPR_TO_U = ko_make_basic(MOD_MASK_CTRL, KC_AMPR, C(KC_U)); +// // astr * +// const key_override_t ASTR_TO_I = ko_make_basic(MOD_MASK_CTRL, KC_ASTR, C(KC_I)); +// // rprn ( +// const key_override_t RPRN_TO_P = ko_make_basic(MOD_MASK_CTRL, KC_RPRN, C(KC_P)); +// // coln ) +// const key_override_t COLN_TO_M = ko_make_with_layers(MOD_MASK_CTRL, KC_COLN, C(KC_M), 1 << _NUM); +// // dlr $ +// const key_override_t DLR_TO_R = ko_make_with_layers(MOD_MASK_CTRL, KC_DLR, C(KC_R), 1 << _NAV); +// // eql = +// const key_override_t EQL_NOSHIFT = ko_make_basic(MOD_MASK_SHIFT, KC_EQL, KC_EQL); +// // pipe | +// const key_override_t PIPE_TO_Z = ko_make_with_layers(MOD_MASK_CTRL, KC_PIPE, C(KC_Z), 1 << _NAV); +// // lcbr { +// const key_override_t LCBR_TO_X = ko_make_with_layers(MOD_MASK_CTRL, KC_LCBR, C(KC_X), 1 << _NAV); +// // rcbr } +// const key_override_t RCBR_TO_C = ko_make_with_layers(MOD_MASK_CTRL, KC_RCBR, C(KC_C), 1 << _NAV); +// // unds _ +// const key_override_t UNDS_TO_V = ko_make_with_layers(MOD_MASK_CTRL, KC_UNDS, C(KC_V), 1 << _NAV); +// // plus + +// const key_override_t PLUS_TO_B = ko_make_with_layers(MOD_MASK_CTRL, KC_PLUS, C(KC_B), 1 << _NAV); +// // F2 +// const key_override_t F2_TO_M = ko_make_with_layers(MOD_MASK_CTRL, KC_F2, C(KC_M), 1 << _NAV); + +// // this globally defines all key overrides to be used +// const key_override_t* key_overrides[] = { +// &CW_CL_TO_TAB_BACKWARDS, +// &COMM_TO_TAB_BACKWARDS, +// &TILDE_TO_TAB_BACKWARDS, +// &Q_TO_KILL, +// // +// &BSPC_TO_OBLITERATE, +// &DEL_TO_OBLITERATE, + +// &HOME_NOCTRL, +// &HOME_TO_MEGA_HOME, +// &END_NO_CTRL, +// &END_TO_META_END, + +// &ESC_TO_TAB_FORWARD, + +// &GRV_TO_TAB_FORWARD, +// &GRV_NOSHIFT, + +// &DOWN_TO_ZOOM_OUT, +// &DOWN_DEFAULT, +// &UP_TO_ZOOM_IN, +// &UP_DEFAULT, + +// &FIVE_NOSHIFT, +// &SIX_NOSHIFT, +// &LOW_6_TO_Z, +// &LOW_6_NOSHIFT, +// &LOW_6_DEFAULT, +// &LOW_7_TO_X, +// &LOW_7_NOSHIFT, +// &LOW_7_DEFAULT, +// &LOW_8_TO_C, +// &LOW_8_NOSHIFT, +// &LOW_8_DEFAULT, +// &LOW_9_TO_V, +// &LOW_9_NOSHIFT, +// &LOW_9_DEFAULT, +// &LOW_0_TO_B, +// &LOW_0_NOSHIFT, +// &LOW_0_DEFAULT, + +// &MINUS_TO_R, +// &MINUS_NOSHIFT, + +// &MULT_DEFAULT, + +// &CIRC_TO_Y, + +// &R_TO_U, + +// &ASTR_TO_I, + +// &RPRN_TO_P, + +// &COLN_TO_M, + +// &DLR_TO_R, + +// &EQL_NOSHIFT, + +// &PIPE_TO_Z, + +// &LCBR_TO_X, + +// &RCBR_TO_C, + +// &UNDS_TO_V, + +// &PLUS_TO_B, + +// &F2_TO_M, +// }; diff --git a/keyboards/keebio/iris_lm/keymaps/drew/layers.h b/keyboards/keebio/iris_lm/keymaps/drew/layers.h new file mode 100644 index 00000000..1fb9cb6a --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/layers.h @@ -0,0 +1,8 @@ +#pragma once + +#define _BASE 0 +#define _GAME 1 +#define _NAV 2 +#define _SYM 3 +#define _NUM 4 +#define _FUNC 5 diff --git a/keyboards/keebio/iris_lm/keymaps/drew/rules.mk b/keyboards/keebio/iris_lm/keymaps/drew/rules.mk new file mode 100644 index 00000000..244bab28 --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/rules.mk @@ -0,0 +1,17 @@ +BOOTLOADER = stm32-dfu + +SRC += caps_word/caps_word.c +# SRC += taphold/taphold_options.c +# SRC += utils/utils.c +# SRC += chordal_hold/chordal_options.c +# SRC += flow_tap/flow_tap_options.c + +# VIA_ENABLE = yes +LTO_ENABLE = yes + +CAPS_WORD_ENABLE = yes + +# CONSOLE_ENABLE = yes + +TAP_DANCE_ENABLE = yes +# KEY_OVERRIDE_ENABLE = yes diff --git a/keyboards/keebio/iris_lm/keymaps/drew/tap_dance/tap_dance.c b/keyboards/keebio/iris_lm/keymaps/drew/tap_dance/tap_dance.c new file mode 100644 index 00000000..e1c27f3d --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/tap_dance/tap_dance.c @@ -0,0 +1,23 @@ +#include QMK_KEYBOARD_H +#include "./tap_dance.h" +#include "../alias.h" + +void CAD_lock_sleep(tap_dance_state_t* state, void*) { + switch (state->count) { + case 1: + tap_code16(CAD); + break; + case 2: + tap_code16(G(KC_L)); + break; + case 3: + tap_code16(KC_SLEP); + default: + reset_tap_dance(state); + break; + } +} + +tap_dance_action_t tap_dance_actions[] = { + [TD_CAD_LOCK_SLEEP] = ACTION_TAP_DANCE_FN(CAD_lock_sleep), +}; diff --git a/keyboards/keebio/iris_lm/keymaps/drew/tap_dance/tap_dance.h b/keyboards/keebio/iris_lm/keymaps/drew/tap_dance/tap_dance.h new file mode 100644 index 00000000..3321d686 --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/tap_dance/tap_dance.h @@ -0,0 +1,5 @@ +#pragma once + +enum { + TD_CAD_LOCK_SLEEP, +}; diff --git a/keyboards/keebio/iris_lm/keymaps/drew/taphold/taphold_options.c b/keyboards/keebio/iris_lm/keymaps/drew/taphold/taphold_options.c new file mode 100644 index 00000000..ad07169f --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/taphold/taphold_options.c @@ -0,0 +1,139 @@ +#include QMK_KEYBOARD_H + +#include "../alias.h" +#include "../tap_dance/tap_dance.h" + +uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t* record) { + switch (keycode) { + case GUI_LAUNCH: + case NUM_SPC: + case NAV_ENT: + case FUNC_PLAY: // no repeat tapping for these keys + + case GUI_A: + case ALT_S: + case CTL_D: + case SFT_F: + case GUI_SCLN: + case ALT_L: + case CTL_K: + case SFT_J: + + case GUI_BSLS: + case ALT_LBRC: + case CTL_RBRC: + case SFT_MINS: + // intentionally omitting arrow keys + + case GUI_1: + case ALT_2: + case CTL_3: + case SFT_4: + case GUI_0: + case ALT_9: + case CTL_8: + case SFT_7: // no repeat tapping for homerow mods + return 0; + break; + } + return QUICK_TAP_TERM; +} + +bool get_permissive_hold(uint16_t keycode, keyrecord_t* record) { + switch (keycode) { + case NUM_SPC: // permissive hold for layer tap space + return true; + break; + + case GUI_A: + case ALT_S: + case CTL_D: + case SFT_F: + case GUI_SCLN: + case ALT_L: + case CTL_K: + case SFT_J: + + case GUI_BSLS: + case ALT_LBRC: + case CTL_RBRC: + case SFT_MINS: + case GUI_RGHT: + case ALT_UP: + case CTL_DOWN: + case SFT_LEFT: + + case GUI_1: + case ALT_2: + case CTL_3: + case SFT_4: + case GUI_0: + case ALT_9: + case CTL_8: + case SFT_7: // permissive hold for mod-taps + return true; + break; + } + return false; +} + +bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t* record) { + switch (keycode) { + case NUM_SPC: // no hold on other key press for layer tap space + return false; + break; + + case GUI_A: + case ALT_S: + case CTL_D: + case SFT_F: + case GUI_SCLN: + case ALT_L: + case CTL_K: + case SFT_J: + + case GUI_BSLS: + case ALT_LBRC: + case CTL_RBRC: + case SFT_MINS: + case GUI_RGHT: + case ALT_UP: + case CTL_DOWN: + case SFT_LEFT: + + case GUI_1: + case ALT_2: + case CTL_3: + case SFT_4: + case GUI_0: + case ALT_9: + case CTL_8: + case SFT_7: // no hold on other key press for mod taps + return false; + break; + } + return true; +} + +uint16_t get_tapping_term(uint16_t keycode, keyrecord_t* record) { + switch (keycode) { + case ALT_S: + case ALT_L: + case ALT_2: + case ALT_9: + case ALT_LBRC: + case ALT_UP: + + case GUI_A: + case GUI_SCLN: + case GUI_1: + case GUI_0: + case GUI_BSLS: + case GUI_RGHT: // alt and gui have events for a hold and release + + case GUI_LAUNCH: // also non-homerow mod-taps + return 400; + break; + } + return TAPPING_TERM; +} diff --git a/keyboards/keebio/iris_lm/keymaps/drew/utils/utils.c b/keyboards/keebio/iris_lm/keymaps/drew/utils/utils.c new file mode 100644 index 00000000..018a79e1 --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/utils/utils.c @@ -0,0 +1,60 @@ +#include "./utils.h" + +bool obliterate_line(bool key_down, uint8_t deletion_keycode, uint8_t movement_keycode) { + if (key_down) { + tap_code16(S(movement_keycode)); + register_code(deletion_keycode); + } else { + unregister_code(deletion_keycode); + } + return false; +} + +bool obliterate_line_backwards(bool key_down, void* _) { + return obliterate_line(key_down, KC_BSPC, KC_HOME); +} + +bool obliterate_line_forwards(bool key_down, void* _) { + return obliterate_line(key_down, KC_DEL, KC_END); +} + +bool toggle_caps_word(bool key_down, void* _) { + caps_word_toggle(); + return false; +} + +bool unshift_register_or_ctrl_fallthrough( + uint8_t keycode, uint8_t control_keycode, keyrecord_t* record +) { + if (record->tap.count) { + if (record->event.pressed) { + uint8_t mods = get_mods(); + if (mods & MOD_MASK_CTRL) { + register_code(control_keycode); + return false; + } else if (mods & MOD_MASK_SHIFT) { + del_mods(MOD_MASK_SHIFT); // remove shift + // register the code. This is fine because you will just chop to the 8-bit keycode + register_code(keycode); + set_mods(mods); // re-add shift + return false; + } + } else { + unregister_code(control_keycode); + } + } + return true; +} + +bool unshift_register(uint8_t keycode, keyrecord_t* record) { + if (record->tap.count && record->event.pressed) { + uint8_t mods = get_mods(); + if (mods & MOD_MASK_SHIFT) { + del_mods(MOD_MASK_SHIFT); + register_code(keycode); + set_mods(mods); + return false; + } + } + return true; +} diff --git a/keyboards/keebio/iris_lm/keymaps/drew/utils/utils.h b/keyboards/keebio/iris_lm/keymaps/drew/utils/utils.h new file mode 100644 index 00000000..1c2112a9 --- /dev/null +++ b/keyboards/keebio/iris_lm/keymaps/drew/utils/utils.h @@ -0,0 +1,54 @@ +#pragma once + +#include QMK_KEYBOARD_H +#include "stdbool.h" +#include "stdint.h" + +/// @brief Obliterate a line of text. +/// @param key_down Whether the key was pressed down. +/// @param deletion_keycode The deletion keycode. Either `KC_BSPC` or `KC_DEL`. +/// @param movement_keycode The movement keycode. Either `KC_HOME` or `KC_END`. +/// @return Always returns `false`. +bool obliterate_line(bool key_down, uint8_t deletion_keycode, uint8_t movement_keycode); + +/// @brief Obliterate a line of text backwards from the cursor. +/// @param key_down Whether the key was pressed down. +/// @param _ Unused. +/// @return Always returns `false`. +bool obliterate_line_backwards(bool key_down, void* _); + +/// @brief Obliterate a line of text forwards from the cursor. +/// @param key_down Whether the key was pressed down. +/// @param _ Unused. +/// @return Always returns `false`. +bool obliterate_line_forwards(bool key_down, void* _); + +/// @brief Wrapper to turn on caps word. +/// @param key_down Whether the key was pressed down. +/// @param _ Unused. +/// @return Always returns `false`. +bool toggle_caps_word(bool key_down, void* _); + +/// @brief Neutralize flashing modifiers (Alt and Super) if they are active. +static inline void neutralize_flashing_mods(void) { + if (get_mods() & MOD_MASK_AG) { + tap_code(DUMMY_MOD_NEUTRALIZER_KEYCODE); + } +} // have to define this here because it is inline + +/// @brief If control is held, register the control keycode. Otherwise, if shift is being held, +/// register the key without shift. Otherwise, register the key normally. +/// @param keycode The keycode being processed. +/// @param ctrl_keycode The keycode to register if control is being held. +/// @param record The current `keyrecord_t`. +/// @return Whether processing of the key should continue. +bool unshift_register_or_ctrl_fallthrough( + uint8_t keycode, uint8_t ctrl_keycode, keyrecord_t* record +); + +/// @brief Register a keycode without shift. +/// @param keycode The keycode being processed. +/// @param record The current `keyrecord_t`. +/// @return Whether processing of the key should continue. +bool unshift_register(uint8_t keycode, keyrecord_t* record); + diff --git a/qmk.json b/qmk.json index e008d168..d3f3a8b1 100644 --- a/qmk.json +++ b/qmk.json @@ -1,9 +1,6 @@ { "userspace_version": "1.1", "build_targets": [ - [ - "keebio/nyquist/rev4", - "drew" - ] + ["keebio/iris_lm/g1", "drew"] ] } \ No newline at end of file