From 650539993f20e0ab18cc67e2855aedb62130cd51 Mon Sep 17 00:00:00 2001 From: moutis <35399827+moutis@users.noreply.github.com> Date: Thu, 7 Oct 2021 10:03:37 -0400 Subject: [PATCH] Semantic Keys, Adaptive Keys updated Finished integrating Semantic Keys with updated keymaps (HD-BronzeSilver_SK) updated combos to send semantic keys where appropriate. Polished process_adaptive_key a bit for compatibility w/Neu variants (except Gold). bug fix in process_record_user resetting mod state on exit caused bad mod states. Still have potential issue on unsplit boards (Cornelius, naked48) not releasing shift w/KC_HASH. Still have mod-tap prob in terminate_caps_word disabling mod/layer keys. stupid mask issue, no doubt, but I'm unfamiliar atm. --- config.h | 88 +++ cornelius/cornelius_hd_bronze.json | 316 ++++---- cornelius/cornelius_hd_bronze_sk.json | 461 ++++++++++++ cornelius/cornelius_hd_bronzesilver_sk.json | 461 ++++++++++++ cornelius/cornelius_hd_keymap.c | 16 +- cornelius/cornelius_hd_keymap.c.bak | 16 +- cornelius/kyria_hd_bronze.json | 479 ++++++++++++ cornelius/kyria_hd_bronzesilver_sk.json | 479 ++++++++++++ ferris/ferris_hd_bronze.json | 299 ++++++++ ferris/ferris_hd_keymap.c | 18 + ferris/ferris_hd_keymap.c.bak | 18 + ferris/keymap.json | 299 ++++++++ kyria/kyria_hd_bronze.json | 114 +-- kyria/kyria_hd_bronze_2.json | 479 ++++++++++++ kyria/kyria_hd_bronze_SK.json | 479 ++++++++++++ kyria/kyria_hd_bronzesilver_sk.json | 479 ++++++++++++ kyria/kyria_hd_keymap.c | 14 +- kyria/kyria_hd_keymap.c.bak | 19 + kyria/kyria_hd_keymap.configurator0924.c | 19 + kyria/kyria_hd_platinum.json | 479 ++++++++++++ kyria/naked48_hd_bronze_sk.json | 361 +++++++++ moutis.c | 87 +-- moutis.h | 71 +- moutis_COMBO_hd.h | 27 +- moutis_COMBO_hd_bronze.c | 53 +- moutis_COMBO_hd_bronze_sk.c | 692 +++++++++++++++++ moutis_COMBO_hd_platinum.c | 790 ++++++++++++++++++++ moutis_ENCODER.c | 18 +- moutis_MATRIX.c | 83 +- moutis_PROCESS_RECORD_hd_neu.c | 398 ++++++++++ moutis_adaptivekeys.c | 188 ++++- moutis_casemods.c | 6 +- moutis_semantickeys.c | 144 +++- moutis_semantickeys.h | 11 +- naked48/naked48_hd_bronze.json | 361 +++++++++ naked48/naked48_hd_bronze_2.json | 361 +++++++++ naked48/naked48_hd_bronze_SK.json | 361 +++++++++ naked48/naked48_hd_bronzesilver_sk.json | 361 +++++++++ naked48/naked48_hd_keymap.c | 17 + naked48/naked48_hd_keymap.c.bak | 17 + naked48/naked48_hd_platinum.json | 361 +++++++++ 41 files changed, 9383 insertions(+), 417 deletions(-) create mode 100644 cornelius/cornelius_hd_bronze_sk.json create mode 100644 cornelius/cornelius_hd_bronzesilver_sk.json create mode 100644 cornelius/kyria_hd_bronze.json create mode 100644 cornelius/kyria_hd_bronzesilver_sk.json create mode 100644 ferris/ferris_hd_bronze.json create mode 100644 ferris/ferris_hd_keymap.c create mode 100644 ferris/ferris_hd_keymap.c.bak create mode 100644 ferris/keymap.json create mode 100644 kyria/kyria_hd_bronze_2.json create mode 100644 kyria/kyria_hd_bronze_SK.json create mode 100644 kyria/kyria_hd_bronzesilver_sk.json create mode 100644 kyria/kyria_hd_keymap.c.bak create mode 100644 kyria/kyria_hd_keymap.configurator0924.c create mode 100644 kyria/kyria_hd_platinum.json create mode 100644 kyria/naked48_hd_bronze_sk.json create mode 100644 moutis_COMBO_hd_bronze_sk.c create mode 100644 moutis_COMBO_hd_platinum.c create mode 100644 moutis_PROCESS_RECORD_hd_neu.c create mode 100644 naked48/naked48_hd_bronze.json create mode 100644 naked48/naked48_hd_bronze_2.json create mode 100644 naked48/naked48_hd_bronze_SK.json create mode 100644 naked48/naked48_hd_bronzesilver_sk.json create mode 100644 naked48/naked48_hd_keymap.c create mode 100644 naked48/naked48_hd_keymap.c.bak create mode 100644 naked48/naked48_hd_platinum.json diff --git a/config.h b/config.h index 3f59c93..71d00e7 100644 --- a/config.h +++ b/config.h @@ -1,2 +1,90 @@ #pragma once + +// Set the mouse settings to a comfortable speed/accuracy trade-off, +// assuming a screen refresh rate of 60 Htz or higher +// The default is 50. This makes the mouse ~3 times faster and more accurate + +// The Leader key allows to flexibly assign macros to key sequences. +#ifdef LEADER_ENABLE + #define LEADER_PER_KEY_TIMING + #define LEADER_TIMEOUT 750 + #define LEADER_NO_TIMEOUT +#endif + +#ifdef RGBLIGHT_ENABLE + +#ifdef RGBLIGHT_ANIMATIONS + #undef RGBLIGHT_ANIMATIONS +#endif +#define RGBLIGHT_ANIMATIONS + +#ifdef RGBLIGHT_HUE_STEP + #undef RGBLIGHT_HUE_STEP +#endif +#define RGBLIGHT_HUE_STEP 8 + +#ifdef RGBLIGHT_SAT_STEP + #undef RGBLIGHT_SAT_STEP +#endif +#define RGBLIGHT_SAT_STEP 8 + +#ifdef RGBLIGHT_VAL_STEP + #undef RGBLIGHT_VAL_STEP +#endif +#define RGBLIGHT_VAL_STEP 8 + +#ifdef RGBLIGHT_SLEEP + #undef RGBLIGHT_SLEEP +#endif +#define RGBLIGHT_SLEEP + +#endif + +#ifdef OLED_DRIVER_ENABLE + #define OLED_DISPLAY_128X64 + #ifdef OLED_TIMEOUT + #undef OLED_TIMEOUT + #endif + #define OLED_TIMEOUT 9000 +#endif + +// I dont' know why these must be here, not in user space... +// but it won't compile otherwise +// +#define TAPPING_TOGGLE 2 + +#define TAPPING_TERM 170 // TAP VS HOLD timing in milliseconds + +// Pick good defaults for enabling homerow modifiers +// Allows media codes to properly register in macros and rotary encoder code +#define TAP_CODE_DELAY 5 +#define TAP_HOLD_CAPS_DELAY 0 +#define PERMISSIVE_HOLD +#define BILATERAL_COMBINATIONS +#define IGNORE_MOD_TAP_INTERRUPT + +#define ADAPTIVE_TERM TAPPING_TERM/2 // default time between keystrokes allowed for adaptives +#ifdef COMBO_ENABLE + #ifdef COMBO_COUNT + #undef COMBO_COUNT + #endif + + #define COMBO_ALLOW_ACTION_KEYS + #define COMBO_STRICT_TIMER + + #ifdef COMBO_TERM + #undef COMBO_TERM + #endif + #define COMBO_TERM (TAPPING_TERM/5) // time to get all combo keys down + #define COMBO_HOLD (COMBO_TERM*4) // time to hold to trigger delayed combo +#endif + +#ifdef COMBO_HOLD + #undef ADAPTIVE_TERM + #define ADAPTIVE_TERM COMBO_HOLD // use COMBO_HOLD time as a standard threshold (same recation time) +#endif + +#define LINGER_TIME TAPPING_TERM * 1.3 // how long to hold before a time-depentant behavior begins +#define STATE_RESET_TIME LINGER_TIME * 4 // how long to leave a state active before resetting + diff --git a/cornelius/cornelius_hd_bronze.json b/cornelius/cornelius_hd_bronze.json index b627d19..b64c7c8 100644 --- a/cornelius/cornelius_hd_bronze.json +++ b/cornelius/cornelius_hd_bronze.json @@ -1,24 +1,25 @@ { "version": 1, - "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "notes": "", + "documentation": "\"This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\"\n", "keyboard": "foostan/cornelius", "keymap": "cornelius_hd_bronze", "layout": "LAYOUT", "layers": [ [ - "LT(8,KC_TAB)", - "KC_J", + "LT(5,KC_TAB)", + "KC_MINS", "KC_F", "KC_M", "KC_P", "KC_V", - "KC_HASH", + "KC_EQL", "KC_DOT", "KC_SLSH", - "KC_DQUO", "KC_QUOT", + "KC_DQUO", "LT(8,KC_MPLY)", - "LT(5,KC_HOME)", + "KC_UP", "LCTL_T(KC_R)", "LALT_T(KC_S)", "LGUI_T(KC_N)", @@ -27,36 +28,36 @@ "KC_COMM", "RSFT_T(KC_A)", "RGUI_T(KC_E)", - "RALT_T(KC_I)", - "RCTL_T(KC_C)", - "LT(4,KC_MUTE)", - "LT(6,KC_END)", + "RALT_T(KC_C)", + "RCTL_T(KC_I)", + "TG(5)", + "KC_DOWN", "KC_X", "KC_G", "KC_L", "KC_D", "KC_B", - "KC_MINS", + "KC_HASH", "KC_U", "KC_O", - "KC_Y", "KC_W", - "KC_UP", + "KC_Y", + "LT(4,KC_BSPC)", "KC_LEFT", "KC_RGHT", "KC_APP", - "LT(3,KC_LANG2)", - "LT(4,KC_BSPC)", - "LT(5,KC_H)", + "LT(2,KC_LANG2)", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", "LT(2,KC_SPC)", "LT(4,KC_ENT)", - "LT(3,KC_LANG1)", + "LT(6,KC_LANG1)", "KC_LBRC", "KC_RBRC", - "KC_DOWN" + "LT(3,KC_MUTE)" ], [ - "KC_NO", + "KC_TRNS", "KC_Q", "KC_W", "KC_E", @@ -67,8 +68,8 @@ "KC_I", "KC_O", "KC_QUOT", - "KC_NO", - "KC_NO", + "KC_TRNS", + "KC_TRNS", "LCTL_T(KC_A)", "LALT_T(KC_S)", "LGUI_T(KC_D)", @@ -79,9 +80,9 @@ "RGUI_T(KC_K)", "RALT_T(KC_L)", "RCTL_T(KC_P)", - "KC_NO", - "KC_NO", - "KC_Z", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", "KC_X", "KC_C", "KC_V", @@ -91,8 +92,8 @@ "KC_COMM", "KC_DOT", "KC_SLSH", - "KC_NO", - "KC_NO", + "KC_TRNS", + "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_BSPC", @@ -111,176 +112,176 @@ "ANY(A(S(KC_RBRC)))", "LALT(KC_LBRC)", "ANY(A(S(KC_LBRC)))", - "ANY(A(S(KC_9)))", + "LALT(KC_8)", "LALT(KC_4)", "KC_DLR", "ANY(A(S(KC_2)))", "LALT(KC_Y)", "RALT(KC_3)", - "KC_NO", + "KC_TRNS", "ANY(C(S(G(KC_4))))", "KC_LT", "KC_GT", "KC_LPRN", "KC_RPRN", - "LALT(KC_8)", + "LALT(KC_7)", "RALT(KC_1)", "LSFT_T(KC_PAST)", "LGUI_T(KC_PEQL)", "LALT_T(KC_PPLS)", "LCTL_T(KC_BSLS)", - "KC_NO", - "KC_NO", + "KC_TRNS", + "KC_TRNS", "ANY(A(S(KC_5)))", "ANY(A(S(KC_7)))", "KC_LCBR", "KC_RCBR", "RALT(KC_5)", "KC_UNDS", - "KC_CIRC", - "KC_AMPR", "KC_PIPE", + "KC_AMPR", + "KC_CIRC", "KC_PERC", - "KC_NO", - "TO(5)", - "KC_NO", - "KC_NO", - "LALT(KC_BSPC)", - "LALT(KC_DEL)", "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LCA(KC_DEL)", + "KC_TRNS", + "ANY(SK_DELWDL)", + "ANY(SK_DELWDR)", "ANY(A(S(KC_9)))", "LALT(KC_8)", "ANY(A(S(KC_8)))", "ANY(A(S(KC_R)))", "TO(5)", - "KC_NO" + "KC_TRNS" ], [ - "KC_NO", - "KC_F7", - "KC_F3", + "KC_F16", + "KC_F11", + "KC_F12", + "KC_F13", + "KC_F14", + "KC_F15", + "KC_SLSH", + "KC_7", + "KC_8", + "KC_9", + "KC_0", + "KC_TRNS", + "KC_F17", + "LCTL_T(KC_F6)", + "LALT_T(KC_F7)", + "LGUI_T(KC_F8)", + "LSFT_T(KC_F9)", + "KC_F10", + "KC_EQL", + "RSFT_T(KC_4)", + "RGUI_T(KC_N)", + "RALT_T(KC_6)", + "RCTL_T(KC_MINS)", + "KC_TRNS", + "KC_F18", "KC_F1", - "KC_F5", - "KC_F9", - "KC_F8", "KC_F2", - "KC_F10", + "KC_F3", "KC_F4", - "KC_F6", - "KC_NO", - "KC_NO", - "LCTL_T(KC_9)", - "LALT_T(KC_3)", - "LGUI_T(KC_1)", - "LSFT_T(KC_5)", - "KC_7", - "KC_6", - "RSFT_T(KC_2)", - "RGUI_T(KC_0)", - "RALT_T(KC_4)", - "RCTL_T(KC_8)", - "KC_NO", - "KC_NO", - "DF(1)", - "TO(1)", - "TO(0)", - "DF(0)", - "KC_F11", - "KC_F12", - "DF(0)", - "TO(0)", - "TO(1)", - "DF(1)", - "KC_NO", - "KC_NO", - "KC_NO", - "ANY(C(A(KC_DEL)))", - "AG_NORM", - "AG_SWAP", + "KC_F5", + "KC_MINS", + "KC_1", + "KC_2", + "KC_3", + "KC_EQL", "KC_TRNS", + "KC_F19", + "KC_F20", + "KC_F21", + "KC_F21", "KC_TRNS", - "CG_SWAP", - "CG_NORM", - "ANY(C(A(KC_DEL)))", - "KC_NO", - "KC_NO" + "KC_TRNS", + "KC_INS", + "KC_LSCR", + "KC_LNUM", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" ], [ "KC_MUTE", - "KC_NO", - "KC_NO", - "KC_NO", - "KC_NO", - "KC_NO", - "LALT(KC_HOME)", + "ANY(SK_QUIT)", + "ANY(SK_CLOZ)", + "ANY(SK_SCAP)", + "ANY(SK_SCLP)", + "ANY(SK_FAGN)", + "ANY(SK_DOCBEG)", "KC_HOME", "KC_UP", "KC_PGUP", - "LALT(KC_PGUP)", - "KC_NO", - "KC_VOLU", + "ANY(SK_PARAPRV)", + "KC_TRNS", + "KC_MFFD", "KC_LCTL", "KC_LALT", "KC_LGUI", "KC_LSFT", - "KC_NO", - "LALT(KC_LEFT)", + "ANY(SK_FIND)", + "ANY(SK_WORDPRV)", "KC_LEFT", "KC_DOWN", "KC_RGHT", - "LALT(KC_RGHT)", - "KC_NO", - "KC_VOLD", - "KC_NO", - "KC_NO", - "KC_NO", - "KC_NO", - "KC_NO", - "LALT(KC_END)", + "ANY(SK_WORDNXT)", + "KC_TRNS", + "KC_MRWD", + "ANY(SK_UNDO)", + "ANY(SK_CUT)", + "ANY(SK_COPY)", + "ANY(SK_PSTE)", + "ANY(SK_PSTM)", + "ANY(SK_DOCEND)", "KC_END", "KC_DOWN", "KC_PGDN", - "LALT(KC_PGDN)", - "KC_NO", - "KC_MSTP", - "KC_NO", - "TG(5)", - "KC_NO", - "KC_NO", - "KC_NO", - "LGUI(KC_LBRC)", - "LGUI(KC_RBRC)", - "ANY(G(S(KC_EQL)))", - "LGUI(KC_MINS)", - "LGUI(KC_0)", - "KC_NO" + "ANY(SK_PARANXT)", + "KC_TRNS", + "KC_MPRV", + "KC_MNXT", + "LCA(KC_DEL)", + "KC_VOLD", + "KC_VOLU", + "KC_MPLY", + "ANY(SK_ZOOMRST)", + "ANY(SK_HISTPRV)", + "ANY(SK_HISTNXT)", + "ANY(SK_ZOOMOUT)", + "ANY(SK_ZOOMIN)", + "ANY(SK_ZOOMRST)" ], [ - "KC_NO", + "ANY(S(G(KC_4)))", "LALT(KC_RBRC)", "ANY(A(S(KC_RBRC)))", "LALT(KC_LBRC)", "ANY(A(S(KC_LBRC)))", - "ANY(A(S(KC_9)))", + "ANY(A(S(KC_8)))", "KC_PSLS", "KC_P7", "KC_P8", "KC_P9", "KC_PMNS", - "KC_NO", - "KC_NO", + "KC_NLCK", + "ANY(C(S(G(KC_4))))", "KC_LT", "KC_GT", "KC_LPRN", "KC_RPRN", - "LALT(KC_8)", + "LALT(KC_7)", "KC_PAST", "KC_P4", "KC_P5", "KC_P6", "KC_PPLS", - "KC_NO", - "KC_NO", + "KC_TRNS", + "KC_TRNS", "ANY(A(S(KC_5)))", "ANY(A(S(KC_7)))", "KC_LBRC", @@ -291,19 +292,19 @@ "KC_P2", "KC_P3", "KC_PEQL", - "KC_NO", - "TG(5)", "KC_TRNS", - "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_ENT", "KC_BSPC", "KC_DEL", - "KC_TRNS", - "ANY(A(S(KC_EQL)))", "KC_P0", "KC_PDOT", "KC_C", + "KC_C", "KC_TRNS", - "TG(5)" + "KC_TRNS" ], [ "KC_NO", @@ -343,7 +344,6 @@ "KC_NO", "KC_NO", "KC_NO", - "RESET", "KC_NO", "KC_NO", "KC_NO", @@ -352,7 +352,8 @@ "KC_NO", "KC_NO", "KC_NO", - "RESET", + "KC_NO", + "KC_NO", "KC_NO" ], [ @@ -406,56 +407,55 @@ "KC_NO" ], [ - "RESET", - "KC_PSCR", - "KC_SLCK", + "KC_PWR", + "KC_SLEP", "KC_NO", + "LCA(KC_DEL)", "KC_NO", - "KC_EJCT", + "NK_TOGG", "BL_TOGG", + "BL_ON", + "BL_OFF", + "KC_NO", "KC_NO", "KC_NO", - "RGB_TOG", "KC_NO", + "KC_WAKE", "KC_NO", "KC_NO", - "LCTL_T(KC_BRIU)", - "LALT_T(KC_MRWD)", - "LGUI_T(KC_MSTP)", - "LSFT_T(KC_MFFD)", - "LT(5,KC_VOLU)", + "KC_NO", + "NK_ON", "BL_STEP", - "BL_ON", "BL_INC", "RGB_HUI", "RGB_SAI", + "RGB_VAD", "KC_NO", + "DF(0)", + "DF(1)", "KC_NO", - "KC_BRID", - "KC_MPRV", - "KC_MUTE", - "KC_MNXT", - "KC_VOLD", + "KC_NO", + "KC_NO", + "NK_OFF", "BL_BRTG", - "BL_OFF", "BL_DEC", "RGB_HUD", "RGB_SAD", "RGB_VAI", + "KC_BRIU", + "TO(0)", + "TO(1)", "RESET", "KC_NO", - "KC_NO", - "KC_PAUS", - "KC_MPLY", - "KC_NO", - "KC_NO", - "CG_SWAP", + "AG_SWAP", + "AG_NORM", "CG_NORM", + "CG_SWAP", "KC_NO", + "RESET", "KC_NO", - "RGB_VAD" + "KC_BRID" ] ], - "author": "", - "notes": "" + "author": "" } \ No newline at end of file diff --git a/cornelius/cornelius_hd_bronze_sk.json b/cornelius/cornelius_hd_bronze_sk.json new file mode 100644 index 0000000..8d46fe8 --- /dev/null +++ b/cornelius/cornelius_hd_bronze_sk.json @@ -0,0 +1,461 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "foostan/cornelius", + "keymap": "cornelius_hd_bronze_sk", + "layout": "LAYOUT", + "layers": [ + [ + "LT(5,KC_MUTE)", + "KC_J", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "KC_HASH", + "KC_DOT", + "KC_SLSH", + "KC_QUOT", + "KC_DQUO", + "LT(8,KC_MPLY)", + "KC_UP", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_C)", + "RCTL_T(KC_I)", + "TG(5)", + "KC_DOWN", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "KC_MINS", + "KC_U", + "KC_O", + "KC_W", + "KC_Y", + "LT(4,KC_BSPC)", + "KC_LEFT", + "KC_RGHT", + "KC_APP", + "LT(2,KC_LANG2)", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "LT(6,KC_LANG1)", + "KC_LBRC", + "KC_RBRC", + "LT(3,KC_EQL)" + ], + [ + "KC_TRNS", + "KC_Q", + "KC_W", + "KC_E", + "KC_R", + "KC_T", + "KC_Y", + "KC_U", + "KC_I", + "KC_O", + "KC_QUOT", + "KC_TRNS", + "KC_TRNS", + "LCTL_T(KC_A)", + "LALT_T(KC_S)", + "LGUI_T(KC_D)", + "LSFT_T(KC_F)", + "KC_G", + "KC_H", + "RSFT_T(KC_J)", + "RGUI_T(KC_K)", + "RALT_T(KC_L)", + "RCTL_T(KC_P)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_X", + "KC_C", + "KC_V", + "KC_B", + "KC_N", + "KC_M", + "KC_COMM", + "KC_DOT", + "KC_SLSH", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_BSPC", + "KC_SPC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "ANY(S(G(KC_4)))", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "LALT(KC_8)", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT(KC_Y)", + "RALT(KC_3)", + "KC_TRNS", + "ANY(C(S(G(KC_4))))", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "LGUI_T(KC_PEQL)", + "LALT_T(KC_PPLS)", + "LCTL_T(KC_BSLS)", + "KC_TRNS", + "KC_TRNS", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LCA(KC_DEL)", + "KC_TRNS", + "ANY(SK_DELWDL)", + "ANY(SK_DELWDR)", + "ANY(A(S(KC_9)))", + "LALT(KC_8)", + "ANY(A(S(KC_8)))", + "ANY(A(S(KC_R)))", + "TO(5)", + "KC_TRNS" + ], + [ + "KC_F16", + "KC_F11", + "KC_F12", + "KC_F13", + "KC_F14", + "KC_F15", + "KC_SLSH", + "KC_7", + "KC_8", + "KC_9", + "KC_0", + "KC_TRNS", + "KC_F17", + "LCTL_T(KC_F6)", + "LALT_T(KC_F7)", + "LGUI_T(KC_F8)", + "LSFT_T(KC_F9)", + "KC_F10", + "KC_EQL", + "RSFT_T(KC_4)", + "RGUI_T(KC_N)", + "RALT_T(KC_6)", + "RCTL_T(KC_MINS)", + "KC_TRNS", + "KC_F18", + "KC_F1", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_MINS", + "KC_1", + "KC_2", + "KC_3", + "KC_EQL", + "KC_TRNS", + "KC_F19", + "KC_F20", + "KC_F21", + "KC_F21", + "KC_TRNS", + "KC_TRNS", + "KC_INS", + "KC_LSCR", + "KC_LNUM", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_MUTE", + "ANY(SK_QUIT)", + "ANY(SK_CLOZ)", + "ANY(SK_SCAP)", + "ANY(SK_SCLP)", + "ANY(SK_FAGN)", + "ANY(SK_DOCBEG)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "ANY(SK_PARAPRV)", + "KC_TRNS", + "KC_MFFD", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "ANY(SK_FIND)", + "ANY(SK_WORDPRV)", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "ANY(SK_WORDNXT)", + "KC_TRNS", + "KC_MRWD", + "ANY(SK_UNDO)", + "ANY(SK_CUT)", + "ANY(SK_COPY)", + "ANY(SK_PSTE)", + "ANY(SK_PSTM)", + "ANY(SK_DOCEND)", + "KC_END", + "KC_DOWN", + "KC_PGDN", + "ANY(SK_PARANXT)", + "KC_TRNS", + "KC_MPRV", + "KC_MNXT", + "LCA(KC_DEL)", + "KC_VOLD", + "KC_VOLU", + "KC_MPLY", + "ANY(SK_ZOOMRST)", + "ANY(SK_HISTPRV)", + "ANY(SK_HISTNXT)", + "ANY(SK_ZOOMOUT)", + "ANY(SK_ZOOMIN)", + "ANY(SK_ZOOMRST)" + ], + [ + "ANY(S(G(KC_4)))", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_8)))", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_NLCK", + "ANY(C(S(G(KC_4))))", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "KC_TRNS", + "KC_TRNS", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LBRC", + "KC_RBRC", + "RALT(KC_5)", + "KC_COMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_ENT", + "KC_BSPC", + "KC_DEL", + "KC_P0", + "KC_PDOT", + "KC_C", + "KC_C", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_NO", + "RALT(KC_W)", + "RALT(KC_E)", + "RALT(KC_6)", + "RALT(KC_GRV)", + "LALT(KC_J)", + "RALT(KC_Q)", + "LALT(KC_U)", + "LALT(KC_K)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_A)", + "LALT(KC_N)", + "LALT(KC_I)", + "LALT(KC_L)", + "KC_NO", + "KC_NO", + "RALT(KC_X)", + "RALT(KC_C)", + "RALT(KC_L)", + "RALT(KC_D)", + "RALT(KC_B)", + "RALT(KC_Z)", + "RALT(KC_C)", + "LALT(KC_H)", + "LALT(KC_P)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "KC_NO", + "RALT(KC_1)", + "RALT(KC_R)", + "RALT(KC_G)", + "RALT(KC_2)", + "ANY(A(S(KC_SCLN)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_BSLS)", + "ANY(A(S(KC_3)))", + "ANY(A(S(KC_4)))", + "ANY(A(S(KC_BSLS)))", + "ANY(A(S(KC_5)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_9)", + "LALT(KC_QUOT)", + "RALT(KC_Q)", + "RALT(KC_F)", + "ANY(A(S(KC_7)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "LALT(KC_BSPC)", + "KC_DEL", + "LALT(KC_DEL)", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "KC_PWR", + "KC_SLEP", + "KC_NO", + "LCA(KC_DEL)", + "KC_NO", + "NK_TOGG", + "BL_TOGG", + "BL_ON", + "BL_OFF", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_WAKE", + "KC_NO", + "KC_NO", + "KC_NO", + "NK_ON", + "BL_STEP", + "BL_INC", + "RGB_HUI", + "RGB_SAI", + "RGB_VAD", + "KC_NO", + "DF(0)", + "DF(1)", + "KC_NO", + "KC_NO", + "KC_NO", + "NK_OFF", + "BL_BRTG", + "BL_DEC", + "RGB_HUD", + "RGB_SAD", + "RGB_VAI", + "KC_BRIU", + "TO(0)", + "TO(1)", + "RESET", + "KC_NO", + "AG_SWAP", + "AG_NORM", + "CG_NORM", + "CG_SWAP", + "KC_NO", + "RESET", + "KC_NO", + "KC_BRID" + ] + ], + "author": "", + "notes": "" +} \ No newline at end of file diff --git a/cornelius/cornelius_hd_bronzesilver_sk.json b/cornelius/cornelius_hd_bronzesilver_sk.json new file mode 100644 index 0000000..8cde5bb --- /dev/null +++ b/cornelius/cornelius_hd_bronzesilver_sk.json @@ -0,0 +1,461 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "foostan/cornelius", + "keymap": "cornelius_hd_bronzesilver_sk", + "layout": "LAYOUT", + "layers": [ + [ + "LT(5,KC_MUTE)", + "KC_J", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "KC_HASH", + "KC_DOT", + "KC_SLSH", + "KC_QUOT", + "KC_DQUO", + "LT(8,KC_MPLY)", + "KC_UP", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_C)", + "RCTL_T(KC_I)", + "TG(5)", + "KC_DOWN", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "KC_MINS", + "KC_U", + "KC_O", + "KC_W", + "KC_Y", + "LT(4,KC_BSPC)", + "KC_LEFT", + "KC_RGHT", + "KC_APP", + "LT(2,KC_LANG2)", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "LT(6,KC_LANG1)", + "KC_LBRC", + "KC_RBRC", + "LT(3,KC_EQL)" + ], + [ + "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", + "LGUI_T(KC_H)", + "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_DOT", + "KC_SLSH", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LT(4,KC_N)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "ANY(S(G(KC_4)))", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "LALT(KC_8)", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT(KC_Y)", + "RALT(KC_3)", + "KC_TRNS", + "ANY(C(S(G(KC_4))))", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "LGUI_T(KC_PEQL)", + "LALT_T(KC_PPLS)", + "LCTL_T(KC_BSLS)", + "KC_TRNS", + "KC_TRNS", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LCA(KC_DEL)", + "KC_TRNS", + "ANY(SK_DELWDL)", + "ANY(SK_DELWDR)", + "ANY(A(S(KC_9)))", + "LALT(KC_8)", + "ANY(A(S(KC_8)))", + "ANY(A(S(KC_R)))", + "TO(5)", + "KC_TRNS" + ], + [ + "KC_F16", + "KC_F11", + "KC_F12", + "KC_F13", + "KC_F14", + "KC_F15", + "KC_SLSH", + "KC_7", + "KC_8", + "KC_9", + "KC_0", + "KC_TRNS", + "KC_F17", + "LCTL_T(KC_F6)", + "LALT_T(KC_F7)", + "LGUI_T(KC_F8)", + "LSFT_T(KC_F9)", + "KC_F10", + "KC_EQL", + "RSFT_T(KC_4)", + "RGUI_T(KC_N)", + "RALT_T(KC_6)", + "RCTL_T(KC_MINS)", + "KC_TRNS", + "KC_F18", + "KC_F1", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_MINS", + "KC_1", + "KC_2", + "KC_3", + "KC_EQL", + "KC_TRNS", + "KC_F19", + "KC_F20", + "KC_F21", + "KC_F21", + "KC_TRNS", + "KC_TRNS", + "KC_INS", + "KC_LSCR", + "KC_LNUM", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_MUTE", + "ANY(SK_QUIT)", + "ANY(SK_CLOZ)", + "ANY(SK_SCAP)", + "ANY(SK_SCLP)", + "ANY(SK_FAGN)", + "ANY(SK_DOCBEG)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "ANY(SK_PARAPRV)", + "KC_TRNS", + "KC_MFFD", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "ANY(SK_FIND)", + "ANY(SK_WORDPRV)", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "ANY(SK_WORDNXT)", + "KC_TRNS", + "KC_MRWD", + "ANY(SK_UNDO)", + "ANY(SK_CUT)", + "ANY(SK_COPY)", + "ANY(SK_PSTE)", + "ANY(SK_PSTM)", + "ANY(SK_DOCEND)", + "KC_END", + "KC_DOWN", + "KC_PGDN", + "ANY(SK_PARANXT)", + "KC_TRNS", + "KC_MPRV", + "KC_MNXT", + "LCA(KC_DEL)", + "KC_VOLD", + "KC_VOLU", + "KC_MPLY", + "ANY(SK_ZOOMRST)", + "ANY(SK_HISTPRV)", + "ANY(SK_HISTNXT)", + "ANY(SK_ZOOMOUT)", + "ANY(SK_ZOOMIN)", + "ANY(SK_ZOOMRST)" + ], + [ + "ANY(S(G(KC_4)))", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_8)))", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_NLCK", + "ANY(C(S(G(KC_4))))", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "KC_TRNS", + "KC_TRNS", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LBRC", + "KC_RBRC", + "RALT(KC_5)", + "KC_COMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_ENT", + "KC_BSPC", + "KC_DEL", + "KC_P0", + "KC_PDOT", + "KC_C", + "KC_C", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_NO", + "RALT(KC_W)", + "RALT(KC_E)", + "RALT(KC_6)", + "RALT(KC_GRV)", + "LALT(KC_J)", + "RALT(KC_Q)", + "LALT(KC_U)", + "LALT(KC_K)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_A)", + "LALT(KC_N)", + "LALT(KC_I)", + "LALT(KC_L)", + "KC_NO", + "KC_NO", + "RALT(KC_X)", + "RALT(KC_C)", + "RALT(KC_L)", + "RALT(KC_D)", + "RALT(KC_B)", + "RALT(KC_Z)", + "RALT(KC_C)", + "LALT(KC_H)", + "LALT(KC_P)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "KC_NO", + "RALT(KC_1)", + "RALT(KC_R)", + "RALT(KC_G)", + "RALT(KC_2)", + "ANY(A(S(KC_SCLN)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_BSLS)", + "ANY(A(S(KC_3)))", + "ANY(A(S(KC_4)))", + "ANY(A(S(KC_BSLS)))", + "ANY(A(S(KC_5)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_9)", + "LALT(KC_QUOT)", + "RALT(KC_Q)", + "RALT(KC_F)", + "ANY(A(S(KC_7)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "LALT(KC_BSPC)", + "KC_DEL", + "LALT(KC_DEL)", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "KC_PWR", + "KC_SLEP", + "KC_NO", + "LCA(KC_DEL)", + "KC_NO", + "NK_TOGG", + "BL_TOGG", + "BL_ON", + "BL_OFF", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_WAKE", + "KC_NO", + "KC_NO", + "KC_NO", + "NK_ON", + "BL_STEP", + "BL_INC", + "RGB_HUI", + "RGB_SAI", + "RGB_VAD", + "KC_NO", + "DF(0)", + "DF(1)", + "KC_NO", + "KC_NO", + "KC_NO", + "NK_OFF", + "BL_BRTG", + "BL_DEC", + "RGB_HUD", + "RGB_SAD", + "RGB_VAI", + "KC_BRIU", + "TO(0)", + "TO(1)", + "RESET", + "KC_NO", + "AG_SWAP", + "AG_NORM", + "CG_NORM", + "CG_SWAP", + "KC_NO", + "RESET", + "KC_NO", + "KC_BRID" + ] + ], + "author": "", + "notes": "" +} \ No newline at end of file diff --git a/cornelius/cornelius_hd_keymap.c b/cornelius/cornelius_hd_keymap.c index 9a107b4..fa34747 100644 --- a/cornelius/cornelius_hd_keymap.c +++ b/cornelius/cornelius_hd_keymap.c @@ -7,13 +7,13 @@ */ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { - [0] = LAYOUT(LT(8,KC_TAB), KC_J, KC_F, KC_M, KC_P, KC_V, KC_HASH, KC_DOT, KC_SLSH, KC_DQUO, KC_QUOT, LT(8,KC_MPLY), LT(5,KC_HOME), LCTL_T(KC_R), LALT_T(KC_S), LGUI_T(KC_N), LSFT_T(KC_T), KC_K, KC_COMM, RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_I), RCTL_T(KC_C), LT(4,KC_MUTE), LT(6,KC_END), KC_X, KC_G, KC_L, KC_D, KC_B, KC_MINS, KC_U, KC_O, KC_Y, KC_W, KC_UP, KC_LEFT, KC_RGHT, KC_APP, LT(3,KC_LANG2), LT(4,KC_BSPC), LT(5,KC_H), LT(2,KC_SPC), LT(4,KC_ENT), LT(3,KC_LANG1), KC_LBRC, KC_RBRC, KC_DOWN), - [1] = LAYOUT(KC_NO, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_QUOT, KC_NO, KC_NO, LCTL_T(KC_A), LALT_T(KC_S), LGUI_T(KC_D), LSFT_T(KC_F), KC_G, KC_H, RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_P), KC_NO, KC_NO, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_NO, KC_NO, KC_TRNS, KC_TRNS, KC_BSPC, KC_SPC, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), - [2] = LAYOUT(S(G(KC_4)), LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_9)), LALT(KC_4), KC_DLR, A(S(KC_2)), LALT(KC_Y), RALT(KC_3), KC_NO, C(S(G(KC_4))), KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_8), RALT(KC_1), LSFT_T(KC_PAST), LGUI_T(KC_PEQL), LALT_T(KC_PPLS), LCTL_T(KC_BSLS), KC_NO, KC_NO, A(S(KC_5)), A(S(KC_7)), KC_LCBR, KC_RCBR, RALT(KC_5), KC_UNDS, KC_CIRC, KC_AMPR, KC_PIPE, KC_PERC, KC_NO, TO(5), KC_NO, KC_NO, LALT(KC_BSPC), LALT(KC_DEL), KC_TRNS, A(S(KC_9)), LALT(KC_8), A(S(KC_8)), A(S(KC_R)), TO(5), KC_NO), - [3] = LAYOUT(RESET, KC_F7, KC_F3, KC_F1, KC_F5, KC_F9, KC_F8, KC_F2, KC_F10, KC_F4, KC_F6, RESET, KC_NO, LCTL_T(KC_9), LALT_T(KC_3), LGUI_T(KC_1), LSFT_T(KC_5), KC_7, KC_6, RSFT_T(KC_2), RGUI_T(KC_0), RALT_T(KC_4), RCTL_T(KC_8), KC_NO, KC_NO, DF(1), TO(1), TO(0), DF(0), KC_F11, KC_F12, DF(0), TO(0), TO(1), DF(1), KC_NO, KC_NO, KC_NO, C(A(KC_DEL)), AG_NORM, AG_SWAP, KC_TRNS, KC_TRNS, CG_SWAP, CG_NORM, C(A(KC_DEL)), KC_NO, KC_NO), - [4] = LAYOUT(KC_MUTE, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_HOME), KC_HOME, KC_UP, KC_PGUP, LALT(KC_PGUP), KC_NO, KC_VOLU, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, KC_NO, LALT(KC_LEFT), KC_LEFT, KC_DOWN, KC_RGHT, LALT(KC_RGHT), KC_NO, KC_VOLD, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_END), KC_END, KC_DOWN, KC_PGDN, LALT(KC_PGDN), KC_NO, KC_MSTP, KC_NO, TG(5), KC_NO, KC_NO, KC_NO, LGUI(KC_LBRC), LGUI(KC_RBRC), G(S(KC_EQL)), LGUI(KC_MINS), LGUI(KC_0), KC_NO), - [5] = LAYOUT(KC_NO, LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_9)), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, KC_NO, KC_NO, KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_8), KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, KC_NO, KC_NO, A(S(KC_5)), A(S(KC_7)), KC_LBRC, KC_RBRC, RALT(KC_5), KC_COMM, KC_P1, KC_P2, KC_P3, KC_PEQL, KC_NO, TG(5), KC_TRNS, KC_NO, KC_BSPC, KC_DEL, KC_TRNS, A(S(KC_EQL)), KC_P0, KC_PDOT, KC_C, KC_TRNS, TG(5)), - [6] = LAYOUT(KC_NO, RALT(KC_W), RALT(KC_E), RALT(KC_6), RALT(KC_GRV), LALT(KC_J), RALT(KC_Q), LALT(KC_U), LALT(KC_K), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RALT(KC_A), LALT(KC_N), LALT(KC_I), LALT(KC_L), KC_NO, KC_NO, RALT(KC_X), RALT(KC_C), RALT(KC_L), RALT(KC_D), RALT(KC_B), RALT(KC_Z), RALT(KC_C), LALT(KC_H), LALT(KC_P), KC_NO, KC_NO, KC_NO, RESET, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET, KC_NO), + [0] = LAYOUT(LT(5,KC_MUTE), KC_J, KC_F, KC_M, KC_P, KC_V, KC_HASH, KC_DOT, KC_SLSH, KC_QUOT, KC_DQUO, LT(8,KC_MPLY), KC_UP, LCTL_T(KC_R), LALT_T(KC_S), LGUI_T(KC_N), LSFT_T(KC_T), KC_K, KC_COMM, RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_C), RCTL_T(KC_I), TG(5), KC_DOWN, KC_X, KC_G, KC_L, KC_D, KC_B, KC_MINS, KC_U, KC_O, KC_W, KC_Y, LT(4,KC_BSPC), KC_LEFT, KC_RGHT, KC_APP, LT(2,KC_LANG2), LT(5,KC_BSPC), LT(4,KC_H), LT(2,KC_SPC), LT(4,KC_ENT), LT(6,KC_LANG1), KC_LBRC, KC_RBRC, LT(3,KC_EQL)), + [1] = LAYOUT(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, LGUI_T(KC_H), 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_DOT, KC_SLSH, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LT(4,KC_N), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [2] = LAYOUT(S(G(KC_4)), LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), LALT(KC_8), LALT(KC_4), KC_DLR, A(S(KC_2)), LALT(KC_Y), RALT(KC_3), KC_TRNS, C(S(G(KC_4))), KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_7), RALT(KC_1), LSFT_T(KC_PAST), LGUI_T(KC_PEQL), LALT_T(KC_PPLS), LCTL_T(KC_BSLS), KC_TRNS, KC_TRNS, A(S(KC_5)), A(S(KC_7)), KC_LCBR, KC_RCBR, RALT(KC_5), KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, KC_TRNS, KC_TRNS, KC_TRNS, LCA(KC_DEL), KC_TRNS, SK_DELWDL, SK_DELWDR, A(S(KC_9)), LALT(KC_8), A(S(KC_8)), A(S(KC_R)), TO(5), KC_TRNS), + [3] = LAYOUT(KC_F16, KC_F11, KC_F12, KC_F13, KC_F14, KC_F15, KC_SLSH, KC_7, KC_8, KC_9, KC_0, KC_TRNS, KC_F17, LCTL_T(KC_F6), LALT_T(KC_F7), LGUI_T(KC_F8), LSFT_T(KC_F9), KC_F10, KC_EQL, RSFT_T(KC_4), RGUI_T(KC_N), RALT_T(KC_6), RCTL_T(KC_MINS), KC_TRNS, KC_F18, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_MINS, KC_1, KC_2, KC_3, KC_EQL, KC_TRNS, KC_F19, KC_F20, KC_F21, KC_F21, KC_TRNS, KC_TRNS, KC_INS, KC_LSCR, KC_LNUM, KC_TRNS, KC_TRNS, KC_TRNS), + [4] = LAYOUT(KC_MUTE, SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_TRNS, KC_MFFD, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_TRNS, KC_MRWD, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, KC_TRNS, KC_MPRV, KC_MNXT, LCA(KC_DEL), KC_VOLD, KC_VOLU, KC_MPLY, SK_ZOOMRST, SK_HISTPRV, SK_HISTNXT, SK_ZOOMOUT, SK_ZOOMIN, SK_ZOOMRST), + [5] = LAYOUT(S(G(KC_4)), LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_8)), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, KC_NLCK, C(S(G(KC_4))), KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_7), KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, KC_TRNS, KC_TRNS, A(S(KC_5)), A(S(KC_7)), KC_LBRC, KC_RBRC, RALT(KC_5), KC_COMM, KC_P1, KC_P2, KC_P3, KC_PEQL, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_ENT, KC_BSPC, KC_DEL, KC_P0, KC_PDOT, KC_C, KC_C, KC_TRNS, KC_TRNS), + [6] = LAYOUT(KC_NO, RALT(KC_W), RALT(KC_E), RALT(KC_6), RALT(KC_GRV), LALT(KC_J), RALT(KC_Q), LALT(KC_U), LALT(KC_K), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RALT(KC_A), LALT(KC_N), LALT(KC_I), LALT(KC_L), KC_NO, KC_NO, RALT(KC_X), RALT(KC_C), RALT(KC_L), RALT(KC_D), RALT(KC_B), RALT(KC_Z), RALT(KC_C), LALT(KC_H), LALT(KC_P), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO), [7] = LAYOUT(KC_NO, RALT(KC_1), RALT(KC_R), RALT(KC_G), RALT(KC_2), A(S(KC_SCLN)), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_BSLS), A(S(KC_3)), A(S(KC_4)), A(S(KC_BSLS)), A(S(KC_5)), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_9), LALT(KC_QUOT), RALT(KC_Q), RALT(KC_F), A(S(KC_7)), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_TRNS, LALT(KC_BSPC), KC_DEL, LALT(KC_DEL), KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO), - [8] = LAYOUT(KC_NO, KC_PSCR, KC_SLCK, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, CG_NORM, KC_NO, LCTL_T(KC_BRIU), LALT_T(KC_MRWD), LGUI_T(KC_MSTP), LSFT_T(KC_MFFD), LT(5,KC_VOLU), RGB_TOG, RGB_VAI, RGB_HUI, RGB_SAI, KC_NO, CG_SWAP, KC_NO, KC_BRID, KC_MPRV, KC_MUTE, KC_MNXT, KC_VOLD, BL_BRTG, RGB_VAD, RGB_HUD, RGB_SAD, KC_NO, KC_NO, KC_NO, RESET, KC_EJCT, KC_PAUS, KC_MPLY, KC_NO, BL_TOGG, BL_ON, BL_OFF, KC_NO, RESET, KC_NO) + [8] = LAYOUT(KC_PWR, KC_SLEP, KC_NO, LCA(KC_DEL), KC_NO, NK_TOGG, BL_TOGG, BL_ON, BL_OFF, KC_NO, KC_NO, KC_NO, KC_NO, KC_WAKE, KC_NO, KC_NO, KC_NO, NK_ON, BL_STEP, BL_INC, RGB_HUI, RGB_SAI, RGB_VAD, KC_NO, DF(0), DF(1), KC_NO, KC_NO, KC_NO, NK_OFF, BL_BRTG, BL_DEC, RGB_HUD, RGB_SAD, RGB_VAI, KC_BRIU, TO(0), TO(1), RESET, KC_NO, AG_SWAP, AG_NORM, CG_NORM, CG_SWAP, KC_NO, RESET, KC_NO, KC_BRID) }; diff --git a/cornelius/cornelius_hd_keymap.c.bak b/cornelius/cornelius_hd_keymap.c.bak index b3eefe8..a90a355 100644 --- a/cornelius/cornelius_hd_keymap.c.bak +++ b/cornelius/cornelius_hd_keymap.c.bak @@ -7,13 +7,13 @@ */ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { - [0] = LAYOUT(LT(8,KC_TAB), KC_J, KC_F, KC_M, KC_P, KC_V, KC_HASH, KC_DOT, KC_SLSH, KC_DQUO, KC_QUOT, LT(8,KC_MPLY), LT(5,KC_HOME), LCTL_T(KC_R), LALT_T(KC_S), LGUI_T(KC_N), LSFT_T(KC_T), KC_K, KC_COMM, RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_I), RCTL_T(KC_C), LT(4,KC_MUTE), LT(6,KC_END), KC_X, KC_G, KC_L, KC_D, KC_B, KC_MINS, KC_U, KC_O, KC_Y, KC_W, KC_UP, KC_LEFT, KC_RGHT, KC_APP, LT(3,KC_LANG2), LT(5,KC_BSPC), LT(4,KC_H), LT(2,KC_SPC), LT(4,KC_ENT), LT(3,KC_LANG1), KC_LBRC, KC_RBRC, KC_DOWN), - [1] = LAYOUT(KC_NO, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_QUOT, KC_NO, KC_NO, LCTL_T(KC_A), LALT_T(KC_S), LGUI_T(KC_D), LSFT_T(KC_F), KC_G, KC_H, RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_P), KC_NO, KC_NO, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_NO, KC_NO, KC_TRNS, KC_TRNS, KC_BSPC, KC_SPC, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), - [2] = LAYOUT(S(G(KC_4)), LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_9)), LALT(KC_4), KC_DLR, A(S(KC_2)), LALT(KC_Y), RALT(KC_3), KC_NO, C(S(G(KC_4))), KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_8), RALT(KC_1), LSFT_T(KC_PAST), LGUI_T(KC_PEQL), LALT_T(KC_PPLS), LCTL_T(KC_BSLS), KC_NO, KC_NO, A(S(KC_5)), A(S(KC_7)), KC_LCBR, KC_RCBR, RALT(KC_5), KC_UNDS, KC_CIRC, KC_AMPR, KC_PIPE, KC_PERC, KC_NO, TO(5), KC_NO, KC_NO, LALT(KC_BSPC), LALT(KC_DEL), KC_TRNS, A(S(KC_9)), LALT(KC_8), A(S(KC_8)), A(S(KC_R)), TO(5), KC_NO), - [3] = LAYOUT(RESET, KC_F7, KC_F3, KC_F1, KC_F5, KC_F9, KC_F8, KC_F2, KC_F10, KC_F4, KC_F6, RESET, KC_NO, LCTL_T(KC_9), LALT_T(KC_3), LGUI_T(KC_1), LSFT_T(KC_5), KC_7, KC_6, RSFT_T(KC_2), RGUI_T(KC_0), RALT_T(KC_4), RCTL_T(KC_8), KC_NO, KC_NO, DF(1), TO(1), TO(0), DF(0), KC_F11, KC_F12, DF(0), TO(0), TO(1), DF(1), KC_NO, KC_NO, KC_NO, C(A(KC_DEL)), AG_NORM, AG_SWAP, KC_TRNS, KC_TRNS, CG_SWAP, CG_NORM, C(A(KC_DEL)), KC_NO, KC_NO), - [4] = LAYOUT(KC_MUTE, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_HOME), KC_HOME, KC_UP, KC_PGUP, LALT(KC_PGUP), KC_NO, KC_VOLU, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, KC_NO, LALT(KC_LEFT), KC_LEFT, KC_DOWN, KC_RGHT, LALT(KC_RGHT), KC_NO, KC_VOLD, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_END), KC_END, KC_DOWN, KC_PGDN, LALT(KC_PGDN), KC_NO, KC_MSTP, KC_NO, TG(5), KC_NO, KC_NO, KC_NO, LGUI(KC_LBRC), LGUI(KC_RBRC), G(S(KC_EQL)), LGUI(KC_MINS), LGUI(KC_0), KC_NO), - [5] = LAYOUT(KC_NO, LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_9)), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, KC_NO, KC_NO, KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_8), KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, KC_NO, KC_NO, A(S(KC_5)), A(S(KC_7)), KC_LBRC, KC_RBRC, RALT(KC_5), KC_COMM, KC_P1, KC_P2, KC_P3, KC_PEQL, KC_NO, TG(5), KC_TRNS, KC_NO, KC_BSPC, KC_DEL, KC_TRNS, A(S(KC_EQL)), KC_P0, KC_PDOT, KC_C, KC_TRNS, TG(5)), - [6] = LAYOUT(KC_NO, RALT(KC_W), RALT(KC_E), RALT(KC_6), RALT(KC_GRV), LALT(KC_J), RALT(KC_Q), LALT(KC_U), LALT(KC_K), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RALT(KC_A), LALT(KC_N), LALT(KC_I), LALT(KC_L), KC_NO, KC_NO, RALT(KC_X), RALT(KC_C), RALT(KC_L), RALT(KC_D), RALT(KC_B), RALT(KC_Z), RALT(KC_C), LALT(KC_H), LALT(KC_P), KC_NO, KC_NO, KC_NO, RESET, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET, KC_NO), + [0] = LAYOUT(LT(5,KC_MUTE), KC_J, KC_F, KC_M, KC_P, KC_HASH, KC_V, KC_DOT, KC_SLSH, KC_QUOT, KC_DQUO, LT(8,KC_MPLY), KC_UP, LCTL_T(KC_R), LALT_T(KC_S), LGUI_T(KC_N), LSFT_T(KC_T), KC_K, KC_COMM, RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_C), RCTL_T(KC_I), TG(5), KC_DOWN, KC_X, KC_G, KC_L, KC_D, KC_B, KC_MINS, KC_U, KC_O, KC_W, KC_Y, LT(4,KC_BSPC), KC_LEFT, KC_RGHT, KC_APP, LT(2,KC_LANG2), LT(5,KC_BSPC), LT(4,KC_H), LT(2,KC_SPC), LT(4,KC_ENT), LT(6,KC_LANG1), KC_LBRC, KC_RBRC, LT(3,KC_EQL)), + [1] = LAYOUT(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, LGUI_T(KC_H), 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_DOT, KC_SLSH, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LT(4,KC_N), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [2] = LAYOUT(S(G(KC_4)), LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), LALT(KC_8), LALT(KC_4), KC_DLR, A(S(KC_2)), LALT(KC_Y), RALT(KC_3), KC_TRNS, C(S(G(KC_4))), KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_7), RALT(KC_1), LSFT_T(KC_PAST), LGUI_T(KC_PEQL), LALT_T(KC_PPLS), LCTL_T(KC_BSLS), KC_TRNS, KC_TRNS, A(S(KC_5)), A(S(KC_7)), KC_LCBR, KC_RCBR, RALT(KC_5), KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, KC_TRNS, KC_TRNS, KC_TRNS, LCA(KC_DEL), KC_TRNS, SK_DELWDL, SK_DELWDR, A(S(KC_9)), LALT(KC_8), A(S(KC_8)), A(S(KC_R)), TO(5), KC_TRNS), + [3] = LAYOUT(KC_F16, KC_F11, KC_F12, KC_F13, KC_F14, KC_F15, KC_SLSH, KC_7, KC_8, KC_9, KC_0, KC_TRNS, KC_F17, LCTL_T(KC_F6), LALT_T(KC_F7), LGUI_T(KC_F8), LSFT_T(KC_F9), KC_F10, KC_EQL, RSFT_T(KC_4), RGUI_T(KC_N), RALT_T(KC_6), RCTL_T(KC_MINS), KC_TRNS, KC_F18, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_MINS, KC_1, KC_2, KC_3, KC_EQL, KC_TRNS, KC_F19, KC_F20, KC_F21, KC_F21, KC_TRNS, KC_TRNS, KC_INS, KC_LSCR, KC_LNUM, KC_TRNS, KC_TRNS, KC_TRNS), + [4] = LAYOUT(KC_MUTE, SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_TRNS, KC_MFFD, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_TRNS, KC_MRWD, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, KC_TRNS, KC_MPRV, KC_MNXT, LCA(KC_DEL), KC_VOLD, KC_VOLU, KC_MPLY, SK_ZOOMRST, SK_HISTPRV, SK_HISTNXT, SK_ZOOMOUT, SK_ZOOMIN, SK_ZOOMRST), + [5] = LAYOUT(S(G(KC_4)), LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_8)), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, KC_NLCK, C(S(G(KC_4))), KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_7), KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, KC_TRNS, KC_TRNS, A(S(KC_5)), A(S(KC_7)), KC_LBRC, KC_RBRC, RALT(KC_5), KC_COMM, KC_P1, KC_P2, KC_P3, KC_PEQL, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_ENT, KC_BSPC, KC_DEL, KC_P0, KC_PDOT, KC_C, KC_C, KC_TRNS, KC_TRNS), + [6] = LAYOUT(KC_NO, RALT(KC_W), RALT(KC_E), RALT(KC_6), RALT(KC_GRV), LALT(KC_J), RALT(KC_Q), LALT(KC_U), LALT(KC_K), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RALT(KC_A), LALT(KC_N), LALT(KC_I), LALT(KC_L), KC_NO, KC_NO, RALT(KC_X), RALT(KC_C), RALT(KC_L), RALT(KC_D), RALT(KC_B), RALT(KC_Z), RALT(KC_C), LALT(KC_H), LALT(KC_P), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO), [7] = LAYOUT(KC_NO, RALT(KC_1), RALT(KC_R), RALT(KC_G), RALT(KC_2), A(S(KC_SCLN)), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_BSLS), A(S(KC_3)), A(S(KC_4)), A(S(KC_BSLS)), A(S(KC_5)), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_9), LALT(KC_QUOT), RALT(KC_Q), RALT(KC_F), A(S(KC_7)), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_TRNS, LALT(KC_BSPC), KC_DEL, LALT(KC_DEL), KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO), - [8] = LAYOUT(KC_NO, KC_PSCR, KC_SLCK, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, CG_NORM, KC_NO, LCTL_T(KC_BRIU), LALT_T(KC_MRWD), LGUI_T(KC_MSTP), LSFT_T(KC_MFFD), LT(5,KC_VOLU), RGB_TOG, RGB_VAI, RGB_HUI, RGB_SAI, KC_NO, CG_SWAP, KC_NO, KC_BRID, KC_MPRV, KC_MUTE, KC_MNXT, KC_VOLD, BL_BRTG, RGB_VAD, RGB_HUD, RGB_SAD, KC_NO, KC_NO, KC_NO, RESET, KC_EJCT, KC_PAUS, KC_MPLY, KC_NO, BL_TOGG, BL_ON, BL_OFF, KC_NO, RESET, KC_NO) + [8] = LAYOUT(KC_PWR, KC_SLEP, KC_NO, LCA(KC_DEL), KC_NO, NK_TOGG, BL_TOGG, BL_ON, BL_OFF, KC_NO, KC_NO, KC_NO, KC_NO, KC_WAKE, KC_NO, KC_NO, KC_NO, NK_ON, BL_STEP, BL_INC, RGB_HUI, RGB_SAI, RGB_VAD, KC_NO, DF(0), DF(1), KC_NO, KC_NO, KC_NO, NK_OFF, BL_BRTG, BL_DEC, RGB_HUD, RGB_SAD, RGB_VAI, KC_BRIU, TO(0), TO(1), RESET, KC_NO, AG_SWAP, AG_NORM, CG_NORM, CG_SWAP, KC_NO, RESET, KC_NO, KC_BRID) }; diff --git a/cornelius/kyria_hd_bronze.json b/cornelius/kyria_hd_bronze.json new file mode 100644 index 0000000..b514d83 --- /dev/null +++ b/cornelius/kyria_hd_bronze.json @@ -0,0 +1,479 @@ +{ + "version": 1, + "notes": "Hands Down Kyria\n\n0—Hands Down (mods on home row, Layers on thumbs)\n1—QWERTY\n2—SYMBOL\n3—FN\n4—MEDIA/NAV\n5—NUM\n6—DIACRIT", + "documentation": "\"This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\"\n", + "keyboard": "splitkb/kyria/rev1", + "keymap": "kyria_hd_bronze", + "layout": "LAYOUT", + "layers": [ + [ + "ANY(G(KC_C))", + "KC_J", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "KC_HASH", + "KC_DOT", + "KC_SLSH", + "KC_DQUO", + "KC_QUOT", + "KC_LANG1", + "ANY(G(KC_V))", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_I)", + "RCTL_T(KC_C)", + "KC_LANG2", + "ANY(S(G(KC_4)))", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "LT(3,KC_LANG2)", + "ANY(SH_TT)", + "ANY(SH_TT)", + "LT(3,KC_LANG1)", + "KC_MINS", + "KC_U", + "KC_O", + "KC_Y", + "KC_W", + "KC_EQL", + "LT(6,KC_MUTE)", + "KC_APP", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(3,KC_TAB)", + "LT(3,KC_BSPC)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "LT(5,KC_TAB)", + "LT(8,KC_MPLY)" + ], + [ + "KC_NO", + "KC_Q", + "KC_W", + "KC_E", + "KC_R", + "KC_T", + "KC_Y", + "KC_U", + "KC_I", + "KC_O", + "KC_P", + "KC_NO", + "KC_NO", + "LCTL_T(KC_A)", + "LALT_T(KC_S)", + "LGUI_T(KC_D)", + "LSFT_T(KC_F)", + "KC_G", + "KC_H", + "RSFT_T(KC_J)", + "RGUI_T(KC_K)", + "RALT_T(KC_L)", + "RCTL_T(KC_SCLN)", + "KC_NO", + "KC_NO", + "KC_Z", + "KC_X", + "KC_C", + "KC_V", + "KC_B", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_N", + "KC_M", + "KC_COMM", + "KC_DOT", + "KC_SLSH", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_BSPC", + "KC_SPC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "ANY(G(KC_C))", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "LALT(KC_8)", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT(KC_Y)", + "RALT(KC_3)", + "KC_NO", + "ANY(C(S(G(KC_4))))", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "LGUI_T(KC_PEQL)", + "LALT_T(KC_PPLS)", + "LCTL_T(KC_BSLS)", + "KC_NO", + "ANY(S(G(KC_3)))", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_LANG2", + "KC_TRNS", + "KC_TRNS", + "KC_HANJ", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_NO", + "KC_VOLD", + "KC_VOLU", + "LALT(KC_BSPC)", + "LALT(KC_DEL)", + "KC_LANG2", + "ANY(A(S(KC_9)))", + "KC_TRNS", + "LALT(KC_9)", + "ANY(A(S(KC_8)))", + "TG(5)" + ], + [ + "KC_TRNS", + "KC_F7", + "KC_F3", + "KC_F1", + "KC_F5", + "KC_F9", + "KC_F8", + "KC_F2", + "KC_F10", + "KC_F4", + "KC_F6", + "KC_TRNS", + "KC_TRNS", + "LCTL_T(KC_9)", + "LALT_T(KC_3)", + "LGUI_T(KC_1)", + "LSFT_T(KC_5)", + "KC_7", + "KC_6", + "RSFT_T(KC_2)", + "RGUI_T(KC_0)", + "RALT_T(KC_4)", + "RCTL_T(KC_8)", + "KC_TRNS", + "KC_TRNS", + "DF(1)", + "TO(1)", + "TO(0)", + "DF(0)", + "KC_F11", + "RESET", + "KC_TRNS", + "KC_TRNS", + "RESET", + "KC_F12", + "DF(0)", + "TO(0)", + "TO(1)", + "DF(1)", + "KC_TRNS", + "RESET", + "ANY(C(A(KC_DEL)))", + "AG_NORM", + "AG_SWAP", + "KC_TRNS", + "KC_TRNS", + "CG_SWAP", + "CG_NORM", + "ANY(C(A(KC_DEL)))", + "RESET" + ], + [ + "KC_NO", + "LGUI(KC_Q)", + "LGUI(KC_W)", + "ANY(S(G(KC_4)))", + "ANY(C(S(G(KC_4))))", + "LGUI(KC_G)", + "LALT(KC_HOME)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "LALT(KC_PGUP)", + "KC_NO", + "KC_NO", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "LGUI(KC_F)", + "LALT(KC_LEFT)", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "LALT(KC_RGHT)", + "KC_NO", + "KC_NO", + "LGUI(KC_Z)", + "LGUI(KC_X)", + "LGUI(KC_C)", + "LGUI(KC_V)", + "ANY(G(S(A(KC_V))))", + "KC_LANG2", + "KC_NO", + "KC_NO", + "KC_HANJ", + "LALT(KC_END)", + "KC_END", + "KC_DOWN", + "KC_PGDN", + "LALT(KC_PGDN)", + "KC_NO", + "KC_BRID", + "KC_BRIU", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LGUI(KC_LBRC)", + "LGUI(KC_RBRC)", + "ANY(G(S(KC_EQL)))", + "LGUI(KC_MINS)", + "LGUI(KC_0)" + ], + [ + "KC_NO", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_8)))", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_NO", + "KC_NO", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "KC_NO", + "KC_NO", + "LCTL_T(KC_LBRC)", + "LALT_T(KC_RBRC)", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "LALT(KC_MINS)", + "KC_TRNS", + "LALT(KC_SLSH)", + "LALT(KC_EQL)", + "KC_COMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_NO", + "TG(5)", + "KC_TRNS", + "KC_BSPC", + "KC_DEL", + "KC_TRNS", + "ANY(A(S(KC_EQL)))", + "KC_P0", + "KC_PDOT", + "KC_C", + "KC_TRNS" + ], + [ + "KC_NO", + "RALT(KC_W)", + "RALT(KC_E)", + "RALT(KC_6)", + "RALT(KC_GRV)", + "LALT(KC_J)", + "RALT(KC_Q)", + "LALT(KC_U)", + "LALT(KC_K)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_A)", + "LALT(KC_N)", + "LALT(KC_I)", + "LALT(KC_L)", + "KC_NO", + "KC_NO", + "RALT(KC_X)", + "RALT(KC_C)", + "RALT(KC_L)", + "RALT(KC_D)", + "RALT(KC_B)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_Z)", + "RALT(KC_C)", + "LALT(KC_H)", + "LALT(KC_P)", + "KC_NO", + "KC_NO", + "RESET", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET" + ], + [ + "KC_NO", + "RALT(KC_1)", + "RALT(KC_R)", + "RALT(KC_G)", + "RALT(KC_2)", + "ANY(A(S(KC_SCLN)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_BSLS)", + "ANY(A(S(KC_3)))", + "ANY(A(S(KC_4)))", + "ANY(A(S(KC_BSLS)))", + "ANY(A(S(KC_5)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_9)", + "LALT(KC_QUOT)", + "RALT(KC_Q)", + "RALT(KC_F)", + "ANY(A(S(KC_7)))", + "KC_CAPS", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "LALT(KC_BSPC)", + "KC_DEL", + "LALT(KC_DEL)", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "KC_NO", + "KC_PSCR", + "KC_SLCK", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LCTL_T(KC_BRIU)", + "LALT_T(KC_MRWD)", + "LGUI_T(KC_MSTP)", + "LSFT_T(KC_MFFD)", + "LT(5,KC_VOLU)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRID", + "KC_MPRV", + "KC_MUTE", + "KC_MNXT", + "KC_VOLD", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET", + "KC_EJCT", + "KC_PAUS", + "KC_MPLY", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET" + ] + ], + "author": "Hands Down Kyria" +} \ No newline at end of file diff --git a/cornelius/kyria_hd_bronzesilver_sk.json b/cornelius/kyria_hd_bronzesilver_sk.json new file mode 100644 index 0000000..429287f --- /dev/null +++ b/cornelius/kyria_hd_bronzesilver_sk.json @@ -0,0 +1,479 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "splitkb/kyria/rev1", + "keymap": "kyria_hd_bronzesilver_sk", + "layout": "LAYOUT", + "layers": [ + [ + "ANY(SK_COPY)", + "KC_J", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "KC_SCLN", + "KC_DOT", + "KC_SLSH", + "KC_QUOT", + "KC_DQUO", + "KC_KANA", + "ANY(SK_PSTE)", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_C)", + "RCTL_T(KC_I)", + "KC_LANG2", + "ANY(S(G(KC_4)))", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "LT(3,KC_LANG2)", + "ANY(SH_TT)", + "TG(5)", + "LT(3,KC_LANG1)", + "KC_MINS", + "KC_U", + "KC_O", + "KC_W", + "KC_Y", + "KC_EQL", + "LT(6,KC_MUTE)", + "KC_APP", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(3,KC_LANG2)", + "LT(3,KC_BSPC)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "LT(5,KC_TAB)", + "LT(8,KC_MPLY)" + ], + [ + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_U", + "KC_TRNS", + "KC_O", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LGUI_T(KC_H)", + "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_DOT", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LT(4,KC_N)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_TRNS", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "LALT(KC_8)", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT(KC_Y)", + "RALT(KC_3)", + "KC_TRNS", + "KC_TRNS", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "LGUI_T(KC_PEQL)", + "LALT_T(KC_PPLS)", + "LCTL_T(KC_BSLS)", + "KC_TRNS", + "KC_TRNS", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_TRNS", + "KC_VOLD", + "KC_VOLU", + "ANY(SK_DELWDL)", + "ANY(SK_DELWDR)", + "KC_TRNS", + "ANY(A(S(KC_9)))", + "KC_TRNS", + "LALT(KC_9)", + "ANY(A(S(KC_8)))", + "TG(5)" + ], + [ + "KC_TRNS", + "KC_F9", + "KC_F3", + "KC_F1", + "KC_F5", + "KC_F7", + "KC_F6", + "KC_F2", + "KC_F10", + "KC_F4", + "KC_F8", + "KC_TRNS", + "KC_TRNS", + "LCTL_T(KC_9)", + "LALT_T(KC_3)", + "LGUI_T(KC_1)", + "LSFT_T(KC_5)", + "KC_7", + "KC_6", + "RSFT_T(KC_2)", + "RGUI_T(KC_0)", + "RALT_T(KC_4)", + "RCTL_T(KC_8)", + "KC_TRNS", + "KC_TRNS", + "DF(1)", + "TO(1)", + "AG_SWAP", + "CG_SWAP", + "KC_F11", + "RESET", + "KC_TRNS", + "KC_TRNS", + "RESET", + "KC_F12", + "DF(0)", + "TO(0)", + "CG_NORM", + "AG_NORM", + "KC_TRNS", + "RESET", + "LCA(KC_DEL)", + "KC_NO", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_NO", + "KC_NO", + "LCA(KC_DEL)", + "RESET" + ], + [ + "KC_TRNS", + "ANY(SK_QUIT)", + "ANY(SK_CLOZ)", + "ANY(SK_SCAP)", + "ANY(SK_SCLP)", + "ANY(SK_FAGN)", + "ANY(SK_DOCBEG)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "ANY(SK_PARAPRV)", + "KC_TRNS", + "KC_TRNS", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "ANY(SK_FIND)", + "ANY(SK_WORDPRV)", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "ANY(SK_WORDNXT)", + "KC_TRNS", + "KC_TRNS", + "ANY(SK_UNDO)", + "ANY(SK_CUT)", + "ANY(SK_COPY)", + "ANY(SK_PSTE)", + "ANY(SK_PSTM)", + "KC_HANJ", + "KC_TRNS", + "KC_TRNS", + "KC_HANJ", + "ANY(SK_DOCEND)", + "KC_END", + "KC_DOWN", + "KC_PGDN", + "ANY(SK_PARANXT)", + "KC_TRNS", + "KC_BRID", + "KC_BRIU", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "ANY(SK_ZOOMOUT)", + "ANY(SK_HISTPRV)", + "ANY(SK_HISTNXT)", + "ANY(SK_ZOOMIN)", + "ANY(SK_ZOOMRST)" + ], + [ + "KC_NO", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_8)))", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_NO", + "KC_NO", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "KC_NO", + "KC_NO", + "LCTL_T(KC_LBRC)", + "LALT_T(KC_RBRC)", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "LALT(KC_MINS)", + "TG(0)", + "KC_TRNS", + "LALT(KC_EQL)", + "KC_COMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_NO", + "KC_TRNS", + "KC_APP", + "KC_BSPC", + "LT(4,KC_DEL)", + "KC_PENT", + "KC_BSPC", + "KC_P0", + "KC_PDOT", + "KC_C", + "KC_TRNS" + ], + [ + "KC_NO", + "RALT(KC_W)", + "RALT(KC_E)", + "RALT(KC_6)", + "RALT(KC_GRV)", + "LALT(KC_J)", + "RALT(KC_Q)", + "LALT(KC_U)", + "LALT(KC_K)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_A)", + "LALT(KC_N)", + "LALT(KC_I)", + "LALT(KC_L)", + "KC_NO", + "KC_NO", + "RALT(KC_X)", + "RALT(KC_C)", + "RALT(KC_L)", + "RALT(KC_D)", + "RALT(KC_B)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_Z)", + "RALT(KC_C)", + "LALT(KC_H)", + "LALT(KC_P)", + "KC_NO", + "KC_NO", + "RESET", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET" + ], + [ + "KC_NO", + "RALT(KC_1)", + "RALT(KC_R)", + "RALT(KC_G)", + "RALT(KC_2)", + "ANY(A(S(KC_SCLN)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_BSLS)", + "ANY(A(S(KC_3)))", + "ANY(A(S(KC_4)))", + "ANY(A(S(KC_BSLS)))", + "ANY(A(S(KC_5)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_9)", + "LALT(KC_QUOT)", + "RALT(KC_Q)", + "RALT(KC_F)", + "ANY(A(S(KC_7)))", + "KC_CAPS", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "LALT(KC_BSPC)", + "KC_DEL", + "LALT(KC_DEL)", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "KC_NO", + "KC_PSCR", + "KC_SLCK", + "LCA(KC_DEL)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LCTL_T(KC_BRIU)", + "LALT_T(KC_MRWD)", + "LGUI_T(KC_MSTP)", + "LSFT_T(KC_MFFD)", + "LT(5,KC_VOLU)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRID", + "KC_MPRV", + "KC_MUTE", + "KC_MNXT", + "KC_VOLD", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET", + "KC_EJCT", + "KC_PAUS", + "KC_MPLY", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET" + ] + ], + "author": "Hands Down Kyria", + "notes": "Hands Down Kyria\n\n0—Hands Down (mods on home row, Layers on thumbs)\n1—QWERTY\n2—SYMBOL\n3—FN\n4—MEDIA/NAV\n5—NUM\n6—DIACRIT" +} \ No newline at end of file diff --git a/ferris/ferris_hd_bronze.json b/ferris/ferris_hd_bronze.json new file mode 100644 index 0000000..e45a0de --- /dev/null +++ b/ferris/ferris_hd_bronze.json @@ -0,0 +1,299 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "ferris/0_2/compact", + "keymap": "ferris_hd_bronze", + "layout": "LAYOUT", + "layers": [ + [ + "KC_J", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "KC_HASH", + "KC_DOT", + "KC_SLSH", + "KC_DQUO", + "KC_QUOT", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_I)", + "RCTL_T(KC_C)", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "KC_MINS", + "KC_U", + "KC_O", + "KC_Y", + "KC_W", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)" + ], + [ + "KC_Q", + "KC_W", + "KC_E", + "KC_R", + "KC_T", + "KC_Y", + "KC_U", + "KC_I", + "KC_O", + "KC_SCLN", + "LCTL_T(KC_A)", + "LALT_T(KC_S)", + "LGUI_T(KC_D)", + "LSFT_T(KC_F)", + "KC_G", + "KC_H", + "RSFT_T(KC_J)", + "RGUI_T(KC_K)", + "RALT_T(KC_L)", + "RCTL_T(KC_P)", + "KC_Z", + "KC_X", + "KC_C", + "KC_V", + "KC_B", + "KC_N", + "KC_M", + "KC_COMM", + "KC_DOT", + "KC_SLSH", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_Q", + "KC_Z", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "ANY(A(S(KC_9)))", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT(KC_Y)", + "RALT(KC_3)", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "RALT(KC_1)", + "RSFT_T(KC_PAST)", + "RGUI_T(KC_PEQL)", + "RALT_T(KC_PPLS)", + "RCTL_T(KC_PSLS)", + "KC_LBRC", + "KC_RBRC", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_UNDS", + "KC_CIRC", + "KC_AMPR", + "KC_PIPE", + "KC_TRNS", + "LALT(KC_BSPC)", + "LALT(KC_DEL)", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_F11", + "KC_F12", + "KC_F13", + "KC_F14", + "KC_F15", + "KC_NUHS", + "KC_7", + "KC_8", + "KC_9", + "KC_0", + "LCTL_T(KC_F6)", + "LALT_T(KC_F7)", + "LGUI_T(KC_F8)", + "LSFT_T(KC_F9)", + "KC_F10", + "KC_SLSH", + "RSFT_T(KC_4)", + "RGUI_T(KC_5)", + "RALT_T(KC_6)", + "RCTL_T(KC_MINS)", + "KC_F1", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_MINS", + "KC_1", + "KC_2", + "KC_3", + "KC_EQL", + "KC_PSCR", + "KC_SLCK", + "KC_PAUS", + "KC_INS" + ], + [ + "ANY(C(A(KC_DEL)))", + "CG_SWAP", + "CG_NORM", + "KC_MUTE", + "KC_VOLU", + "LALT(KC_HOME)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "LALT(KC_PGUP)", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "KC_VOLD", + "LALT(KC_LEFT)", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "LALT(KC_RGHT)", + "KC_MRWD", + "KC_MPRV", + "KC_MPLY", + "KC_MNXT", + "KC_MFFD", + "LALT(KC_END)", + "KC_END", + "KC_DOWN", + "KC_PGDN", + "LALT(KC_PGDN)", + "KC_LANG2", + "KC_LANG1", + "LGUI(KC_LBRC)", + "LGUI(KC_RBRC)" + ], + [ + "KC_TRNS", + "KC_TRNS", + "RESET", + "KC_TRNS", + "ANY(A(S(KC_9)))", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "KC_LBRC", + "KC_RBRC", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_COMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_BSPC", + "KC_DEL", + "KC_P0", + "KC_PDOT" + ], + [ + "KC_PSLS", + "KC_7", + "KC_8", + "KC_9", + "KC_PPLS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_0", + "KC_1", + "KC_2", + "KC_3", + "KC_PMNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_NO", + "KC_TRNS", + "KC_PAST", + "KC_4", + "KC_5", + "KC_6", + "KC_PEQL", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_TRNS", + "KC_TRNS", + "KC_COLN", + "KC_ESC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_DEL", + "KC_TRNS", + "KC_PERC", + "KC_SLSH", + "KC_ENT", + "KC_TRNS", + "DF(1)", + "KC_LGUI", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_EXLM", + "KC_TRNS", + "DF(0)", + "KC_TRNS", + "RALT_T(KC_COMM)", + "RCTL_T(KC_DOT)", + "RESET", + "KC_TRNS", + "KC_TAB", + "KC_NO", + "KC_TRNS" + ] + ], + "author": "", + "notes": "" +} \ No newline at end of file diff --git a/ferris/ferris_hd_keymap.c b/ferris/ferris_hd_keymap.c new file mode 100644 index 0000000..5673e74 --- /dev/null +++ b/ferris/ferris_hd_keymap.c @@ -0,0 +1,18 @@ +#include QMK_KEYBOARD_H + +/* THIS FILE WAS GENERATED! + * + * This file was generated by qmk json2c. You may or may not want to + * edit it directly. + */ + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + [0] = LAYOUT(KC_J, KC_F, KC_M, KC_P, KC_V, KC_HASH, KC_DOT, KC_SLSH, KC_DQUO, KC_QUOT, LCTL_T(KC_R), LALT_T(KC_S), LGUI_T(KC_N), LSFT_T(KC_T), KC_K, KC_COMM, RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_I), RCTL_T(KC_C), KC_X, KC_G, KC_L, KC_D, KC_B, KC_MINS, KC_U, KC_O, KC_Y, KC_W, LT(5,KC_BSPC), LT(4,KC_H), LT(2,KC_SPC), LT(4,KC_ENT)), + [1] = LAYOUT(KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_SCLN, LCTL_T(KC_A), LALT_T(KC_S), LGUI_T(KC_D), LSFT_T(KC_F), KC_G, KC_H, RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_P), KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [2] = LAYOUT(KC_Q, KC_Z, A(S(KC_5)), A(S(KC_7)), A(S(KC_9)), LALT(KC_4), KC_DLR, A(S(KC_2)), LALT(KC_Y), RALT(KC_3), KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_8), RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_PSLS), KC_LBRC, KC_RBRC, KC_LCBR, KC_RCBR, RALT(KC_5), KC_UNDS, KC_CIRC, KC_AMPR, KC_PIPE, KC_TRNS, LALT(KC_BSPC), LALT(KC_DEL), KC_TRNS, KC_TRNS), + [3] = LAYOUT(KC_F11, KC_F12, KC_F13, KC_F14, KC_F15, KC_NUHS, KC_7, KC_8, KC_9, KC_0, LCTL_T(KC_F6), LALT_T(KC_F7), LGUI_T(KC_F8), LSFT_T(KC_F9), KC_F10, KC_SLSH, RSFT_T(KC_4), RGUI_T(KC_5), RALT_T(KC_6), RCTL_T(KC_MINS), KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_MINS, KC_1, KC_2, KC_3, KC_EQL, KC_PSCR, KC_SLCK, KC_PAUS, KC_INS), + [4] = LAYOUT(CG_NORM, CG_SWAP, C(A(KC_DEL)), KC_MUTE, KC_VOLD, LALT(KC_HOME), KC_HOME, KC_UP, KC_PGUP, LALT(KC_PGUP), KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, KC_VOLU, LALT(KC_LEFT), KC_LEFT, KC_DOWN, KC_RGHT, LALT(KC_RGHT), KC_MRWD, KC_MPRV, KC_MPLY, KC_MNXT, KC_MFFD, LALT(KC_END), KC_END, KC_DOWN, KC_PGDN, LALT(KC_PGDN), KC_LANG2, KC_LANG1, LGUI(KC_LBRC), LGUI(KC_RBRC)), + [5] = LAYOUT(RESET, KC_TRNS, KC_TRNS, KC_TRNS, A(S(KC_9)), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_8), KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, KC_LBRC, KC_RBRC, KC_LCBR, KC_RCBR, RALT(KC_5), KC_COMM, KC_P1, KC_P2, KC_P3, KC_PEQL, KC_BSPC, KC_DEL, KC_P0, KC_PDOT), + [6] = LAYOUT(KC_PSLS, KC_7, KC_8, KC_9, KC_PPLS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_0, KC_1, KC_2, KC_3, KC_PMNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_TRNS, KC_PAST, KC_4, KC_5, KC_6, KC_PEQL, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [7] = LAYOUT(KC_TRNS, KC_TRNS, KC_COLN, KC_ESC, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_DEL, KC_TRNS, KC_PERC, KC_SLSH, KC_ENT, KC_TRNS, DF(1), KC_LGUI, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_EXLM, KC_TRNS, DF(0), KC_TRNS, RALT_T(KC_COMM), RCTL_T(KC_DOT), RESET, KC_TRNS, KC_TAB, KC_NO, KC_TRNS) +}; diff --git a/ferris/ferris_hd_keymap.c.bak b/ferris/ferris_hd_keymap.c.bak new file mode 100644 index 0000000..11f476c --- /dev/null +++ b/ferris/ferris_hd_keymap.c.bak @@ -0,0 +1,18 @@ +#include QMK_KEYBOARD_H + +/* THIS FILE WAS GENERATED! + * + * This file was generated by qmk json2c. You may or may not want to + * edit it directly. + */ + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + [0] = LAYOUT(KC_J, KC_F, KC_M, KC_P, KC_V, KC_HASH, KC_DOT, KC_SLSH, KC_DQUO, KC_QUOT, LCTL_T(KC_R), LALT_T(KC_S), LGUI_T(KC_N), LSFT_T(KC_T), KC_K, KC_COMM, RSFT(KC_A), RGUI(KC_E), RALT(KC_I), RGUI(KC_C), KC_X, KC_G, KC_L, KC_D, KC_B, KC_MINS, KC_U, KC_O, KC_Y, KC_W, LT(5,KC_BSPC), LT(4,KC_H), LT(2,KC_SPC), LT(4,KC_ENT)), + [1] = LAYOUT(KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_BTN1, KC_WH_U, KC_BTN2, KC_TRNS, KC_TRNS, KC_BTN2, KC_NO, KC_BTN1, KC_TRNS, KC_TRNS, KC_MS_L, KC_MS_D, KC_MS_U, KC_MS_R, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_WH_L, KC_WH_D, KC_WH_R, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [2] = LAYOUT(KC_Q, KC_Z, KC_TRNS, KC_TRNS, KC_TRNS, LALT(KC_4), KC_DLR, A(S(KC_2)), LALT(KC_Y), RALT(KC_3), KC_LT, KC_GT, KC_LPRN, KC_RPRN, KC_TRNS, RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_PSLS), A(S(KC_5)), A(S(KC_7)), KC_LCBR, KC_RCBR, KC_TRNS, KC_UNDS, KC_CIRC, KC_AMPR, KC_PIPE, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [3] = LAYOUT(KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_UNDS, KC_PIPE, KC_QUOT, KC_TRNS, KC_CIRC, KC_ASTR, KC_AMPR, KC_NO, KC_TRNS, KC_HASH, KC_TILD, KC_SLSH, KC_DQUO, KC_DLR, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_MINS, KC_BSLS, KC_GRV, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [4] = LAYOUT(KC_TRNS, KC_COLN, KC_LT, KC_GT, KC_SCLN, LALT(KC_HOME), KC_HOME, KC_UP, KC_PGUP, LALT(KC_PGUP), KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, KC_AT, LALT(KC_LEFT), KC_LEFT, KC_DOWN, KC_RGHT, LALT(KC_RGHT), KC_TRNS, KC_EXLM, KC_LBRC, KC_RBRC, KC_TRNS, LALT(KC_END), KC_END, KC_DOWN, KC_PGDN, LALT(KC_PGDN), KC_VOLD, LT(4,KC_NO), KC_TRNS, KC_VOLU), + [5] = LAYOUT(KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_F7, KC_F8, KC_F9, KC_F10, KC_TRNS, KC_NO, LCTL(KC_LALT), KC_TRNS, KC_TRNS, KC_TRNS, KC_F4, KC_F5, KC_F6, KC_F11, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_F1, KC_F2, KC_F3, KC_F12, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [6] = LAYOUT(KC_PSLS, KC_7, KC_8, KC_9, KC_PPLS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_0, KC_1, KC_2, KC_3, KC_PMNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_TRNS, KC_PAST, KC_4, KC_5, KC_6, KC_PEQL, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [7] = LAYOUT(KC_TRNS, KC_TRNS, KC_COLN, KC_ESC, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_DEL, KC_TRNS, KC_PERC, KC_SLSH, KC_ENT, KC_TRNS, DF(1), KC_LGUI, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_EXLM, KC_TRNS, DF(0), KC_TRNS, RALT_T(KC_COMM), RCTL_T(KC_DOT), RESET, KC_TRNS, KC_TAB, KC_NO, KC_TRNS) +}; diff --git a/ferris/keymap.json b/ferris/keymap.json new file mode 100644 index 0000000..e45a0de --- /dev/null +++ b/ferris/keymap.json @@ -0,0 +1,299 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "ferris/0_2/compact", + "keymap": "ferris_hd_bronze", + "layout": "LAYOUT", + "layers": [ + [ + "KC_J", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "KC_HASH", + "KC_DOT", + "KC_SLSH", + "KC_DQUO", + "KC_QUOT", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_I)", + "RCTL_T(KC_C)", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "KC_MINS", + "KC_U", + "KC_O", + "KC_Y", + "KC_W", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)" + ], + [ + "KC_Q", + "KC_W", + "KC_E", + "KC_R", + "KC_T", + "KC_Y", + "KC_U", + "KC_I", + "KC_O", + "KC_SCLN", + "LCTL_T(KC_A)", + "LALT_T(KC_S)", + "LGUI_T(KC_D)", + "LSFT_T(KC_F)", + "KC_G", + "KC_H", + "RSFT_T(KC_J)", + "RGUI_T(KC_K)", + "RALT_T(KC_L)", + "RCTL_T(KC_P)", + "KC_Z", + "KC_X", + "KC_C", + "KC_V", + "KC_B", + "KC_N", + "KC_M", + "KC_COMM", + "KC_DOT", + "KC_SLSH", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_Q", + "KC_Z", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "ANY(A(S(KC_9)))", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT(KC_Y)", + "RALT(KC_3)", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "RALT(KC_1)", + "RSFT_T(KC_PAST)", + "RGUI_T(KC_PEQL)", + "RALT_T(KC_PPLS)", + "RCTL_T(KC_PSLS)", + "KC_LBRC", + "KC_RBRC", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_UNDS", + "KC_CIRC", + "KC_AMPR", + "KC_PIPE", + "KC_TRNS", + "LALT(KC_BSPC)", + "LALT(KC_DEL)", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_F11", + "KC_F12", + "KC_F13", + "KC_F14", + "KC_F15", + "KC_NUHS", + "KC_7", + "KC_8", + "KC_9", + "KC_0", + "LCTL_T(KC_F6)", + "LALT_T(KC_F7)", + "LGUI_T(KC_F8)", + "LSFT_T(KC_F9)", + "KC_F10", + "KC_SLSH", + "RSFT_T(KC_4)", + "RGUI_T(KC_5)", + "RALT_T(KC_6)", + "RCTL_T(KC_MINS)", + "KC_F1", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_MINS", + "KC_1", + "KC_2", + "KC_3", + "KC_EQL", + "KC_PSCR", + "KC_SLCK", + "KC_PAUS", + "KC_INS" + ], + [ + "ANY(C(A(KC_DEL)))", + "CG_SWAP", + "CG_NORM", + "KC_MUTE", + "KC_VOLU", + "LALT(KC_HOME)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "LALT(KC_PGUP)", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "KC_VOLD", + "LALT(KC_LEFT)", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "LALT(KC_RGHT)", + "KC_MRWD", + "KC_MPRV", + "KC_MPLY", + "KC_MNXT", + "KC_MFFD", + "LALT(KC_END)", + "KC_END", + "KC_DOWN", + "KC_PGDN", + "LALT(KC_PGDN)", + "KC_LANG2", + "KC_LANG1", + "LGUI(KC_LBRC)", + "LGUI(KC_RBRC)" + ], + [ + "KC_TRNS", + "KC_TRNS", + "RESET", + "KC_TRNS", + "ANY(A(S(KC_9)))", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "KC_LBRC", + "KC_RBRC", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_COMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_BSPC", + "KC_DEL", + "KC_P0", + "KC_PDOT" + ], + [ + "KC_PSLS", + "KC_7", + "KC_8", + "KC_9", + "KC_PPLS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_0", + "KC_1", + "KC_2", + "KC_3", + "KC_PMNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_NO", + "KC_TRNS", + "KC_PAST", + "KC_4", + "KC_5", + "KC_6", + "KC_PEQL", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_TRNS", + "KC_TRNS", + "KC_COLN", + "KC_ESC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_DEL", + "KC_TRNS", + "KC_PERC", + "KC_SLSH", + "KC_ENT", + "KC_TRNS", + "DF(1)", + "KC_LGUI", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_EXLM", + "KC_TRNS", + "DF(0)", + "KC_TRNS", + "RALT_T(KC_COMM)", + "RCTL_T(KC_DOT)", + "RESET", + "KC_TRNS", + "KC_TAB", + "KC_NO", + "KC_TRNS" + ] + ], + "author": "", + "notes": "" +} \ No newline at end of file diff --git a/kyria/kyria_hd_bronze.json b/kyria/kyria_hd_bronze.json index 3b85566..cd485fb 100644 --- a/kyria/kyria_hd_bronze.json +++ b/kyria/kyria_hd_bronze.json @@ -1,12 +1,13 @@ { "version": 1, - "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "notes": "Hands Down Kyria\n\n0—Hands Down (mods on home row, Layers on thumbs)\n1—QWERTY\n2—SYMBOL\n3—FN\n4—MEDIA/NAV\n5—NUM\n6—DIACRIT", + "documentation": "\"This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\"\n", "keyboard": "splitkb/kyria/rev1", "keymap": "kyria_hd_bronze", "layout": "LAYOUT", "layers": [ [ - "KC_UNDO", + "ANY(G(KC_C))", "KC_J", "KC_F", "KC_M", @@ -17,8 +18,8 @@ "KC_SLSH", "KC_DQUO", "KC_QUOT", - "KC_MENU", - "KC_CUT", + "KC_LANG1", + "ANY(G(KC_V))", "LCTL_T(KC_R)", "LALT_T(KC_S)", "LGUI_T(KC_N)", @@ -29,8 +30,8 @@ "RGUI_T(KC_E)", "RALT_T(KC_I)", "RCTL_T(KC_C)", - "KC_FIND", - "KC_COPY", + "KC_LANG2", + "ANY(S(G(KC_4)))", "KC_X", "KC_G", "KC_L", @@ -45,13 +46,13 @@ "KC_O", "KC_Y", "KC_W", - "KC_PSTE", + "KC_EQL", "LT(6,KC_MUTE)", "KC_APP", "LT(5,KC_BSPC)", "LT(4,KC_H)", - "LT(3,KC_LANG2)", - "LT(3,KC_LANG1)", + "LT(3,KC_TAB)", + "LT(3,KC_BSPC)", "LT(2,KC_SPC)", "LT(4,KC_ENT)", "LT(5,KC_TAB)", @@ -110,51 +111,51 @@ "KC_TRNS" ], [ - "KC_NO", + "ANY(G(KC_C))", "LALT(KC_RBRC)", "ANY(A(S(KC_RBRC)))", "LALT(KC_LBRC)", "ANY(A(S(KC_LBRC)))", - "ANY(A(S(KC_9)))", + "LALT(KC_8)", "LALT(KC_4)", "KC_DLR", "ANY(A(S(KC_2)))", "LALT(KC_Y)", "RALT(KC_3)", "KC_NO", - "KC_NO", + "ANY(C(S(G(KC_4))))", "KC_LT", "KC_GT", "KC_LPRN", "KC_RPRN", - "LALT(KC_8)", + "LALT(KC_7)", "RALT(KC_1)", "LSFT_T(KC_PAST)", "LGUI_T(KC_PEQL)", "LALT_T(KC_PPLS)", "LCTL_T(KC_BSLS)", "KC_NO", - "KC_NO", + "ANY(S(G(KC_3)))", "ANY(A(S(KC_5)))", "ANY(A(S(KC_7)))", "KC_LCBR", "KC_RCBR", "RALT(KC_5)", - "KC_HAEN", + "KC_LANG2", "KC_TRNS", "KC_TRNS", "KC_HANJ", "KC_UNDS", - "KC_CIRC", - "KC_AMPR", "KC_PIPE", + "KC_AMPR", + "KC_CIRC", "KC_PERC", "KC_NO", "KC_VOLD", "KC_VOLU", "LALT(KC_BSPC)", "LALT(KC_DEL)", - "KC_TRNS", + "KC_LANG2", "ANY(A(S(KC_9)))", "KC_TRNS", "LALT(KC_9)", @@ -162,7 +163,7 @@ "TG(5)" ], [ - "RESET", + "KC_TRNS", "KC_F7", "KC_F3", "KC_F1", @@ -173,8 +174,8 @@ "KC_F10", "KC_F4", "KC_F6", - "DEBUG", - "KC_NO", + "KC_TRNS", + "KC_TRNS", "LCTL_T(KC_9)", "LALT_T(KC_3)", "LGUI_T(KC_1)", @@ -185,8 +186,8 @@ "RGUI_T(KC_0)", "RALT_T(KC_4)", "RCTL_T(KC_8)", - "KC_NO", - "KC_NO", + "KC_TRNS", + "KC_TRNS", "DF(1)", "TO(1)", "TO(0)", @@ -195,14 +196,14 @@ "RESET", "KC_TRNS", "KC_TRNS", - "KC_TRNS", + "RESET", "KC_F12", "DF(0)", "TO(0)", "TO(1)", "DF(1)", - "KC_NO", "KC_TRNS", + "RESET", "ANY(C(A(KC_DEL)))", "AG_NORM", "AG_SWAP", @@ -214,51 +215,51 @@ "RESET" ], [ - "KC_NO", - "KC_NO", - "KC_NO", - "KC_NO", - "KC_NO", - "KC_NO", + "KC_TRNS", + "RGUI(KC_Q)", + "RGUI(KC_W)", + "ANY(S(G(KC_4)))", + "ANY(C(S(G(KC_4))))", + "RGUI(KC_G)", "LALT(KC_HOME)", "KC_HOME", "KC_UP", "KC_PGUP", "LALT(KC_PGUP)", - "KC_NO", - "KC_NO", + "KC_TRNS", + "KC_TRNS", "KC_LCTL", "KC_LALT", "KC_LGUI", "KC_LSFT", - "KC_NO", + "RGUI(KC_F)", "LALT(KC_LEFT)", "KC_LEFT", "KC_DOWN", "KC_RGHT", "LALT(KC_RGHT)", - "KC_NO", - "KC_NO", - "KC_NO", - "KC_NO", - "KC_NO", - "KC_NO", - "KC_NO", - "KC_HAEN", - "KC_NO", - "KC_NO", + "KC_TRNS", + "KC_TRNS", + "RGUI(KC_Z)", + "RGUI(KC_X)", + "RGUI(KC_C)", + "RGUI(KC_V)", + "ANY(G(S(A(KC_V))))", + "KC_LANG2", + "KC_TRNS", + "KC_TRNS", "KC_HANJ", "LALT(KC_END)", "KC_END", "KC_DOWN", "KC_PGDN", "LALT(KC_PGDN)", - "KC_NO", + "KC_TRNS", "KC_BRID", "KC_BRIU", - "KC_NO", - "KC_NO", - "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", "LGUI(KC_LBRC)", "LGUI(KC_RBRC)", "ANY(G(S(KC_EQL)))", @@ -271,7 +272,7 @@ "ANY(A(S(KC_RBRC)))", "LALT(KC_LBRC)", "ANY(A(S(KC_LBRC)))", - "ANY(A(S(KC_5)))", + "ANY(A(S(KC_8)))", "KC_PSLS", "KC_P7", "KC_P8", @@ -279,8 +280,8 @@ "KC_PMNS", "KC_NO", "KC_NO", - "ANY(A(S(KC_EQL)))", - "LALT(KC_EQL)", + "KC_LT", + "KC_GT", "KC_LPRN", "KC_RPRN", "LALT(KC_7)", @@ -291,10 +292,10 @@ "KC_PPLS", "KC_NO", "KC_NO", - "RALT(KC_1)", - "KC_NO", - "KC_LT", - "KC_GT", + "LCTL_T(KC_LBRC)", + "LALT_T(KC_RBRC)", + "KC_LCBR", + "KC_RCBR", "RALT(KC_5)", "LALT(KC_MINS)", "KC_TRNS", @@ -474,6 +475,5 @@ "RESET" ] ], - "author": "Hands Down Kyria", - "notes": "Hands Down Kyria\n\n0—Hands Down (mods on home row, Layers on thumbs)\n1—QWERTY\n2—SYMBOL\n3—FN\n4—MEDIA/NAV\n5—NUM\n6—DIACRIT" + "author": "Hands Down Kyria" } \ No newline at end of file diff --git a/kyria/kyria_hd_bronze_2.json b/kyria/kyria_hd_bronze_2.json new file mode 100644 index 0000000..72c2954 --- /dev/null +++ b/kyria/kyria_hd_bronze_2.json @@ -0,0 +1,479 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "splitkb/kyria/rev1", + "keymap": "kyria_hd_bronze_2", + "layout": "LAYOUT", + "layers": [ + [ + "LGUI(KC_C)", + "KC_MINS", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "KC_EQL", + "KC_DOT", + "KC_SLSH", + "KC_QUOT", + "KC_DQUO", + "KC_HAEN", + "LGUI(KC_V)", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_C)", + "RCTL_T(KC_I)", + "KC_HANJ", + "ANY(S(G(KC_4)))", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "KC_APP", + "ANY(SH_TT)", + "ANY(SH_TT)", + "LT(5,KC_TAB)", + "KC_HASH", + "KC_U", + "KC_O", + "KC_W", + "KC_Y", + "KC_J", + "LT(6,KC_MUTE)", + "LT(3,KC_LANG2)", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(3,KC_LANG2)", + "LT(3,KC_LANG1)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "LT(3,KC_LANG1)", + "LT(8,KC_MPLY)" + ], + [ + "KC_NO", + "KC_Q", + "KC_W", + "KC_E", + "KC_R", + "KC_T", + "KC_Y", + "KC_U", + "KC_I", + "KC_O", + "KC_P", + "KC_NO", + "KC_NO", + "LCTL_T(KC_A)", + "LALT_T(KC_S)", + "LGUI_T(KC_D)", + "LSFT_T(KC_F)", + "KC_G", + "KC_H", + "RSFT_T(KC_J)", + "RGUI_T(KC_K)", + "RALT_T(KC_L)", + "RCTL_T(KC_SCLN)", + "KC_NO", + "KC_NO", + "KC_Z", + "KC_X", + "KC_C", + "KC_V", + "KC_B", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_N", + "KC_M", + "KC_COMM", + "KC_DOT", + "KC_SLSH", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_BSPC", + "KC_SPC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "LGUI(KC_C)", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "LALT(KC_8)", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT(KC_Y)", + "RALT(KC_3)", + "KC_NO", + "ANY(C(S(G(KC_4))))", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "LGUI_T(KC_PEQL)", + "LALT_T(KC_PPLS)", + "LCTL_T(KC_BSLS)", + "KC_NO", + "ANY(S(G(KC_3)))", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_HANJ", + "KC_TRNS", + "KC_TRNS", + "KC_HANJ", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_NO", + "KC_VOLD", + "KC_VOLU", + "LALT(KC_BSPC)", + "LALT(KC_DEL)", + "KC_HANJ", + "ANY(A(S(KC_9)))", + "KC_TRNS", + "LALT(KC_9)", + "ANY(A(S(KC_8)))", + "TG(5)" + ], + [ + "KC_TRNS", + "KC_F7", + "KC_F3", + "KC_F1", + "KC_F5", + "KC_F9", + "KC_F8", + "KC_F2", + "KC_F10", + "KC_F4", + "KC_F6", + "KC_TRNS", + "KC_TRNS", + "LCTL_T(KC_9)", + "LALT_T(KC_3)", + "LGUI_T(KC_1)", + "LSFT_T(KC_5)", + "KC_7", + "KC_6", + "RSFT_T(KC_2)", + "RGUI_T(KC_0)", + "RALT_T(KC_4)", + "RCTL_T(KC_8)", + "KC_TRNS", + "KC_TRNS", + "DF(1)", + "TO(1)", + "TO(0)", + "DF(0)", + "KC_F11", + "RESET", + "KC_TRNS", + "KC_TRNS", + "RESET", + "KC_F12", + "DF(0)", + "TO(0)", + "TO(1)", + "DF(1)", + "KC_TRNS", + "RESET", + "LCA(KC_DEL)", + "AG_SWAP", + "AG_NORM", + "KC_TRNS", + "KC_TRNS", + "CG_NORM", + "CG_SWAP", + "LCA(KC_DEL)", + "RESET" + ], + [ + "KC_TRNS", + "RGUI(KC_Q)", + "RGUI(KC_W)", + "ANY(S(G(KC_4)))", + "ANY(C(S(G(KC_4))))", + "RGUI(KC_G)", + "LALT(KC_HOME)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "LALT(KC_PGUP)", + "KC_TRNS", + "KC_TRNS", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "RGUI(KC_F)", + "LALT(KC_LEFT)", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "LALT(KC_RGHT)", + "KC_TRNS", + "KC_TRNS", + "RGUI(KC_Z)", + "RGUI(KC_X)", + "RGUI(KC_C)", + "RGUI(KC_V)", + "ANY(G(S(A(KC_V))))", + "KC_HANJ", + "KC_TRNS", + "KC_TRNS", + "KC_HANJ", + "LALT(KC_END)", + "KC_END", + "KC_DOWN", + "KC_PGDN", + "LALT(KC_PGDN)", + "KC_TRNS", + "KC_BRID", + "KC_BRIU", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LGUI(KC_LBRC)", + "LGUI(KC_RBRC)", + "ANY(G(S(KC_EQL)))", + "LGUI(KC_MINS)", + "LGUI(KC_0)" + ], + [ + "KC_NO", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_8)))", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_NO", + "KC_NO", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "KC_NO", + "KC_NO", + "LCTL_T(KC_LBRC)", + "LALT_T(KC_RBRC)", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "LALT(KC_MINS)", + "KC_TRNS", + "LALT(KC_SLSH)", + "LALT(KC_EQL)", + "KC_COMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_NO", + "TG(5)", + "KC_TRNS", + "KC_BSPC", + "KC_DEL", + "KC_TRNS", + "ANY(A(S(KC_EQL)))", + "KC_P0", + "KC_PDOT", + "KC_C", + "KC_TRNS" + ], + [ + "KC_NO", + "RALT(KC_W)", + "RALT(KC_E)", + "RALT(KC_6)", + "RALT(KC_GRV)", + "LALT(KC_J)", + "RALT(KC_Q)", + "LALT(KC_U)", + "LALT(KC_K)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_A)", + "LALT(KC_N)", + "LALT(KC_I)", + "LALT(KC_L)", + "KC_NO", + "KC_NO", + "RALT(KC_X)", + "RALT(KC_C)", + "RALT(KC_L)", + "RALT(KC_D)", + "RALT(KC_B)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_Z)", + "RALT(KC_C)", + "LALT(KC_H)", + "LALT(KC_P)", + "KC_NO", + "KC_NO", + "RESET", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET" + ], + [ + "KC_NO", + "RALT(KC_1)", + "RALT(KC_R)", + "RALT(KC_G)", + "RALT(KC_2)", + "ANY(A(S(KC_SCLN)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_BSLS)", + "ANY(A(S(KC_3)))", + "ANY(A(S(KC_4)))", + "ANY(A(S(KC_BSLS)))", + "ANY(A(S(KC_5)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_9)", + "LALT(KC_QUOT)", + "RALT(KC_Q)", + "RALT(KC_F)", + "ANY(A(S(KC_7)))", + "KC_CAPS", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "LALT(KC_BSPC)", + "KC_DEL", + "LALT(KC_DEL)", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "KC_NO", + "KC_PSCR", + "KC_SLCK", + "LCA(KC_DEL)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LCTL_T(KC_BRIU)", + "LALT_T(KC_MRWD)", + "LGUI_T(KC_MSTP)", + "LSFT_T(KC_MFFD)", + "LT(5,KC_VOLU)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRID", + "KC_MPRV", + "KC_MUTE", + "KC_MNXT", + "KC_VOLD", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET", + "KC_EJCT", + "KC_PAUS", + "KC_MPLY", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET" + ] + ], + "author": "Hands Down Kyria", + "notes": "Hands Down Kyria\n\n0—Hands Down (mods on home row, Layers on thumbs)\n1—QWERTY\n2—SYMBOL\n3—FN\n4—MEDIA/NAV\n5—NUM\n6—DIACRIT" +} \ No newline at end of file diff --git a/kyria/kyria_hd_bronze_SK.json b/kyria/kyria_hd_bronze_SK.json new file mode 100644 index 0000000..71efafa --- /dev/null +++ b/kyria/kyria_hd_bronze_SK.json @@ -0,0 +1,479 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "splitkb/kyria/rev1", + "keymap": "kyria_hd_bronze_sk", + "layout": "LAYOUT", + "layers": [ + [ + "ANY(SK_COPY)", + "KC_J", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "KC_HASH", + "KC_DOT", + "KC_SLSH", + "KC_QUOT", + "KC_DQUO", + "KC_LANG1", + "ANY(SK_PSTE)", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_C)", + "RCTL_T(KC_I)", + "KC_LANG2", + "ANY(S(G(KC_4)))", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "LT(3,KC_LANG2)", + "ANY(SH_TT)", + "ANY(SH_TT)", + "LT(3,KC_LANG1)", + "KC_MINS", + "KC_U", + "KC_O", + "KC_W", + "KC_Y", + "KC_EQL", + "LT(6,KC_MUTE)", + "KC_APP", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(3,KC_LANG2)", + "LT(3,KC_LANG1)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "LT(5,KC_TAB)", + "LT(8,KC_MPLY)" + ], + [ + "KC_TRNS", + "KC_Q", + "KC_W", + "KC_E", + "KC_R", + "KC_T", + "KC_Y", + "KC_U", + "KC_I", + "KC_O", + "KC_P", + "KC_TRNS", + "KC_TRNS", + "LCTL_T(KC_A)", + "LALT_T(KC_S)", + "LGUI_T(KC_D)", + "LSFT_T(KC_F)", + "KC_G", + "KC_H", + "RSFT_T(KC_J)", + "RGUI_T(KC_K)", + "RALT_T(KC_L)", + "RCTL_T(KC_SCLN)", + "KC_TRNS", + "KC_TRNS", + "KC_Z", + "KC_X", + "KC_C", + "KC_V", + "KC_B", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_N", + "KC_M", + "KC_COMM", + "KC_DOT", + "KC_SLSH", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_TRNS", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "LALT(KC_8)", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT(KC_Y)", + "RALT(KC_3)", + "KC_TRNS", + "KC_TRNS", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "LGUI_T(KC_PEQL)", + "LALT_T(KC_PPLS)", + "LCTL_T(KC_BSLS)", + "KC_TRNS", + "KC_TRNS", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_TRNS", + "KC_VOLD", + "KC_VOLU", + "ANY(SK_DELWDL)", + "ANY(SK_DELWDR)", + "KC_TRNS", + "ANY(A(S(KC_9)))", + "KC_TRNS", + "LALT(KC_9)", + "ANY(A(S(KC_8)))", + "TG(5)" + ], + [ + "KC_TRNS", + "KC_F7", + "KC_F3", + "KC_F1", + "KC_F5", + "KC_F9", + "KC_F8", + "KC_F2", + "KC_F10", + "KC_F4", + "KC_F6", + "KC_TRNS", + "KC_TRNS", + "LCTL_T(KC_9)", + "LALT_T(KC_3)", + "LGUI_T(KC_1)", + "LSFT_T(KC_5)", + "KC_7", + "KC_6", + "RSFT_T(KC_2)", + "RGUI_T(KC_0)", + "RALT_T(KC_4)", + "RCTL_T(KC_8)", + "KC_TRNS", + "KC_TRNS", + "DF(1)", + "TO(1)", + "TO(0)", + "DF(0)", + "KC_F11", + "RESET", + "KC_TRNS", + "KC_TRNS", + "RESET", + "KC_F12", + "DF(0)", + "TO(0)", + "TO(1)", + "DF(1)", + "KC_TRNS", + "RESET", + "LCA(KC_DEL)", + "AG_SWAP", + "AG_NORM", + "KC_TRNS", + "KC_TRNS", + "CG_NORM", + "CG_SWAP", + "LCA(KC_DEL)", + "RESET" + ], + [ + "KC_TRNS", + "ANY(SK_QUIT)", + "ANY(SK_CLOZ)", + "ANY(SK_SCAP)", + "ANY(SK_SCLP)", + "ANY(SK_FAGN)", + "ANY(SK_DOCBEG)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "ANY(SK_PARAPRV)", + "KC_TRNS", + "KC_TRNS", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "ANY(SK_FIND)", + "ANY(SK_WORDPRV)", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "ANY(SK_WORDNXT)", + "KC_TRNS", + "KC_TRNS", + "ANY(SK_UNDO)", + "ANY(SK_CUT)", + "ANY(SK_COPY)", + "ANY(SK_PSTE)", + "ANY(SK_PSTM)", + "KC_HANJ", + "KC_TRNS", + "KC_TRNS", + "KC_HANJ", + "ANY(SK_DOCEND)", + "KC_END", + "KC_DOWN", + "KC_PGDN", + "ANY(SK_PARANXT)", + "KC_TRNS", + "KC_BRID", + "KC_BRIU", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "ANY(SK_ZOOMOUT)", + "ANY(SK_HISTPRV)", + "ANY(SK_HISTNXT)", + "ANY(SK_ZOOMIN)", + "ANY(SK_ZOOMRST)" + ], + [ + "KC_NO", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_8)))", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_NO", + "KC_NO", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "KC_NO", + "KC_NO", + "LCTL_T(KC_LBRC)", + "LALT_T(KC_RBRC)", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "LALT(KC_MINS)", + "KC_TRNS", + "LALT(KC_SLSH)", + "LALT(KC_EQL)", + "KC_COMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_NO", + "TG(5)", + "KC_TRNS", + "KC_BSPC", + "KC_DEL", + "KC_TRNS", + "ANY(A(S(KC_EQL)))", + "KC_P0", + "KC_PDOT", + "KC_C", + "KC_TRNS" + ], + [ + "KC_NO", + "RALT(KC_W)", + "RALT(KC_E)", + "RALT(KC_6)", + "RALT(KC_GRV)", + "LALT(KC_J)", + "RALT(KC_Q)", + "LALT(KC_U)", + "LALT(KC_K)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_A)", + "LALT(KC_N)", + "LALT(KC_I)", + "LALT(KC_L)", + "KC_NO", + "KC_NO", + "RALT(KC_X)", + "RALT(KC_C)", + "RALT(KC_L)", + "RALT(KC_D)", + "RALT(KC_B)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_Z)", + "RALT(KC_C)", + "LALT(KC_H)", + "LALT(KC_P)", + "KC_NO", + "KC_NO", + "RESET", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET" + ], + [ + "KC_NO", + "RALT(KC_1)", + "RALT(KC_R)", + "RALT(KC_G)", + "RALT(KC_2)", + "ANY(A(S(KC_SCLN)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_BSLS)", + "ANY(A(S(KC_3)))", + "ANY(A(S(KC_4)))", + "ANY(A(S(KC_BSLS)))", + "ANY(A(S(KC_5)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_9)", + "LALT(KC_QUOT)", + "RALT(KC_Q)", + "RALT(KC_F)", + "ANY(A(S(KC_7)))", + "KC_CAPS", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "LALT(KC_BSPC)", + "KC_DEL", + "LALT(KC_DEL)", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "KC_NO", + "KC_PSCR", + "KC_SLCK", + "LCA(KC_DEL)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LCTL_T(KC_BRIU)", + "LALT_T(KC_MRWD)", + "LGUI_T(KC_MSTP)", + "LSFT_T(KC_MFFD)", + "LT(5,KC_VOLU)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRID", + "KC_MPRV", + "KC_MUTE", + "KC_MNXT", + "KC_VOLD", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET", + "KC_EJCT", + "KC_PAUS", + "KC_MPLY", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET" + ] + ], + "author": "Hands Down Kyria", + "notes": "Hands Down Kyria\n\n0—Hands Down (mods on home row, Layers on thumbs)\n1—QWERTY\n2—SYMBOL\n3—FN\n4—MEDIA/NAV\n5—NUM\n6—DIACRIT" +} \ No newline at end of file diff --git a/kyria/kyria_hd_bronzesilver_sk.json b/kyria/kyria_hd_bronzesilver_sk.json new file mode 100644 index 0000000..92fb4e8 --- /dev/null +++ b/kyria/kyria_hd_bronzesilver_sk.json @@ -0,0 +1,479 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "splitkb/kyria/rev1", + "keymap": "kyria_hd_bronzesilver_sk", + "layout": "LAYOUT", + "layers": [ + [ + "ANY(SK_COPY)", + "KC_J", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "KC_HASH", + "KC_DOT", + "KC_SLSH", + "KC_QUOT", + "KC_DQUO", + "KC_KANA", + "ANY(SK_PSTE)", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_C)", + "RCTL_T(KC_I)", + "KC_HANJ", + "ANY(S(G(KC_4)))", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "LT(3,KC_LANG2)", + "ANY(SH_TT)", + "TG(5)", + "LT(3,KC_LANG1)", + "KC_MINS", + "KC_U", + "KC_O", + "KC_W", + "KC_Y", + "KC_EQL", + "LT(6,KC_MUTE)", + "KC_APP", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(3,KC_LANG2)", + "LT(3,KC_BSPC)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "LT(5,KC_TAB)", + "LT(8,KC_MPLY)" + ], + [ + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_U", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LGUI_T(KC_H)", + "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_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LT(4,KC_N)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_TRNS", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "LALT(KC_8)", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT(KC_Y)", + "RALT(KC_3)", + "KC_TRNS", + "KC_TRNS", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "LGUI_T(KC_PEQL)", + "LALT_T(KC_PPLS)", + "LCTL_T(KC_BSLS)", + "KC_TRNS", + "KC_TRNS", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_TRNS", + "KC_VOLD", + "KC_VOLU", + "ANY(SK_DELWDL)", + "ANY(SK_DELWDR)", + "KC_TRNS", + "ANY(A(S(KC_9)))", + "KC_TRNS", + "LALT(KC_9)", + "ANY(A(S(KC_8)))", + "TG(5)" + ], + [ + "KC_TRNS", + "KC_F9", + "KC_F3", + "KC_F1", + "KC_F5", + "KC_F7", + "KC_F6", + "KC_F2", + "KC_F10", + "KC_F4", + "KC_F8", + "KC_TRNS", + "KC_TRNS", + "LCTL_T(KC_9)", + "LALT_T(KC_3)", + "LGUI_T(KC_1)", + "LSFT_T(KC_5)", + "KC_7", + "KC_6", + "RSFT_T(KC_2)", + "RGUI_T(KC_0)", + "RALT_T(KC_4)", + "RCTL_T(KC_8)", + "KC_TRNS", + "KC_TRNS", + "DF(1)", + "TO(1)", + "AG_SWAP", + "CG_SWAP", + "KC_F11", + "RESET", + "KC_TRNS", + "KC_TRNS", + "RESET", + "KC_F12", + "CG_NORM", + "AG_NORM", + "TO(0)", + "DF(0)", + "KC_TRNS", + "RESET", + "LCA(KC_DEL)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LCA(KC_DEL)", + "RESET" + ], + [ + "KC_TRNS", + "ANY(SK_QUIT)", + "ANY(SK_CLOZ)", + "ANY(SK_SCAP)", + "ANY(SK_SCLP)", + "ANY(SK_FAGN)", + "ANY(SK_DOCBEG)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "ANY(SK_PARAPRV)", + "KC_TRNS", + "KC_TRNS", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "ANY(SK_FIND)", + "ANY(SK_WORDPRV)", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "ANY(SK_WORDNXT)", + "KC_TRNS", + "KC_TRNS", + "ANY(SK_UNDO)", + "ANY(SK_CUT)", + "ANY(SK_COPY)", + "ANY(SK_PSTE)", + "ANY(SK_PSTM)", + "KC_HANJ", + "KC_TRNS", + "KC_TRNS", + "KC_HANJ", + "ANY(SK_DOCEND)", + "KC_END", + "KC_DOWN", + "KC_PGDN", + "ANY(SK_PARANXT)", + "KC_TRNS", + "KC_BRID", + "KC_BRIU", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "ANY(SK_ZOOMOUT)", + "ANY(SK_HISTPRV)", + "ANY(SK_HISTNXT)", + "ANY(SK_ZOOMIN)", + "ANY(SK_ZOOMRST)" + ], + [ + "KC_NO", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_8)))", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_NO", + "KC_NO", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "KC_NO", + "KC_NO", + "LCTL_T(KC_LBRC)", + "LALT_T(KC_RBRC)", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "LALT(KC_MINS)", + "TG(0)", + "KC_TRNS", + "LALT(KC_EQL)", + "KC_COMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_NO", + "KC_TRNS", + "KC_APP", + "KC_BSPC", + "LT(4,KC_DEL)", + "KC_PENT", + "KC_BSPC", + "KC_P0", + "KC_PDOT", + "KC_C", + "KC_TRNS" + ], + [ + "KC_NO", + "RALT(KC_W)", + "RALT(KC_E)", + "RALT(KC_6)", + "RALT(KC_GRV)", + "LALT(KC_J)", + "RALT(KC_Q)", + "LALT(KC_U)", + "LALT(KC_K)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_A)", + "LALT(KC_N)", + "LALT(KC_I)", + "LALT(KC_L)", + "KC_NO", + "KC_NO", + "RALT(KC_X)", + "RALT(KC_C)", + "RALT(KC_L)", + "RALT(KC_D)", + "RALT(KC_B)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_Z)", + "RALT(KC_C)", + "LALT(KC_H)", + "LALT(KC_P)", + "KC_NO", + "KC_NO", + "RESET", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET" + ], + [ + "KC_NO", + "RALT(KC_1)", + "RALT(KC_R)", + "RALT(KC_G)", + "RALT(KC_2)", + "ANY(A(S(KC_SCLN)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_BSLS)", + "ANY(A(S(KC_3)))", + "ANY(A(S(KC_4)))", + "ANY(A(S(KC_BSLS)))", + "ANY(A(S(KC_5)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_9)", + "LALT(KC_QUOT)", + "RALT(KC_Q)", + "RALT(KC_F)", + "ANY(A(S(KC_7)))", + "KC_CAPS", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "LALT(KC_BSPC)", + "KC_DEL", + "LALT(KC_DEL)", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "KC_NO", + "KC_PSCR", + "KC_SLCK", + "LCA(KC_DEL)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LCTL_T(KC_BRIU)", + "LALT_T(KC_MRWD)", + "LGUI_T(KC_MSTP)", + "LSFT_T(KC_MFFD)", + "LT(5,KC_VOLU)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRID", + "KC_MPRV", + "KC_MUTE", + "KC_MNXT", + "KC_VOLD", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET", + "KC_EJCT", + "KC_PAUS", + "KC_MPLY", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET" + ] + ], + "author": "Hands Down Kyria", + "notes": "Hands Down Kyria\n\n0—Hands Down (mods on home row, Layers on thumbs)\n1—QWERTY\n2—SYMBOL\n3—FN\n4—MEDIA/NAV\n5—NUM\n6—DIACRIT" +} \ No newline at end of file diff --git a/kyria/kyria_hd_keymap.c b/kyria/kyria_hd_keymap.c index 4395c32..1c4f14c 100644 --- a/kyria/kyria_hd_keymap.c +++ b/kyria/kyria_hd_keymap.c @@ -7,13 +7,13 @@ */ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { - [0] = LAYOUT(KC_UNDO, KC_J, KC_F, KC_M, KC_P, KC_V, KC_HASH, KC_DOT, KC_SLSH, KC_DQUO, KC_QUOT, KC_MENU, KC_CUT, LCTL_T(KC_R), LALT_T(KC_S), LGUI_T(KC_N), LSFT_T(KC_T), KC_K, KC_COMM, RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_I), RCTL_T(KC_C), KC_FIND, KC_COPY, KC_X, KC_G, KC_L, KC_D, KC_B, LT(3,KC_LANG2), SH_TT, SH_TT, LT(3,KC_LANG1), KC_MINS, KC_U, KC_O, KC_Y, KC_W, KC_PSTE, LT(6,KC_MUTE), KC_APP, LT(5,KC_BSPC), LT(4,KC_H), LT(3,KC_LANG2), LT(3,KC_LANG1), LT(2,KC_SPC), LT(4,KC_ENT), LT(5,KC_TAB), LT(8,KC_MPLY)), - [1] = LAYOUT(KC_NO, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_NO, KC_NO, LCTL_T(KC_A), LALT_T(KC_S), LGUI_T(KC_D), LSFT_T(KC_F), KC_G, KC_H, RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), KC_NO, KC_NO, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_NO, KC_TRNS, KC_TRNS, KC_BSPC, KC_SPC, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), - [2] = LAYOUT(KC_NO, LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_9)), LALT(KC_4), KC_DLR, A(S(KC_2)), LALT(KC_Y), RALT(KC_3), KC_NO, KC_NO, KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_8), RALT(KC_1), LSFT_T(KC_PAST), LGUI_T(KC_PEQL), LALT_T(KC_PPLS), LCTL_T(KC_BSLS), KC_NO, KC_NO, A(S(KC_5)), A(S(KC_7)), KC_LCBR, KC_RCBR, RALT(KC_5), KC_HAEN, KC_TRNS, KC_TRNS, KC_HANJ, KC_UNDS, KC_CIRC, KC_AMPR, KC_PIPE, KC_PERC, KC_NO, KC_VOLD, KC_VOLU, LALT(KC_BSPC), LALT(KC_DEL), KC_TRNS, A(S(KC_9)), KC_TRNS, LALT(KC_9), A(S(KC_8)), TG(5)), - [3] = LAYOUT(RESET, KC_F7, KC_F3, KC_F1, KC_F5, KC_F9, KC_F8, KC_F2, KC_F10, KC_F4, KC_F6, DEBUG, KC_NO, LCTL_T(KC_9), LALT_T(KC_3), LGUI_T(KC_1), LSFT_T(KC_5), KC_7, KC_6, RSFT_T(KC_2), RGUI_T(KC_0), RALT_T(KC_4), RCTL_T(KC_8), KC_NO, KC_NO, DF(1), TO(1), TO(0), DF(0), KC_F11, RESET, KC_TRNS, KC_TRNS, KC_TRNS, KC_F12, DF(0), TO(0), TO(1), DF(1), KC_NO, KC_TRNS, C(A(KC_DEL)), AG_NORM, AG_SWAP, KC_TRNS, KC_TRNS, CG_SWAP, CG_NORM, C(A(KC_DEL)), RESET), - [4] = LAYOUT(KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_HOME), KC_HOME, KC_UP, KC_PGUP, LALT(KC_PGUP), KC_NO, KC_NO, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, KC_NO, LALT(KC_LEFT), KC_LEFT, KC_DOWN, KC_RGHT, LALT(KC_RGHT), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_HAEN, KC_NO, KC_NO, KC_HANJ, LALT(KC_END), KC_END, KC_DOWN, KC_PGDN, LALT(KC_PGDN), KC_NO, KC_BRID, KC_BRIU, KC_NO, KC_NO, KC_NO, LGUI(KC_LBRC), LGUI(KC_RBRC), G(S(KC_EQL)), LGUI(KC_MINS), LGUI(KC_0)), - [5] = LAYOUT(KC_NO, LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_5)), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, KC_NO, KC_NO, A(S(KC_EQL)), LALT(KC_EQL), KC_LPRN, KC_RPRN, LALT(KC_7), KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, KC_NO, KC_NO, RALT(KC_1), KC_NO, KC_LT, KC_GT, RALT(KC_5), LALT(KC_MINS), KC_TRNS, LALT(KC_SLSH), LALT(KC_EQL), KC_COMM, KC_P1, KC_P2, KC_P3, KC_PEQL, KC_NO, TG(5), KC_TRNS, KC_BSPC, KC_DEL, KC_TRNS, A(S(KC_EQL)), KC_P0, KC_PDOT, KC_C, KC_TRNS), + [0] = LAYOUT(SK_COPY, KC_J, KC_F, KC_M, KC_P, KC_V, KC_HASH, KC_DOT, KC_SLSH, KC_QUOT, KC_DQUO, KC_KANA, SK_PSTE, LCTL_T(KC_R), LALT_T(KC_S), LGUI_T(KC_N), LSFT_T(KC_T), KC_K, KC_COMM, RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_C), RCTL_T(KC_I), KC_HANJ, S(G(KC_4)), KC_X, KC_G, KC_L, KC_D, KC_B, LT(3,KC_LANG2), SH_TT, TG(5), LT(3,KC_LANG1), KC_MINS, KC_U, KC_O, KC_W, KC_Y, KC_EQL, LT(6,KC_MUTE), KC_APP, LT(5,KC_BSPC), LT(4,KC_H), LT(3,KC_LANG2), LT(3,KC_BSPC), LT(2,KC_SPC), LT(4,KC_ENT), LT(5,KC_TAB), LT(8,KC_MPLY)), + [1] = LAYOUT(KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_U, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LGUI_T(KC_H), 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_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LT(4,KC_N), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [2] = LAYOUT(KC_TRNS, LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), LALT(KC_8), LALT(KC_4), KC_DLR, A(S(KC_2)), LALT(KC_Y), RALT(KC_3), KC_TRNS, KC_TRNS, KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_7), RALT(KC_1), LSFT_T(KC_PAST), LGUI_T(KC_PEQL), LALT_T(KC_PPLS), LCTL_T(KC_BSLS), KC_TRNS, KC_TRNS, A(S(KC_5)), A(S(KC_7)), KC_LCBR, KC_RCBR, RALT(KC_5), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, KC_TRNS, KC_VOLD, KC_VOLU, SK_DELWDL, SK_DELWDR, KC_TRNS, A(S(KC_9)), KC_TRNS, LALT(KC_9), A(S(KC_8)), TG(5)), + [3] = LAYOUT(KC_TRNS, KC_F9, KC_F3, KC_F1, KC_F5, KC_F7, KC_F6, KC_F2, KC_F10, KC_F4, KC_F8, KC_TRNS, KC_TRNS, LCTL_T(KC_9), LALT_T(KC_3), LGUI_T(KC_1), LSFT_T(KC_5), KC_7, KC_6, RSFT_T(KC_2), RGUI_T(KC_0), RALT_T(KC_4), RCTL_T(KC_8), KC_TRNS, KC_TRNS, DF(1), TO(1), AG_SWAP, CG_SWAP, KC_F11, RESET, KC_TRNS, KC_TRNS, RESET, KC_F12, CG_NORM, AG_NORM, TO(0), DF(0), KC_TRNS, RESET, LCA(KC_DEL), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LCA(KC_DEL), RESET), + [4] = LAYOUT(KC_TRNS, SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_TRNS, KC_TRNS, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_TRNS, KC_TRNS, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, KC_HANJ, KC_TRNS, KC_TRNS, KC_HANJ, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, KC_TRNS, KC_BRID, KC_BRIU, KC_TRNS, KC_TRNS, KC_TRNS, SK_ZOOMOUT, SK_HISTPRV, SK_HISTNXT, SK_ZOOMIN, SK_ZOOMRST), + [5] = LAYOUT(KC_NO, LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_8)), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, KC_NO, KC_NO, KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_7), KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, KC_NO, KC_NO, LCTL_T(KC_LBRC), LALT_T(KC_RBRC), KC_LCBR, KC_RCBR, RALT(KC_5), LALT(KC_MINS), TG(0), KC_TRNS, LALT(KC_EQL), KC_COMM, KC_P1, KC_P2, KC_P3, KC_PEQL, KC_NO, KC_TRNS, KC_APP, KC_BSPC, LT(4,KC_DEL), KC_PENT, KC_BSPC, KC_P0, KC_PDOT, KC_C, KC_TRNS), [6] = LAYOUT(KC_NO, RALT(KC_W), RALT(KC_E), RALT(KC_6), RALT(KC_GRV), LALT(KC_J), RALT(KC_Q), LALT(KC_U), LALT(KC_K), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RALT(KC_A), LALT(KC_N), LALT(KC_I), LALT(KC_L), KC_NO, KC_NO, RALT(KC_X), RALT(KC_C), RALT(KC_L), RALT(KC_D), RALT(KC_B), KC_NO, KC_NO, KC_NO, KC_NO, RALT(KC_Z), RALT(KC_C), LALT(KC_H), LALT(KC_P), KC_NO, KC_NO, RESET, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET), [7] = LAYOUT(KC_NO, RALT(KC_1), RALT(KC_R), RALT(KC_G), RALT(KC_2), A(S(KC_SCLN)), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_BSLS), A(S(KC_3)), A(S(KC_4)), A(S(KC_BSLS)), A(S(KC_5)), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_9), LALT(KC_QUOT), RALT(KC_Q), RALT(KC_F), A(S(KC_7)), KC_CAPS, KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_TRNS, LALT(KC_BSPC), KC_DEL, LALT(KC_DEL), KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO), - [8] = LAYOUT(KC_NO, KC_PSCR, KC_SLCK, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LCTL_T(KC_BRIU), LALT_T(KC_MRWD), LGUI_T(KC_MSTP), LSFT_T(KC_MFFD), LT(5,KC_VOLU), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_BRID, KC_MPRV, KC_MUTE, KC_MNXT, KC_VOLD, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET, KC_EJCT, KC_PAUS, KC_MPLY, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET) + [8] = LAYOUT(KC_NO, KC_PSCR, KC_SLCK, LCA(KC_DEL), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LCTL_T(KC_BRIU), LALT_T(KC_MRWD), LGUI_T(KC_MSTP), LSFT_T(KC_MFFD), LT(5,KC_VOLU), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_BRID, KC_MPRV, KC_MUTE, KC_MNXT, KC_VOLD, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET, KC_EJCT, KC_PAUS, KC_MPLY, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET) }; diff --git a/kyria/kyria_hd_keymap.c.bak b/kyria/kyria_hd_keymap.c.bak new file mode 100644 index 0000000..e1fa94d --- /dev/null +++ b/kyria/kyria_hd_keymap.c.bak @@ -0,0 +1,19 @@ +#include QMK_KEYBOARD_H + +/* THIS FILE WAS GENERATED! + * + * This file was generated by qmk json2c. You may or may not want to + * edit it directly. + */ + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + [0] = LAYOUT(SK_COPY, KC_J, KC_F, KC_M, KC_P, KC_V, KC_HASH, KC_DOT, KC_SLSH, KC_QUOT, KC_DQUO, KC_KANA, SK_PSTE, LCTL_T(KC_R), LALT_T(KC_S), LGUI_T(KC_N), LSFT_T(KC_T), KC_K, KC_COMM, RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_C), RCTL_T(KC_I), KC_HANJ, S(G(KC_4)), KC_X, KC_G, KC_L, KC_D, KC_B, LT(3,KC_LANG2), SH_TT, TG(5), LT(3,KC_LANG1), KC_MINS, KC_U, KC_O, KC_W, KC_Y, KC_EQL, LT(6,KC_MUTE), KC_APP, LT(5,KC_BSPC), LT(4,KC_H), LT(3,KC_LANG2), LT(3,KC_BSPC), LT(2,KC_SPC), LT(4,KC_ENT), LT(5,KC_TAB), LT(8,KC_MPLY)), + [1] = LAYOUT(KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_U, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LGUI_T(KC_H), 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_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LT(4,KC_N), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [2] = LAYOUT(KC_TRNS, LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), LALT(KC_8), LALT(KC_4), KC_DLR, A(S(KC_2)), LALT(KC_Y), RALT(KC_3), KC_TRNS, KC_TRNS, KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_7), RALT(KC_1), LSFT_T(KC_PAST), LGUI_T(KC_PEQL), LALT_T(KC_PPLS), LCTL_T(KC_BSLS), KC_TRNS, KC_TRNS, A(S(KC_5)), A(S(KC_7)), KC_LCBR, KC_RCBR, RALT(KC_5), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, KC_TRNS, KC_VOLD, KC_VOLU, SK_DELWDL, SK_DELWDR, KC_TRNS, A(S(KC_9)), KC_TRNS, LALT(KC_9), A(S(KC_8)), TG(5)), + [3] = LAYOUT(KC_TRNS, KC_F9, KC_F3, KC_F1, KC_F5, KC_F7, KC_F6, KC_F2, KC_F10, KC_F4, KC_F8, KC_TRNS, KC_TRNS, LCTL_T(KC_9), LALT_T(KC_3), LGUI_T(KC_1), LSFT_T(KC_5), KC_7, KC_6, RSFT_T(KC_2), RGUI_T(KC_0), RALT_T(KC_4), RCTL_T(KC_8), KC_TRNS, KC_TRNS, DF(1), TO(1), AG_SWAP, CG_SWAP, KC_F11, RESET, KC_TRNS, KC_TRNS, RESET, KC_F12, DF(0), TO(0), CG_NORM, AG_NORM, KC_TRNS, RESET, LCA(KC_DEL), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LCA(KC_DEL), RESET), + [4] = LAYOUT(KC_TRNS, SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_TRNS, KC_TRNS, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_TRNS, KC_TRNS, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, KC_HANJ, KC_TRNS, KC_TRNS, KC_HANJ, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, KC_TRNS, KC_BRID, KC_BRIU, KC_TRNS, KC_TRNS, KC_TRNS, SK_ZOOMOUT, SK_HISTPRV, SK_HISTNXT, SK_ZOOMIN, SK_ZOOMRST), + [5] = LAYOUT(KC_NO, LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_8)), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, KC_NO, KC_NO, KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_7), KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, KC_NO, KC_NO, LCTL_T(KC_LBRC), LALT_T(KC_RBRC), KC_LCBR, KC_RCBR, RALT(KC_5), LALT(KC_MINS), TG(0), KC_TRNS, LALT(KC_EQL), KC_COMM, KC_P1, KC_P2, KC_P3, KC_PEQL, KC_NO, KC_TRNS, KC_APP, KC_BSPC, LT(4,KC_DEL), KC_PENT, KC_BSPC, KC_P0, KC_PDOT, KC_C, KC_TRNS), + [6] = LAYOUT(KC_NO, RALT(KC_W), RALT(KC_E), RALT(KC_6), RALT(KC_GRV), LALT(KC_J), RALT(KC_Q), LALT(KC_U), LALT(KC_K), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RALT(KC_A), LALT(KC_N), LALT(KC_I), LALT(KC_L), KC_NO, KC_NO, RALT(KC_X), RALT(KC_C), RALT(KC_L), RALT(KC_D), RALT(KC_B), KC_NO, KC_NO, KC_NO, KC_NO, RALT(KC_Z), RALT(KC_C), LALT(KC_H), LALT(KC_P), KC_NO, KC_NO, RESET, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET), + [7] = LAYOUT(KC_NO, RALT(KC_1), RALT(KC_R), RALT(KC_G), RALT(KC_2), A(S(KC_SCLN)), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_BSLS), A(S(KC_3)), A(S(KC_4)), A(S(KC_BSLS)), A(S(KC_5)), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_9), LALT(KC_QUOT), RALT(KC_Q), RALT(KC_F), A(S(KC_7)), KC_CAPS, KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_TRNS, LALT(KC_BSPC), KC_DEL, LALT(KC_DEL), KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO), + [8] = LAYOUT(KC_NO, KC_PSCR, KC_SLCK, LCA(KC_DEL), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LCTL_T(KC_BRIU), LALT_T(KC_MRWD), LGUI_T(KC_MSTP), LSFT_T(KC_MFFD), LT(5,KC_VOLU), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_BRID, KC_MPRV, KC_MUTE, KC_MNXT, KC_VOLD, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET, KC_EJCT, KC_PAUS, KC_MPLY, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET) +}; diff --git a/kyria/kyria_hd_keymap.configurator0924.c b/kyria/kyria_hd_keymap.configurator0924.c new file mode 100644 index 0000000..ae6d9ab --- /dev/null +++ b/kyria/kyria_hd_keymap.configurator0924.c @@ -0,0 +1,19 @@ +#include QMK_KEYBOARD_H + +/* THIS FILE WAS GENERATED! + * + * This file was generated by qmk json2c. You may or may not want to + * edit it directly. + */ + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + [0] = LAYOUT(LGUI(KC_C), KC_MINS, KC_F, KC_M, KC_P, KC_V, KC_EQL, KC_DOT, KC_SLSH, KC_QUOT, KC_DQUO, KC_HAEN, LGUI(KC_V), LCTL_T(KC_R), LALT_T(KC_S), LGUI_T(KC_N), LSFT_T(KC_T), KC_K, KC_COMM, RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_C), RCTL_T(KC_I), KC_HANJ, S(G(KC_4)), KC_X, KC_G, KC_L, KC_D, KC_B, KC_APP, SH_TT, SH_TT, LT(5,KC_TAB), KC_HASH, KC_U, KC_O, KC_W, KC_Y, KC_J, LT(6,KC_MUTE), LT(3,KC_LANG2), LT(5,KC_BSPC), LT(4,KC_H), LT(3,KC_LANG2), LT(3,KC_LANG1), LT(2,KC_SPC), LT(4,KC_ENT), LT(3,KC_LANG1), LT(8,KC_MPLY)), + [1] = LAYOUT(KC_NO, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_NO, KC_NO, LCTL_T(KC_A), LALT_T(KC_S), LGUI_T(KC_D), LSFT_T(KC_F), KC_G, KC_H, RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), KC_NO, KC_NO, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_NO, KC_TRNS, KC_TRNS, KC_BSPC, KC_SPC, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [2] = LAYOUT(LGUI(KC_C), LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), LALT(KC_8), LALT(KC_4), KC_DLR, A(S(KC_2)), LALT(KC_Y), RALT(KC_3), KC_NO, C(S(G(KC_4))), KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_7), RALT(KC_1), LSFT_T(KC_PAST), LGUI_T(KC_PEQL), LALT_T(KC_PPLS), LCTL_T(KC_BSLS), KC_NO, S(G(KC_3)), A(S(KC_5)), A(S(KC_7)), KC_LCBR, KC_RCBR, RALT(KC_5), KC_HANJ, KC_TRNS, KC_TRNS, KC_HANJ, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, KC_NO, KC_VOLD, KC_VOLU, LALT(KC_BSPC), LALT(KC_DEL), KC_HANJ, A(S(KC_9)), KC_TRNS, LALT(KC_9), A(S(KC_8)), TG(5)), + [3] = LAYOUT(KC_TRNS, KC_F7, KC_F3, KC_F1, KC_F5, KC_F9, KC_F8, KC_F2, KC_F10, KC_F4, KC_F6, KC_TRNS, KC_TRNS, LCTL_T(KC_9), LALT_T(KC_3), LGUI_T(KC_1), LSFT_T(KC_5), KC_7, KC_6, RSFT_T(KC_2), RGUI_T(KC_0), RALT_T(KC_4), RCTL_T(KC_8), KC_TRNS, KC_TRNS, DF(1), TO(1), TO(0), DF(0), KC_F11, RESET, KC_TRNS, KC_TRNS, RESET, KC_F12, DF(0), TO(0), TO(1), DF(1), KC_TRNS, RESET, LCA(KC_DEL), AG_SWAP, AG_NORM, KC_TRNS, KC_TRNS, CG_NORM, CG_SWAP, LCA(KC_DEL), RESET), + [4] = LAYOUT(KC_TRNS, RGUI(KC_Q), RGUI(KC_W), S(G(KC_4)), C(S(G(KC_4))), RGUI(KC_G), LALT(KC_HOME), KC_HOME, KC_UP, KC_PGUP, LALT(KC_PGUP), KC_TRNS, KC_TRNS, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, RGUI(KC_F), LALT(KC_LEFT), KC_LEFT, KC_DOWN, KC_RGHT, LALT(KC_RGHT), KC_TRNS, KC_TRNS, RGUI(KC_Z), RGUI(KC_X), RGUI(KC_C), RGUI(KC_V), G(S(A(KC_V))), KC_HANJ, KC_TRNS, KC_TRNS, KC_HANJ, LALT(KC_END), KC_END, KC_DOWN, KC_PGDN, LALT(KC_PGDN), KC_TRNS, KC_BRID, KC_BRIU, KC_TRNS, KC_TRNS, KC_TRNS, LGUI(KC_LBRC), LGUI(KC_RBRC), G(S(KC_EQL)), LGUI(KC_MINS), LGUI(KC_0)), + [5] = LAYOUT(KC_NO, LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_8)), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, KC_NO, KC_NO, KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_7), KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, KC_NO, KC_NO, LCTL_T(KC_LBRC), LALT_T(KC_RBRC), KC_LCBR, KC_RCBR, RALT(KC_5), LALT(KC_MINS), KC_TRNS, LALT(KC_SLSH), LALT(KC_EQL), KC_COMM, KC_P1, KC_P2, KC_P3, KC_PEQL, KC_NO, TG(5), KC_TRNS, KC_BSPC, KC_DEL, KC_TRNS, A(S(KC_EQL)), KC_P0, KC_PDOT, KC_C, KC_TRNS), + [6] = LAYOUT(KC_NO, RALT(KC_W), RALT(KC_E), RALT(KC_6), RALT(KC_GRV), LALT(KC_J), RALT(KC_Q), LALT(KC_U), LALT(KC_K), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RALT(KC_A), LALT(KC_N), LALT(KC_I), LALT(KC_L), KC_NO, KC_NO, RALT(KC_X), RALT(KC_C), RALT(KC_L), RALT(KC_D), RALT(KC_B), KC_NO, KC_NO, KC_NO, KC_NO, RALT(KC_Z), RALT(KC_C), LALT(KC_H), LALT(KC_P), KC_NO, KC_NO, RESET, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET), + [7] = LAYOUT(KC_NO, RALT(KC_1), RALT(KC_R), RALT(KC_G), RALT(KC_2), A(S(KC_SCLN)), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_BSLS), A(S(KC_3)), A(S(KC_4)), A(S(KC_BSLS)), A(S(KC_5)), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LALT(KC_9), LALT(KC_QUOT), RALT(KC_Q), RALT(KC_F), A(S(KC_7)), KC_CAPS, KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_TRNS, LALT(KC_BSPC), KC_DEL, LALT(KC_DEL), KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO), + [8] = LAYOUT(KC_NO, KC_PSCR, KC_SLCK, LCA(KC_DEL), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LCTL_T(KC_BRIU), LALT_T(KC_MRWD), LGUI_T(KC_MSTP), LSFT_T(KC_MFFD), LT(5,KC_VOLU), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_BRID, KC_MPRV, KC_MUTE, KC_MNXT, KC_VOLD, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET, KC_EJCT, KC_PAUS, KC_MPLY, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET) +}; diff --git a/kyria/kyria_hd_platinum.json b/kyria/kyria_hd_platinum.json new file mode 100644 index 0000000..73646d5 --- /dev/null +++ b/kyria/kyria_hd_platinum.json @@ -0,0 +1,479 @@ +{ + "version": 1, + "notes": "Hands Down Kyria\n\n0—Hands Down (mods on home row, Layers on thumbs)\n1—QWERTY\n2—SYMBOL\n3—FN\n4—MEDIA/NAV\n5—NUM\n6—DIACRIT", + "documentation": "\"This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\"\n", + "keyboard": "splitkb/kyria/rev1", + "keymap": "kyria_hd_platinum", + "layout": "LAYOUT", + "layers": [ + [ + "LGUI(KC_C)", + "KC_W", + "KC_G", + "KC_H", + "KC_P", + "KC_V", + "KC_HASH", + "KC_DOT", + "KC_SLSH", + "KC_DQUO", + "KC_GRV", + "KC_LANG1", + "LGUI(KC_V)", + "LCTL_T(KC_C)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_I)", + "RCTL_T(KC_R)", + "KC_LANG2", + "ANY(S(G(KC_4)))", + "KC_QUOT", + "KC_F", + "KC_M", + "KC_D", + "KC_B", + "LT(3,KC_LANG2)", + "ANY(SH_TT)", + "ANY(SH_TT)", + "LT(3,KC_LANG1)", + "KC_MINS", + "KC_U", + "KC_O", + "KC_Y", + "KC_X", + "KC_EQL", + "LT(6,KC_MUTE)", + "KC_APP", + "LT(5,KC_BSPC)", + "LT(4,KC_L)", + "LT(3,KC_LANG2)", + "LT(3,KC_BSPC)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "LT(5,KC_TAB)", + "LT(8,KC_MPLY)" + ], + [ + "KC_NO", + "KC_Q", + "KC_W", + "KC_E", + "KC_R", + "KC_T", + "KC_Y", + "KC_U", + "KC_I", + "KC_O", + "KC_P", + "KC_NO", + "KC_NO", + "LCTL_T(KC_A)", + "LALT_T(KC_S)", + "LGUI_T(KC_D)", + "LSFT_T(KC_F)", + "KC_G", + "KC_H", + "RSFT_T(KC_J)", + "RGUI_T(KC_K)", + "RALT_T(KC_L)", + "RCTL_T(KC_SCLN)", + "KC_NO", + "KC_NO", + "KC_Z", + "KC_X", + "KC_C", + "KC_V", + "KC_B", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_N", + "KC_M", + "KC_COMM", + "KC_DOT", + "KC_SLSH", + "KC_NO", + "KC_TRNS", + "KC_TRNS", + "KC_BSPC", + "KC_SPC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "LGUI(KC_C)", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "LALT(KC_8)", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT(KC_Y)", + "RALT(KC_3)", + "KC_NO", + "ANY(C(S(G(KC_4))))", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "LGUI_T(KC_PEQL)", + "LALT_T(KC_PPLS)", + "LCTL_T(KC_BSLS)", + "KC_NO", + "ANY(S(G(KC_3)))", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_LANG2", + "KC_TRNS", + "KC_TRNS", + "KC_HANJ", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_NO", + "KC_VOLD", + "KC_VOLU", + "LALT(KC_BSPC)", + "LALT(KC_DEL)", + "KC_LANG2", + "ANY(A(S(KC_9)))", + "KC_TRNS", + "LALT(KC_9)", + "ANY(A(S(KC_8)))", + "TG(5)" + ], + [ + "KC_TRNS", + "KC_F7", + "KC_F3", + "KC_F1", + "KC_F5", + "KC_F9", + "KC_F8", + "KC_F2", + "KC_F10", + "KC_F4", + "KC_F6", + "KC_TRNS", + "KC_TRNS", + "LCTL_T(KC_9)", + "LALT_T(KC_3)", + "LGUI_T(KC_1)", + "LSFT_T(KC_5)", + "KC_7", + "KC_6", + "RSFT_T(KC_2)", + "RGUI_T(KC_0)", + "RALT_T(KC_4)", + "RCTL_T(KC_8)", + "KC_TRNS", + "KC_TRNS", + "DF(1)", + "TO(1)", + "TO(0)", + "DF(0)", + "KC_F11", + "RESET", + "KC_TRNS", + "KC_TRNS", + "RESET", + "KC_F12", + "DF(0)", + "TO(0)", + "TO(1)", + "DF(1)", + "KC_TRNS", + "RESET", + "ANY(C(A(KC_DEL)))", + "AG_NORM", + "AG_SWAP", + "KC_TRNS", + "KC_TRNS", + "CG_SWAP", + "CG_NORM", + "ANY(C(A(KC_DEL)))", + "RESET" + ], + [ + "KC_TRNS", + "RGUI(KC_Q)", + "RGUI(KC_W)", + "ANY(S(G(KC_4)))", + "ANY(C(S(G(KC_4))))", + "RGUI(KC_G)", + "LALT(KC_HOME)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "LALT(KC_PGUP)", + "KC_TRNS", + "KC_TRNS", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "RGUI(KC_F)", + "LALT(KC_LEFT)", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "LALT(KC_RGHT)", + "KC_TRNS", + "KC_TRNS", + "RALT(KC_Z)", + "RALT(KC_X)", + "RALT(KC_C)", + "RALT(KC_V)", + "ANY(G(S(A(KC_V))))", + "KC_LANG2", + "KC_TRNS", + "KC_TRNS", + "KC_HANJ", + "LALT(KC_END)", + "KC_END", + "KC_DOWN", + "KC_PGDN", + "LALT(KC_PGDN)", + "KC_TRNS", + "KC_BRID", + "KC_BRIU", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LGUI(KC_LBRC)", + "LGUI(KC_RBRC)", + "ANY(G(S(KC_EQL)))", + "LGUI(KC_MINS)", + "LGUI(KC_0)" + ], + [ + "KC_NO", + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_8)))", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_NO", + "KC_NO", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_7)", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "KC_NO", + "KC_NO", + "LCTL_T(KC_LBRC)", + "LALT_T(KC_RBRC)", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "LALT(KC_MINS)", + "KC_TRNS", + "LALT(KC_SLSH)", + "LALT(KC_EQL)", + "KC_COMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_NO", + "TG(5)", + "KC_TRNS", + "KC_BSPC", + "KC_DEL", + "KC_TRNS", + "ANY(A(S(KC_EQL)))", + "KC_P0", + "KC_PDOT", + "KC_C", + "KC_TRNS" + ], + [ + "KC_NO", + "RALT(KC_W)", + "RALT(KC_E)", + "RALT(KC_6)", + "RALT(KC_GRV)", + "LALT(KC_J)", + "RALT(KC_Q)", + "LALT(KC_U)", + "LALT(KC_K)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_A)", + "LALT(KC_N)", + "LALT(KC_I)", + "LALT(KC_L)", + "KC_NO", + "KC_NO", + "RALT(KC_X)", + "RALT(KC_C)", + "RALT(KC_L)", + "RALT(KC_D)", + "RALT(KC_B)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RALT(KC_Z)", + "RALT(KC_C)", + "LALT(KC_H)", + "LALT(KC_P)", + "KC_NO", + "KC_NO", + "RESET", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET" + ], + [ + "KC_NO", + "RALT(KC_1)", + "RALT(KC_R)", + "RALT(KC_G)", + "RALT(KC_2)", + "ANY(A(S(KC_SCLN)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_BSLS)", + "ANY(A(S(KC_3)))", + "ANY(A(S(KC_4)))", + "ANY(A(S(KC_BSLS)))", + "ANY(A(S(KC_5)))", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LALT(KC_9)", + "LALT(KC_QUOT)", + "RALT(KC_Q)", + "RALT(KC_F)", + "ANY(A(S(KC_7)))", + "KC_CAPS", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_TRNS", + "LALT(KC_BSPC)", + "KC_DEL", + "LALT(KC_DEL)", + "KC_TRNS", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO" + ], + [ + "KC_NO", + "KC_PSCR", + "KC_SLCK", + "LCA(KC_DEL)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "LCTL_T(KC_BRIU)", + "LALT_T(KC_MRWD)", + "LGUI_T(KC_MSTP)", + "LSFT_T(KC_MFFD)", + "LT(5,KC_VOLU)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRID", + "KC_MPRV", + "KC_MUTE", + "KC_MNXT", + "KC_VOLD", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET", + "KC_EJCT", + "KC_PAUS", + "KC_MPLY", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET" + ] + ], + "author": "Hands Down Kyria" +} \ No newline at end of file diff --git a/kyria/naked48_hd_bronze_sk.json b/kyria/naked48_hd_bronze_sk.json new file mode 100644 index 0000000..4bb64d4 --- /dev/null +++ b/kyria/naked48_hd_bronze_sk.json @@ -0,0 +1,361 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "naked48/rev1", + "keymap": "naked48_hd_bronze_sk", + "layout": "LAYOUT", + "layers": [ + [ + "KC_J", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "KC_APP", + "TG(5)", + "KC_HASH", + "KC_DOT", + "KC_SLSH", + "KC_QUOT", + "KC_DQUO", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "LT(5,KC_TAB)", + "LT(5,KC_ESC)", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_C)", + "RCTL_T(KC_I)", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "KC_LBRC", + "KC_RBRC", + "KC_MINS", + "KC_U", + "KC_O", + "KC_W", + "KC_Y", + "KC_LEFT", + "KC_RGHT", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(2,KC_LANG2)", + "LT(3,KC_MUTE)", + "LT(3,KC_MPLY)", + "LT(6,KC_LANG1)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "KC_UP", + "KC_DOWN" + ], + [ + "KC_TILD", + "KC_EXLM", + "KC_AT", + "KC_HASH", + "KC_DLR", + "KC_PERC", + "KC_CIRC", + "KC_AMPR", + "KC_ASTR", + "KC_LPRN", + "KC_RPRN", + "KC_DEL", + "KC_TRNS", + "KC_TRNS", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_F6", + "KC_UNDS", + "KC_PLUS", + "KC_LCBR", + "KC_RCBR", + "KC_PIPE", + "KC_TRNS", + "KC_TRNS", + "KC_F8", + "KC_F9", + "KC_F10", + "KC_F11", + "KC_F12", + "LSFT(KC_NUHS)", + "LSFT(KC_NUBS)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_MNXT", + "KC_VOLD", + "KC_VOLU", + "KC_MPLY" + ], + [ + "KC_Q", + "KC_Z", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_9)))", + "ANY(S(G(KC_4)))", + "KC_TRNS", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT_T(KC_Y)", + "RALT(KC_3)", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "ANY(C(S(G(KC_4))))", + "KC_TRNS", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "RGUI_T(KC_PEQL)", + "RALT_T(KC_PPLS)", + "RCTL_T(KC_RO)", + "ANY(A(S(KC_5)))", + "KC_TRNS", + "KC_LCBR", + "KC_RPRN", + "RALT(KC_5)", + "KC_TRNS", + "KC_TRNS", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_TRNS", + "KC_TRNS", + "ANY(SK_DELWDL)", + "ANY(SK_DELWDR)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_F11", + "KC_F12", + "KC_F13", + "KC_F14", + "KC_F15", + "KC_F16", + "KC_TRNS", + "KC_SLSH", + "KC_7", + "KC_8", + "KC_9", + "KC_0", + "LCTL_T(KC_F6)", + "LALT_T(KC_F7)", + "LGUI_T(KC_F8)", + "LSFT_T(KC_F9)", + "KC_F10", + "KC_F17", + "KC_TRNS", + "KC_EQL", + "RSFT_T(KC_4)", + "RGUI_T(KC_5)", + "RALT_T(KC_6)", + "RCTL_T(KC_MINS)", + "KC_F1", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_F18", + "KC_TRNS", + "KC_MINS", + "KC_1", + "KC_2", + "KC_3", + "KC_EQL", + "KC_F19", + "KC_F20", + "KC_F21", + "KC_F22", + "KC_F23", + "KC_NO", + "KC_NO", + "KC_NLCK", + "KC_SLCK", + "KC_INS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "ANY(SK_QUIT)", + "ANY(SK_CLOZ)", + "ANY(SK_SCAP)", + "ANY(SK_SCLP)", + "ANY(SK_FAGN)", + "KC_VOLU", + "KC_MRWD", + "ANY(SK_DOCBEG)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "ANY(SK_PARAPRV)", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "ANY(SK_FIND)", + "KC_VOLD", + "KC_MFFD", + "ANY(SK_WORDPRV)", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "ANY(SK_WORDNXT)", + "ANY(SK_UNDO)", + "ANY(SK_CUT)", + "ANY(SK_COPY)", + "ANY(SK_PSTE)", + "ANY(SK_PSTM)", + "KC_MPRV", + "KC_MNXT", + "ANY(SK_DOCEND)", + "KC_END", + "KC_DOWN", + "KC_LALT", + "ANY(SK_PARANXT)", + "KC_TRNS", + "KC_TRNS", + "ANY(SK_DELWDL)", + "ANY(SK_DELWDR)", + "KC_TRNS", + "KC_MUTE", + "KC_MPLY", + "ANY(SK_ZOOMRST)", + "ANY(SK_HISTPRV)", + "ANY(SK_HISTNXT)", + "ANY(SK_ZOOMOUT)", + "ANY(SK_ZOOMIN)" + ], + [ + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_LBRC)))", + "KC_TRNS", + "KC_TRNS", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "KC_TRNS", + "KC_NLCK", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_TRNS", + "KC_TAB", + "KC_PCMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_TRNS", + "KC_TRNS", + "KC_BSPC", + "KC_DEL", + "KC_TRNS", + "KC_ENT", + "KC_TRNS", + "KC_C", + "KC_PEQL", + "KC_P0", + "KC_P0", + "KC_PDOT" + ], + [ + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET", + "KC_NO", + "BL_BRTG", + "RGB_SPI", + "RGB_SPD", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRIU", + "BL_STEP", + "BL_INC", + "RGB_HUI", + "RGB_SAI", + "RGB_VAI", + "KC_NO", + "TO(1)", + "DF(1)", + "KC_NO", + "AG_SWAP", + "CG_SWAP", + "KC_BRID", + "BL_TOGG", + "BL_DEC", + "RGB_HUD", + "RGB_SAD", + "RGB_VAD", + "TO(0)", + "DF(0)", + "KC_NO", + "AG_NORM", + "CG_NORM", + "KC_NO", + "KC_NO", + "KC_NO", + "BL_ON", + "BL_OFF", + "KC_NO", + "KC_NO" + ] + ], + "author": "", + "notes": "" +} \ No newline at end of file diff --git a/moutis.c b/moutis.c index 676447d..88d8809 100644 --- a/moutis.c +++ b/moutis.c @@ -2,13 +2,6 @@ #include QMK_KEYBOARD_H #include -#ifdef EE_HANDS - #include "split_util.h" -#endif - -#ifdef COMBO_ENABLE - #include "process_combo.h" -#endif #include "moutis.h" @@ -19,50 +12,21 @@ user_config_t user_config; uint8_t saved_mods = 0; // to pass state between process_record_user and matrix_scan_user uint16_t record_keycode = 0; // the keykcode we poke at in process_record +uint16_t linger_key = 0; // keycode for linger actions (ex. "Qu") uint32_t linger_timer = 0; // time to hold a key before something else happens. -uint32_t state_reset_timer = 0; // time to leave a state active before shutting it down. +uint32_t state_reset_timer = 0; // time to leave a state active before shutting it down automatically. bool appmenu_on = false; // state of windows-like app switcher bool mods_held = false; // nood to remember how we entered the appmenu state bool key_trap = false; // used for shift BS = del (right) - -uint8_t combo_on = 0; // for combo actions to hold before triggering -bool combo_triggered = false; // for one-shot-combo-actions - - -#include "moutis_semantickeys.c" // anything could send a semantic, so…first - -#ifdef OLED_DRIVER_ENABLE - #include "moutis_OLED.c" +#ifdef RGBLIGHT_ENABLE +int RGB_current_mode; #endif -#ifdef ENCODER_ENABLE - #include "moutis_ENCODER.c" -#endif - -#ifdef COMBO_ENABLE - #include "moutis_COMBO_hd_bronze.c" -#endif -#ifdef KEY_OVERRIDE_ENABLE -const key_override_t delete_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_BSPACE, KC_DELETE); -const key_override_t ques_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_QUES, KC_EXLM); - -// This globally defines all key overrides to be used -const key_override_t **key_overrides = (const key_override_t *[]){ - &delete_key_override, - &ques_key_override, - NULL // Null terminate the array of overrides! -}; -#endif - -#include "moutis_casemods.c" - -#include "moutis_adaptivekeys.c" - -#include "moutis_PROCESS_RECORD_hd_bronze.c" - -#include "moutis_MATRIX.c" +uint8_t combo_on = 0; // for combo actions to hold before triggering +bool combo_triggered = false; // for one-shot-combo-actions +uint8_t OSIndex = (uint8_t) 0; // kludge, 'cause I'm stupid void keyboard_post_init_user(void) { // Read the user config from EEPROM to facilitate @@ -92,3 +56,40 @@ void keyboard_post_init_user(void) { oled_on(); #endif } + + + +#include "moutis_semantickeys.c" // anything could send a semantic, so…first + +#ifdef OLED_DRIVER_ENABLE + #include "moutis_OLED.c" +#endif + +#ifdef ENCODER_ENABLE + #include "moutis_ENCODER.c" +#endif + +#ifdef COMBO_ENABLE + #include "moutis_COMBO_hd_bronze_sk.c" +#endif + +#include "moutis_casemods.c" + +#include "moutis_adaptivekeys.c" + +#include "moutis_PROCESS_RECORD_hd_neu.c" + +#include "moutis_MATRIX.c" + +#ifdef KEY_OVERRIDE_ENABLE +const key_override_t delete_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_BSPACE, KC_DELETE); +const key_override_t ques_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_QUES, KC_EXLM); + +// This globally defines all key overrides to be used +const key_override_t **key_overrides = (const key_override_t *[]){ + &delete_key_override, + &ques_key_override, + NULL // Null terminate the array of overrides! +}; +#endif + diff --git a/moutis.h b/moutis.h index ac0e1b2..1c3dfaa 100644 --- a/moutis.h +++ b/moutis.h @@ -6,23 +6,26 @@ #include -#include "moutis_semantickeys.h" - -#include "moutis_casemods.h" +#ifdef EE_HANDS + #include "split_util.h" +#endif #ifdef COMBO_ENABLE -#include "moutis_COMBO_hd.h" + #include "process_combo.h" #endif +#ifdef RGBLIGHT_ENABLE +//Following line allows macro to read current RGB settings +extern rgblight_config_t rgblight_config; +#endif + +#include "moutis_casemods.h" -#define ADAPTIVE_TERM TAPPING_TERM/3 // default time between keystrokes allowed for adaptives -#ifdef COMBO_HOLD - #undef ADAPTIVE_TERM - #define ADAPTIVE_TERM COMBO_HOLD // use COMBO_HOLD time as a standard threshold (same recation time) +#ifdef COMBO_ENABLE + #include "moutis_COMBO_hd.h" #endif -#define LINGER_TIME TAPPING_TERM * 2 // how long to hold before a time-depentant behavior begins -#define STATE_RESET_TIME LINGER_TIME * 2 // how long to leave a state active before resetting + void matrix_scan_user_process_combo(void); // this borrowed from Thomas Bart @@ -33,8 +36,6 @@ typedef union { }; } user_config_t; -uint8_t OSIndex = (uint8_t) 0; // kludge, 'cause I'm stupid - @@ -48,8 +49,41 @@ enum my_layers { L_DIACR }; -/* enum my_keycodes { - HD_aumlt = SAFE_RANGE, + enum my_keycodes { + SK_KILL = SAFE_RANGE, // SK_KILL must be the first of contiguous block of SKs + SK_UNDO, // undo + SK_CUT, // cut + SK_COPY, // copy + SK_PSTE, // paste + SK_PSTM, // paste_match + SK_SALL, // select all + SK_CLOZ, // close + SK_QUIT, // quit + SK_FIND, // find + SK_FAGN, // find again + SK_SCAP, // screen capture to clipboard + SK_SCLP, // selection capture to clipboard + SK_DELWDL, // Delete word left of cursor + SK_DELWDR, // Delete word right of cursor + + SK_WORDPRV, // WORD LEFT + SK_WORDNXT, // WORD RIGHT + SK_DOCBEG, // Go to start of document + SK_DOCEND, // Go to end of document + SK_LINEBEG, // Go to beg of line + SK_LINEEND, // Go to end of line + SK_PARAPRV, // Go to previous paragraph + SK_PARANXT, // Go to next paragraph + SK_HISTPRV, // BROWSER BACK + SK_HISTNXT, // BROWSER FWD + SK_ZOOMIN, // ZOOM IN + SK_ZOOMOUT, // ZOOM OUT + SK_ZOOMRST, // ZOOM RESET + SK_SECT, // § + SemKeys_COUNT, // end of non-glyph SemKeys + +/* Eventually…these should be handled as SemKeys + HD_aumlt, HD_amacr, HD_aacut, HD_acrcm, @@ -78,7 +112,14 @@ enum my_layers { HD_uacut, HD_ucrcm, HD_ugrav - +*/ }; +#include "moutis_semantickeys.h" + +#define register_linger_key(kc) {register_code16(kc);linger_key = kc;linger_timer = state_reset_timer = timer_read();} +#define unregister_linger_key() {unregister_code16(linger_key);linger_key = 0;} +/* +#define register_linger_key(kc) register_code16(kc); +#define unregister_linger_key(kc) unregister_code16(kc); */ diff --git a/moutis_COMBO_hd.h b/moutis_COMBO_hd.h index a680501..0c5f4d8 100644 --- a/moutis_COMBO_hd.h +++ b/moutis_COMBO_hd.h @@ -10,6 +10,7 @@ enum my_combos { HC_EXLM, // ! HC_AT, // @ HC_SCLN, // ; + HC_COLN, // : HC_UNDS, // _ underscore HC_NDSH, // – N-dash HC_MDSH, // — M-dash @@ -19,9 +20,18 @@ enum my_combos { HC_TAB, QC_TAB, + HC_J, // J is not on the map HC_Q, // Q is not on the map - HC_Q2, // 2nd location for Q on the other hand HC_Z, // Z is not on the map + HC_Ch, // treat as digraph 'CH' + HC_Ph, // treat as φ + HC_Th, // treat as θ + HC_Sh, // TYPE "sh" + HC_Wh, // treat as digraph 'WH' + HC_I, // Cap I + "'ve " if lingered + HC_Id, // "I'd " … + HC_Ill, // "I'll " … + HC_Im, // "I'm " … // // ACTION COMBOS (ie, not simple combos as above) @@ -39,26 +49,21 @@ enum my_combos { // since combos are a bit slower, // needs to be a 4gram+ or more to be worth it HC_ing_3gram, // TYPE "ing" - HC_tion_4gram, // TYPE "tion" #1 +// HC_tion_4gram, // TYPE "tion" #1 // handled via adaptive keys HC_with_4gram, // TYPE "with" #5 HC_ment_4gram, // TYPE "ment" #6 HC_this_4gram, // TYPE "this" #8 HC_here_4gram, // TYPE "here" #9 HC_ould_4gram, // TYPE "ould" #11 HC_ting_4gram, // TYPE "ting" #12 - HC_sion_4gram, // TYPE "sion" #20 HC_they_4gram, // TYPE "they" #23 HC_ough_4gram, // TYPE "ough" #25 HC_their_5gram, // TYPE "their" #6 HC_there_5gram, // TYPE "there" #7 -/* - HC_people_6gram, // TYPE "people" #23 - HC_present_7gram, // TYPE "present" #1 - HC_through_7gram, // TYPE "through" #3 - HC_between_7gram, // TYPE "between" #4 -*/ + HC_where_5gram, // TYPE "where" + HC_theyre_7gram, // TYPE "they're" HC_TYPE_JAPAN, // TYPE "Japan" and hold for "ese" HC_CAPSWORD, // CAPS WORD @@ -96,10 +101,8 @@ enum my_combos { PC_AC, MYMACRO, - HC_TYPE_LM, HC_2DQUO, // "|" insertion point between double quotes - HC_2DBRC, // [|] insertion point between double BRACKETS (japanese quote) HC_ENYE, // ~ enye HC_ACUT, // ´ acute @@ -132,10 +135,12 @@ enum my_combos { HC_QUIT, HC_FIND, // Find the selection HC_SALL, + HC_UNDO, HC_CUT, HC_COPY, HC_PSTE, HC_PSTM, + COMBO_LENGTH // END OF DELAY BLOCK }; diff --git a/moutis_COMBO_hd_bronze.c b/moutis_COMBO_hd_bronze.c index 3c4c333..3fb688d 100644 --- a/moutis_COMBO_hd_bronze.c +++ b/moutis_COMBO_hd_bronze.c @@ -65,7 +65,7 @@ const uint16_t PROGMEM Hgrv_combo[] = {KC_HASH, KC_DQUO, COMBO_END}; // ` grave const uint16_t PROGMEM Hmacr_combo[] = {KC_DOT, KC_DQUO, COMBO_END}; // - macron (dead key)ā const uint16_t PROGMEM Hcirc_combo[] = {KC_QUOT, KC_DOT, COMBO_END}; // ˆ circumflex (dead key) const uint16_t PROGMEM Hdier_combo[] = {KC_U, KC_O, COMBO_END}; // ¨ dieresis (dead key) -const uint16_t PROGMEM Hring_combo[] = {KC_O, KC_Y, COMBO_END}; // ˚ ring (dead key) +const uint16_t PROGMEM Hring_combo[] = {KC_O, KC_W, COMBO_END}; // ˚ ring (dead key) const uint16_t PROGMEM Henye_combo[] = {KC_F, KC_P, COMBO_END}; // ˜ enye (dead key) (over N) // LOWER ROW @@ -74,10 +74,13 @@ const uint16_t PROGMEM Henye_combo[] = {KC_F, KC_P, COMBO_END}; // ˜ enye (dead // LEFT HAND // TEXT ENTRY - off map (ANY ROW/ MIXED ROWS) and row jump prevention +const uint16_t PROGMEM H_J_combo[] = {KC_O, KC_Y, COMBO_END}; // TYPE "j" const uint16_t PROGMEM H_Z_combo[] = {KC_F, KC_M, COMBO_END}; // TYPE "z" const uint16_t PROGMEM H_Q_combo[] = {KC_J, KC_F, COMBO_END}; // TYPE "q" const uint16_t PROGMEM H_Q2_combo[] = {KC_U, KC_W, COMBO_END}; // TYPE "q" -const uint16_t PROGMEM H_LM_combo[] = {KC_M, KC_P, COMBO_END}; // TYPE "lp" +const uint16_t PROGMEM H_Ph_combo[] = {KC_M, KC_P, COMBO_END}; // TYPE "ph" +const uint16_t PROGMEM H_Th_combo[] = {LGUI_T(KC_N), LSFT_T(KC_T), COMBO_END}; // "th" +const uint16_t PROGMEM H_Sh_combo[] = {LALT_T(KC_S), LGUI_T(KC_N), COMBO_END}; // "sh" const uint16_t PROGMEM H_ing_combo[] = {RALT_T(KC_I), KC_G, COMBO_END}; // TYPE "ing" only a 3gram, let's see it it's worth it @@ -99,7 +102,7 @@ const uint16_t PROGMEM H_ough_combo[] = {KC_O, LSFT_T(KC_H), COMBO_END}; // "oug */ // FOR INDEX SHIFT -const uint16_t PROGMEM H_tion_combo[] = {LGUI_T(KC_N), LSFT_T(KC_T), COMBO_END}; // "tion" #1 +//const uint16_t PROGMEM H_tion_combo[] = {LGUI_T(KC_N), LSFT_T(KC_T), COMBO_END}; // "tion" #1 const uint16_t PROGMEM H_with_combo[] = {KC_W, LT(L_MEDIA_NAV,KC_H), COMBO_END}; // "with" #5 const uint16_t PROGMEM H_ment_combo[] = {KC_M, LSFT_T(KC_T), COMBO_END}; // "ment" #6 const uint16_t PROGMEM H_this_combo[] = {LSFT_T(KC_T), LALT_T(KC_S), COMBO_END}; // "this" #8 @@ -107,7 +110,7 @@ const uint16_t PROGMEM H_here_combo[] = {LT(L_MEDIA_NAV,KC_H), RGUI_T(KC_E), COM const uint16_t PROGMEM H_ould_combo[] = {KC_O, KC_D, COMBO_END}; // "ould" #11 const uint16_t PROGMEM H_ting_combo[] = {LSFT_T(KC_T), KC_G, COMBO_END}; // "ting" #12 const uint16_t PROGMEM H_sion_combo[] = {LALT_T(KC_S), LGUI_T(KC_N), COMBO_END}; // "sion" #20 -const uint16_t PROGMEM H_they_combo[] = {LSFT_T(KC_T), KC_Y, COMBO_END}; // "they" #23 +const uint16_t PROGMEM H_they_combo[] = {LSFT_T(KC_T), KC_J, COMBO_END}; // "they" #23 const uint16_t PROGMEM H_ough_combo[] = {KC_O, LT(L_MEDIA_NAV,KC_H), COMBO_END}; // "ough" #25 @@ -182,10 +185,13 @@ combo_t key_combos[] = { [HC_TAB] = COMBO(Htab_combo, KC_TAB), [QC_TAB] = COMBO(Qtab_combo, KC_TAB), + [HC_J] = COMBO(H_J_combo, KC_J), [HC_Q] = COMBO_ACTION(H_Q_combo), [HC_Q2] = COMBO_ACTION(H_Q2_combo), [HC_Z] = COMBO(H_Z_combo, KC_Z), - + [HC_Ph] = COMBO_ACTION(H_Ph_combo), + [HC_Th] = COMBO_ACTION(H_Th_combo), + [HC_Sh] = COMBO_ACTION(H_Sh_combo), [PC_PENT] = COMBO(P3E_combo, KC_PENT), // on num [PC_BSPC] = COMBO(P01_combo, KC_BSPC), // on num @@ -262,14 +268,13 @@ combo_t key_combos[] = { // Fast entry 4grams [HC_ing_3gram] = COMBO_ACTION(H_ing_combo), // TYPE "ing" - [HC_tion_4gram] = COMBO_ACTION(H_tion_combo), // TYPE "tion" #1 +// [HC_tion_4gram] = COMBO_ACTION(H_tion_combo), // TYPE "tion" #1 // handled via adaptive keys? [HC_with_4gram] = COMBO_ACTION(H_with_combo), // TYPE "with" #5 [HC_ment_4gram] = COMBO_ACTION(H_ment_combo), // TYPE "ment" #6 [HC_this_4gram] = COMBO_ACTION(H_this_combo), // TYPE "this" #8 [HC_here_4gram] = COMBO_ACTION(H_here_combo), // TYPE "here" #9 [HC_ould_4gram] = COMBO_ACTION(H_ould_combo), // TYPE "ould" #11 [HC_ting_4gram] = COMBO_ACTION(H_ting_combo), // TYPE "ting" #12 - [HC_sion_4gram] = COMBO_ACTION(H_sion_combo), // TYPE "sion" #20 [HC_they_4gram] = COMBO_ACTION(H_they_combo), // TYPE "they" #23 [HC_ough_4gram] = COMBO_ACTION(H_ough_combo), // TYPE "ough" #25 @@ -285,7 +290,6 @@ combo_t key_combos[] = { [HC_between_7gram] = COMBO_ACTION(H_between_combo), // TYPE "between" #4 */ - [HC_TYPE_LM] = COMBO_ACTION(H_LM_combo), [HC_TYPE_JAPAN] = COMBO_ACTION(H_Japan_combo), // a personally useful 5-8gram! [MYMACRO] = COMBO_ACTION(Macro_combo), // a demonstrator, how long autotypes can be! @@ -332,9 +336,10 @@ void process_combo_event(uint16_t combo_index, bool pressed) { case HC_ing_3gram: // TYPE "ing" SEND_STRING("ing"); break; - case HC_tion_4gram: // TYPE "tion" #1 +/* case HC_tion_4gram: // TYPE "tion" #1 SEND_STRING("tion"); break; +*/ case HC_with_4gram: // TYPE "with" #5 SEND_STRING("with"); break; @@ -353,9 +358,6 @@ void process_combo_event(uint16_t combo_index, bool pressed) { case HC_ting_4gram: // TYPE "ting" #12 SEND_STRING("ting"); break; - case HC_sion_4gram: // TYPE "sion" #20 - SEND_STRING("sion"); - break; case HC_they_4gram: // TYPE "they" #23 SEND_STRING("they"); break; @@ -394,6 +396,15 @@ void process_combo_event(uint16_t combo_index, bool pressed) { SEND_STRING("q"); // send "q" right away combo_on = combo_index; // may add "u" in matrix_scan_user_process_combo break; + case HC_Ph: + SEND_STRING("ph"); // send right away (adaptive PH sends PL) + break; + case HC_Sh: + SEND_STRING("sh"); // send right away + break; + case HC_Th: + SEND_STRING("th"); // send right away + break; } // end switch (combo_index) } else { // end if (pressed) @@ -493,9 +504,6 @@ void process_combo_event(uint16_t combo_index, bool pressed) { SEND_STRING("fe"); break; */ - case HC_TYPE_LM: - SEND_STRING("gm"); - break; case HC_SALL: SEND_STRING("xd"); @@ -590,7 +598,10 @@ extern uint8_t saved_mods; // global, so we're not wasting time allocating... break; case HC_ELIP: case PC_ELIP: - tap_code16(A(KC_SLSH)); + saved_mods = get_mods(); + clear_mods(); // + tap_code16(A(KC_SCLN)); // this should use semkeys + set_mods(saved_mods); // break; case PC_COLN: tap_code16(KC_COLN); @@ -666,6 +677,8 @@ extern uint8_t saved_mods; // global, so we're not wasting time allocating... tap_code16(A(KC_K)); break; /* + // THESE SHOULD ALL BE SEMKEYS + // case HC_UM: // Ü tap_code16(A(KC_U)); tap_code16(KC_U); @@ -717,15 +730,11 @@ extern uint8_t saved_mods; // global, so we're not wasting time allocating... SEND_STRING("End of times in 2020\n"); break; - case HC_TYPE_LM: - SEND_STRING("lm"); - break; - case HC_Q: // already "Q" has been sent; if held, add "u" case HC_Q2: // already "Q" has been sent; if held, add "u" saved_mods = get_mods(); - clear_mods(); // - SEND_STRING("u"); + set_mods(saved_mods & ~MOD_MASK_SHIFT); // This isn't working since 14.1 + tap_code(KC_U); set_mods(saved_mods); // break; case HC_TYPE_JAPAN: // already "Japan" has been sent; if held, add "ese" diff --git a/moutis_COMBO_hd_bronze_sk.c b/moutis_COMBO_hd_bronze_sk.c new file mode 100644 index 0000000..1057420 --- /dev/null +++ b/moutis_COMBO_hd_bronze_sk.c @@ -0,0 +1,692 @@ + +// functions / state keys + +uint16_t COMBO_LEN = COMBO_LENGTH; + +const uint16_t PROGMEM F_ESC_combo[] = {KC_X, KC_B, COMBO_END}; // ESCape +const uint16_t PROGMEM F_KILL_combo[] = {KC_X, KC_Y, COMBO_END}; // Force quit OR CTRL-ALT-DEL +const uint16_t PROGMEM F_SCLP_combo[] = {KC_J, KC_P, COMBO_END}; // SCREEN shot SELECTION to clipboard +const uint16_t PROGMEM F_SCAP_combo[] = {KC_J, KC_V, COMBO_END}; // SCREEN shot SELECTION to file +const uint16_t PROGMEM F_CAPS_combo[] = {KC_D, KC_U, COMBO_END}; // CAPS LOCK (on until hit again) +const uint16_t PROGMEM H_CAPS_combo[] = {LSFT_T(KC_T), RSFT_T(KC_A), COMBO_END}; // CAPS WORD (on until delimiter) + +// (22) keypad combos +const uint16_t PROGMEM PSLMN_combo[] = {KC_PSLS, KC_PMNS, COMBO_END}; // toggle num layer +const uint16_t PROGMEM P0E_combo[] = {KC_P0, KC_PEQL, COMBO_END}; +const uint16_t PROGMEM PCME_combo[] = {KC_DOT, KC_PEQL, COMBO_END}; +const uint16_t PROGMEM PCM1_combo[] = {KC_DOT, KC_P1, COMBO_END}; +const uint16_t PROGMEM PCM2_combo[] = {KC_DOT, KC_P2, COMBO_END}; +const uint16_t PROGMEM P01_combo[] = {KC_P0, KC_P1, COMBO_END}; +const uint16_t PROGMEM P02_combo[] = {KC_P0, KC_P2, COMBO_END}; +const uint16_t PROGMEM P04_combo[] = {KC_P0, KC_P4, COMBO_END}; +const uint16_t PROGMEM P05_combo[] = {KC_P0, KC_P5, COMBO_END}; +const uint16_t PROGMEM P12_combo[] = {KC_P1, KC_P2, COMBO_END}; +const uint16_t PROGMEM P23_combo[] = {KC_P2, KC_P3, COMBO_END}; +const uint16_t PROGMEM P13_combo[] = {KC_P1, KC_P3, COMBO_END}; +const uint16_t PROGMEM P1E_combo[] = {KC_P1, KC_PEQL, COMBO_END}; +const uint16_t PROGMEM P2E_combo[] = {KC_P2, KC_PEQL, COMBO_END}; +const uint16_t PROGMEM P3E_combo[] = {KC_P3, KC_PEQL, COMBO_END}; +const uint16_t PROGMEM P45_combo[] = {KC_P4, KC_P5, COMBO_END}; +const uint16_t PROGMEM P56_combo[] = {KC_P5, KC_P6, COMBO_END}; +const uint16_t PROGMEM P46_combo[] = {KC_P4, KC_P6, COMBO_END}; +const uint16_t PROGMEM P5PLS_combo[] = {KC_P5, KC_PPLS, COMBO_END}; +const uint16_t PROGMEM P6PLS_combo[] = {KC_P6, KC_PPLS, COMBO_END}; +const uint16_t PROGMEM PS7_combo[] = {KC_PSLS, KC_P7, COMBO_END}; +const uint16_t PROGMEM P78_combo[] = {KC_P7, KC_P8, COMBO_END}; +const uint16_t PROGMEM P79_combo[] = {KC_P7, KC_P9, COMBO_END}; +const uint16_t PROGMEM P89_combo[] = {KC_P8, KC_P9, COMBO_END}; +const uint16_t PROGMEM P9M_combo[] = {KC_P9, KC_PMNS, COMBO_END}; +const uint16_t PROGMEM PSLT_combo[] = {KC_P7, KC_PMNS, COMBO_END}; +const uint16_t PROGMEM PPLMN_combo[] = {KC_P4, KC_PPLS, COMBO_END}; + + +// Off map and other letter/symbol thingies typically on keyboard + + +// RIGHT HAND +// LOWER ROW + +const uint16_t PROGMEM Hndsh_combo[] = {KC_MINS, KC_U, COMBO_END}; // – n dash +const uint16_t PROGMEM Hmdsh_combo[] = {KC_MINS, KC_O, COMBO_END}; // — m dash +const uint16_t PROGMEM Hunds_combo[] = {KC_U, KC_W, COMBO_END}; // _ underscore +const uint16_t PROGMEM Htild_combo[] = {KC_MINS, KC_W, COMBO_END}; // ~ tilde (not the dead one) +const uint16_t PROGMEM Hequal_combo[] = {KC_Y, KC_W, COMBO_END}; // = equal +const uint16_t PROGMEM Hscln_combo[] = {KC_COMM, RSFT_T(KC_A), COMBO_END}; // ; semicolon +const uint16_t PROGMEM Hcoln_combo[] = {KC_HASH, KC_DOT, COMBO_END}; // : colon + +// spatially arranged characters and diacritics +const uint16_t PROGMEM Hexlm_combo[] = {KC_DOT, KC_SLSH, COMBO_END}; // ! +const uint16_t PROGMEM Hques_combo[] = {KC_SLSH, KC_QUOT, COMBO_END}; // ? +const uint16_t PROGMEM Hat_combo[] = {KC_J, KC_F, COMBO_END}; // @ at mark +const uint16_t PROGMEM Helip_combo[] = {KC_HASH, KC_SLSH, COMBO_END}; // … elipses +const uint16_t PROGMEM Htic_combo[] = {KC_DQUO, KC_QUOT, COMBO_END}; // ` tic (not dead key grave) +const uint16_t PROGMEM Hacut_combo[] = {KC_SLSH, KC_DQUO, COMBO_END}; // ´ acute (dead key) +const uint16_t PROGMEM Hgrv_combo[] = {KC_EQL, KC_QUOT, COMBO_END}; // ` grave (dead key) +const uint16_t PROGMEM Hmacr_combo[] = {KC_DOT, KC_QUOT, COMBO_END}; // - macron (dead key)ā +const uint16_t PROGMEM Hcirc_combo[] = {KC_DOT, KC_DQUO, COMBO_END}; // ˆ circumflex (dead key) +const uint16_t PROGMEM Hdier_combo[] = {KC_U, KC_O, COMBO_END}; // ¨ dieresis (dead key) +const uint16_t PROGMEM Hring_combo[] = {KC_O, KC_Y, COMBO_END}; // ˚ ring (dead key) +const uint16_t PROGMEM Henye_combo[] = {KC_F, KC_P, COMBO_END}; // ˜ enye (dead key) (over N) + +// LOWER ROW +// SYMBOLS spatially arranged + +// LEFT HAND + +// TEXT ENTRY - off map (ANY ROW/ MIXED ROWS) and row jump prevention +const uint16_t PROGMEM H_J_combo[] = {KC_O, KC_W, COMBO_END}; // TYPE "j" +const uint16_t PROGMEM H_Z_combo[] = {KC_M, KC_F, COMBO_END}; // TYPE "z" +const uint16_t PROGMEM H_Q_combo[] = {KC_U, KC_Y, COMBO_END}; // TYPE "q" +const uint16_t PROGMEM H_Ch_combo[] = {RALT_T(KC_C), RGUI_T(KC_E), COMBO_END}; // TYPE "ch" // for HD Gold +const uint16_t PROGMEM H_Wh_combo[] = {KC_O, KC_W, COMBO_END}; // TYPE "wh" +const uint16_t PROGMEM H_Ph_combo[] = {KC_M, KC_P, COMBO_END}; // TYPE "ph" +const uint16_t PROGMEM H_Th_combo[] = {LGUI_T(KC_N), LSFT_T(KC_T), COMBO_END}; // "th" +const uint16_t PROGMEM H_Sh_combo[] = {LALT_T(KC_S), LGUI_T(KC_N), COMBO_END}; // "sh" +const uint16_t PROGMEM H_Icap_combo[] = {RALT_T(KC_C), RCTL_T(KC_I), COMBO_END}; // TYPE "I"+"'ve" +const uint16_t PROGMEM H_Id_combo[] = {KC_D, RCTL_T(KC_I), COMBO_END}; // TYPE "I'd"+"'ve" +const uint16_t PROGMEM H_Ill_combo[] = {KC_L, RCTL_T(KC_I), COMBO_END}; // TYPE "I'll"+"'ve" +const uint16_t PROGMEM H_Im_combo[] = {KC_M, RCTL_T(KC_I), COMBO_END}; // TYPE "I'm" + +const uint16_t PROGMEM H_ing_combo[] = {RCTL_T(KC_I), KC_G, COMBO_END}; // TYPE "ing" only a 3gram, let's see it it's worth it + +// Fast 4grams +// FOR THUMB SHIFT +/* +const uint16_t PROGMEM H_tion_combo[] = {LGUI_T(KC_N), LT(L_LANG_NUM, KC_T), COMBO_END}; // "tion" #1 +const uint16_t PROGMEM H_with_combo[] = {KC_W, LSFT_T(KC_H), COMBO_END}; // "with" #5 +const uint16_t PROGMEM H_ment_combo[] = {KC_M, LT(L_LANG_NUM, KC_T), COMBO_END}; // "ment" #6 +const uint16_t PROGMEM H_this_combo[] = {LT(L_LANG_NUM, KC_T), LALT_T(KC_S), COMBO_END}; // "this" #8 +const uint16_t PROGMEM H_here_combo[] = {LSFT(KC_H), RCTL_T(KC_R), COMBO_END}; // "here" #9 +const uint16_t PROGMEM H_ould_combo[] = {KC_O, KC_D, COMBO_END}; // "ould" #11 +const uint16_t PROGMEM H_ting_combo[] = {LT(L_LANG_NUM, KC_T), KC_G, COMBO_END}; // "ting" #12 +const uint16_t PROGMEM H_sion_combo[] = {LALT_T(KC_S), LGUI_T(KC_N), COMBO_END}; // "sion" #20 +const uint16_t PROGMEM H_they_combo[] = {LT(L_LANG_NUM, KC_T), KC_J, COMBO_END}; // "they" #23 +const uint16_t PROGMEM H_their_combo[] = {LT(L_LANG_NUM, KC_T), KC_X, COMBO_END}; // "their" #6 +const uint16_t PROGMEM H_there_combo[] = {LT(L_LANG_NUM, KC_T), LCTL_T(KC_R), COMBO_END}; // "there" #7 +const uint16_t PROGMEM H_ough_combo[] = {KC_O, LSFT_T(KC_H), COMBO_END}; // "ough" #25 + */ +// FOR INDEX SHIFT + +//const uint16_t PROGMEM H_tion_combo[] = {LGUI_T(KC_N), LSFT_T(KC_T), COMBO_END}; // "tion" #1 +const uint16_t PROGMEM H_with_combo[] = {KC_W, LT(L_MEDIA_NAV,KC_H), COMBO_END}; // "with" #5 +const uint16_t PROGMEM H_ment_combo[] = {KC_M, LSFT_T(KC_T), COMBO_END}; // "ment" #6 +const uint16_t PROGMEM H_this_combo[] = {LSFT_T(KC_T), LALT_T(KC_S), COMBO_END}; // "this" #8 +const uint16_t PROGMEM H_here_combo[] = {LT(L_MEDIA_NAV,KC_H), LCTL_T(KC_R), COMBO_END}; // "here" #9 +const uint16_t PROGMEM H_ould_combo[] = {KC_O, KC_D, COMBO_END}; // "ould" #11 +const uint16_t PROGMEM H_ting_combo[] = {LSFT_T(KC_T), KC_G, COMBO_END}; // "ting" #12 +const uint16_t PROGMEM H_sion_combo[] = {LALT_T(KC_S), LGUI_T(KC_N), COMBO_END}; // "sion" #20 +const uint16_t PROGMEM H_they_combo[] = {LSFT_T(KC_T), KC_Y, COMBO_END}; // "they" #23 +const uint16_t PROGMEM H_ough_combo[] = {KC_O, LT(L_MEDIA_NAV,KC_H), COMBO_END}; // "ough" #25 + + +// Fast 5-7grams + +const uint16_t PROGMEM H_their_combo[] = {LSFT_T(KC_T), KC_X, COMBO_END}; // TYPE "their" #6 +const uint16_t PROGMEM H_there_combo[] = {LSFT_T(KC_T), LCTL_T(KC_R), COMBO_END}; // TYPE "there" #7 +const uint16_t PROGMEM H_theyre_combo[] = {LSFT_T(KC_T), KC_QUOT, COMBO_END}; // "they're" +const uint16_t PROGMEM H_where_combo[] = {KC_W, LCTL_T(KC_R), COMBO_END}; // "where" + + +/* other examples or text entry combos */ +const uint16_t PROGMEM H_Japan_combo[] = {KC_F, KC_M, KC_P, COMBO_END}; // TYPE "Japan" +const uint16_t PROGMEM Macro_combo[] = {KC_J, KC_B, COMBO_END}; // some demonstrator macro placeholder + +// UPPER ROW + +// FUNCTIONS Spatially arranged +const uint16_t PROGMEM Qtab_combo[] = {KC_Q, KC_W, COMBO_END}; // tab QWERTY +const uint16_t PROGMEM Htab_combo[] = {LCTL_T(KC_R), LALT_T(KC_S), COMBO_END}; // tab HANDS DOWN +const uint16_t PROGMEM Hent_combo[] = {LSFT_T(KC_T), KC_K, COMBO_END}; // ENTER +const uint16_t PROGMEM Hspc_combo[] = {KC_D, KC_B, COMBO_END}; // SPACE + +// LOWER ROW + +// SEMANTIC FUNCTIONS Spatially arranged ** uses SemKeys ** +const uint16_t PROGMEM Hclose_combo[] = {KC_L, KC_B, COMBO_END}; // close +const uint16_t PROGMEM Hquit_combo[] = {KC_G, KC_B, COMBO_END}; // quit +const uint16_t PROGMEM Hfind_combo[] = {KC_F, KC_V, COMBO_END}; // find +const uint16_t PROGMEM Hsall_combo[] = {KC_X, KC_D, COMBO_END}; // select all +const uint16_t PROGMEM Hundo_combo[] = {KC_X, KC_G, COMBO_END}; // undo +const uint16_t PROGMEM Hcut_combo[] = {KC_X, KC_L, COMBO_END}; // cut +const uint16_t PROGMEM Hcopy_combo[] = {KC_G, KC_L, COMBO_END}; // copy +const uint16_t PROGMEM Hpste_combo[] = {KC_L, KC_D, COMBO_END}; // paste +const uint16_t PROGMEM Hpstm_combo[] = {KC_G, KC_D, COMBO_END}; // paste-match + +// TWO HANDS +const uint16_t PROGMEM Hdquo_combo[] = {KC_HASH, KC_DQUO, COMBO_END}; // "|" insert between double quote + +// Major diacritic combos will use SemKeys for platform independance +/* + const uint16_t PROGMEM HUM_combo[] = {KC_F, KC_U, COMBO_END}; // Ü +const uint16_t PROGMEM HOM_combo[] = {KC_F, KC_O, COMBO_END}; // Ö +const uint16_t PROGMEM HUK_combo[] = {KC_L, KC_U, COMBO_END}; // Ů +const uint16_t PROGMEM HOK_combo[] = {KC_L, KC_O, COMBO_END}; // O̊ +const uint16_t PROGMEM HUV_combo[] = {KC_P, KC_U, COMBO_END}; // Û +const uint16_t PROGMEM HOV_combo[] = {KC_P, KC_O, COMBO_END}; // Ô +const uint16_t PROGMEM HUF_combo[] = {KC_V, KC_U, COMBO_END}; // Ú +const uint16_t PROGMEM HOF_combo[] = {KC_V, KC_O, COMBO_END}; // Ó + +const uint16_t PROGMEM HGRAV_E_combo[] = {LT(L_LANG_NUM, KC_T), KC_E, COMBO_END}; // É +const uint16_t PROGMEM HACUT_E_combo[] = {LGUI_T(KC_N), KC_E, COMBO_END}; // Ê +const uint16_t PROGMEM HDIER_E_combo[] = {LCTL_T(KC_S), KC_E, COMBO_END}; // Ë +const uint16_t PROGMEM HRING_E_combo[] = {LALT_T(KC_R), KC_E, COMBO_END}; // E̊ +const uint16_t PROGMEM HMACR_E_combo[] = {KC_M, KC_E, COMBO_END}; // Ē +*/ + + +combo_t key_combos[] = { + // These simple combos trigger on press, repeat. + [HC_EQL] = COMBO(Hequal_combo, KC_EQL), // = + [HC_SCLN] = COMBO(Hscln_combo, KC_SCLN), // ; + [HC_COLN] = COMBO(Hcoln_combo, KC_COLN), // : + [HC_UNDS] = COMBO(Hunds_combo, KC_UNDS), // _ + [HC_TILD] = COMBO(Htild_combo, KC_TILD), // ~ + [HC_TIC] = COMBO(Htic_combo, KC_GRV), // ` + [HC_EXLM] = COMBO(Hexlm_combo, KC_EXLM), // ! + [HC_QUES] = COMBO(Hques_combo, KC_QUES), // ? + [HC_AT] = COMBO(Hat_combo, KC_AT), // @ + [HC_TAB] = COMBO(Htab_combo, KC_TAB), + [QC_TAB] = COMBO(Qtab_combo, KC_TAB), + + [HC_I] = COMBO_ACTION(H_Icap_combo),// TYPE "I"+"'ve " + [HC_Id] = COMBO_ACTION(H_Id_combo),// TYPE "I'd " + [HC_Ill] = COMBO_ACTION(H_Ill_combo),// TYPE "I'll " + [HC_Im] = COMBO_ACTION(H_Im_combo),// TYPE "I'm " + [HC_J] = COMBO(H_J_combo, KC_J), + [HC_Q] = COMBO(H_Q_combo, KC_Q), + [HC_Z] = COMBO(H_Z_combo, KC_Z), + [HC_Ch] = COMBO_ACTION(H_Ch_combo), + [HC_Ph] = COMBO_ACTION(H_Ph_combo), + [HC_Th] = COMBO_ACTION(H_Th_combo), + [HC_Sh] = COMBO_ACTION(H_Sh_combo), + [HC_Wh] = COMBO_ACTION(H_Wh_combo), + + [PC_PENT] = COMBO(P3E_combo, KC_PENT), // on num + [PC_BSPC] = COMBO(P01_combo, KC_BSPC), // on num + [PC_DEL] = COMBO(P02_combo, KC_DEL), // on num + [PC_TAB] = COMBO(PCM1_combo, KC_TAB), // on num + + // action combos below + // This group have custom actions on trigger (no hold-delay), repeat if held + [HC_2DQUO] = COMBO_ACTION(Hdquo_combo), + + // this block should be contiguous, + // Delayed action (COMBO_HOLD threshold). No repeat if held (tap_code) + // should send the underlying combo keys if COMBO_HOLD is not met. + + // Keypad combos (all need actions or mods, so must be here) + [PC_STAB] = COMBO_ACTION(PCM2_combo), // shift- on num + [PC_TGNM] = COMBO_ACTION(PSLMN_combo), // toggle num layer + + [PC_SENT] = COMBO_ACTION(P2E_combo), // shift- on num + [PC_DASH] = COMBO_ACTION(P12_combo), // – for time span on number layer + [PC_TILD] = COMBO_ACTION(P13_combo), // ~ for time span on number layer + [PC_ELIP] = COMBO_ACTION(P23_combo), // … for time span on number layer + [PC_LPRN] = COMBO_ACTION(P45_combo), // ( on number layer + [PC_RPRN] = COMBO_ACTION(P56_combo), // ) on number layer + [PC_COLN] = COMBO_ACTION(P46_combo), // : on number layer for time 12:30xx + [PC_PERC] = COMBO_ACTION(P6PLS_combo), // % on numbers + [PC_DEG] = COMBO_ACTION(P5PLS_combo), // degree symbol on number layer + [PC_JYEN] = COMBO_ACTION(PS7_combo), // € + [PC_DOLR] = COMBO_ACTION(P78_combo), // $ + [PC_CENT] = COMBO_ACTION(P79_combo), // ¢ + [PC_EURO] = COMBO_ACTION(P89_combo), // ¥ + [PC_BPND] = COMBO_ACTION(P9M_combo), // £ + [PC_DIV] = COMBO_ACTION(PSLT_combo), // ÷ + [PC_PLMN] = COMBO_ACTION(PPLMN_combo), // ± + [PC_NEQL] = COMBO_ACTION(P1E_combo), // ≠ + [PC_CLR] = COMBO(P0E_combo, KC_C), // C for "CLEAR" + [PC_AC] = COMBO(PCME_combo, KC_ESC), // ESC for "ALL CLEAR" + [PC_PLMN] = COMBO_ACTION(PPLMN_combo), // ± + + [FC_ESC] = COMBO(F_ESC_combo, KC_ESC), // ESCape + [FC_KILL] = COMBO(F_KILL_combo, SK_KILL), // Force quit + [FC_SCAP] = COMBO(F_SCAP_combo, SK_SCAP), // SCREEN CAPTURE SELECTION + [FC_SCLP] = COMBO(F_SCLP_combo, SK_SCLP), // SCREEN CAPTURE SELECTION to clipboard + [FC_CAPS] = COMBO(F_CAPS_combo, KC_CAPS), // CAPS LOCK + [HC_CAPSWORD] = COMBO_ACTION(H_CAPS_combo), // CAPS_WORD + +// HANDSDOWN + [HC_NDSH] = COMBO_ACTION(Hndsh_combo), // – N-DASH + [HC_MDSH] = COMBO_ACTION(Hmdsh_combo), // — M-DASH + [HC_ACUT] = COMBO_ACTION(Hacut_combo), // ´ acute + [HC_GRV] = COMBO_ACTION(Hgrv_combo), // ` grave + [HC_CIRC] = COMBO_ACTION(Hcirc_combo), // ˆ circumflex + [HC_MACR] = COMBO_ACTION(Hmacr_combo), // - macron + [HC_DIER] = COMBO_ACTION(Hdier_combo), // ¨ dieresis + [HC_RING] = COMBO_ACTION(Hring_combo), // ˚ ring + [HC_ENYE] = COMBO_ACTION(Henye_combo), // ˜ enye + [HC_ELIP] = COMBO_ACTION(Helip_combo), // … +/* These will be handled by SemKeys + [HC_UM] = COMBO_ACTION(HUM_combo), // Ü + [HC_OM] = COMBO_ACTION(HOM_combo), // Ö + [HC_UK] = COMBO_ACTION(HUK_combo), // Ů + [HC_OK] = COMBO_ACTION(HOK_combo), // O̊ + [HC_UV] = COMBO_ACTION(HUM_combo), // Û + [HC_OV] = COMBO_ACTION(HOM_combo), // Ô + [HC_UF] = COMBO_ACTION(HUK_combo), // Ú + [HC_OF] = COMBO_ACTION(HOK_combo), // Ó + + [HC_1E] = COMBO_ACTION(H1E_combo), // É + [HC_2E] = COMBO_ACTION(H2E_combo), // Ē + [HC_3E] = COMBO_ACTION(H3E_combo), // Ê +*/ + + // Fast entry 4grams + [HC_ing_3gram] = COMBO_ACTION(H_ing_combo), // TYPE "ing" +// [HC_tion_4gram] = COMBO_ACTION(H_tion_combo), // TYPE "tion" #1 // handled via adaptive keys? + [HC_with_4gram] = COMBO_ACTION(H_with_combo), // TYPE "with" #5 + [HC_ment_4gram] = COMBO_ACTION(H_ment_combo), // TYPE "ment" #6 + [HC_this_4gram] = COMBO_ACTION(H_this_combo), // TYPE "this" #8 + [HC_here_4gram] = COMBO_ACTION(H_here_combo), // TYPE "here" #9 + [HC_ould_4gram] = COMBO_ACTION(H_ould_combo), // TYPE "ould" #11 + [HC_ting_4gram] = COMBO_ACTION(H_ting_combo), // TYPE "ting" #12 + [HC_they_4gram] = COMBO_ACTION(H_they_combo), // TYPE "they" #23 + [HC_ough_4gram] = COMBO_ACTION(H_ough_combo), // TYPE "ough" #25 + + // Fast entry 5-7grams + + [HC_their_5gram] = COMBO_ACTION(H_their_combo), // TYPE "their" #6 + [HC_there_5gram] = COMBO_ACTION(H_there_combo), // TYPE "there" #7 + [HC_where_5gram] = COMBO_ACTION(H_where_combo), // TYPE "where" + [HC_theyre_7gram] = COMBO_ACTION(H_theyre_combo), // TYPE "they're" + +/* Maybe not worth the possible misfire? + [HC_people_6gram] = COMBO_ACTION(H_people_combo), // TYPE "people" #23 + [HC_present_7gram] = COMBO_ACTION(H_present_combo), // TYPE "present" #1 + [HC_through_7gram] = COMBO_ACTION(H_through_combo), // TYPE "through" #3 + [HC_between_7gram] = COMBO_ACTION(H_between_combo), // TYPE "between" #4 +*/ + + [HC_TYPE_JAPAN] = COMBO_ACTION(H_Japan_combo), // a personally useful 5-8gram! + [MYMACRO] = COMBO_ACTION(Macro_combo), // a demonstrator, how long autotypes can be! + +// [HC_APP] = COMBO(Happ_combo, KC_APP), // app menu + [HC_SPC] = COMBO(Hspc_combo, KC_SPC), // SPACE + [HC_ENT] = COMBO(Hent_combo, KC_ENT), // ENTER + /* Uses SemKeys, even as simple combos (handled by process_semkey from process_record_user) */ + [HC_CLOZ] = COMBO(Hclose_combo, SK_CLOZ), + [HC_QUIT] = COMBO(Hquit_combo, SK_QUIT), + [HC_FIND] = COMBO(Hfind_combo, SK_FIND), + [HC_SALL] = COMBO(Hsall_combo, SK_SALL), + [HC_UNDO] = COMBO(Hundo_combo, SK_UNDO), + [HC_CUT] = COMBO(Hcut_combo, SK_CUT), + [HC_COPY] = COMBO(Hcopy_combo, SK_COPY), + [HC_PSTE] = COMBO(Hpste_combo, SK_PSTE), + [HC_PSTM] = COMBO(Hpstm_combo, SK_PSTM), + + +}; + +void process_combo_event(uint16_t combo_index, bool pressed) { +#ifdef OLED_DRIVER_ENABLE + oled_set_cursor(0, combo_OLED_row); +#endif + if (pressed) { +#ifdef OLED_DRIVER_ENABLE + oled_write_P(PSTR("Combo: "), false); +#endif + switch(combo_index) { + case PC_STAB ... COMBO_LENGTH: // these have a hold delay before triggering + combo_on = combo_index; // queue for matrix_scan_user_process_combo + break; + case HC_CAPSWORD: // turn on capsword (automatically turns off on delimiter) + toggle_caps_word(); + break; + + case HC_NDSH: + register_code16(A(KC_MINS)); + break; + case HC_MDSH: + register_code16(A(S(KC_MINS))); + break; + + + case HC_ing_3gram: // TYPE "ing" + SEND_STRING("ing"); + combo_on = combo_index; // may add "s " in matrix_scan_user_process_combo + break; +/* case HC_tion_4gram: // TYPE "tion" #1 + SEND_STRING("tion"); + break; +*/ + case HC_with_4gram: // TYPE "with" #5 + SEND_STRING("with"); + break; + case HC_ment_4gram: // TYPE "ment" #6 + SEND_STRING("ment"); + combo_on = combo_index; // may add "s " in matrix_scan_user_process_combo + break; + case HC_this_4gram: // TYPE "this" #8 + SEND_STRING("this "); + break; + case HC_here_4gram: // TYPE "here" #9 + SEND_STRING("here"); + combo_on = combo_index; // may add "s " in matrix_scan_user_process_combo + break; + case HC_ould_4gram: // TYPE "ould" #11 + SEND_STRING("ould"); + combo_on = combo_index; // may add "'ve " in matrix_scan_user_process_combo + break; + case HC_ting_4gram: // TYPE "ting" #12 + SEND_STRING("ting "); + break; + case HC_they_4gram: // TYPE "they" #23 + SEND_STRING("they"); + combo_on = combo_index; // may add "'ve " in matrix_scan_user_process_combo + break; + case HC_ough_4gram: // TYPE "ough" #25 + SEND_STRING("ough "); + break; + + case HC_their_5gram: // TYPE "their" #6 + SEND_STRING("their"); + combo_on = combo_index; // may add "'s " in matrix_scan_user_process_combo + break; + case HC_there_5gram: // TYPE "there" #7 + SEND_STRING("there"); + combo_on = combo_index; // may add "'s " in matrix_scan_user_process_combo + break; + case HC_where_5gram: // TYPE "where" // this should be a linger add text? + SEND_STRING("where"); + combo_on = combo_index; // may add "'s " in matrix_scan_user_process_combo + break; + + + case HC_TYPE_JAPAN: + SEND_STRING("Japan"); // send "Japan" right away + combo_on = combo_index; // may add "ese " in matrix_scan_user_process_combo + break; + case HC_Id: + SEND_STRING("I'd"); // send "I'd" right away + combo_on = combo_index; // may add "'ve " in matrix_scan_user_process_combo + break; + case HC_Ill: + SEND_STRING("I'll"); // send "I'll" right away + combo_on = combo_index; // may add "'ve " in matrix_scan_user_process_combo + break; + case HC_Im: + SEND_STRING("I'm "); // send "I'm " right away + break; + case HC_I: + tap_code16(S(KC_I)); // send "I" CAPITALIZED + combo_on = combo_index; // may add "'ve " in matrix_scan_user_process_combo + break; + case HC_Ch: + tap_code(KC_C); // send "C" honoring caps + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. + tap_code(KC_H); // send "h" honoring CAPSLK state + break; + case HC_Ph: + tap_code(KC_P); // send "P" honoring caps + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. + tap_code(KC_H); // send "h" honoring CAPSLK state + break; + case HC_Sh: + tap_code(KC_S); // send "S" honoring caps + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. + tap_code(KC_H); // send "h" honoring CAPSLK state + break; + case HC_Th: + tap_code(KC_T); // send "T" honoring caps + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. + tap_code(KC_H); // send "h" honoring CAPSLK state + break; + case HC_Wh: + tap_code(KC_W); // send "G" honoring caps + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. + tap_code(KC_H); // send "h" honoring CAPSLK state + break; + } // end switch (combo_index) + if (combo_on) linger_timer = timer_read(); // start timing for linger process + } else { // end if (pressed) this is the key up switch threshold not met. + +#ifdef OLED_DRIVER_ENABLE + oled_set_cursor(0,combo_OLED_row); + oled_write_P(PSTR(" "), false); +#endif +/* + This is the key up event +*/ + // make this smarter/smaller/faster. + // lookup keys to output from the key_combos[key_combos] table, bypassing this switch? + if (combo_on && !combo_triggered) {// no combo, so send the underlying keys +#ifdef OLED_DRIVER_ENABLE + oled_set_cursor(oled_max_chars() - 5, combo_OLED_row); + oled_write_P(PSTR("abort"), true); +#endif + switch(combo_index) { + case PC_DASH: + tap_code(KC_P1); + tap_code(KC_P2); + break; + case PC_TILD: + tap_code(KC_P1); + tap_code(KC_P3); + break; + case PC_ELIP: + tap_code(KC_P2); + tap_code(KC_P3); + break; + case PC_LPRN: + tap_code(KC_P4); + tap_code(KC_P5); + break; + case PC_RPRN: + tap_code(KC_P5); + tap_code(KC_P6); + break; + case PC_COLN: + tap_code(KC_P4); + tap_code(KC_P6); + break; + case PC_PERC: + tap_code(KC_P6); + tap_code(KC_PPLS); + break; + case PC_JYEN: + tap_code(KC_SLSH); + tap_code(KC_7); + break; + case PC_DOLR: + tap_code(KC_7); + tap_code(KC_8); + break; + case PC_CENT: + tap_code(KC_7); + tap_code(KC_9); + break; + case PC_EURO: + tap_code(KC_8); + tap_code(KC_9); + break; + + + case HC_I: + case HC_Id: + case HC_Ill: + case HC_ing_3gram: // TYPE "ing" + case HC_ment_4gram: // TYPE "ment" #6 + case HC_ting_4gram: // TYPE "ting" #12 + case HC_here_4gram: + case HC_ould_4gram: // TYPE "ould" #11 + case HC_they_4gram: // TYPE "they" #23 + case HC_their_5gram: // + case HC_there_5gram: // + case HC_where_5gram: // + case HC_TYPE_JAPAN: + SEND_STRING(" "); // + break; + } // end switch(combo_index) { + } else { + // Key up, threshold met, so we'll WRAP-UP the combo action if neccessary. + // unregister_code for repeating keys, etc. that weren't handled in matrix_scan_user + switch(combo_index) { + case HC_NDSH: + unregister_code16(A(KC_MINS)); + break; + case HC_MDSH: + unregister_code16(A(S(KC_MINS))); + break; + + } // end switch(combo_index) { + } // else if (threshold met) + combo_on = combo_triggered = false; + } // ELSE IF (pressed) meaning keyup +#ifdef OLED_DRIVER_ENABLE +// oled_render(); +#endif + return; +} + +void matrix_scan_user_process_combo() { // called from matrix_scan_user if combo_on +//extern uint8_t saved_mods; // global, so we're not wasting time allocating... + + // These combos are to be held for TAPPING_TERM before triggering + // to avoid accidental triggers while fast typing these common rolls. + // If repeats aren't deemed necessary, use tap_code here, otherwise register_code here + // and add unregister_code to the !pressed switch in process_combo_event above. + // Checking combo_triggered above can enable sending untriggered keys + // and thus allow for longer COMBO_TERM. (recommend < TAPPING_TERM / 2) + // still, really fast rolls, esp if they can go both ways, are going to be + // a problem for this (ex er, re; io oi), so maybe best to avoid them as + // combos. On Hands Down, this means no combos on home row, but that's fine, + // because home already has modifiers, so it all works out. + if (!combo_triggered) { + // do simple "on" on first press actions here: + + // then turn on combo state for hold acions to be resolved in keyup event above + // if necessary (like releasing the underlying keys, or other cleanup) + if (combo_on && (timer_elapsed(linger_timer) > COMBO_HOLD)) { + saved_mods = get_mods(); + clear_mods(); + switch(combo_on) { // combo_on is global, set in process_combo above + case PC_STAB: + tap_code16(S(KC_TAB)); + break; + case PC_TGNM: + layer_on(L_LANG_NUM); // toggle num layer + break; + case PC_SENT: + tap_code16(S(KC_ENT)); + break; + case PC_DASH: + tap_code16(A(KC_MINS)); + break; + case PC_TILD: + tap_code16(KC_TILD); + break; + case HC_ELIP: + case PC_ELIP: + tap_code16(A(KC_SCLN)); // this should use semkeys + break; + case PC_COLN: + tap_code16(KC_COLN); + break; + case PC_PERC: + tap_code16(KC_PERC); + break; + case PC_EURO: + tap_code16(A(S(KC_2))); + break; + case PC_DOLR: + tap_code16(S(KC_4)); + break; + case PC_CENT: + tap_code16(A(KC_4)); + break; + case PC_JYEN: + tap_code16(A(KC_Y)); + break; + case PC_BPND: + tap_code16(A(KC_3)); + break; + case PC_NEQL: + tap_code16(A(KC_EQL)); + break; + case PC_DIV: + tap_code16(A(KC_SLSH)); + break; + case PC_PLMN: + tap_code16(A(S(KC_EQL))); + break; + case PC_DEG: + tap_code16(A(KC_0)); + break; + case PC_LPRN: + tap_code16(KC_LPRN); + break; + case PC_RPRN: + tap_code16(KC_RPRN); + break; + + + case HC_2DQUO: // "|" + tap_code16(A(KC_LBRC)); + tap_code16(A(S(KC_LBRC))); + tap_code(KC_LEFT); + break; + + case HC_ENYE: + tap_code16(A(KC_N)); + break; + case HC_ACUT: + tap_code16(A(KC_E)); + break; + case HC_GRV: + tap_code16(A(KC_GRV)); + break; + case HC_CIRC: + tap_code16(A(KC_6)); + break; + case HC_MACR: + tap_code16(A(KC_A)); + break; + case HC_DIER: + tap_code16(A(KC_U)); + break; + case HC_RING: + tap_code16(A(KC_K)); + break; + + case MYMACRO: + SEND_STRING("End of times in 2020\n"); // some random demonstrator + break; + case HC_ing_3gram: // TYPE "ing" + case HC_ment_4gram: // TYPE "ment" #6 + case HC_ting_4gram: // TYPE "ting" #12 + SEND_STRING("s "); + break; + case HC_I: // TYPE "'ve " // should it be I'd? Stats on this? + case HC_Id: // + case HC_Ill: // + case HC_Im: // + case HC_ould_4gram: // TYPE "ould " #11 + case HC_they_4gram: // TYPE "they " #23 + SEND_STRING("'ve "); // or should it be "'nt"? + break; + case HC_here_4gram: + case HC_their_5gram: // TYPE "their" #6 + case HC_there_5gram: // TYPE "there" #7 + case HC_where_5gram: // + SEND_STRING("'s "); + break; + case HC_TYPE_JAPAN: // already "Japan" has been sent; if held, add "ese" + SEND_STRING("ese "); + break; + + } // switch + set_mods(saved_mods); // Restore mods + combo_triggered = true; + #ifdef OLED_DRIVER_ENABLE + oled_set_cursor(oled_max_chars() - 5, combo_OLED_row); + oled_write_P(PSTR(" sent"), false); + #endif + } // if (combo_on) { + } +} diff --git a/moutis_COMBO_hd_platinum.c b/moutis_COMBO_hd_platinum.c new file mode 100644 index 0000000..1353b1a --- /dev/null +++ b/moutis_COMBO_hd_platinum.c @@ -0,0 +1,790 @@ + +// functions / state keys + +uint16_t COMBO_LEN = COMBO_LENGTH; + +const uint16_t PROGMEM F_ESC_combo[] = {KC_QUOT, KC_B, COMBO_END}; // ESCape +const uint16_t PROGMEM F_KILL_combo[] = {KC_X, KC_QUOT, COMBO_END}; // Force quit OR CTRL-ALT-DEL +const uint16_t PROGMEM F_SCLP_combo[] = {KC_W, KC_V, COMBO_END}; // SCREEN shot SELECTION to clipboard +const uint16_t PROGMEM F_SCAP_combo[] = {KC_W, KC_K, COMBO_END}; // SCREEN shot SELECTION to file +const uint16_t PROGMEM F_CAPS_combo[] = {KC_D, KC_U, COMBO_END}; // CAPS LOCK (on until hit again) +//const uint16_t PROGMEM H_CAPS_combo[] = {LSFT_T(KC_BSPC), RSFT_T(KC_ENT), COMBO_END}; // CAPS WORD (on until delimiter) +const uint16_t PROGMEM H_CAPS_combo[] = {LSFT_T(KC_T), RSFT_T(KC_A), COMBO_END}; // CAPS WORD (on until delimiter) + +// (22) keypad combos +const uint16_t PROGMEM PSLMN_combo[] = {KC_PSLS, KC_PMNS, COMBO_END}; // toggle num layer +const uint16_t PROGMEM P0E_combo[] = {KC_P0, KC_PEQL, COMBO_END}; +const uint16_t PROGMEM PCME_combo[] = {KC_DOT, KC_PEQL, COMBO_END}; +const uint16_t PROGMEM PCM1_combo[] = {KC_DOT, KC_P1, COMBO_END}; +const uint16_t PROGMEM PCM2_combo[] = {KC_DOT, KC_P2, COMBO_END}; +const uint16_t PROGMEM P01_combo[] = {KC_P0, KC_P1, COMBO_END}; +const uint16_t PROGMEM P02_combo[] = {KC_P0, KC_P2, COMBO_END}; +const uint16_t PROGMEM P04_combo[] = {KC_P0, KC_P4, COMBO_END}; +const uint16_t PROGMEM P05_combo[] = {KC_P0, KC_P5, COMBO_END}; +const uint16_t PROGMEM P12_combo[] = {KC_P1, KC_P2, COMBO_END}; +const uint16_t PROGMEM P23_combo[] = {KC_P2, KC_P3, COMBO_END}; +const uint16_t PROGMEM P13_combo[] = {KC_P1, KC_P3, COMBO_END}; +const uint16_t PROGMEM P1E_combo[] = {KC_P1, KC_PEQL, COMBO_END}; +const uint16_t PROGMEM P2E_combo[] = {KC_P2, KC_PEQL, COMBO_END}; +const uint16_t PROGMEM P3E_combo[] = {KC_P3, KC_PEQL, COMBO_END}; +const uint16_t PROGMEM P45_combo[] = {KC_P4, KC_P5, COMBO_END}; +const uint16_t PROGMEM P56_combo[] = {KC_P5, KC_P6, COMBO_END}; +const uint16_t PROGMEM P46_combo[] = {KC_P4, KC_P6, COMBO_END}; +const uint16_t PROGMEM P5PLS_combo[] = {KC_P5, KC_PPLS, COMBO_END}; +const uint16_t PROGMEM P6PLS_combo[] = {KC_P6, KC_PPLS, COMBO_END}; +const uint16_t PROGMEM PS7_combo[] = {KC_PSLS, KC_P7, COMBO_END}; +const uint16_t PROGMEM P78_combo[] = {KC_P7, KC_P8, COMBO_END}; +const uint16_t PROGMEM P79_combo[] = {KC_P7, KC_P9, COMBO_END}; +const uint16_t PROGMEM P89_combo[] = {KC_P8, KC_P9, COMBO_END}; +const uint16_t PROGMEM P9M_combo[] = {KC_P9, KC_PMNS, COMBO_END}; +const uint16_t PROGMEM PSLT_combo[] = {KC_P7, KC_PMNS, COMBO_END}; +const uint16_t PROGMEM PPLMN_combo[] = {KC_P4, KC_PPLS, COMBO_END}; + + +// Off map and other letter/symbol thingies typically on keyboard + + +// RIGHT HAND +// LOWER ROW + +const uint16_t PROGMEM Hndsh_combo[] = {KC_MINS, KC_U, COMBO_END}; // – n dash +const uint16_t PROGMEM Hmdsh_combo[] = {KC_MINS, KC_O, COMBO_END}; // — m dash +const uint16_t PROGMEM Hunds_combo[] = {KC_U, KC_Y, COMBO_END}; // _ underscore +const uint16_t PROGMEM Htild_combo[] = {KC_MINS, KC_Y, COMBO_END}; // ~ tilde (not the dead one) +const uint16_t PROGMEM Hequal_combo[] = {KC_Y, KC_X, COMBO_END}; // = equal +const uint16_t PROGMEM Hscln_combo[] = {KC_COMM, RSFT_T(KC_A), COMBO_END}; // ; semicolon + +// spatially arranged characters and diacritics +const uint16_t PROGMEM Hexlm_combo[] = {KC_DOT, KC_SLSH, COMBO_END}; // ! +const uint16_t PROGMEM Hques_combo[] = {KC_SLSH, KC_DQUO, COMBO_END}; // ? +const uint16_t PROGMEM Hat_combo[] = {KC_HASH, KC_DOT, COMBO_END}; // @ at mark +const uint16_t PROGMEM Helip_combo[] = {KC_HASH, KC_SLSH, COMBO_END}; // … elipses +const uint16_t PROGMEM Htic_combo[] = {KC_GRV, KC_DQUO, COMBO_END}; // ` tic (not dead key grave) +const uint16_t PROGMEM Hacut_combo[] = {KC_GRV, KC_SLSH, COMBO_END}; // ´ acute (dead key) +const uint16_t PROGMEM Hgrv_combo[] = {KC_HASH, KC_DQUO, COMBO_END}; // ` grave (dead key) +const uint16_t PROGMEM Hmacr_combo[] = {KC_DOT, KC_DQUO, COMBO_END}; // - macron (dead key)ā +const uint16_t PROGMEM Hcirc_combo[] = {KC_J, KC_DOT, COMBO_END}; // ˆ circumflex (dead key) +const uint16_t PROGMEM Hdier_combo[] = {KC_U, KC_O, COMBO_END}; // ¨ dieresis (dead key) +const uint16_t PROGMEM Hring_combo[] = {KC_O, KC_X, COMBO_END}; // ˚ ring (dead key) +const uint16_t PROGMEM Henye_combo[] = {KC_G, KC_P, COMBO_END}; // ˜ enye (dead key) (over N) + +// LOWER ROW +// SYMBOLS spatially arranged + +// LEFT HAND + +// TEXT ENTRY - off map (ANY ROW/ MIXED ROWS) and row jump prevention +const uint16_t PROGMEM H_J_combo[] = {KC_O, KC_Y, COMBO_END}; // TYPE "j" +const uint16_t PROGMEM H_Z_combo[] = {KC_G, KC_H, COMBO_END}; // TYPE "z" +const uint16_t PROGMEM H_Q_combo[] = {KC_W, KC_G, COMBO_END}; // TYPE "q" +const uint16_t PROGMEM H_Q2_combo[] = {KC_U, KC_X, COMBO_END}; // TYPE "q" + +const uint16_t PROGMEM H_Ph_combo[] = {KC_H, KC_P, COMBO_END}; // TYPE "ph" +const uint16_t PROGMEM H_Th_combo[] = {LGUI_T(KC_N), LSFT_T(KC_T), COMBO_END}; // "th" +const uint16_t PROGMEM H_Sh_combo[] = {LALT_T(KC_S), LGUI_T(KC_N), COMBO_END}; // "sh" + +const uint16_t PROGMEM H_ing_combo[] = {RALT_T(KC_I), KC_G, COMBO_END}; // TYPE "ing" only a 3gram, let's see if it's worth it + +// Fast 4grams +// FOR THUMB SHIFT +/* +const uint16_t PROGMEM H_tion_combo[] = {LGUI_T(KC_N), LT(L_LANG_NUM, KC_T), COMBO_END}; // "tion" #1 +const uint16_t PROGMEM H_with_combo[] = {KC_W, LSFT_T(KC_H), COMBO_END}; // "with" #5 +const uint16_t PROGMEM H_ment_combo[] = {KC_M, LT(L_LANG_NUM, KC_T), COMBO_END}; // "ment" #6 +const uint16_t PROGMEM H_this_combo[] = {LT(L_LANG_NUM, KC_T), LALT_T(KC_S), COMBO_END}; // "this" #8 +const uint16_t PROGMEM H_here_combo[] = {LSFT(KC_H), RCTL_T(KC_R), COMBO_END}; // "here" #9 +const uint16_t PROGMEM H_ould_combo[] = {KC_O, KC_D, COMBO_END}; // "ould" #11 +const uint16_t PROGMEM H_ting_combo[] = {LT(L_LANG_NUM, KC_T), KC_G, COMBO_END}; // "ting" #12 +const uint16_t PROGMEM H_sion_combo[] = {LALT_T(KC_S), LGUI_T(KC_N), COMBO_END}; // "sion" #20 +const uint16_t PROGMEM H_they_combo[] = {LT(L_LANG_NUM, KC_T), KC_J, COMBO_END}; // "they" #23 +const uint16_t PROGMEM H_their_combo[] = {LT(L_LANG_NUM, KC_T), KC_X, COMBO_END}; // "their" #6 +const uint16_t PROGMEM H_there_combo[] = {LT(L_LANG_NUM, KC_T), LCTL_T(KC_R), COMBO_END}; // "there" #7 +const uint16_t PROGMEM H_ough_combo[] = {KC_O, LSFT_T(KC_H), COMBO_END}; // "ough" #25 + */ +// FOR INDEX SHIFT + +//const uint16_t PROGMEM H_tion_combo[] = {LGUI_T(KC_N), LSFT_T(KC_T), COMBO_END}; // "tion" #1 +const uint16_t PROGMEM H_with_combo[] = {KC_W, LSFT_T(KC_T), COMBO_END}; // "with" #5 +const uint16_t PROGMEM H_ment_combo[] = {KC_M, LSFT_T(KC_T), COMBO_END}; // "ment" #6 +const uint16_t PROGMEM H_this_combo[] = {LSFT_T(KC_T), LALT_T(KC_S), COMBO_END}; // "this" #8 +const uint16_t PROGMEM H_here_combo[] = {KC_H, RGUI_T(KC_E), COMBO_END}; // "here" #9 +const uint16_t PROGMEM H_ould_combo[] = {KC_O, KC_D, COMBO_END}; // "ould" #11 +const uint16_t PROGMEM H_ting_combo[] = {LSFT_T(KC_T), KC_G, COMBO_END}; // "ting" #12 +const uint16_t PROGMEM H_they_combo[] = {LSFT_T(KC_T), KC_Y, COMBO_END}; // "they" #23 +const uint16_t PROGMEM H_ough_combo[] = {KC_O, KC_F, COMBO_END}; // "ough" #25 + + +// Fast 5-7grams + +const uint16_t PROGMEM H_their_combo[] = {LSFT_T(KC_T), RCTL_T(KC_R), COMBO_END}; // TYPE "their" #6 +const uint16_t PROGMEM H_there_combo[] = {LSFT_T(KC_T), KC_X, COMBO_END}; // TYPE "there" #7 +/*const uint16_t PROGMEM H_people_combo[] = {KC_P, RGUI_T(KC_E), COMBO_END}; // TYPE "people" #23 +const uint16_t PROGMEM H_present_combo[] = {KC_P, LSFT_T(KC_T), COMBO_END}; // TYPE "present" #1 +const uint16_t PROGMEM H_through_combo[] = {LSFT_T(KC_T), LT(L_MEDIA_NAV,KC_H), COMBO_END}; // TYPE "through" #3 +const uint16_t PROGMEM H_between_combo[] = {KC_B, LGUI_T(KC_N), COMBO_END}; // TYPE "between" #4 +*/ + +/* other examples or text entry combos */ +const uint16_t PROGMEM H_Japan_combo[] = {KC_Y, KC_P, COMBO_END}; // TYPE "Japan" +const uint16_t PROGMEM Macro_combo[] = {KC_G, KC_F, COMBO_END}; // some macro placeholder + +// UPPER ROW + +// FUNCTIONS Spatially arranged +const uint16_t PROGMEM Qtab_combo[] = {KC_Q, KC_W, COMBO_END}; // tab QWERTY +const uint16_t PROGMEM Htab_combo[] = {LCTL_T(KC_C), LALT_T(KC_S), COMBO_END}; // tab HANDS DOWN +const uint16_t PROGMEM Hent_combo[] = {LSFT_T(KC_T), KC_K, COMBO_END}; // ENTER +const uint16_t PROGMEM Hspc_combo[] = {KC_P, KC_K, COMBO_END}; // SPACE + +// LOWER ROW + +// SEMANTIC FUNCTIONS Spatially arranged ** uses SemKeys ** +const uint16_t PROGMEM Hclose_combo[] = {KC_H, KC_K, COMBO_END}; // close +const uint16_t PROGMEM Hquit_combo[] = {KC_G, KC_K, COMBO_END}; // quit +const uint16_t PROGMEM Hfind_combo[] = {KC_H, LT(L_MEDIA_NAV, KC_L), COMBO_END}; // find sel +const uint16_t PROGMEM Hsall_combo[] = {KC_QUOT, KC_D, COMBO_END}; // select all +const uint16_t PROGMEM Hundo_combo[] = {KC_QUOT, KC_F, COMBO_END}; // undo +const uint16_t PROGMEM Hcut_combo[] = {KC_QUOT, KC_M, COMBO_END}; // cut +const uint16_t PROGMEM Hcopy_combo[] = {KC_F, KC_M, COMBO_END}; // copy +const uint16_t PROGMEM Hpste_combo[] = {KC_M, KC_D, COMBO_END}; // paste +const uint16_t PROGMEM Hpstm_combo[] = {KC_F, KC_D, COMBO_END}; // paste-match + +// TWO HANDS +const uint16_t PROGMEM Hdquo_combo[] = {KC_HASH, KC_J, COMBO_END}; // "|" insert between double quote +const uint16_t PROGMEM Hdbrc_combo[] = {KC_MINS, KC_X, COMBO_END}; // [|] insert between double BRACKET + +// Major diacritic combos will use SemKeys for platform independance +/* + const uint16_t PROGMEM HUM_combo[] = {KC_F, KC_U, COMBO_END}; // Ü +const uint16_t PROGMEM HOM_combo[] = {KC_F, KC_O, COMBO_END}; // Ö +const uint16_t PROGMEM HUK_combo[] = {KC_L, KC_U, COMBO_END}; // Ů +const uint16_t PROGMEM HOK_combo[] = {KC_L, KC_O, COMBO_END}; // O̊ +const uint16_t PROGMEM HUV_combo[] = {KC_P, KC_U, COMBO_END}; // Û +const uint16_t PROGMEM HOV_combo[] = {KC_P, KC_O, COMBO_END}; // Ô +const uint16_t PROGMEM HUF_combo[] = {KC_V, KC_U, COMBO_END}; // Ú +const uint16_t PROGMEM HOF_combo[] = {KC_V, KC_O, COMBO_END}; // Ó + +const uint16_t PROGMEM HGRAV_E_combo[] = {LT(L_LANG_NUM, KC_T), KC_E, COMBO_END}; // É +const uint16_t PROGMEM HACUT_E_combo[] = {LGUI_T(KC_N), KC_E, COMBO_END}; // Ê +const uint16_t PROGMEM HDIER_E_combo[] = {LCTL_T(KC_S), KC_E, COMBO_END}; // Ë +const uint16_t PROGMEM HRING_E_combo[] = {LALT_T(KC_R), KC_E, COMBO_END}; // E̊ +const uint16_t PROGMEM HMACR_E_combo[] = {KC_M, KC_E, COMBO_END}; // Ē +*/ + + +combo_t key_combos[] = { + // These simple combos trigger on press, repeat. + [HC_EQL] = COMBO(Hequal_combo, KC_EQL), // = + [HC_SCLN] = COMBO(Hscln_combo, KC_SCLN), // ; + [HC_UNDS] = COMBO(Hunds_combo, KC_UNDS), // _ + [HC_TILD] = COMBO(Htild_combo, KC_TILD), // ~ + [HC_TIC] = COMBO(Htic_combo, KC_GRV), // ` + [HC_EXLM] = COMBO(Hexlm_combo, KC_EXLM), // ! + [HC_QUES] = COMBO(Hques_combo, KC_QUES), // ? + [HC_AT] = COMBO(Hat_combo, KC_AT), // @ + [HC_TAB] = COMBO(Htab_combo, KC_TAB), + [QC_TAB] = COMBO(Qtab_combo, KC_TAB), + + [HC_J] = COMBO(H_J_combo, KC_J), + [HC_Q] = COMBO_ACTION(H_Q_combo), + [HC_Q2] = COMBO_ACTION(H_Q2_combo), + [HC_Z] = COMBO(H_Z_combo, KC_Z), + [HC_Ph] = COMBO_ACTION(H_Ph_combo), + [HC_Th] = COMBO_ACTION(H_Th_combo), + [HC_Sh] = COMBO_ACTION(H_Sh_combo), + + + [PC_PENT] = COMBO(P3E_combo, KC_PENT), // on num + [PC_BSPC] = COMBO(P01_combo, KC_BSPC), // on num + [PC_DEL] = COMBO(P02_combo, KC_DEL), // on num + [PC_TAB] = COMBO(PCM1_combo, KC_TAB), // on num + + // action combos below + // This group have custom actions on trigger (no hold-delay), repeat if held + [HC_2DQUO] = COMBO_ACTION(Hdquo_combo), + [HC_2DBRC] = COMBO_ACTION(Hdbrc_combo), + + // this block should be contiguous, + // Delayed action (COMBO_HOLD threshold). No repeat if held (tap_code) + // should send the underlying combo keys if COMBO_HOLD is not met. + + // Keypad combos (all need actions or mods, so must be here) + [PC_STAB] = COMBO_ACTION(PCM2_combo), // shift- on num + [PC_TGNM] = COMBO_ACTION(PSLMN_combo), // toggle num layer + + [PC_SENT] = COMBO_ACTION(P2E_combo), // shift- on num + [PC_DASH] = COMBO_ACTION(P12_combo), // – for time span on number layer + [PC_TILD] = COMBO_ACTION(P13_combo), // ~ for time span on number layer + [PC_ELIP] = COMBO_ACTION(P23_combo), // … for time span on number layer + [PC_LPRN] = COMBO_ACTION(P45_combo), // ( on number layer + [PC_RPRN] = COMBO_ACTION(P56_combo), // ) on number layer + [PC_COLN] = COMBO_ACTION(P46_combo), // : on number layer for time 12:30xx + [PC_PERC] = COMBO_ACTION(P6PLS_combo), // % on numbers + [PC_DEG] = COMBO_ACTION(P5PLS_combo), // degree symbol on number layer + [PC_JYEN] = COMBO_ACTION(PS7_combo), // € + [PC_DOLR] = COMBO_ACTION(P78_combo), // $ + [PC_CENT] = COMBO_ACTION(P79_combo), // ¢ + [PC_EURO] = COMBO_ACTION(P89_combo), // ¥ + [PC_BPND] = COMBO_ACTION(P9M_combo), // £ + [PC_DIV] = COMBO_ACTION(PSLT_combo), // ÷ + [PC_PLMN] = COMBO_ACTION(PPLMN_combo), // ± + [PC_NEQL] = COMBO_ACTION(P1E_combo), // ≠ + [PC_CLR] = COMBO(P0E_combo, KC_C), // C for "CLEAR" + [PC_AC] = COMBO(PCME_combo, KC_ESC), // ESC for "ALL CLEAR" + [PC_PLMN] = COMBO_ACTION(PPLMN_combo), // ± + + [FC_ESC] = COMBO(F_ESC_combo, KC_ESC), // ESCape + [FC_KILL] = COMBO_ACTION(F_KILL_combo), // Force quit + [FC_SCAP] = COMBO_ACTION(F_SCAP_combo), // SCREEN CAPTURE SELECTION + [FC_SCLP] = COMBO_ACTION(F_SCLP_combo), // SCREEN CAPTURE SELECTION to clipboard + [FC_CAPS] = COMBO(F_CAPS_combo, KC_CAPS), // CAPS LOCK + [HC_CAPSWORD] = COMBO_ACTION(H_CAPS_combo), // CAPS_WORD + +// HANDSDOWN + [HC_NDSH] = COMBO_ACTION(Hndsh_combo), // – N-DASH + [HC_MDSH] = COMBO_ACTION(Hmdsh_combo), // — M-DASH + [HC_ACUT] = COMBO_ACTION(Hacut_combo), // ´ acute + [HC_GRV] = COMBO_ACTION(Hgrv_combo), // ` grave + [HC_CIRC] = COMBO_ACTION(Hcirc_combo), // ˆ circumflex + [HC_MACR] = COMBO_ACTION(Hmacr_combo), // - macron + [HC_DIER] = COMBO_ACTION(Hdier_combo), // ¨ dieresis + [HC_RING] = COMBO_ACTION(Hring_combo), // ˚ ring + [HC_ENYE] = COMBO_ACTION(Henye_combo), // ˜ enye + [HC_ELIP] = COMBO_ACTION(Helip_combo), // … + [HC_EQL] = COMBO(Hequal_combo, KC_EQL), // = +/* + [HC_UM] = COMBO_ACTION(HUM_combo), // Ü + [HC_OM] = COMBO_ACTION(HOM_combo), // Ö + [HC_UK] = COMBO_ACTION(HUK_combo), // Ů + [HC_OK] = COMBO_ACTION(HOK_combo), // O̊ + [HC_UV] = COMBO_ACTION(HUM_combo), // Û + [HC_OV] = COMBO_ACTION(HOM_combo), // Ô + [HC_UF] = COMBO_ACTION(HUK_combo), // Ú + [HC_OF] = COMBO_ACTION(HOK_combo), // Ó + + [HC_1E] = COMBO_ACTION(H1E_combo), // É + [HC_2E] = COMBO_ACTION(H2E_combo), // Ē + [HC_3E] = COMBO_ACTION(H3E_combo), // Ê +*/ + + // Fast entry 4grams + [HC_ing_3gram] = COMBO_ACTION(H_ing_combo), // TYPE "ing" +// [HC_tion_4gram] = COMBO_ACTION(H_tion_combo), // TYPE "tion" #1 + [HC_with_4gram] = COMBO_ACTION(H_with_combo), // TYPE "with" #5 + [HC_ment_4gram] = COMBO_ACTION(H_ment_combo), // TYPE "ment" #6 + [HC_this_4gram] = COMBO_ACTION(H_this_combo), // TYPE "this" #8 + [HC_here_4gram] = COMBO_ACTION(H_here_combo), // TYPE "here" #9 + [HC_ould_4gram] = COMBO_ACTION(H_ould_combo), // TYPE "ould" #11 + [HC_ting_4gram] = COMBO_ACTION(H_ting_combo), // TYPE "ting" #12 + [HC_they_4gram] = COMBO_ACTION(H_they_combo), // TYPE "they" #23 + [HC_ough_4gram] = COMBO_ACTION(H_ough_combo), // TYPE "ough" #25 + + // Fast entry 5-7grams + + [HC_their_5gram] = COMBO_ACTION(H_their_combo), // TYPE "their" #6 + [HC_there_5gram] = COMBO_ACTION(H_there_combo), // TYPE "there" #7 + +/* + [HC_people_6gram] = COMBO_ACTION(H_people_combo), // TYPE "people" #23 + [HC_present_7gram] = COMBO_ACTION(H_present_combo), // TYPE "present" #1 + [HC_through_7gram] = COMBO_ACTION(H_through_combo), // TYPE "through" #3 + [HC_between_7gram] = COMBO_ACTION(H_between_combo), // TYPE "between" #4 +*/ + + [HC_TYPE_JAPAN] = COMBO_ACTION(H_Japan_combo), // a personally useful 5-8gram! + [MYMACRO] = COMBO_ACTION(Macro_combo), // a demonstrator, how long autotypes can be! + +/* Uses SemKeys */ +// [HC_APP] = COMBO(Happ_combo, KC_APP), // app menu + [HC_SPC] = COMBO(Hspc_combo, KC_SPC), // SPACE + [HC_ENT] = COMBO(Hent_combo, KC_ENT), // ENTER + [HC_CLOZ] = COMBO_ACTION(Hclose_combo), + [HC_QUIT] = COMBO_ACTION(Hquit_combo), + [HC_FIND] = COMBO_ACTION(Hfind_combo), // Find the selection (COPY, FIND, PASTE) + [HC_SALL] = COMBO_ACTION(Hsall_combo), + [HC_UNDO] = COMBO_ACTION(Hundo_combo), + [HC_CUT] = COMBO_ACTION(Hcut_combo), + [HC_COPY] = COMBO_ACTION(Hcopy_combo), + [HC_PSTE] = COMBO_ACTION(Hpste_combo), + [HC_PSTM] = COMBO_ACTION(Hpstm_combo), +}; + +void process_combo_event(uint16_t combo_index, bool pressed) { +#ifdef OLED_DRIVER_ENABLE + oled_set_cursor(0, combo_OLED_row); +#endif + if (pressed) { +#ifdef OLED_DRIVER_ENABLE + oled_write_P(PSTR("Combo: "), false); +#endif + linger_timer = timer_read(); // UPDATE timer for combo hold threshold + switch(combo_index) { + case PC_STAB ... COMBO_LENGTH: // these have a hold delay before triggering + combo_on = combo_index; // queue for matrix_scan_user_process_combo + break; + case HC_CAPSWORD: // turn on capsword (automatically turns off on delimiter) + toggle_caps_word(); + break; + + case HC_NDSH: + register_code16(A(KC_MINS)); + break; + case HC_MDSH: + register_code16(A(S(KC_MINS))); + break; + + + case HC_ing_3gram: // TYPE "ing" + SEND_STRING("ing"); + break; + case HC_tion_4gram: // TYPE "tion" #1 + SEND_STRING("th"); + break; + case HC_with_4gram: // TYPE "with" #5 + SEND_STRING("with"); + break; + case HC_ment_4gram: // TYPE "ment" #6 + SEND_STRING("ment"); + break; + case HC_this_4gram: // TYPE "this" #8 + SEND_STRING("this"); + break; + case HC_here_4gram: // TYPE "here" #9 + SEND_STRING("here"); + break; + case HC_ould_4gram: // TYPE "ould" #11 + SEND_STRING("ould"); + break; + case HC_ting_4gram: // TYPE "ting" #12 + SEND_STRING("ting"); + break; + case HC_they_4gram: // TYPE "they" #23 + SEND_STRING("they"); + break; + case HC_ough_4gram: // TYPE "ough" #25 + SEND_STRING("ough"); + break; + + case HC_their_5gram: // TYPE "their" #6 + SEND_STRING("their"); + break; + case HC_there_5gram: // TYPE "there" #7 + SEND_STRING("there"); + break; +/* + case HC_people_6gram: // TYPE "people" #23 + SEND_STRING("people"); + break; + case HC_present_7gram: // TYPE "present" #1 + SEND_STRING("present"); + break; + case HC_through_7gram: // TYPE "through" #3 + SEND_STRING("through"); + break; + case HC_between_7gram: // TYPE "between" #4 + SEND_STRING("between"); + break; +*/ + + + case HC_TYPE_JAPAN: + SEND_STRING("Japan"); // send "Japan" right away + combo_on = combo_index; // may add "ese" in matrix_scan_user_process_combo + break; + case HC_Q: + case HC_Q2: + SEND_STRING("q"); // send "q" right away + combo_on = combo_index; // may add "u" in matrix_scan_user_process_combo + break; + case HC_Ph: + SEND_STRING("ph"); // send right away (adaptive PH sends PL) + break; + case HC_Sh: + SEND_STRING("sh"); // send right away + break; + case HC_Th: + SEND_STRING("th"); // send right away + break; + } // end switch (combo_index) + } else { // end if (pressed) + +#ifdef OLED_DRIVER_ENABLE + oled_set_cursor(0,combo_OLED_row); + oled_write_P(PSTR(" "), false); +#endif +/*/ + This is the NOT pressed switch (ie. it is the key up event) +/*/ + // make this smarter/smaller/faster. + // lookup keys to output from the key_combos[key_combos] table, bypassing this switch + if (combo_on && !combo_triggered) {// no combo, so send the underlying keys +#ifdef OLED_DRIVER_ENABLE + oled_set_cursor(oled_max_chars() - 5, combo_OLED_row); + oled_write_P(PSTR("abort"), true); +#endif + switch(combo_index) { + case PC_DASH: + tap_code(KC_P1); + tap_code(KC_P2); + break; + case PC_TILD: + tap_code(KC_P1); + tap_code(KC_P3); + break; + case PC_ELIP: + tap_code(KC_P2); + tap_code(KC_P3); + break; + case PC_LPRN: + tap_code(KC_P4); + tap_code(KC_P5); + break; + case PC_RPRN: + tap_code(KC_P5); + tap_code(KC_P6); + break; + case PC_COLN: + tap_code(KC_P4); + tap_code(KC_P6); + break; + case PC_PERC: + tap_code(KC_P6); + tap_code(KC_PPLS); + break; + case PC_JYEN: + tap_code(KC_SLSH); + tap_code(KC_7); + break; + case PC_DOLR: + tap_code(KC_7); + tap_code(KC_8); + break; + case PC_CENT: + tap_code(KC_7); + tap_code(KC_9); + break; + case PC_EURO: + tap_code(KC_8); + tap_code(KC_9); + break; + +/* + case HC_UM: // Ü + SEND_STRING("mu"); + break; + case HC_OM: // Ö + SEND_STRING("mo"); + break; + case HC_UK: // Ů + SEND_STRING("ku"); + break; + case HC_OK: // O̊ + SEND_STRING("ko"); + break; + case HC_UV: // Û + SEND_STRING("vu"); + break; + case HC_OV: // Ô + SEND_STRING("vo"); + break; + case HC_UF: // Ú + SEND_STRING("fu"); + break; + case HC_OF: // Ó + SEND_STRING("fo"); + break; + + case HC_1E: // É + SEND_STRING("pe"); + break; + case HC_2E: // Ē + SEND_STRING("me"); + break; + case HC_3E: // Ê + SEND_STRING("fe"); + break; +*/ + + case HC_SALL: + SEND_STRING("xd"); + break; + case HC_UNDO: + SEND_STRING("xg"); + break; + case HC_CUT: + SEND_STRING("xl"); + break; + case HC_COPY: + SEND_STRING("gl"); + break; + case HC_PSTE: + SEND_STRING("ld"); + break; + case HC_PSTM: + SEND_STRING("gd"); + break; + } // end switch(combo_index) { + } else { + // Key up, threshold met, so we'll WRAP-UP the combo action if neccessary. + // unregister_code for repeating keys, etc. that weren't handled in matrix_scan_user + switch(combo_index) { + case HC_NDSH: + unregister_code16(A(KC_MINS)); + break; + case HC_MDSH: + unregister_code16(A(S(KC_MINS))); + break; + + case HC_CLOZ: + unregister_SemKey(SK_CLOZ); + break; + case HC_QUIT: + unregister_SemKey(SK_QUIT); + break; + case HC_UNDO: + unregister_SemKey(SK_UNDO); + break; + case HC_PSTE: + unregister_SemKey(SK_PSTE); + break; + case HC_PSTM: + unregister_SemKey(SK_PSTM); + break; + } // end switch(combo_index) { + } // else if (threshold met) + combo_on = combo_triggered = false; + } // ELSE IF (pressed) meaning keyup +#ifdef OLED_DRIVER_ENABLE +// oled_render(); +#endif + return; +} + +void matrix_scan_user_process_combo() { // called from matrix_scan_user +extern uint8_t saved_mods; // global, so we're not wasting time allocating... + + // These combos are to be held for TAPPING_TERM before triggering + // to avoid accidental triggers while fast typing these common rolls. + // If repeats aren't deemed necessary, use tap_code here, otherwise register_code here + // and add unregister_code to the !pressed switch in process_combo_event above. + // Checking combo_triggered above can enable sending untriggered keys + // and thus allow for longer COMBO_TERM. (recommend < TAPPING_TERM / 2) + // still, really fast rolls, esp if they can go both ways, are going to be + // a problem for this (ex er, re; io oi), so maybe best to avoid them as + // combos. On Hands Down, this means no combos on home row, but that's fine, + // because home already has modifiers, so it all works out. + if (!combo_triggered) { + // do simple "on" on first press actions here, + // then turn on combo state for hold acions to be resolved in keyup event above + // if necessary (like releasing the underlying keys, or other cleanup) + + + if (combo_on && (timer_elapsed(linger_timer) > COMBO_HOLD)) { + switch(combo_on) { // combo_on is global, set in process_combo above + case PC_STAB: + tap_code16(S(KC_TAB)); + break; + case PC_TGNM: + layer_on(L_LANG_NUM); // toggle num layer + break; + case PC_SENT: + tap_code16(S(KC_ENT)); + break; + case PC_DASH: + tap_code16(A(KC_MINS)); + break; + case PC_TILD: + tap_code16(KC_TILD); + break; + case HC_ELIP: + case PC_ELIP: + saved_mods = get_mods(); + clear_mods(); // + tap_code16(A(KC_SCLN)); // this should use semkeys + set_mods(saved_mods); // + break; + case PC_COLN: + tap_code16(KC_COLN); + break; + case PC_PERC: + tap_code16(KC_PERC); + break; + case PC_EURO: + tap_code16(A(S(KC_2))); // this should use semkeys + break; + case PC_DOLR: + tap_code16(S(KC_4)); + break; + case PC_CENT: + tap_code16(A(KC_4)); // this should use semkeys + break; + case PC_JYEN: + tap_code16(A(KC_Y)); // this should use semkeys + break; + case PC_BPND: + tap_code16(A(KC_3)); // this should use semkeys + break; + case PC_NEQL: + tap_code16(A(KC_EQL)); // this should use semkeys + break; + case PC_DIV: + tap_code16(A(KC_SLSH)); // this should use semkeys + break; + case PC_PLMN: + tap_code16(A(S(KC_EQL))); // this should use semkeys + break; + case PC_DEG: + tap_code16(A(KC_0)); // this should use semkeys + break; + case PC_LPRN: + tap_code16(KC_LPRN); + break; + case PC_RPRN: + tap_code16(KC_RPRN); + break; + + + case HC_2DQUO: // "|" + tap_code16(A(KC_LBRC)); + tap_code16(A(S(KC_LBRC))); + tap_code(KC_LEFT); + break; + case HC_2DBRC: // [|] + tap_code16(KC_LBRC); + tap_code16(KC_RBRC); + tap_code(KC_LEFT); + break; + + case HC_ENYE: + tap_code16(A(KC_N)); // this should use semkeys + break; + case HC_ACUT: + tap_code16(A(KC_E)); // this should use semkeys + break; + case HC_GRV: + tap_code16(A(KC_GRV)); // this should use semkeys + break; + case HC_CIRC: + tap_code16(A(KC_6)); // this should use semkeys + break; + case HC_MACR: + tap_code16(A(KC_A)); // this should use semkeys + break; + case HC_DIER: + tap_code16(A(KC_U)); // this should use semkeys + break; + case HC_RING: + tap_code16(A(KC_K)); // this should use semkeys + break; +/* + case HC_UM: // Ü + tap_code16(A(KC_U)); + tap_code16(KC_U); + break; + case HC_OM: // Ö + tap_code16(A(KC_U)); + tap_code16(KC_O); + break; + case HC_UK: // Ů + tap_code16(A(KC_K)); + tap_code16(KC_U); + break; + case HC_OK: // + tap_code16(A(KC_K)); + tap_code16(KC_O); + break; + case HC_UV: // Û + tap_code16(A(KC_6)); + tap_code16(KC_U); + break; + case HC_OV: // Ô + tap_code16(A(KC_6)); + tap_code16(KC_O); + break; + case HC_UF: // Ú + tap_code16(A(KC_E)); + tap_code16(KC_U); + break; + case HC_OF: // Ó + tap_code16(A(KC_E)); + tap_code16(KC_O); + break; + + case HC_1E: // É + tap_code16(A(KC_E)); + tap_code16(KC_E); + break; + case HC_2E: // Ē + tap_code16(A(KC_A)); + tap_code16(KC_O); + break; + case HC_3E: // Ê + tap_code16(A(KC_6)); + tap_code16(KC_E); + break; +*/ + + case MYMACRO: + SEND_STRING("End of times in 2020\n"); + break; + + case HC_Q: // already "Q" has been sent; if held, add "u" + case HC_Q2: // already "Q" has been sent; if held, add "u" + saved_mods = get_mods(); + clear_mods(); // + SEND_STRING("u"); + set_mods(saved_mods); // + break; + case HC_TYPE_JAPAN: // already "Japan" has been sent; if held, add "ese" + SEND_STRING("ese "); + break; + + case FC_KILL: + tap_SemKeys(SK_KILL); + break; + case FC_SCAP: + tap_SemKeys(SK_SCAP); + break; + case FC_SCLP: + tap_SemKeys(SK_SCLP); + break; + + case HC_CLOZ: + register_SemKey(SK_CLOZ); + break; + case HC_QUIT: + register_SemKey(SK_QUIT); + break; + case HC_FIND: // Find the selection + tap_SemKeys(SK_COPY); + tap_SemKeys(SK_FIND); + tap_SemKeys(SK_PSTE); + case HC_SALL: + tap_SemKeys(SK_SALL); + + + break; + case HC_UNDO: + register_SemKey(SK_UNDO); + break; + case HC_CUT: + tap_SemKeys(SK_CUT); + break; + case HC_COPY: + tap_SemKeys(SK_COPY); + break; + case HC_PSTE: + register_SemKey(SK_PSTE); + break; + case HC_PSTM: + register_SemKey(SK_PSTM); + break; + } // switch + combo_triggered = true; + #ifdef OLED_DRIVER_ENABLE + oled_set_cursor(oled_max_chars() - 5, combo_OLED_row); + oled_write_P(PSTR(" sent"), false); + #endif + } // if (combo_on) { + } +} diff --git a/moutis_ENCODER.c b/moutis_ENCODER.c index 7b1e80e..16ba733 100644 --- a/moutis_ENCODER.c +++ b/moutis_ENCODER.c @@ -21,17 +21,17 @@ bool encoder_update_user(uint8_t index, bool clockwise) { } else { // Second (right) encoder switch(get_highest_layer(layer_state)){ case L_MEDIA_NAV: // media/nav layer -// if (clockwise) { -// tap_code16(G(KC_RBRC)); // prev page -// } else { -// tap_code16(G(KC_LBRC)); // next page -// } -// break; + if (clockwise) { + tap_SemKey(SK_HISTPRV); // prev page + } else { + tap_SemKey(SK_HISTNXT); // next page + } + break; case L_LANG_NUM: // punctuation layer if (clockwise) { - tap_code16(G(S(KC_EQL))); // ZOOM IN + tap_SemKey(SK_ZOOMIN); // ZOOM IN } else { - tap_code16(G(KC_MINS)); // ZOOM OUT + tap_SemKey(SK_ZOOMOUT); // ZOOM OUT } break; default: @@ -43,5 +43,5 @@ bool encoder_update_user(uint8_t index, bool clockwise) { break; } } - return true; + return false; } diff --git a/moutis_MATRIX.c b/moutis_MATRIX.c index 41dd743..41e5278 100644 --- a/moutis_MATRIX.c +++ b/moutis_MATRIX.c @@ -1,65 +1,70 @@ -#ifdef LEADER_ENABLE -bool did_leader_succeed; -LEADER_EXTERNS(); -#endif void matrix_scan_user(void) { -//extern uint8_t saved_mods; - -#ifdef LEADER_ENABLE - #include "moutis_LEADER.c" -#endif #ifdef COMBO_ENABLE + if (combo_on) { // This will be true only if a combo_action is being held. matrix_scan_user_process_combo(); + } #endif - if (state_reset_timer) { // is there an active state? - + if (state_reset_timer) { // is there an active state to check on? + if (caps_word_on) { // caps_word mode on, (no mods) check if it needs to be cleared - if (timer_elapsed(state_reset_timer) > STATE_RESET_TIME * 6) {// linger time over? + if (timer_elapsed(state_reset_timer) > STATE_RESET_TIME * 4) {// linger time over? disable_caps_word(); // turn off all open states state_reset_timer = 0; } } if (appmenu_on) { // App menu up, (no mods) check if it needs to be cleared - if (timer_elapsed(state_reset_timer) > STATE_RESET_TIME) {// linger time over? + if (timer_elapsed(state_reset_timer) > STATE_RESET_TIME) {// menu up time over? if (user_config.osIsWindows) { // Y. stop the menu. - unregister_code(KC_LALT); + unregister_code(KC_RALT); } else { - unregister_code(KC_LGUI); + unregister_code(KC_RGUI); } - state_reset_timer = 0; + state_reset_timer = mods_held = 0; // stop the timer    appmenu_on = false; } } - } -} - -#ifdef LEADER_ENABLE - -void leader_start(void) { - // Add your code to run when pressing the leader key here -#ifdef OLED_DRIVER_ENABLE - oled_set_cursor(0, 3); - oled_write_P(PSTR("Leader: "), false); -#endif - -} -void leader_end(void) { -// Add your code to run when a leader key sequence ends here + if (linger_key) { // A linger key is being held down + if (timer_elapsed(linger_timer) > LINGER_TIME) { + saved_mods = get_mods(); + clear_mods(); + switch(linger_key) { // only one linger_key at a time, obviously + case KC_Q: // already "Q" has been sent; if held, add "u" + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. + tap_code(KC_U); + break; + case KC_LPRN: // + tap_code16(KC_RPRN); + tap_code16(KC_LEFT); + break; + case KC_LBRC: // + tap_code16(KC_RBRC); + tap_code16(KC_LEFT); + break; + case KC_LCBR: // + tap_code16(KC_RCBR); + tap_code16(KC_LEFT); + break; + case KC_DQUO: // + tap_code16(KC_DQUO); + tap_code16(KC_LEFT); + break; + default: + break; + } + linger_timer = state_reset_timer = 0; // finished with this state + set_mods(saved_mods); // Restore mods + } + } -#ifdef OLED_DRIVER_ENABLE - if (!leading) { - oled_set_cursor(0, 3); - oled_write_P(PSTR(" "), false); -// oled_render(); } -#endif -} -#endif + } + diff --git a/moutis_PROCESS_RECORD_hd_neu.c b/moutis_PROCESS_RECORD_hd_neu.c new file mode 100644 index 0000000..a4365e6 --- /dev/null +++ b/moutis_PROCESS_RECORD_hd_neu.c @@ -0,0 +1,398 @@ +/* + + This is compatible with Hands Down Neu, Platinum (neu-lx), Silver (neu-nx), Bronze (neu-hx) + Won't play nice with Hands Down Gold (neu-tx) + + */ + + +bool process_record_user(uint16_t keycode, keyrecord_t *record) { + + bool return_state = true; + uint8_t saved_mods; + + saved_mods = get_mods(); + return_state = true; // default is we didn't do anything + + + + // Do we turn off CAPS_WORD? + if (!process_caps_word(keycode, record)) { + return false; // took care of that key + } + + // Do we handle an adaptive key? + if (!process_adaptive_key(keycode, record)) { + return false; // took care of that key + } + + // Do we handle a semantic key? Combos or adaptives could have sent one. + if (!process_semkey(keycode, record)) { + return false; // took care of that key + } + + switch (keycode) { // should switch off record_keycode? +// case KC_BSPC: // make S(KC_BSPC) = KC_DEL; plus word_del L & R + case LT(L_LANG_NUM,KC_BSPC): // make S(KC_BSPC) = KC_DEL; plus word_del L & R + // This logic feels kludgey (but it works). fix it. + if (record->event.pressed) { // key down + if (saved_mods & MOD_MASK_SHIFT) { // shift down with KC_BSPC? + clear_keyboard(); // clean record to tinker with. + register_code16(KC_DEL); + key_trap = true; // mode monitor on to clear this on keyup + return_state = false; // don't do more with this record. + set_mods(saved_mods); + } + } else { // key up + if (key_trap) { // did we snag this earlier? + unregister_code16(KC_DEL); // make sure KC_DEL isn't held down + key_trap = false; // mode monitor off. + return_state = false; // don't do more with this record. + } + } + break; + case KC_APP: // mimic windows app key behavior (only better?) + if (record->event.pressed) { + mods_held = (saved_mods & (MOD_MASK_GUI | MOD_MASK_ALT)); // were mods held? + if (!mods_held) { // gui/alt not down, supply them + if (user_config.osIsWindows) { + register_code(KC_RALT); + } else { + register_code(KC_RGUI); + } + } + state_reset_timer = timer_read(); // (re)start timing hold for keyup below + tap_code(KC_TAB); + } else { // key up event + if (!mods_held) {// just app key, so see if held for menu + if (!appmenu_on) {// menu not already up + if (timer_elapsed(state_reset_timer) > LINGER_TIME) { // held for menu? + appmenu_on = true; // turn on menu (taken down in matrix_scan_user) + state_reset_timer = timer_read(); // start timer + } else { // no, just a quick tap for app switch. + if (user_config.osIsWindows) { // let mod keys up now + unregister_code(KC_RALT); + } else { + unregister_code(KC_RGUI); + } + state_reset_timer = 0; // stop the timer    + } + } + } + } + return_state = false; // don't do more with this record. + break; + + case CG_SWAP: // SINCE MAC IS MY DEFAULT switch to windows + user_config.osIsWindows = true; // Remember platform after powerdown + OSIndex = 1; + eeconfig_update_user(user_config.raw); + break; + case CG_NORM: // Back to mac + user_config.osIsWindows = false; // Remember platform after powerdown + OSIndex = 0; + eeconfig_update_user(user_config.raw); + break; + + /* + overrides here for off-map keys + * QMK v14.1 overrides footprint is too big, so I'm still rolling my own. + */ + case KC_Q: // + if (record->event.pressed) { // key down + if ((!saved_mods) || (saved_mods & MOD_MASK_SHIFT)) { // can this linger? + // register_linger_key(kc); + linger_key = keycode; // may add "u" in matrix_scan_user + linger_timer = state_reset_timer = timer_read(); // start timers threshold + } // can only linger on no mods or shift + register_code16(keycode); + } else { + unregister_code16(keycode); + linger_key = 0; // + } + return_state = false; // don't do more with this record. + break; + + /* + Key overrides here. Should be updated to use SemKey + */ + case KC_LPRN: // send { FOR Shift ( + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (record->event.pressed) { // key down + if (!saved_mods) { + register_linger_key(keycode); // example of simple linger macro + return_state = false; // don't do more with this record. + } else if ((saved_mods & MOD_MASK_SHIFT)) { // shift down with KC_RPRN? + clear_keyboard(); // clean record to tinker with. + if ((saved_mods & MOD_MASK_ALT)) { // alt also? + tap_code16(KC_LBRC); + } else { + tap_code16(KC_LCBR); + } + return_state = false; // don't do more with this record. + } else { + if ((saved_mods & MOD_MASK_ALT)) { // alt down with KC_LPRN? + clear_keyboard(); // clean record to tinker with. + tap_code16(KC_LBRC); + return_state = false; // don't do more with this record. + } + } + } else { // keyup event + if (!saved_mods) { + unregister_linger_key(); // stop lingering + return_state = false; // don't do more with this record. + } + } + break; + case KC_RPRN: // send } FOR Shift ) + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (record->event.pressed) { // key downSS + if ((saved_mods & MOD_MASK_SHIFT)) { // shift down with KC_RPRN? + clear_keyboard(); // clean record to tinker with. + if ((saved_mods & MOD_MASK_ALT)) { // alt also? + tap_code16(KC_RBRC); + } else { + tap_code16(KC_RCBR); + } + return_state = false; // don't do more with this record. + } else { + if ((saved_mods & MOD_MASK_ALT)) { // alt down with KC_RPRN? + clear_keyboard(); // clean record to tinker with. + tap_code16(KC_RBRC); + return_state = false; // don't do more with this record. + } + } + } + break; + case KC_LBRC: // + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (!saved_mods) { // this order saves code space in this case + if (record->event.pressed) { // key down + register_linger_key(keycode); // example of simple linger macro + } else { // keyup event + unregister_linger_key(); // stop lingering + } + return_state = false; // don't do more with this record. + } + break; + case KC_LCBR: // + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (!saved_mods) { // this order saves code space in this case + if (record->event.pressed) { // key down + register_linger_key(keycode); // example of simple linger macro + } else { // keyup event + unregister_linger_key(); // stop lingering + } + return_state = false; // don't do more with this record. + } + break; + + case KC_LT: // send ≤ FOR Shift ( + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (record->event.pressed) { // key down + if (saved_mods & MOD_MASK_SHIFT) { // shift down with KC_LT? + clear_keyboard(); // clean record to tinker with. + tap_code16(A(KC_COMM)); + return_state = false; // don't do more with this record. + } + } + break; + case KC_GT: // send ≥ FOR Alt + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (record->event.pressed) { // key downSS + if (saved_mods & MOD_MASK_SHIFT) { // shift down with KC_GT? + clear_keyboard(); // clean record to tinker with. + tap_code16(A(KC_DOT)); + return_state = false; // don't do more with this record. + } + } + break; + + case KC_COMM: // send ; FOR SHIFT , + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (record->event.pressed) { // key down + if (saved_mods & MOD_MASK_ALT) { // ALT down? + clear_keyboard(); // clean record to tinker with. + if ((saved_mods & MOD_MASK_SHIFT)) { // SFT too? + tap_code16(A(KC_BSLS)); + } else { + tap_code16(KC_UNDS); + } + return_state = false; // don't do more with this record. + } else { + if (saved_mods & MOD_MASK_SHIFT) { // SHFT? + clear_keyboard(); // clean record to tinker with. + tap_code16(KC_SCLN); // just semicolon + return_state = false; // don't do more with this record. + } + } + } + break; + case KC_DOT: // send : FOR SHIFT . + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (record->event.pressed) { // key down + if (saved_mods & MOD_MASK_ALT) { // ALT down? + clear_keyboard(); // clean record to tinker with. + if ((saved_mods & MOD_MASK_SHIFT)) { // SHFT too? + tap_code16(KC_BSLS); + } else { + tap_code16(A(KC_SCLN)); // + } + return_state = false; // don't do more with this record. + } else { + if ((saved_mods & MOD_MASK_SHIFT)) { // SHFT? + clear_keyboard(); // clean record to tinker with. + tap_code16(KC_COLN); + return_state = false; // don't do more with this record. + } + } + } + break; + + case KC_QUOT: // + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (record->event.pressed) { // key down + if (saved_mods & MOD_MASK_ALT) { // ALT (only) down? + clear_keyboard(); // clean record to tinker with. + if (saved_mods & MOD_MASK_SHIFT) { // SHFT too? + tap_code16(A(KC_BSLS)); + } else { + tap_code16(A(S(KC_3))); + } + return_state = false; // don't do more with this record. + } else if (saved_mods & MOD_MASK_SHIFT) { // SHFT (only) down? + clear_keyboard(); // clean record to tinker with. + register_linger_key(KC_LBRC); // example of simple linger macro + return_state = false; // don't do more with this record. + } + } else { // keyup event (just unregister it) + unregister_linger_key(); // stop lingering + unregister_code16(keycode); // may still need to handle this + return_state = false; // don't do more with this record. + } + break; + case KC_DQUO: // send on shift + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (record->event.pressed) { // key down + if (saved_mods) { // any mods? + if (saved_mods & MOD_MASK_ALT) { // ALT (only) down? + clear_keyboard(); // clean record to tinker with. + if (saved_mods & MOD_MASK_SHIFT) { // SHFT too? + tap_code16(A(S(KC_BSLS))); + } else { + tap_code16(A(S(KC_4))); + } + return_state = false; // don't do more with this record. + } else if (saved_mods & MOD_MASK_SHIFT) { // SHFT? + clear_keyboard(); // clean record to tinker with. + tap_code16(KC_RBRC); + return_state = false; // don't do more with this record. + } + } else { // no mods, so linger + register_linger_key(keycode); // example of simple linger macro + return_state = false; // don't do more with this record. + } + } else { // keyup event (just unregister it) + if (!saved_mods) { + unregister_linger_key(); // stop lingering + return_state = false; // don't do more with this record. + } + } + break; + + + case KC_QUES: + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (record->event.pressed) { // key down + if (saved_mods & MOD_MASK_SHIFT) { // SHFT? = ¿ +// clear_keyboard(); // clean record to tinker with. + del_mods(MOD_MASK_CG); // turn off unused mods (timing off in 14.1) + tap_code16(S(A(KC_SLSH))); + return_state = false; // don't do more with this record. + } + } + break; + + case KC_MINS: // send + FOR SHIFT - (_) + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (record->event.pressed) { // key down + if (saved_mods & MOD_MASK_SHIFT) { // shift down? + del_mods(MOD_MASK_CG); // turn off unused mods (timing off in 14.1) + register_code16(KC_PLUS); + key_trap = true; // mode monitor – enter state + return_state = false; // don't do more with this record. + } + } else { // key up + if (key_trap) { // did we snag this earlier? + unregister_code16(KC_PLUS); // + key_trap = false; // mode monitor – exit state. + return_state = false; // don't do more with this record. + } + } + break; + case KC_SLSH: // send FOR ALT /(?) + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (record->event.pressed) { // key down + if (saved_mods & MOD_MASK_ALT) { // ALT down? + if (saved_mods & MOD_MASK_SHIFT) { // SHFT too? + tap_code16(A(S(KC_1))); // Y: + } else { + clear_keyboard(); // clean record to tinker with. + tap_code16(KC_BSLS); // N: just alt, so + } + return_state = false; // don't do more with this record. + } else { + if (saved_mods & MOD_MASK_SHIFT) { // only SHFT? + del_mods(MOD_MASK_CAG); // turn off unused mods. + register_code16(KC_ASTR); // * + key_trap = true; // mode monitor – enter state + return_state = false; // don't do more with this record. + } + } + } else { + if (key_trap) { // did we snag this earlier? + unregister_code16(KC_ASTR); // * + key_trap = false; // mode monitor – exit state. + return_state = false; // don't do more with this record. + } + } + break; + case KC_SCLN: // send + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (record->event.pressed) { // key down + if (saved_mods & MOD_MASK_ALT) { // ALT down? + if ((saved_mods & MOD_MASK_SHIFT)) { // SHFT too? + clear_keyboard(); // clean record to tinker with. + tap_code16(KC_PERC); // % + } else { + tap_SemKey(SK_SECT); // § + } + return_state = false; // don't do more with this record. + } + } + break; + case KC_HASH: // send @ FOR SHIFT # + // This logic feels kludgey, but it works. fix it? convert to SemKey + if (record->event.pressed) { // key down + if (saved_mods & MOD_MASK_SHIFT) { // shift down? + clear_keyboard(); // clean record to tinker with. + register_code16(KC_AT); + key_trap = true; // mode monitor – enter state + return_state = false; // don't do more with this record. + } + } else { // key up + if (key_trap) { // did we snag this earlier? + unregister_code16(KC_AT); // + key_trap = false; // mode monitor – exit state. + return_state = false; // don't do more with this record. + } + } + + break; + + } // switch (keycode) { + + return return_state; // keep processing record +} + + diff --git a/moutis_adaptivekeys.c b/moutis_adaptivekeys.c index 171bcd9..ad74ec0 100644 --- a/moutis_adaptivekeys.c +++ b/moutis_adaptivekeys.c @@ -4,29 +4,38 @@ ** This will misbehave w/o QMK 14.1 or later (Sevanteri's early combos) + I think this will work with all Hands Down Neu variants (Platinum, Gold, Silver, Bronze) + Finally getting to the last of imagined features that spurred Hands Down design! + uses globals uint16_t prior_keycode = KC_NO; // for process_adaptive_key - uint16_t prior_keydown = 0; - - + uint16_t prior_keydown = 0; // time since finished processing prior_keycode + */ bool process_adaptive_key(uint16_t keycode, const keyrecord_t *record) { -static uint16_t prior_keycode = KC_NO; // for process_adaptive_key -static uint16_t prior_keydown = 0; -bool return_state = true; // assume we don't do anything. + bool return_state = true; // assume we don't do anything. + static uint16_t prior_keycode = KC_NO; // for process_adaptive_key + static uint16_t prior_keydown = 0; if (record->event.pressed) { - keycode = keycode & 0xFF; // ignore all mods + keycode = keycode & 0xFF; // ignore all mods? or just shift? if ((timer_elapsed(prior_keydown) < ADAPTIVE_TERM)) { switch (keycode) { + +/* +// Left hand adaptives (most are single-handed, bc speed, dexterity limits) +*/ + case KC_D: case KC_F: switch (prior_keycode) { case KC_B: case KC_K: - tap_code(KC_L); + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. + tap_code(KC_L); return_state = false; // done. break; case KC_M: // LF @@ -34,36 +43,113 @@ bool return_state = true; // assume we don't do anything. tap_code(KC_L); tap_code16(keycode); return_state = false; // done. + break; + case KC_P: + tap_code(KC_S); + return_state = false; // done. + } + break; + case KC_G: + switch (prior_keycode) { + case KC_I: // IG = + send_string("ng "); + return_state = false; // done. + } + break; + case KC_L: + switch (prior_keycode) { + case KC_M: // ML = LL + tap_code(KC_BSPC); + tap_code(KC_L); + tap_code16(keycode); + return_state = false; // done. } break; + case KC_M: switch (prior_keycode) { + case KC_D: case KC_F: - case KC_P: case KC_K: - case KC_W: + case KC_P: case KC_V: + case KC_W: + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. tap_code(KC_L); return_state = false; // done. } break; + case KC_N: // Do we need to watch for more? + switch (prior_keycode) { + case KC_P: // is this needed? + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. + tap_code(KC_H); // quickly typing "?n" yields "?h" + return_state = false; // done. + break; + case KC_T: // demonstrator. TN combo is "TH" digraph + send_string("ion"); + return_state = false; // done. + break; + } + break; case KC_P: switch (prior_keycode) { + case KC_J: // "jp" is "Japan"…ese? A demonstrator AK + tap_code(KC_BSPC); + register_code(KC_LSFT); // shift here. + tap_code(KC_J); // this should always be cap + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. + send_string("apan"); + return_state = false; // done. + break; + case KC_H: // "hp" is "lp" on Platinum + tap_code(KC_BSPC); + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. + tap_code(KC_L); + tap_code16(keycode); + return_state = false; // done. + break; case KC_B: case KC_K: - case KC_V: - tap_code(KC_L); // quickly typing "kv" yields "lv" + case KC_V: // quickly typing "?p" yields "?l" + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. + tap_code(KC_L); return_state = false; // done. break; - case KC_F: // "f?" is really uncommon, we prolly want "L?" + case KC_M: + case KC_F: // "f?" is really uncommon, we prolly want "l?" tap_code(KC_BSPC); + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. tap_code(KC_L); tap_code16(keycode); return_state = false; // done. } break; + case KC_T: + switch (prior_keycode) { + case KC_K: // ML = LL + tap_code(KC_L); + return_state = false; // done. + } + break; + case KC_U: + switch (prior_keycode) { + case KC_Y: // YU = You bc YO is a tad awk, but yu is easy, and uncommon + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. + tap_code(KC_O); + tap_code(KC_U); + return_state = false; // done. + } + break; case KC_B: // take advantage of B & V being phonotacically similar - case KC_V: // (in same finger/column) to process as adaptive key + case KC_V: // (and in same finger/column) to process as adaptive key switch (prior_keycode) { case KC_M: case KC_N: @@ -71,17 +157,87 @@ bool return_state = true; // assume we don't do anything. return_state = false; // done. break; case KC_F: - case KC_P: + case KC_P: /* this is for bronze */ tap_code(KC_BSPC); // get rid of the prior tap_code(KC_L); // quickly typing "p?" yields "l?" tap_code16(keycode); // return_state = false; // done. + break; + case KC_H: /* mostly for platinum */ + tap_code(KC_L); // quickly typing "hv" yields "lh" } break; + + case KC_S: + switch (prior_keycode) { // demonstrator. SN combo is "SH" digraph + case KC_T: + tap_code(KC_N); + case KC_N: + send_string("ess"); + return_state = false; // done. + break; + } + break; + + case KC_J: // SAME-HAND TOWARD PINKY ISSUES + case KC_W: // adjacent fingers don't do next row as easily, + case KC_X: // especially on ring to pinky. + switch (prior_keycode) { + case KC_B: // + case KC_C: // RING TO PINKY This softens the burden, + case KC_D: // + case KC_F: // and equalizes column-stagger & ortho boards. + case KC_G: // + case KC_M: // anything that is statistically much more frequent + case KC_P: // bc why not? + case KC_V: // + unregister_code(KC_LSFT); // remove shift here. + unregister_code(KC_RSFT); // remove shift here. + tap_code16(KC_R); + return_state = false; // done. + break; + case KC_L: // repeater (For Platinum's thumb-L) + tap_code16(KC_L); // LW isn't likely, so we'll leave it for the sake of smaller code + return_state = false; // done. + break; + } + break; + +/* +// right hand adaptives +*/ + + case KC_A: + switch (prior_keycode) { + case KC_COMM: + tap_code(KC_BSPC); // get rid of the prior + tap_code(KC_U); // quickly typing ",A" yields "UA" + tap_code16(keycode); // + return_state = false; // done. + break; + } + break; + case KC_MINS: + switch (prior_keycode) { + case KC_L: + tap_code16(prior_keycode); // repeater (For Platinum's thumb-L) + return_state = false; // done. + break; + } + break; + case KC_COMM: + switch (prior_keycode) { + case KC_A: + tap_code(KC_U); // quickly typing "A," yields "AU" + return_state = false; // done. + break; + } + break; + } } prior_keycode = keycode; - prior_keydown = timer_read(); // (re)start prior timing + prior_keydown = timer_read(); // (re)start prior_key timing } return return_state; // } diff --git a/moutis_casemods.c b/moutis_casemods.c index 88e6abb..7ee9bb7 100644 --- a/moutis_casemods.c +++ b/moutis_casemods.c @@ -29,6 +29,9 @@ * - Added @baffalop's separator defaulting on first keypress, with a * configurable default separator and overrideable function to determine * if the default should be used. + + currently doesn't handle layer/mod taps properly. why? + */ @@ -97,13 +100,14 @@ bool process_caps_word(uint16_t keycode, const keyrecord_t *record) { if (caps_word_on) { // Filter out the actual keycode from MT and LT keys. + // This isn't working right switch (keycode) { case QK_MOD_TAP ... QK_MOD_TAP_MAX: case QK_LAYER_TAP ... QK_LAYER_TAP_MAX: case QK_TAP_DANCE ... QK_TAP_DANCE_MAX: if (record->tap.count == 0) // if not tapped yet… return false; // do that first - keycode = keycode & 0xFF; + keycode = keycode & 0xFF; // This may ignore off layer keys? default: break; } diff --git a/moutis_semantickeys.c b/moutis_semantickeys.c index a11d46e..5f7fccb 100644 --- a/moutis_semantickeys.c +++ b/moutis_semantickeys.c @@ -22,6 +22,7 @@ */ +/* enum SemKeys { SK_KILL, SK_UNDO, @@ -37,39 +38,146 @@ enum SemKeys { SK_SCAP, SK_SCLP, SK_SECT, -/* + SK_GRAV_E, SK_ACUT_E, SK_DIER_E, SK_RING_E, SK_MACR_E, -*/ + SemKeys_COUNT }; +*/ enum SemKeys_OS { SKP_Mac, SKP_Min, SemKeys_OS_COUNT }; +/* +* based on the table at: +* https://en.wikipedia.org/wiki/Table_of_keyboard_shortcuts +* tested on my own machines, seems to work fine. +* +*/ -const uint16_t SemKeys_t[SemKeys_COUNT][SemKeys_OS_COUNT] = { +const uint16_t SemKeys_t[SemKeys_COUNT - SK_KILL][SemKeys_OS_COUNT] = { // Mac, Win, (Phase 3, add others if necessary, expand to multi-key?) - [SK_KILL] = {G(A(KC_ESC)),C(A(KC_DEL))}, // "KILL" OR Force quit / ctrl-alt-del - [SK_UNDO] = {G(KC_Z),C(KC_Z)}, // undo - [SK_CUT ] = {G(KC_X),C(KC_X)}, // cut - [SK_COPY] = {G(KC_C),C(KC_C)}, // copy - [SK_PSTE] = {G(KC_V),C(KC_V)}, // paste - [SK_PSTM] = {G(S(A(KC_V))),C(S(A(KC_V)))}, // paste_match - [SK_SALL] = {G(KC_A),C(KC_C)}, // select all - [SK_CLOZ] = {G(KC_W),C(KC_W)}, // close - [SK_QUIT] = {G(KC_Q),C(KC_Q)}, // quit - [SK_FIND] = {G(KC_F),C(KC_F)}, // find - [SK_FAGN] = {G(KC_G),C(KC_G)}, // find again - [SK_SCAP] = {S(G(KC_4)),KC_PSCR}, // Screen Capture - [SK_SCLP] = {C(S(G(KC_4))),A(KC_PSCR)}, // Selection Capture - [SK_SECT] = {A(KC_5),A(KC_5)}, // § - + [SK_KILL - SK_KILL] = {G(A(KC_ESC)),C(A(KC_DEL))}, // "KILL" OR Force quit / ctrl-alt-del + [SK_UNDO - SK_KILL] = {G(KC_Z),C(KC_Z)}, // undo + [SK_CUT - SK_KILL] = {G(KC_X),C(KC_X)}, // cut + [SK_COPY - SK_KILL] = {G(KC_C),C(KC_C)}, // copy + [SK_PSTE - SK_KILL] = {G(KC_V),C(KC_V)}, // paste + [SK_PSTM - SK_KILL] = {G(S(A(KC_V))),C(S(A(KC_V)))}, // paste_match + [SK_SALL - SK_KILL] = {G(KC_A),C(KC_A)}, // select all + [SK_CLOZ - SK_KILL] = {G(KC_W),C(KC_W)}, // close + [SK_QUIT - SK_KILL] = {G(KC_Q),C(KC_Q)}, // quit + [SK_FIND - SK_KILL] = {G(KC_F),C(KC_F)}, // find + [SK_FAGN - SK_KILL] = {G(KC_G),KC_F3}, // find again + [SK_SCAP - SK_KILL] = {S(G(KC_4)),KC_PSCR}, // Screen Capture + [SK_SCLP - SK_KILL] = {C(S(G(KC_4))),A(KC_PSCR)}, // Selection Capture)) + [SK_DELWDL - SK_KILL] = {A(KC_BSPC),C(KC_BSPC)}, // DELETE WORD LEFT + [SK_DELWDR - SK_KILL] = {A(KC_DEL),C(KC_DEL)}, // DELETE WORD RIGHT + [SK_WORDPRV - SK_KILL] = {A(KC_LEFT),C(KC_LEFT)}, // WORD LEFT + [SK_WORDNXT - SK_KILL] = {A(KC_RIGHT),C(KC_RIGHT)}, // WORD RIGHT + [SK_DOCBEG - SK_KILL] = {G(KC_UP),C(KC_HOME)}, // Go to start of document + [SK_DOCEND - SK_KILL] = {G(KC_DOWN),C(KC_END)}, // Go to end of document + [SK_LINEBEG - SK_KILL] = {G(KC_DOWN),C(KC_END)}, // Go to beg of line + [SK_LINEEND - SK_KILL] = {G(KC_DOWN),C(KC_END)}, // Go to end of line + [SK_PARAPRV - SK_KILL] = {A(KC_UP),C(KC_UP)}, // Go to previous paragraph + [SK_PARANXT - SK_KILL] = {A(KC_DOWN),C(KC_DOWN)}, // Go to next paragraph + [SK_HISTPRV - SK_KILL] = {G(KC_LBRC),A(KC_LEFT)}, // BROWSER BACK + [SK_HISTNXT - SK_KILL] = {G(KC_RBRC),A(KC_RIGHT)}, // BROWSER FWD + [SK_ZOOMIN - SK_KILL] = {G(S(KC_EQL)),C(KC_EQL)}, // ZOOM IN + [SK_ZOOMOUT - SK_KILL] = {G(KC_MINS),C(KC_MINS)}, // ZOOM OUT + [SK_ZOOMRST - SK_KILL] = {G(KC_0),C(KC_0)}, // ZOOM RESET + [SK_SECT - SK_KILL] = {A(KC_5),A(KC_5)}, // § ** SAMPLE OF GLYPH. REALLY NEED UNICODE. }; +bool process_semkey(uint16_t keycode, const keyrecord_t *record) { + // custom processing could hapen here + if (keycode >= SK_KILL && keycode < SemKeys_COUNT) { + if (record->event.pressed) { + switch (keycode) { +/* + // + // demonstrator. can handle multi-keystrokes here + // + case SK_umluatU: // Ü + tap_code16(A(KC_U)); + tap_code16(KC_U); + break; + case SK_umluatO: // Ö + tap_code16(A(KC_U)); + tap_code16(KC_O); + break; + case SK_ringU: // Ů + tap_code16(A(KC_K)); + tap_code16(KC_U); + break; + case SK_ringO: // + tap_code16(A(KC_K)); + tap_code16(KC_O); + break; + case SK_caretU: // Û + tap_code16(A(KC_6)); + tap_code16(KC_U); + break; + case SK_caretO: // Ô + tap_code16(A(KC_6)); + tap_code16(KC_O); + break; + case SK_acuteU: // Ú + tap_code16(A(KC_E)); + tap_code16(KC_U); + break; + case SK_acuteO: // Ó + tap_code16(A(KC_E)); + tap_code16(KC_O); + break; + + case SK_acuteE: // É + tap_code16(A(KC_E)); + tap_code16(KC_E); + break; + case SK_macronE: // Ē + tap_code16(A(KC_A)); + tap_code16(KC_O); + break; + case SK_caretE: // Ê + tap_code16(A(KC_6)); + tap_code16(KC_E); + break; +*/ +/* + Example of custom behaviors. + */ + case SK_SCAP: + tap_SemKey(SK_SCAP); + break; + case SK_SCLP: + tap_SemKey(SK_SCLP); + break; + case SK_CUT: + tap_SemKey(SK_CUT); + break; + case SK_COPY: + tap_SemKey(SK_COPY); + break; + default: // default keydown event + register_SemKey(keycode); + break; + } + } else { // The keyup event + switch (keycode) { + default: + unregister_SemKey(keycode); + break; + } + + } + return false; // don't do more with this record. + } + return true; +}; diff --git a/moutis_semantickeys.h b/moutis_semantickeys.h index 0edbfbc..758a98a 100644 --- a/moutis_semantickeys.h +++ b/moutis_semantickeys.h @@ -14,16 +14,17 @@ Integrate all combo and keymap processing so they both queue SemKeys to be handled in process_record_user, reducing the code and simplifying maintenance. + complete. Phase 3: expand to multi-keystrokes, which would enable sending different compose sequences based on platform (diacritics), - and possibly facilitate editor support (vim/emacs)? + and possibly facilitate support for other editors (vim/emacs)? - Phase 4: use in Hands Down Polyglot. + Phase 4: use in Hands Down Polyglot for all non-ascii glyphs */ -#define tap_SemKeys(sk) tap_code16(SemKeys_t[sk][OSIndex]) -#define register_SemKey(sk) register_code16(SemKeys_t[sk][OSIndex]) -#define unregister_SemKey(sk) unregister_code16(SemKeys_t[sk][OSIndex]) +#define tap_SemKey(sk) tap_code16(SemKeys_t[sk - SK_KILL][OSIndex]) +#define register_SemKey(sk) register_code16(SemKeys_t[sk - SK_KILL][OSIndex]) +#define unregister_SemKey(sk) unregister_code16(SemKeys_t[sk - SK_KILL][OSIndex]) diff --git a/naked48/naked48_hd_bronze.json b/naked48/naked48_hd_bronze.json new file mode 100644 index 0000000..eabb601 --- /dev/null +++ b/naked48/naked48_hd_bronze.json @@ -0,0 +1,361 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "naked48/rev1", + "keymap": "naked48_hd_bronze", + "layout": "LAYOUT", + "layers": [ + [ + "KC_MINS", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "KC_APP", + "TG(5)", + "KC_EQL", + "KC_DOT", + "KC_SLSH", + "KC_QUOT", + "KC_DQUO", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "LT(5,KC_TAB)", + "LT(5,KC_ESC)", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_C)", + "RCTL_T(KC_I)", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "KC_LBRC", + "KC_RBRC", + "KC_HASH", + "KC_U", + "KC_O", + "KC_W", + "KC_Y", + "KC_LEFT", + "KC_RGHT", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(2,KC_LANG2)", + "LT(3,KC_MUTE)", + "LT(3,KC_MPLY)", + "LT(6,KC_LANG1)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "KC_UP", + "KC_DOWN" + ], + [ + "KC_TILD", + "KC_EXLM", + "KC_AT", + "KC_HASH", + "KC_DLR", + "KC_PERC", + "KC_CIRC", + "KC_AMPR", + "KC_ASTR", + "KC_LPRN", + "KC_RPRN", + "KC_DEL", + "KC_TRNS", + "KC_TRNS", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_F6", + "KC_UNDS", + "KC_PLUS", + "KC_LCBR", + "KC_RCBR", + "KC_PIPE", + "KC_TRNS", + "KC_TRNS", + "KC_F8", + "KC_F9", + "KC_F10", + "KC_F11", + "KC_F12", + "LSFT(KC_NUHS)", + "LSFT(KC_NUBS)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_MNXT", + "KC_VOLD", + "KC_VOLU", + "KC_MPLY" + ], + [ + "KC_Q", + "KC_Z", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_9)))", + "ANY(S(G(KC_4)))", + "KC_TRNS", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT_T(KC_Y)", + "RALT(KC_3)", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "ANY(C(S(G(KC_4))))", + "KC_TRNS", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "RGUI_T(KC_PEQL)", + "RALT_T(KC_PPLS)", + "RCTL_T(KC_RO)", + "ANY(A(S(KC_5)))", + "KC_TRNS", + "KC_LCBR", + "KC_RPRN", + "RALT(KC_5)", + "KC_TRNS", + "KC_TRNS", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LALT(KC_BSPC)", + "LALT(KC_DEL)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_F11", + "KC_F12", + "KC_F13", + "KC_F14", + "KC_F15", + "KC_F16", + "KC_TRNS", + "KC_SLSH", + "KC_7", + "KC_8", + "KC_9", + "KC_0", + "LCTL_T(KC_F6)", + "LALT_T(KC_F7)", + "LGUI_T(KC_F8)", + "LSFT_T(KC_F9)", + "KC_F10", + "KC_F17", + "KC_TRNS", + "KC_EQL", + "RSFT_T(KC_4)", + "RGUI_T(KC_5)", + "RALT_T(KC_6)", + "RCTL_T(KC_MINS)", + "KC_F1", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_F18", + "KC_TRNS", + "KC_MINS", + "KC_1", + "KC_2", + "KC_3", + "KC_EQL", + "KC_F19", + "KC_F20", + "KC_F21", + "KC_F22", + "KC_F23", + "KC_NO", + "KC_NO", + "KC_NLCK", + "KC_SLCK", + "KC_INS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "LGUI(KC_Q)", + "LGUI(KC_W)", + "ANY(S(G(KC_4)))", + "ANY(C(S(G(KC_4))))", + "LGUI(KC_G)", + "KC_MUTE", + "KC_NO", + "LALT(KC_HOME)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "LALT(KC_PGUP)", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "LGUI(KC_F)", + "KC_VOLU", + "KC_NO", + "LALT(KC_LEFT)", + "KC_LEFT", + "KC_UP", + "KC_RGHT", + "LALT(KC_RGHT)", + "LGUI(KC_Z)", + "LGUI(KC_X)", + "LGUI(KC_C)", + "LGUI(KC_V)", + "ANY(G(S(A(KC_V))))", + "KC_VOLD", + "KC_NO", + "LALT(KC_END)", + "KC_END", + "KC_DOWN", + "KC_LALT", + "LALT(KC_PGDN)", + "KC_MRWD", + "KC_MPRV", + "KC_MNXT", + "KC_MFFD", + "KC_MPLY", + "KC_NO", + "KC_NO", + "LGUI_T(KC_LBRC)", + "LGUI(KC_RBRC)", + "LGUI(KC_MINS)", + "ANY(G(S(KC_EQL)))", + "LGUI(KC_0)" + ], + [ + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_LBRC)))", + "KC_TRNS", + "KC_TRNS", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "KC_TRNS", + "KC_NLCK", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_TRNS", + "KC_TRNS", + "KC_COMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_ENT", + "KC_BSPC", + "KC_DEL", + "KC_P0", + "KC_PDOT", + "KC_C", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET", + "KC_NO", + "BL_BRTG", + "RGB_SPI", + "RGB_SPD", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRIU", + "BL_STEP", + "BL_INC", + "RGB_HUI", + "RGB_SAI", + "RGB_VAI", + "KC_NO", + "TO(1)", + "DF(1)", + "KC_NO", + "AG_SWAP", + "CG_SWAP", + "KC_BRID", + "BL_TOGG", + "BL_DEC", + "RGB_HUD", + "RGB_SAD", + "RGB_VAD", + "TO(0)", + "DF(0)", + "KC_NO", + "AG_NORM", + "CG_NORM", + "KC_NO", + "KC_NO", + "KC_NO", + "BL_ON", + "BL_OFF", + "KC_NO", + "KC_NO" + ] + ], + "author": "", + "notes": "" +} \ No newline at end of file diff --git a/naked48/naked48_hd_bronze_2.json b/naked48/naked48_hd_bronze_2.json new file mode 100644 index 0000000..16fef52 --- /dev/null +++ b/naked48/naked48_hd_bronze_2.json @@ -0,0 +1,361 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "naked48/rev1", + "keymap": "naked48_hd_bronze", + "layout": "LAYOUT", + "layers": [ + [ + "KC_MINS", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "LT(5,KC_TAB)", + "KC_APP", + "KC_EQL", + "KC_DOT", + "KC_SLSH", + "KC_QUOT", + "KC_DQUO", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "LT(5,KC_ESC)", + "TG(5)", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_C)", + "RCTL_T(KC_I)", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "KC_LBRC", + "KC_RBRC", + "KC_HASH", + "KC_U", + "KC_O", + "KC_W", + "KC_Y", + "KC_LEFT", + "KC_RGHT", + "LT(2,KC_LANG2)", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(8,KC_MUTE)", + "LT(5,KC_MPLY)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "LT(6,KC_LANG1)", + "KC_UP", + "KC_DOWN" + ], + [ + "KC_TILD", + "KC_EXLM", + "KC_AT", + "KC_HASH", + "KC_DLR", + "KC_PERC", + "KC_CIRC", + "KC_AMPR", + "KC_ASTR", + "KC_LPRN", + "KC_RPRN", + "KC_DEL", + "KC_TRNS", + "KC_TRNS", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_F6", + "KC_UNDS", + "KC_PLUS", + "KC_LCBR", + "KC_RCBR", + "KC_PIPE", + "KC_TRNS", + "KC_TRNS", + "KC_F8", + "KC_F9", + "KC_F10", + "KC_F11", + "KC_F12", + "LSFT(KC_NUHS)", + "LSFT(KC_NUBS)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_MNXT", + "KC_VOLD", + "KC_VOLU", + "KC_MPLY" + ], + [ + "KC_Q", + "KC_Z", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_9)))", + "ANY(S(G(KC_4)))", + "KC_TRNS", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT_T(KC_Y)", + "RALT(KC_3)", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "ANY(C(S(G(KC_4))))", + "KC_TRNS", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "RGUI_T(KC_PEQL)", + "RALT_T(KC_PPLS)", + "RCTL_T(KC_RO)", + "ANY(A(S(KC_5)))", + "KC_TRNS", + "KC_LCBR", + "KC_RPRN", + "RALT(KC_5)", + "KC_TRNS", + "KC_TRNS", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LALT(KC_BSPC)", + "LALT(KC_DEL)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_F11", + "KC_F12", + "KC_F13", + "KC_F14", + "KC_F15", + "KC_F16", + "KC_TRNS", + "KC_SLSH", + "KC_7", + "KC_8", + "KC_9", + "KC_0", + "LCTL_T(KC_6)", + "LALT_T(KC_7)", + "LGUI_T(KC_8)", + "LSFT_T(KC_9)", + "KC_F10", + "KC_F17", + "KC_TRNS", + "KC_EQL", + "RSFT_T(KC_4)", + "RGUI_T(KC_5)", + "RALT_T(KC_6)", + "RCTL_T(KC_MINS)", + "KC_F1", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_F18", + "KC_TRNS", + "KC_MINS", + "KC_1", + "KC_2", + "KC_3", + "KC_EQL", + "KC_F19", + "KC_F20", + "KC_F21", + "KC_F22", + "KC_F23", + "KC_NO", + "KC_NO", + "KC_NLCK", + "KC_SLCK", + "KC_INS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_EJCT", + "KC_NO", + "LALT(KC_HOME)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "LALT(KC_PGUP)", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "KC_VOLU", + "KC_NO", + "KC_NO", + "LALT(KC_LEFT)", + "KC_LEFT", + "KC_UP", + "KC_RGHT", + "LALT(KC_RGHT)", + "KC_NO", + "KC_NO", + "KC_MRWD", + "KC_MFFD", + "KC_VOLD", + "KC_NO", + "KC_NO", + "LALT(KC_END)", + "KC_END", + "KC_DOWN", + "KC_LALT", + "LALT(KC_PGDN)", + "KC_NO", + "KC_MPRV", + "KC_MNXT", + "KC_MUTE", + "KC_MPLY", + "KC_NO", + "LGUI_T(KC_LBRC)", + "LGUI(KC_RBRC)", + "ANY(G(S(KC_EQL)))", + "LGUI(KC_MINS)", + "LGUI(KC_0)", + "KC_NO" + ], + [ + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_LBRC)))", + "ANY(S(G(KC_4)))", + "KC_NLCK", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "ANY(C(S(G(KC_4))))", + "TG(5)", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_TRNS", + "KC_TRNS", + "KC_COMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_ENT", + "KC_BSPC", + "KC_DEL", + "KC_P0", + "KC_PDOT", + "KC_C", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "BL_BRTG", + "RGB_SPI", + "RGB_SPD", + "KC_NO", + "KC_NO", + "DF(0)", + "DF(1)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRIU", + "BL_STEP", + "BL_INC", + "RGB_HUI", + "RGB_SAI", + "RGB_VAI", + "TO(0)", + "TO(1)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRID", + "BL_TOGG", + "BL_DEC", + "RGB_HUD", + "RGB_SAD", + "RGB_VAD", + "KC_NO", + "KC_NO", + "RESET", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "BL_ON", + "BL_OFF", + "KC_NO", + "KC_NO" + ] + ], + "author": "", + "notes": "" +} \ No newline at end of file diff --git a/naked48/naked48_hd_bronze_SK.json b/naked48/naked48_hd_bronze_SK.json new file mode 100644 index 0000000..4bb64d4 --- /dev/null +++ b/naked48/naked48_hd_bronze_SK.json @@ -0,0 +1,361 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "naked48/rev1", + "keymap": "naked48_hd_bronze_sk", + "layout": "LAYOUT", + "layers": [ + [ + "KC_J", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "KC_APP", + "TG(5)", + "KC_HASH", + "KC_DOT", + "KC_SLSH", + "KC_QUOT", + "KC_DQUO", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "LT(5,KC_TAB)", + "LT(5,KC_ESC)", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_C)", + "RCTL_T(KC_I)", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "KC_LBRC", + "KC_RBRC", + "KC_MINS", + "KC_U", + "KC_O", + "KC_W", + "KC_Y", + "KC_LEFT", + "KC_RGHT", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(2,KC_LANG2)", + "LT(3,KC_MUTE)", + "LT(3,KC_MPLY)", + "LT(6,KC_LANG1)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "KC_UP", + "KC_DOWN" + ], + [ + "KC_TILD", + "KC_EXLM", + "KC_AT", + "KC_HASH", + "KC_DLR", + "KC_PERC", + "KC_CIRC", + "KC_AMPR", + "KC_ASTR", + "KC_LPRN", + "KC_RPRN", + "KC_DEL", + "KC_TRNS", + "KC_TRNS", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_F6", + "KC_UNDS", + "KC_PLUS", + "KC_LCBR", + "KC_RCBR", + "KC_PIPE", + "KC_TRNS", + "KC_TRNS", + "KC_F8", + "KC_F9", + "KC_F10", + "KC_F11", + "KC_F12", + "LSFT(KC_NUHS)", + "LSFT(KC_NUBS)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_MNXT", + "KC_VOLD", + "KC_VOLU", + "KC_MPLY" + ], + [ + "KC_Q", + "KC_Z", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_9)))", + "ANY(S(G(KC_4)))", + "KC_TRNS", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT_T(KC_Y)", + "RALT(KC_3)", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "ANY(C(S(G(KC_4))))", + "KC_TRNS", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "RGUI_T(KC_PEQL)", + "RALT_T(KC_PPLS)", + "RCTL_T(KC_RO)", + "ANY(A(S(KC_5)))", + "KC_TRNS", + "KC_LCBR", + "KC_RPRN", + "RALT(KC_5)", + "KC_TRNS", + "KC_TRNS", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_TRNS", + "KC_TRNS", + "ANY(SK_DELWDL)", + "ANY(SK_DELWDR)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_F11", + "KC_F12", + "KC_F13", + "KC_F14", + "KC_F15", + "KC_F16", + "KC_TRNS", + "KC_SLSH", + "KC_7", + "KC_8", + "KC_9", + "KC_0", + "LCTL_T(KC_F6)", + "LALT_T(KC_F7)", + "LGUI_T(KC_F8)", + "LSFT_T(KC_F9)", + "KC_F10", + "KC_F17", + "KC_TRNS", + "KC_EQL", + "RSFT_T(KC_4)", + "RGUI_T(KC_5)", + "RALT_T(KC_6)", + "RCTL_T(KC_MINS)", + "KC_F1", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_F18", + "KC_TRNS", + "KC_MINS", + "KC_1", + "KC_2", + "KC_3", + "KC_EQL", + "KC_F19", + "KC_F20", + "KC_F21", + "KC_F22", + "KC_F23", + "KC_NO", + "KC_NO", + "KC_NLCK", + "KC_SLCK", + "KC_INS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "ANY(SK_QUIT)", + "ANY(SK_CLOZ)", + "ANY(SK_SCAP)", + "ANY(SK_SCLP)", + "ANY(SK_FAGN)", + "KC_VOLU", + "KC_MRWD", + "ANY(SK_DOCBEG)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "ANY(SK_PARAPRV)", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "ANY(SK_FIND)", + "KC_VOLD", + "KC_MFFD", + "ANY(SK_WORDPRV)", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "ANY(SK_WORDNXT)", + "ANY(SK_UNDO)", + "ANY(SK_CUT)", + "ANY(SK_COPY)", + "ANY(SK_PSTE)", + "ANY(SK_PSTM)", + "KC_MPRV", + "KC_MNXT", + "ANY(SK_DOCEND)", + "KC_END", + "KC_DOWN", + "KC_LALT", + "ANY(SK_PARANXT)", + "KC_TRNS", + "KC_TRNS", + "ANY(SK_DELWDL)", + "ANY(SK_DELWDR)", + "KC_TRNS", + "KC_MUTE", + "KC_MPLY", + "ANY(SK_ZOOMRST)", + "ANY(SK_HISTPRV)", + "ANY(SK_HISTNXT)", + "ANY(SK_ZOOMOUT)", + "ANY(SK_ZOOMIN)" + ], + [ + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_LBRC)))", + "KC_TRNS", + "KC_TRNS", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "KC_TRNS", + "KC_NLCK", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_TRNS", + "KC_TAB", + "KC_PCMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_TRNS", + "KC_TRNS", + "KC_BSPC", + "KC_DEL", + "KC_TRNS", + "KC_ENT", + "KC_TRNS", + "KC_C", + "KC_PEQL", + "KC_P0", + "KC_P0", + "KC_PDOT" + ], + [ + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET", + "KC_NO", + "BL_BRTG", + "RGB_SPI", + "RGB_SPD", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRIU", + "BL_STEP", + "BL_INC", + "RGB_HUI", + "RGB_SAI", + "RGB_VAI", + "KC_NO", + "TO(1)", + "DF(1)", + "KC_NO", + "AG_SWAP", + "CG_SWAP", + "KC_BRID", + "BL_TOGG", + "BL_DEC", + "RGB_HUD", + "RGB_SAD", + "RGB_VAD", + "TO(0)", + "DF(0)", + "KC_NO", + "AG_NORM", + "CG_NORM", + "KC_NO", + "KC_NO", + "KC_NO", + "BL_ON", + "BL_OFF", + "KC_NO", + "KC_NO" + ] + ], + "author": "", + "notes": "" +} \ No newline at end of file diff --git a/naked48/naked48_hd_bronzesilver_sk.json b/naked48/naked48_hd_bronzesilver_sk.json new file mode 100644 index 0000000..d3c35c0 --- /dev/null +++ b/naked48/naked48_hd_bronzesilver_sk.json @@ -0,0 +1,361 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "naked48/rev1", + "keymap": "naked48_hd_bronze_sk", + "layout": "LAYOUT", + "layers": [ + [ + "KC_J", + "KC_F", + "KC_M", + "KC_P", + "KC_V", + "KC_APP", + "TG(5)", + "KC_HASH", + "KC_DOT", + "KC_SLSH", + "KC_QUOT", + "KC_DQUO", + "LCTL_T(KC_R)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "LT(5,KC_TAB)", + "LT(5,KC_ESC)", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_C)", + "RCTL_T(KC_I)", + "KC_X", + "KC_G", + "KC_L", + "KC_D", + "KC_B", + "KC_LBRC", + "KC_RBRC", + "KC_MINS", + "KC_U", + "KC_O", + "KC_W", + "KC_Y", + "KC_LEFT", + "KC_RGHT", + "LT(5,KC_BSPC)", + "LT(4,KC_H)", + "LT(2,KC_LANG2)", + "LT(3,KC_MUTE)", + "LT(3,KC_MPLY)", + "LT(6,KC_LANG1)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "KC_UP", + "KC_DOWN" + ], + [ + "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", + "LGUI_T(KC_H)", + "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_TRNS", + "LT(4,KC_N)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_Q", + "KC_Z", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_9)))", + "ANY(S(G(KC_4)))", + "KC_TRNS", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT_T(KC_Y)", + "RALT(KC_3)", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "ANY(C(S(G(KC_4))))", + "KC_TRNS", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "RGUI_T(KC_PEQL)", + "RALT_T(KC_PPLS)", + "RCTL_T(KC_RO)", + "ANY(A(S(KC_5)))", + "KC_TRNS", + "KC_LCBR", + "KC_RPRN", + "RALT(KC_5)", + "KC_TRNS", + "KC_TRNS", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_TRNS", + "KC_TRNS", + "ANY(SK_DELWDL)", + "ANY(SK_DELWDR)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_F11", + "KC_F12", + "KC_F13", + "KC_F14", + "KC_F15", + "KC_F16", + "KC_TRNS", + "KC_SLSH", + "KC_7", + "KC_8", + "KC_9", + "KC_0", + "LCTL_T(KC_F6)", + "LALT_T(KC_F7)", + "LGUI_T(KC_F8)", + "LSFT_T(KC_F9)", + "KC_F10", + "KC_F17", + "KC_TRNS", + "KC_EQL", + "RSFT_T(KC_4)", + "RGUI_T(KC_5)", + "RALT_T(KC_6)", + "RCTL_T(KC_MINS)", + "KC_F1", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_F18", + "KC_TRNS", + "KC_MINS", + "KC_1", + "KC_2", + "KC_3", + "KC_EQL", + "KC_F19", + "KC_F20", + "KC_F21", + "KC_F22", + "KC_F23", + "KC_NO", + "KC_NO", + "KC_NLCK", + "KC_SLCK", + "KC_INS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "ANY(SK_QUIT)", + "ANY(SK_CLOZ)", + "ANY(SK_SCAP)", + "ANY(SK_SCLP)", + "ANY(SK_FAGN)", + "KC_VOLU", + "KC_MRWD", + "ANY(SK_DOCBEG)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "ANY(SK_PARAPRV)", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "ANY(SK_FIND)", + "KC_VOLD", + "KC_MFFD", + "ANY(SK_WORDPRV)", + "KC_LEFT", + "KC_DOWN", + "KC_RGHT", + "ANY(SK_WORDNXT)", + "ANY(SK_UNDO)", + "ANY(SK_CUT)", + "ANY(SK_COPY)", + "ANY(SK_PSTE)", + "ANY(SK_PSTM)", + "KC_MPRV", + "KC_MNXT", + "ANY(SK_DOCEND)", + "KC_END", + "KC_DOWN", + "KC_LALT", + "ANY(SK_PARANXT)", + "KC_TRNS", + "KC_TRNS", + "ANY(SK_DELWDL)", + "ANY(SK_DELWDR)", + "KC_TRNS", + "KC_MUTE", + "KC_MPLY", + "ANY(SK_ZOOMRST)", + "ANY(SK_HISTPRV)", + "ANY(SK_HISTNXT)", + "ANY(SK_ZOOMOUT)", + "ANY(SK_ZOOMIN)" + ], + [ + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_LBRC)))", + "KC_TRNS", + "KC_TRNS", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "KC_TRNS", + "KC_NLCK", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_TRNS", + "KC_TAB", + "KC_PCMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_TRNS", + "KC_TRNS", + "KC_BSPC", + "KC_DEL", + "KC_TRNS", + "KC_ENT", + "KC_TRNS", + "KC_C", + "KC_PEQL", + "KC_P0", + "KC_P0", + "KC_PDOT" + ], + [ + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET", + "KC_NO", + "BL_BRTG", + "RGB_SPI", + "RGB_SPD", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRIU", + "BL_STEP", + "BL_INC", + "RGB_HUI", + "RGB_SAI", + "RGB_VAI", + "KC_NO", + "TO(1)", + "DF(1)", + "KC_NO", + "AG_SWAP", + "CG_SWAP", + "KC_BRID", + "BL_TOGG", + "BL_DEC", + "RGB_HUD", + "RGB_SAD", + "RGB_VAD", + "TO(0)", + "DF(0)", + "KC_NO", + "AG_NORM", + "CG_NORM", + "KC_NO", + "KC_NO", + "KC_NO", + "BL_ON", + "BL_OFF", + "KC_NO", + "KC_NO" + ] + ], + "author": "", + "notes": "" +} \ No newline at end of file diff --git a/naked48/naked48_hd_keymap.c b/naked48/naked48_hd_keymap.c new file mode 100644 index 0000000..1e794b7 --- /dev/null +++ b/naked48/naked48_hd_keymap.c @@ -0,0 +1,17 @@ +#include QMK_KEYBOARD_H + +/* THIS FILE WAS GENERATED! + * + * This file was generated by qmk json2c. You may or may not want to + * edit it directly. + */ + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + [0] = LAYOUT(KC_J, KC_F, KC_M, KC_P, KC_V, KC_APP, TG(5), KC_HASH, KC_DOT, KC_SLSH, KC_QUOT, KC_DQUO, LCTL_T(KC_R), LALT_T(KC_S), LGUI_T(KC_N), LSFT_T(KC_T), KC_K, LT(5,KC_TAB), LT(5,KC_ESC), KC_COMM, RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_C), RCTL_T(KC_I), KC_X, KC_G, KC_L, KC_D, KC_B, KC_LBRC, KC_RBRC, KC_MINS, KC_U, KC_O, KC_W, KC_Y, KC_LEFT, KC_RGHT, LT(5,KC_BSPC), LT(4,KC_H), LT(2,KC_LANG2), LT(3,KC_MUTE), LT(3,KC_MPLY), LT(6,KC_LANG1), LT(2,KC_SPC), LT(4,KC_ENT), KC_UP, KC_DOWN), + [1] = LAYOUT(KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_DEL, KC_TRNS, KC_TRNS, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE, KC_TRNS, KC_TRNS, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, LSFT(KC_NUHS), LSFT(KC_NUBS), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY), + [2] = LAYOUT(KC_Q, KC_Z, LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_9)), S(G(KC_4)), KC_TRNS, LALT(KC_4), KC_DLR, A(S(KC_2)), LALT_T(KC_Y), RALT(KC_3), KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_8), C(S(G(KC_4))), KC_TRNS, RALT(KC_1), LSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_RO), A(S(KC_5)), KC_TRNS, KC_LCBR, KC_RPRN, RALT(KC_5), KC_TRNS, KC_TRNS, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, KC_TRNS, KC_TRNS, SK_DELWDL, SK_DELWDR, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [3] = LAYOUT(KC_F11, KC_F12, KC_F13, KC_F14, KC_F15, KC_F16, KC_TRNS, KC_SLSH, KC_7, KC_8, KC_9, KC_0, LCTL_T(KC_F6), LALT_T(KC_F7), LGUI_T(KC_F8), LSFT_T(KC_F9), KC_F10, KC_F17, KC_TRNS, KC_EQL, RSFT_T(KC_4), RGUI_T(KC_5), RALT_T(KC_6), RCTL_T(KC_MINS), KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F18, KC_TRNS, KC_MINS, KC_1, KC_2, KC_3, KC_EQL, KC_F19, KC_F20, KC_F21, KC_F22, KC_F23, KC_NO, KC_NO, KC_NLCK, KC_SLCK, KC_INS, KC_TRNS, KC_TRNS), + [4] = LAYOUT(SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, KC_VOLU, KC_MRWD, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, KC_VOLD, KC_MFFD, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, KC_MPRV, KC_MNXT, SK_DOCEND, KC_END, KC_DOWN, KC_LALT, SK_PARANXT, KC_TRNS, KC_TRNS, SK_DELWDL, SK_DELWDR, KC_TRNS, KC_MUTE, KC_MPLY, SK_ZOOMRST, SK_HISTPRV, SK_HISTNXT, SK_ZOOMOUT, SK_ZOOMIN), + [5] = LAYOUT(LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_LBRC)), KC_TRNS, KC_TRNS, KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_8), KC_TRNS, KC_NLCK, KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, A(S(KC_5)), A(S(KC_7)), KC_LCBR, KC_RCBR, RALT(KC_5), KC_TRNS, KC_TAB, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, KC_TRNS, KC_TRNS, KC_BSPC, KC_DEL, KC_TRNS, KC_ENT, KC_TRNS, KC_C, KC_PEQL, KC_P0, KC_P0, KC_PDOT), + [6] = LAYOUT(KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET, KC_NO, BL_BRTG, RGB_SPI, RGB_SPD, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_BRIU, BL_STEP, BL_INC, RGB_HUI, RGB_SAI, RGB_VAI, KC_NO, TO(1), DF(1), KC_NO, AG_SWAP, CG_SWAP, KC_BRID, BL_TOGG, BL_DEC, RGB_HUD, RGB_SAD, RGB_VAD, TO(0), DF(0), KC_NO, AG_NORM, CG_NORM, KC_NO, KC_NO, KC_NO, BL_ON, BL_OFF, KC_NO, KC_NO) +}; diff --git a/naked48/naked48_hd_keymap.c.bak b/naked48/naked48_hd_keymap.c.bak new file mode 100644 index 0000000..6449510 --- /dev/null +++ b/naked48/naked48_hd_keymap.c.bak @@ -0,0 +1,17 @@ +#include QMK_KEYBOARD_H + +/* THIS FILE WAS GENERATED! + * + * This file was generated by qmk json2c. You may or may not want to + * edit it directly. + */ + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + [0] = LAYOUT(KC_J, KC_F, KC_M, KC_P, KC_V, KC_APP, TG(5), KC_HASH, KC_DOT, KC_SLSH, KC_QUOT, KC_DQUO, LCTL_T(KC_R), LALT_T(KC_S), LGUI_T(KC_N), LSFT_T(KC_T), KC_K, LT(5,KC_TAB), LT(5,KC_ESC), KC_COMM, RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_C), RCTL_T(KC_I), KC_X, KC_G, KC_L, KC_D, KC_B, KC_LBRC, KC_RBRC, KC_MINS, KC_U, KC_O, KC_W, KC_Y, KC_LEFT, KC_RGHT, LT(5,KC_BSPC), LT(4,KC_H), LT(2,KC_LANG2), LT(3,KC_MUTE), LT(3,KC_MPLY), LT(6,KC_LANG1), LT(2,KC_SPC), LT(4,KC_ENT), KC_UP, KC_DOWN), + [1] = LAYOUT(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, LGUI_T(KC_H), 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_TRNS, LT(4,KC_N), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [2] = LAYOUT(KC_Q, KC_Z, LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_9)), S(G(KC_4)), KC_TRNS, LALT(KC_4), KC_DLR, A(S(KC_2)), LALT_T(KC_Y), RALT(KC_3), KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_8), C(S(G(KC_4))), KC_TRNS, RALT(KC_1), LSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_RO), A(S(KC_5)), KC_TRNS, KC_LCBR, KC_RPRN, RALT(KC_5), KC_TRNS, KC_TRNS, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, KC_TRNS, KC_TRNS, SK_DELWDL, SK_DELWDR, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), + [3] = LAYOUT(KC_F11, KC_F12, KC_F13, KC_F14, KC_F15, KC_F16, KC_TRNS, KC_SLSH, KC_7, KC_8, KC_9, KC_0, LCTL_T(KC_F6), LALT_T(KC_F7), LGUI_T(KC_F8), LSFT_T(KC_F9), KC_F10, KC_F17, KC_TRNS, KC_EQL, RSFT_T(KC_4), RGUI_T(KC_5), RALT_T(KC_6), RCTL_T(KC_MINS), KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F18, KC_TRNS, KC_MINS, KC_1, KC_2, KC_3, KC_EQL, KC_F19, KC_F20, KC_F21, KC_F22, KC_F23, KC_NO, KC_NO, KC_NLCK, KC_SLCK, KC_INS, KC_TRNS, KC_TRNS), + [4] = LAYOUT(SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, KC_VOLU, KC_MRWD, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, KC_VOLD, KC_MFFD, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, KC_MPRV, KC_MNXT, SK_DOCEND, KC_END, KC_DOWN, KC_LALT, SK_PARANXT, KC_TRNS, KC_TRNS, SK_DELWDL, SK_DELWDR, KC_TRNS, KC_MUTE, KC_MPLY, SK_ZOOMRST, SK_HISTPRV, SK_HISTNXT, SK_ZOOMOUT, SK_ZOOMIN), + [5] = LAYOUT(LALT(KC_RBRC), A(S(KC_RBRC)), LALT(KC_LBRC), A(S(KC_LBRC)), A(S(KC_LBRC)), KC_TRNS, KC_TRNS, KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, KC_LT, KC_GT, KC_LPRN, KC_RPRN, LALT(KC_8), KC_TRNS, KC_NLCK, KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, A(S(KC_5)), A(S(KC_7)), KC_LCBR, KC_RCBR, RALT(KC_5), KC_TRNS, KC_TAB, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, KC_TRNS, KC_TRNS, KC_BSPC, KC_DEL, KC_TRNS, KC_ENT, KC_TRNS, KC_C, KC_PEQL, KC_P0, KC_P0, KC_PDOT), + [6] = LAYOUT(KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, RESET, KC_NO, BL_BRTG, RGB_SPI, RGB_SPD, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_BRIU, BL_STEP, BL_INC, RGB_HUI, RGB_SAI, RGB_VAI, KC_NO, TO(1), DF(1), KC_NO, AG_SWAP, CG_SWAP, KC_BRID, BL_TOGG, BL_DEC, RGB_HUD, RGB_SAD, RGB_VAD, TO(0), DF(0), KC_NO, AG_NORM, CG_NORM, KC_NO, KC_NO, KC_NO, BL_ON, BL_OFF, KC_NO, KC_NO) +}; diff --git a/naked48/naked48_hd_platinum.json b/naked48/naked48_hd_platinum.json new file mode 100644 index 0000000..28ca9cb --- /dev/null +++ b/naked48/naked48_hd_platinum.json @@ -0,0 +1,361 @@ +{ + "version": 1, + "documentation": "This file is a QMK Configurator export. You can import this at . It can also be used directly with QMK's source code.\n\nTo setup your QMK environment check out the tutorial: \n\nYou can convert this file to a keymap.c using this command: `qmk json2c {keymap}`\n\nYou can compile this keymap using this command: `qmk compile {keymap}`\n", + "keyboard": "naked48/rev1", + "keymap": "naked48_hd_platinum", + "layout": "LAYOUT", + "layers": [ + [ + "KC_QUOT", + "KC_F", + "KC_M", + "KC_D", + "KC_B", + "KC_APP", + "LT(8,KC_MUTE)", + "KC_HASH", + "KC_DOT", + "KC_SLSH", + "KC_DQUO", + "KC_J", + "LCTL_T(KC_C)", + "LALT_T(KC_S)", + "LGUI_T(KC_N)", + "LSFT_T(KC_T)", + "KC_K", + "LT(5,KC_ESC)", + "TG(5)", + "KC_COMM", + "RSFT_T(KC_A)", + "RGUI_T(KC_E)", + "RALT_T(KC_I)", + "RCTL_T(KC_R)", + "KC_W", + "KC_G", + "KC_H", + "KC_P", + "KC_V", + "KC_LPRN", + "KC_RPRN", + "KC_MINS", + "KC_U", + "KC_O", + "KC_Y", + "KC_X", + "KC_LEFT", + "KC_RGHT", + "LT(3,KC_TAB)", + "LT(5,KC_BSPC)", + "LT(4,KC_L)", + "LT(2,KC_LANG2)", + "LT(6,KC_LANG1)", + "LT(2,KC_SPC)", + "LT(4,KC_ENT)", + "LT(3,KC_MPLY)", + "KC_UP", + "KC_DOWN" + ], + [ + "KC_TILD", + "KC_EXLM", + "KC_AT", + "KC_HASH", + "KC_DLR", + "KC_PERC", + "KC_CIRC", + "KC_AMPR", + "KC_ASTR", + "KC_LPRN", + "KC_RPRN", + "KC_DEL", + "KC_TRNS", + "KC_TRNS", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_F6", + "KC_UNDS", + "KC_PLUS", + "KC_LCBR", + "KC_RCBR", + "KC_PIPE", + "KC_TRNS", + "KC_TRNS", + "KC_F8", + "KC_F9", + "KC_F10", + "KC_F11", + "KC_F12", + "LSFT(KC_NUHS)", + "LSFT(KC_NUBS)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_MNXT", + "KC_VOLD", + "KC_VOLU", + "KC_MPLY" + ], + [ + "KC_Q", + "KC_Z", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_9)))", + "ANY(S(G(KC_4)))", + "KC_TRNS", + "LALT(KC_4)", + "KC_DLR", + "ANY(A(S(KC_2)))", + "LALT_T(KC_Y)", + "RALT(KC_3)", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "ANY(C(S(G(KC_4))))", + "KC_TRNS", + "RALT(KC_1)", + "LSFT_T(KC_PAST)", + "RGUI_T(KC_PEQL)", + "RALT_T(KC_PPLS)", + "RCTL_T(KC_RO)", + "ANY(A(S(KC_5)))", + "KC_TRNS", + "KC_LCBR", + "KC_RPRN", + "RALT(KC_5)", + "KC_TRNS", + "KC_TRNS", + "KC_UNDS", + "KC_PIPE", + "KC_AMPR", + "KC_CIRC", + "KC_PERC", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "LALT(KC_BSPC)", + "LALT(KC_DEL)", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_F11", + "KC_F12", + "KC_F13", + "KC_F14", + "KC_F15", + "KC_F16", + "KC_TRNS", + "KC_SLSH", + "KC_7", + "KC_8", + "KC_9", + "KC_0", + "LCTL_T(KC_6)", + "LALT_T(KC_7)", + "LGUI_T(KC_8)", + "LSFT_T(KC_9)", + "KC_F10", + "KC_F17", + "KC_TRNS", + "KC_EQL", + "RSFT_T(KC_4)", + "RGUI_T(KC_5)", + "RALT_T(KC_6)", + "RCTL_T(KC_MINS)", + "KC_F1", + "KC_F2", + "KC_F3", + "KC_F4", + "KC_F5", + "KC_F18", + "KC_TRNS", + "KC_MINS", + "KC_1", + "KC_2", + "KC_3", + "KC_EQL", + "KC_F19", + "KC_F20", + "KC_F21", + "KC_F22", + "KC_F23", + "KC_NO", + "KC_NO", + "KC_NLCK", + "KC_SLCK", + "KC_INS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_EJCT", + "KC_NO", + "LALT(KC_HOME)", + "KC_HOME", + "KC_UP", + "KC_PGUP", + "LALT(KC_PGUP)", + "KC_LCTL", + "KC_LALT", + "KC_LGUI", + "KC_LSFT", + "KC_VOLU", + "KC_NO", + "KC_NO", + "LALT(KC_LEFT)", + "KC_LEFT", + "KC_UP", + "KC_RGHT", + "LALT(KC_RGHT)", + "KC_NO", + "KC_NO", + "KC_MRWD", + "KC_MFFD", + "KC_VOLD", + "KC_NO", + "KC_NO", + "LALT(KC_END)", + "KC_END", + "KC_DOWN", + "KC_LALT", + "LALT(KC_PGDN)", + "KC_NO", + "KC_MPRV", + "KC_MNXT", + "KC_MUTE", + "KC_MPLY", + "KC_NO", + "LGUI_T(KC_LBRC)", + "LGUI(KC_RBRC)", + "ANY(G(S(KC_EQL)))", + "LGUI(KC_MINS)", + "LGUI(KC_0)", + "KC_NO" + ], + [ + "LALT(KC_RBRC)", + "ANY(A(S(KC_RBRC)))", + "LALT(KC_LBRC)", + "ANY(A(S(KC_LBRC)))", + "ANY(A(S(KC_LBRC)))", + "ANY(S(G(KC_4)))", + "KC_NLCK", + "KC_PSLS", + "KC_P7", + "KC_P8", + "KC_P9", + "KC_PMNS", + "KC_LT", + "KC_GT", + "KC_LPRN", + "KC_RPRN", + "LALT(KC_8)", + "ANY(C(S(G(KC_4))))", + "TG(5)", + "KC_PAST", + "KC_P4", + "KC_P5", + "KC_P6", + "KC_PPLS", + "ANY(A(S(KC_5)))", + "ANY(A(S(KC_7)))", + "KC_LCBR", + "KC_RCBR", + "RALT(KC_5)", + "KC_TRNS", + "KC_TRNS", + "KC_COMM", + "KC_P1", + "KC_P2", + "KC_P3", + "KC_PEQL", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS", + "KC_ENT", + "KC_BSPC", + "KC_DEL", + "KC_P0", + "KC_PDOT", + "KC_C", + "KC_TRNS", + "KC_TRNS", + "KC_TRNS" + ], + [ + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "RESET", + "KC_NO", + "BL_BRTG", + "RGB_SPI", + "RGB_SPD", + "KC_NO", + "KC_NO", + "DF(0)", + "DF(1)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRIU", + "BL_STEP", + "BL_INC", + "RGB_HUI", + "RGB_SAI", + "RGB_VAI", + "TO(0)", + "TO(1)", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_BRID", + "BL_TOGG", + "BL_DEC", + "RGB_HUD", + "RGB_SAD", + "RGB_VAD", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "KC_NO", + "BL_ON", + "BL_OFF", + "KC_NO", + "KC_NO" + ] + ], + "author": "", + "notes": "" +} \ No newline at end of file