diff options
| author | Joel Challis <git@zvecr.com> | 2024-11-23 13:35:34 +0000 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2024-11-23 13:35:34 +0000 |
| commit | e4e015c0c80ca59d329e1343ee7803250b7e60fe (patch) | |
| tree | 35fda543ce80327a2b79bdc522a4ebebed1a0729 /keyboards | |
| parent | 4a5bae51cd1f2cbca0ab8c8ae6e15262f8dc5a68 (diff) | |
Update keymaps to use PDF keycode (#24633)
Diffstat (limited to 'keyboards')
80 files changed, 286 insertions, 1705 deletions
diff --git a/keyboards/25keys/zinc/keymaps/default/keymap.c b/keyboards/25keys/zinc/keymaps/default/keymap.c index 0d68eb4541..4c4a6a5f3e 100644 --- a/keyboards/25keys/zinc/keymaps/default/keymap.c +++ b/keyboards/25keys/zinc/keymaps/default/keymap.c | |||
| @@ -23,10 +23,7 @@ enum layer_number { | |||
| 23 | }; | 23 | }; |
| 24 | 24 | ||
| 25 | enum custom_keycodes { | 25 | enum custom_keycodes { |
| 26 | QWERTY = SAFE_RANGE, | 26 | LOWER = SAFE_RANGE, |
| 27 | COLEMAK, | ||
| 28 | DVORAK, | ||
| 29 | LOWER, | ||
| 30 | RAISE, | 27 | RAISE, |
| 31 | ADJUST, | 28 | ADJUST, |
| 32 | BACKLIT, | 29 | BACKLIT, |
| @@ -35,12 +32,9 @@ enum custom_keycodes { | |||
| 35 | RGBRST | 32 | RGBRST |
| 36 | }; | 33 | }; |
| 37 | 34 | ||
| 38 | enum macro_keycodes { | 35 | #define QWERTY PDF(_QWERTY) |
| 39 | KC_SAMPLEMACRO, | 36 | #define COLEMAK PDF(_COLEMAK) |
| 40 | }; | 37 | #define DVORAK PDF(_DVORAK) |
| 41 | |||
| 42 | //Macros | ||
| 43 | #define M_SAMPLE M(KC_SAMPLEMACRO) | ||
| 44 | 38 | ||
| 45 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 39 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 46 | /* Qwerty | 40 | /* Qwerty |
| @@ -169,25 +163,6 @@ void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) { | |||
| 169 | 163 | ||
| 170 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 164 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 171 | switch (keycode) { | 165 | switch (keycode) { |
| 172 | case QWERTY: | ||
| 173 | if (record->event.pressed) { | ||
| 174 | set_single_persistent_default_layer(_QWERTY); | ||
| 175 | } | ||
| 176 | return false; | ||
| 177 | break; | ||
| 178 | case COLEMAK: | ||
| 179 | if (record->event.pressed) { | ||
| 180 | set_single_persistent_default_layer(_COLEMAK); | ||
| 181 | } | ||
| 182 | return false; | ||
| 183 | break; | ||
| 184 | case DVORAK: | ||
| 185 | if (record->event.pressed) { | ||
| 186 | set_single_persistent_default_layer(_DVORAK); | ||
| 187 | } | ||
| 188 | return false; | ||
| 189 | break; | ||
| 190 | |||
| 191 | case LOWER: | 166 | case LOWER: |
| 192 | if (record->event.pressed) { | 167 | if (record->event.pressed) { |
| 193 | //not sure how to have keyboard check mode and set it to a variable, so my work around | 168 | //not sure how to have keyboard check mode and set it to a variable, so my work around |
diff --git a/keyboards/40percentclub/nori/keymaps/default/keymap.c b/keyboards/40percentclub/nori/keymaps/default/keymap.c index 03f8c15787..1c7405f2ac 100644 --- a/keyboards/40percentclub/nori/keymaps/default/keymap.c +++ b/keyboards/40percentclub/nori/keymaps/default/keymap.c | |||
| @@ -13,16 +13,14 @@ enum layer_names { | |||
| 13 | _ADJUST | 13 | _ADJUST |
| 14 | }; | 14 | }; |
| 15 | 15 | ||
| 16 | enum custom_keycodes { | ||
| 17 | QWERTY = SAFE_RANGE, | ||
| 18 | COLEMAK, | ||
| 19 | DVORAK, | ||
| 20 | }; | ||
| 21 | |||
| 22 | #define LOWER MO(_LOWER) | 16 | #define LOWER MO(_LOWER) |
| 23 | #define RAISE MO(_RAISE) | 17 | #define RAISE MO(_RAISE) |
| 24 | #define ADJUST MO(_ADJUST) | 18 | #define ADJUST MO(_ADJUST) |
| 25 | 19 | ||
| 20 | #define QWERTY PDF(_QWERTY) | ||
| 21 | #define COLEMAK PDF(_COLEMAK) | ||
| 22 | #define DVORAK PDF(_DVORAK) | ||
| 23 | |||
| 26 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 24 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 27 | /* Qwerty | 25 | /* Qwerty |
| 28 | * ,-----------------------------------------------------------------------------------. | 26 | * ,-----------------------------------------------------------------------------------. |
| @@ -138,24 +136,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 138 | layer_state_t layer_state_set_user(layer_state_t state) { | 136 | layer_state_t layer_state_set_user(layer_state_t state) { |
| 139 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 137 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 140 | } | 138 | } |
| 141 | |||
| 142 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 143 | switch (keycode) { | ||
| 144 | case QWERTY: | ||
| 145 | if (record->event.pressed) { | ||
| 146 | set_single_persistent_default_layer(_QWERTY); | ||
| 147 | } | ||
| 148 | return false; | ||
| 149 | case COLEMAK: | ||
| 150 | if (record->event.pressed) { | ||
| 151 | set_single_persistent_default_layer(_COLEMAK); | ||
| 152 | } | ||
| 153 | return false; | ||
| 154 | case DVORAK: | ||
| 155 | if (record->event.pressed) { | ||
| 156 | set_single_persistent_default_layer(_DVORAK); | ||
| 157 | } | ||
| 158 | return false; | ||
| 159 | } | ||
| 160 | return true; | ||
| 161 | } | ||
diff --git a/keyboards/aleblazer/zodiark/keymaps/default/keymap.c b/keyboards/aleblazer/zodiark/keymaps/default/keymap.c index 65d431eb9a..7c5414e93a 100644 --- a/keyboards/aleblazer/zodiark/keymaps/default/keymap.c +++ b/keyboards/aleblazer/zodiark/keymaps/default/keymap.c | |||
| @@ -23,9 +23,7 @@ enum sofle_layers { | |||
| 23 | }; | 23 | }; |
| 24 | 24 | ||
| 25 | enum custom_keycodes { | 25 | enum custom_keycodes { |
| 26 | KC_QWERTY = SAFE_RANGE, | 26 | KC_LOWER = SAFE_RANGE, |
| 27 | KC_COLEMAK, | ||
| 28 | KC_LOWER, | ||
| 29 | KC_RAISE, | 27 | KC_RAISE, |
| 30 | KC_ADJUST, | 28 | KC_ADJUST, |
| 31 | KC_PRVWD, | 29 | KC_PRVWD, |
| @@ -35,6 +33,9 @@ enum custom_keycodes { | |||
| 35 | KC_DLINE | 33 | KC_DLINE |
| 36 | }; | 34 | }; |
| 37 | 35 | ||
| 36 | #define KC_QWERTY PDF(_QWERTY) | ||
| 37 | #define KC_COLEMAK PDF(_COLEMAK) | ||
| 38 | |||
| 38 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 39 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 39 | 40 | ||
| 40 | [_QWERTY] = LAYOUT( | 41 | [_QWERTY] = LAYOUT( |
| @@ -148,16 +149,6 @@ bool oled_task_user(void) { | |||
| 148 | 149 | ||
| 149 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 150 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 150 | switch (keycode) { | 151 | switch (keycode) { |
| 151 | case KC_QWERTY: | ||
| 152 | if (record->event.pressed) { | ||
| 153 | set_single_persistent_default_layer(_QWERTY); | ||
| 154 | } | ||
| 155 | return false; | ||
| 156 | case KC_COLEMAK: | ||
| 157 | if (record->event.pressed) { | ||
| 158 | set_single_persistent_default_layer(_COLEMAK); | ||
| 159 | } | ||
| 160 | return false; | ||
| 161 | case KC_LOWER: | 152 | case KC_LOWER: |
| 162 | if (record->event.pressed) { | 153 | if (record->event.pressed) { |
| 163 | layer_on(_LOWER); | 154 | layer_on(_LOWER); |
diff --git a/keyboards/bear_face/v1/keymaps/default/keymap.c b/keyboards/bear_face/v1/keymaps/default/keymap.c index e615a3915d..22235f4af6 100644 --- a/keyboards/bear_face/v1/keymaps/default/keymap.c +++ b/keyboards/bear_face/v1/keymaps/default/keymap.c | |||
| @@ -12,12 +12,9 @@ enum layers { | |||
| 12 | 12 | ||
| 13 | #define FN1_CAPS LT(_FN1, KC_CAPS) | 13 | #define FN1_CAPS LT(_FN1, KC_CAPS) |
| 14 | 14 | ||
| 15 | //custom keycode enums | 15 | #define BASE_QWER PDF(_QWER) |
| 16 | enum custom_keycodes { | 16 | #define BASE_COLE PDF(_COLE) |
| 17 | BASE_QWER = QK_USER, | 17 | #define BASE_DVOR PDF(_DVOR) |
| 18 | BASE_COLE, | ||
| 19 | BASE_DVOR | ||
| 20 | }; | ||
| 21 | 18 | ||
| 22 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 19 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 23 | [_QWER] = LAYOUT( | 20 | [_QWER] = LAYOUT( |
| @@ -67,37 +64,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 67 | ), | 64 | ), |
| 68 | */ | 65 | */ |
| 69 | }; | 66 | }; |
| 70 | |||
| 71 | |||
| 72 | // macros to allow the user to set whatever default layer they want, even after reboot | ||
| 73 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 74 | switch (keycode) { | ||
| 75 | case BASE_QWER: | ||
| 76 | if (record->event.pressed) { | ||
| 77 | // when keycode BASE_QWER is pressed | ||
| 78 | set_single_persistent_default_layer(_QWER); | ||
| 79 | } else { | ||
| 80 | // when keycode BASE_QWER is released | ||
| 81 | } | ||
| 82 | break; | ||
| 83 | |||
| 84 | case BASE_COLE: | ||
| 85 | if (record->event.pressed) { | ||
| 86 | // when keycode BASE_COLE is pressed | ||
| 87 | set_single_persistent_default_layer(_COLE); | ||
| 88 | } else { | ||
| 89 | // when keycode BASE_COLE is released | ||
| 90 | } | ||
| 91 | break; | ||
| 92 | |||
| 93 | case BASE_DVOR: | ||
| 94 | if (record->event.pressed) { | ||
| 95 | // when keycode BASE_DVOR is pressed | ||
| 96 | set_single_persistent_default_layer(_DVOR); | ||
| 97 | } else { | ||
| 98 | // when keycode BASE_DVOR is released | ||
| 99 | } | ||
| 100 | break; | ||
| 101 | } | ||
| 102 | return true; | ||
| 103 | }; | ||
diff --git a/keyboards/bear_face/v2/keymaps/default/keymap.c b/keyboards/bear_face/v2/keymaps/default/keymap.c index 08f193052a..0f8aefb4b3 100644 --- a/keyboards/bear_face/v2/keymaps/default/keymap.c +++ b/keyboards/bear_face/v2/keymaps/default/keymap.c | |||
| @@ -12,12 +12,9 @@ enum layers { | |||
| 12 | 12 | ||
| 13 | #define FN1_CAPS LT(_FN1, KC_CAPS) | 13 | #define FN1_CAPS LT(_FN1, KC_CAPS) |
| 14 | 14 | ||
| 15 | //custom keycode enums | 15 | #define BASE_QWER PDF(_QWER) |
| 16 | enum custom_keycodes { | 16 | #define BASE_COLE PDF(_COLE) |
| 17 | BASE_QWER = QK_USER, | 17 | #define BASE_DVOR PDF(_DVOR) |
| 18 | BASE_COLE, | ||
| 19 | BASE_DVOR | ||
| 20 | }; | ||
| 21 | 18 | ||
| 22 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 19 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 23 | [_QWER] = LAYOUT_83_ansi( | 20 | [_QWER] = LAYOUT_83_ansi( |
| @@ -67,37 +64,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 67 | ), | 64 | ), |
| 68 | */ | 65 | */ |
| 69 | }; | 66 | }; |
| 70 | |||
| 71 | |||
| 72 | // macros to allow the user to set whatever default layer they want, even after reboot | ||
| 73 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 74 | switch (keycode) { | ||
| 75 | case BASE_QWER: | ||
| 76 | if (record->event.pressed) { | ||
| 77 | // when keycode BASE_QWER is pressed | ||
| 78 | set_single_persistent_default_layer(_QWER); | ||
| 79 | } else { | ||
| 80 | // when keycode BASE_QWER is released | ||
| 81 | } | ||
| 82 | break; | ||
| 83 | |||
| 84 | case BASE_COLE: | ||
| 85 | if (record->event.pressed) { | ||
| 86 | // when keycode BASE_COLE is pressed | ||
| 87 | set_single_persistent_default_layer(_COLE); | ||
| 88 | } else { | ||
| 89 | // when keycode BASE_COLE is released | ||
| 90 | } | ||
| 91 | break; | ||
| 92 | |||
| 93 | case BASE_DVOR: | ||
| 94 | if (record->event.pressed) { | ||
| 95 | // when keycode BASE_DVOR is pressed | ||
| 96 | set_single_persistent_default_layer(_DVOR); | ||
| 97 | } else { | ||
| 98 | // when keycode BASE_DVOR is released | ||
| 99 | } | ||
| 100 | break; | ||
| 101 | } | ||
| 102 | return true; | ||
| 103 | }; | ||
diff --git a/keyboards/bear_face/v2/keymaps/default_iso/keymap.c b/keyboards/bear_face/v2/keymaps/default_iso/keymap.c index a5e96207f6..69d6720510 100644 --- a/keyboards/bear_face/v2/keymaps/default_iso/keymap.c +++ b/keyboards/bear_face/v2/keymaps/default_iso/keymap.c | |||
| @@ -12,12 +12,9 @@ enum layers { | |||
| 12 | 12 | ||
| 13 | #define FN1_CAPS LT(_FN1, KC_CAPS) | 13 | #define FN1_CAPS LT(_FN1, KC_CAPS) |
| 14 | 14 | ||
| 15 | //custom keycode enums | 15 | #define BASE_QWER PDF(_QWER) |
| 16 | enum custom_keycodes { | 16 | #define BASE_COLE PDF(_COLE) |
| 17 | BASE_QWER = QK_USER, | 17 | #define BASE_DVOR PDF(_DVOR) |
| 18 | BASE_COLE, | ||
| 19 | BASE_DVOR | ||
| 20 | }; | ||
| 21 | 18 | ||
| 22 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 19 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 23 | [_QWER] = LAYOUT_84_iso( | 20 | [_QWER] = LAYOUT_84_iso( |
| @@ -67,37 +64,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 67 | ), | 64 | ), |
| 68 | */ | 65 | */ |
| 69 | }; | 66 | }; |
| 70 | |||
| 71 | |||
| 72 | //macros to allow the user to set whatever default layer they want, even after reboot | ||
| 73 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 74 | switch (keycode) { | ||
| 75 | case BASE_QWER: | ||
| 76 | if (record->event.pressed) { | ||
| 77 | // when keycode BASE_QWER is pressed | ||
| 78 | set_single_persistent_default_layer(_QWER); | ||
| 79 | } else { | ||
| 80 | // when keycode BASE_QWER is released | ||
| 81 | } | ||
| 82 | break; | ||
| 83 | |||
| 84 | case BASE_COLE: | ||
| 85 | if (record->event.pressed) { | ||
| 86 | // when keycode BASE_COLE is pressed | ||
| 87 | set_single_persistent_default_layer(_COLE); | ||
| 88 | } else { | ||
| 89 | // when keycode BASE_COLE is released | ||
| 90 | } | ||
| 91 | break; | ||
| 92 | |||
| 93 | case BASE_DVOR: | ||
| 94 | if (record->event.pressed) { | ||
| 95 | // when keycode BASE_DVOR is pressed | ||
| 96 | set_single_persistent_default_layer(_DVOR); | ||
| 97 | } else { | ||
| 98 | // when keycode BASE_DVOR is released | ||
| 99 | } | ||
| 100 | break; | ||
| 101 | } | ||
| 102 | return true; | ||
| 103 | }; | ||
diff --git a/keyboards/bear_face/v3/keymaps/default/keymap.c b/keyboards/bear_face/v3/keymaps/default/keymap.c index f6e71f1b34..0f8aefb4b3 100644 --- a/keyboards/bear_face/v3/keymaps/default/keymap.c +++ b/keyboards/bear_face/v3/keymaps/default/keymap.c | |||
| @@ -12,12 +12,9 @@ enum layers { | |||
| 12 | 12 | ||
| 13 | #define FN1_CAPS LT(_FN1, KC_CAPS) | 13 | #define FN1_CAPS LT(_FN1, KC_CAPS) |
| 14 | 14 | ||
| 15 | //custom keycode enums | 15 | #define BASE_QWER PDF(_QWER) |
| 16 | enum custom_keycodes { | 16 | #define BASE_COLE PDF(_COLE) |
| 17 | BASE_QWER = QK_USER, | 17 | #define BASE_DVOR PDF(_DVOR) |
| 18 | BASE_COLE, | ||
| 19 | BASE_DVOR | ||
| 20 | }; | ||
| 21 | 18 | ||
| 22 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 19 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 23 | [_QWER] = LAYOUT_83_ansi( | 20 | [_QWER] = LAYOUT_83_ansi( |
| @@ -67,26 +64,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 67 | ), | 64 | ), |
| 68 | */ | 65 | */ |
| 69 | }; | 66 | }; |
| 70 | |||
| 71 | |||
| 72 | // Macros to allow the user to set whatever default layer they want, even after reboot | ||
| 73 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 74 | switch (keycode) { | ||
| 75 | case BASE_QWER: | ||
| 76 | if (record->event.pressed) { | ||
| 77 | set_single_persistent_default_layer(_QWER); | ||
| 78 | } | ||
| 79 | break; | ||
| 80 | case BASE_COLE: | ||
| 81 | if (record->event.pressed) { | ||
| 82 | set_single_persistent_default_layer(_COLE); | ||
| 83 | } | ||
| 84 | break; | ||
| 85 | case BASE_DVOR: | ||
| 86 | if (record->event.pressed) { | ||
| 87 | set_single_persistent_default_layer(_DVOR); | ||
| 88 | } | ||
| 89 | break; | ||
| 90 | } | ||
| 91 | return true; | ||
| 92 | }; | ||
diff --git a/keyboards/bear_face/v3/keymaps/default_iso/keymap.c b/keyboards/bear_face/v3/keymaps/default_iso/keymap.c index cc97d54a9b..69d6720510 100644 --- a/keyboards/bear_face/v3/keymaps/default_iso/keymap.c +++ b/keyboards/bear_face/v3/keymaps/default_iso/keymap.c | |||
| @@ -12,12 +12,9 @@ enum layers { | |||
| 12 | 12 | ||
| 13 | #define FN1_CAPS LT(_FN1, KC_CAPS) | 13 | #define FN1_CAPS LT(_FN1, KC_CAPS) |
| 14 | 14 | ||
| 15 | //custom keycode enums | 15 | #define BASE_QWER PDF(_QWER) |
| 16 | enum custom_keycodes { | 16 | #define BASE_COLE PDF(_COLE) |
| 17 | BASE_QWER = QK_USER, | 17 | #define BASE_DVOR PDF(_DVOR) |
| 18 | BASE_COLE, | ||
| 19 | BASE_DVOR | ||
| 20 | }; | ||
| 21 | 18 | ||
| 22 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 19 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 23 | [_QWER] = LAYOUT_84_iso( | 20 | [_QWER] = LAYOUT_84_iso( |
| @@ -67,26 +64,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 67 | ), | 64 | ), |
| 68 | */ | 65 | */ |
| 69 | }; | 66 | }; |
| 70 | |||
| 71 | |||
| 72 | // Macros to allow the user to set whatever default layer they want, even after reboot | ||
| 73 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 74 | switch (keycode) { | ||
| 75 | case BASE_QWER: | ||
| 76 | if (record->event.pressed) { | ||
| 77 | set_single_persistent_default_layer(_QWER); | ||
| 78 | } | ||
| 79 | break; | ||
| 80 | case BASE_COLE: | ||
| 81 | if (record->event.pressed) { | ||
| 82 | set_single_persistent_default_layer(_COLE); | ||
| 83 | } | ||
| 84 | break; | ||
| 85 | case BASE_DVOR: | ||
| 86 | if (record->event.pressed) { | ||
| 87 | set_single_persistent_default_layer(_DVOR); | ||
| 88 | } | ||
| 89 | break; | ||
| 90 | } | ||
| 91 | return true; | ||
| 92 | }; | ||
diff --git a/keyboards/beatervan/keymaps/default/keymap.c b/keyboards/beatervan/keymaps/default/keymap.c index a99b9c9e51..ef88ae9207 100644 --- a/keyboards/beatervan/keymaps/default/keymap.c +++ b/keyboards/beatervan/keymaps/default/keymap.c | |||
| @@ -24,11 +24,9 @@ enum layers { | |||
| 24 | _L3, | 24 | _L3, |
| 25 | }; | 25 | }; |
| 26 | 26 | ||
| 27 | enum custom_keycodes { | 27 | #define QWERTY PDF(_QW) |
| 28 | DVORAK = SAFE_RANGE, | 28 | #define DVORAK PDF(_DV) |
| 29 | QWERTY, | 29 | #define COLEMAK PDF(_CM) |
| 30 | COLEMAK | ||
| 31 | }; | ||
| 32 | 30 | ||
| 33 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 31 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 34 | [_QW] = LAYOUT( /* Qwerty */ | 32 | [_QW] = LAYOUT( /* Qwerty */ |
| @@ -68,26 +66,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 68 | _______, KC_LSFT, KC_B, KC_SPC, KC_C, _______, _______, _______ | 66 | _______, KC_LSFT, KC_B, KC_SPC, KC_C, _______, _______, _______ |
| 69 | ) | 67 | ) |
| 70 | }; | 68 | }; |
| 71 | |||
| 72 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 73 | switch(keycode) { | ||
| 74 | case DVORAK: | ||
| 75 | if (record->event.pressed) { | ||
| 76 | set_single_persistent_default_layer(_DV); | ||
| 77 | } | ||
| 78 | return false; | ||
| 79 | case QWERTY: | ||
| 80 | if (record->event.pressed) { | ||
| 81 | set_single_persistent_default_layer(_QW); | ||
| 82 | } | ||
| 83 | return false; | ||
| 84 | case COLEMAK: | ||
| 85 | if (record->event.pressed) { | ||
| 86 | set_single_persistent_default_layer(_CM); | ||
| 87 | } | ||
| 88 | return false; | ||
| 89 | default: | ||
| 90 | return true; | ||
| 91 | } | ||
| 92 | return true; | ||
| 93 | }; | ||
diff --git a/keyboards/contra/keymaps/default/keymap.c b/keyboards/contra/keymaps/default/keymap.c index 29f98033d6..415e22e81a 100644 --- a/keyboards/contra/keymaps/default/keymap.c +++ b/keyboards/contra/keymaps/default/keymap.c | |||
| @@ -28,16 +28,17 @@ enum planck_layers { | |||
| 28 | }; | 28 | }; |
| 29 | 29 | ||
| 30 | enum planck_keycodes { | 30 | enum planck_keycodes { |
| 31 | QWERTY = SAFE_RANGE, | 31 | PLOVER = SAFE_RANGE, |
| 32 | COLEMAK, | ||
| 33 | DVORAK, | ||
| 34 | PLOVER, | ||
| 35 | LOWER, | 32 | LOWER, |
| 36 | RAISE, | 33 | RAISE, |
| 37 | BACKLIT, | 34 | BACKLIT, |
| 38 | EXT_PLV | 35 | EXT_PLV |
| 39 | }; | 36 | }; |
| 40 | 37 | ||
| 38 | #define QWERTY PDF(_QWERTY) | ||
| 39 | #define COLEMAK PDF(_COLEMAK) | ||
| 40 | #define DVORAK PDF(_DVORAK) | ||
| 41 | |||
| 41 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 42 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 42 | 43 | ||
| 43 | /* Qwerty | 44 | /* Qwerty |
| @@ -177,25 +178,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 177 | 178 | ||
| 178 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 179 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 179 | switch (keycode) { | 180 | switch (keycode) { |
| 180 | case QWERTY: | ||
| 181 | if (record->event.pressed) { | ||
| 182 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 183 | set_single_persistent_default_layer(_QWERTY); | ||
| 184 | } | ||
| 185 | return false; | ||
| 186 | break; | ||
| 187 | case COLEMAK: | ||
| 188 | if (record->event.pressed) { | ||
| 189 | set_single_persistent_default_layer(_COLEMAK); | ||
| 190 | } | ||
| 191 | return false; | ||
| 192 | break; | ||
| 193 | case DVORAK: | ||
| 194 | if (record->event.pressed) { | ||
| 195 | set_single_persistent_default_layer(_DVORAK); | ||
| 196 | } | ||
| 197 | return false; | ||
| 198 | break; | ||
| 199 | case LOWER: | 181 | case LOWER: |
| 200 | if (record->event.pressed) { | 182 | if (record->event.pressed) { |
| 201 | layer_on(_LOWER); | 183 | layer_on(_LOWER); |
diff --git a/keyboards/delikeeb/flatbread60/keymaps/default/keymap.c b/keyboards/delikeeb/flatbread60/keymaps/default/keymap.c index 8ed0118578..8dfcce364b 100644 --- a/keyboards/delikeeb/flatbread60/keymaps/default/keymap.c +++ b/keyboards/delikeeb/flatbread60/keymaps/default/keymap.c | |||
| @@ -18,16 +18,13 @@ | |||
| 18 | // Defines names for use in layer keycodes and the keymap | 18 | // Defines names for use in layer keycodes and the keymap |
| 19 | enum layer_names { _QWERTY, _COLEMAK, _DVORAK, _LOWER, _RAISE, _ADJUST }; | 19 | enum layer_names { _QWERTY, _COLEMAK, _DVORAK, _LOWER, _RAISE, _ADJUST }; |
| 20 | 20 | ||
| 21 | enum layer_keycodes { | ||
| 22 | QWERTY = SAFE_RANGE, | ||
| 23 | COLEMAK, | ||
| 24 | DVORAK, | ||
| 25 | }; | ||
| 26 | |||
| 27 | // Defines the keycodes used by our macros in process_record_user | ||
| 28 | #define LOWER MO(_LOWER) | 21 | #define LOWER MO(_LOWER) |
| 29 | #define RAISE MO(_RAISE) | 22 | #define RAISE MO(_RAISE) |
| 30 | 23 | ||
| 24 | #define QWERTY PDF(_QWERTY) | ||
| 25 | #define COLEMAK PDF(_COLEMAK) | ||
| 26 | #define DVORAK PDF(_DVORAK) | ||
| 27 | |||
| 31 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 28 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 32 | /* BASE | 29 | /* BASE |
| 33 | * ,-----------------------------------------------------------------------------------. | 30 | * ,-----------------------------------------------------------------------------------. |
| @@ -163,25 +160,3 @@ layer_state_t layer_state_set_user(layer_state_t state) { | |||
| 163 | state = update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST); | 160 | state = update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST); |
| 164 | return state; | 161 | return state; |
| 165 | } | 162 | } |
| 166 | |||
| 167 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 168 | switch (keycode) { | ||
| 169 | case QWERTY: | ||
| 170 | if (record->event.pressed) { | ||
| 171 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 172 | set_single_persistent_default_layer(_QWERTY); | ||
| 173 | } | ||
| 174 | return false; | ||
| 175 | case COLEMAK: | ||
| 176 | if (record->event.pressed) { | ||
| 177 | set_single_persistent_default_layer(_COLEMAK); | ||
| 178 | } | ||
| 179 | return false; | ||
| 180 | case DVORAK: | ||
| 181 | if (record->event.pressed) { | ||
| 182 | set_single_persistent_default_layer(_DVORAK); | ||
| 183 | } | ||
| 184 | return false; | ||
| 185 | } | ||
| 186 | return true; | ||
| 187 | } | ||
diff --git a/keyboards/dm9records/plaid/keymaps/default/keymap.c b/keyboards/dm9records/plaid/keymaps/default/keymap.c index 2b366f4930..0d8d24c575 100644 --- a/keyboards/dm9records/plaid/keymaps/default/keymap.c +++ b/keyboards/dm9records/plaid/keymaps/default/keymap.c | |||
| @@ -28,10 +28,7 @@ enum plaid_layers { | |||
| 28 | }; | 28 | }; |
| 29 | 29 | ||
| 30 | enum plaid_keycodes { | 30 | enum plaid_keycodes { |
| 31 | QWERTY = SAFE_RANGE, | 31 | PLOVER = SAFE_RANGE, |
| 32 | COLEMAK, | ||
| 33 | DVORAK, | ||
| 34 | PLOVER, | ||
| 35 | EXT_PLV, | 32 | EXT_PLV, |
| 36 | LED_1, | 33 | LED_1, |
| 37 | LED_2, | 34 | LED_2, |
| @@ -48,6 +45,10 @@ enum plaid_keycodes { | |||
| 48 | #define LOWER MO(_LOWER) | 45 | #define LOWER MO(_LOWER) |
| 49 | #define RAISE MO(_RAISE) | 46 | #define RAISE MO(_RAISE) |
| 50 | 47 | ||
| 48 | #define QWERTY PDF(_QWERTY) | ||
| 49 | #define COLEMAK PDF(_COLEMAK) | ||
| 50 | #define DVORAK PDF(_DVORAK) | ||
| 51 | |||
| 51 | // array of keys considered modifiers for led purposes | 52 | // array of keys considered modifiers for led purposes |
| 52 | const uint16_t modifiers[] = { | 53 | const uint16_t modifiers[] = { |
| 53 | KC_LCTL, | 54 | KC_LCTL, |
| @@ -301,25 +302,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 301 | led_keypress_update(LED_GREEN, led_config.green_mode, keycode, record); | 302 | led_keypress_update(LED_GREEN, led_config.green_mode, keycode, record); |
| 302 | } | 303 | } |
| 303 | switch (keycode) { | 304 | switch (keycode) { |
| 304 | case QWERTY: | ||
| 305 | if (record->event.pressed) { | ||
| 306 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 307 | set_single_persistent_default_layer(_QWERTY); | ||
| 308 | } | ||
| 309 | return false; | ||
| 310 | break; | ||
| 311 | case COLEMAK: | ||
| 312 | if (record->event.pressed) { | ||
| 313 | set_single_persistent_default_layer(_COLEMAK); | ||
| 314 | } | ||
| 315 | return false; | ||
| 316 | break; | ||
| 317 | case DVORAK: | ||
| 318 | if (record->event.pressed) { | ||
| 319 | set_single_persistent_default_layer(_DVORAK); | ||
| 320 | } | ||
| 321 | return false; | ||
| 322 | break; | ||
| 323 | case PLOVER: | 305 | case PLOVER: |
| 324 | if (record->event.pressed) { | 306 | if (record->event.pressed) { |
| 325 | layer_off(_RAISE); | 307 | layer_off(_RAISE); |
diff --git a/keyboards/ergotravel/keymaps/default/keymap.c b/keyboards/ergotravel/keymaps/default/keymap.c index 166a6eed7e..fcc1ac76b4 100644 --- a/keyboards/ergotravel/keymaps/default/keymap.c +++ b/keyboards/ergotravel/keymaps/default/keymap.c | |||
| @@ -9,8 +9,7 @@ enum layer_names { | |||
| 9 | }; | 9 | }; |
| 10 | 10 | ||
| 11 | enum custom_keycodes { | 11 | enum custom_keycodes { |
| 12 | QWERTY = SAFE_RANGE, | 12 | LOWER = SAFE_RANGE, |
| 13 | LOWER, | ||
| 14 | RAISE, | 13 | RAISE, |
| 15 | ADJUST, | 14 | ADJUST, |
| 16 | }; | 15 | }; |
| @@ -58,23 +57,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 58 | 57 | ||
| 59 | }; | 58 | }; |
| 60 | 59 | ||
| 61 | |||
| 62 | |||
| 63 | |||
| 64 | |||
| 65 | |||
| 66 | |||
| 67 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 60 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 68 | switch (keycode) { | 61 | switch (keycode) { |
| 69 | case QWERTY: | ||
| 70 | if (record->event.pressed) { | ||
| 71 | #ifdef AUDIO_ENABLE | ||
| 72 | PLAY_SONG(tone_qwerty); | ||
| 73 | #endif | ||
| 74 | set_single_persistent_default_layer(_QWERTY); | ||
| 75 | } | ||
| 76 | return false; | ||
| 77 | break; | ||
| 78 | case LOWER: | 62 | case LOWER: |
| 79 | if (record->event.pressed) { | 63 | if (record->event.pressed) { |
| 80 | layer_on(_LOWER); | 64 | layer_on(_LOWER); |
diff --git a/keyboards/fortitude60/keymaps/default/keymap.c b/keyboards/fortitude60/keymaps/default/keymap.c index d03c2b7a4b..729b940d76 100644 --- a/keyboards/fortitude60/keymaps/default/keymap.c +++ b/keyboards/fortitude60/keymaps/default/keymap.c | |||
| @@ -14,18 +14,13 @@ enum my_layers { | |||
| 14 | _ADJUST | 14 | _ADJUST |
| 15 | }; | 15 | }; |
| 16 | 16 | ||
| 17 | enum custom_keycodes { | ||
| 18 | QWERTY = SAFE_RANGE, | ||
| 19 | COLEMAK, | ||
| 20 | DVORAK, | ||
| 21 | LOWER, | ||
| 22 | RAISE, | ||
| 23 | ADJUST, | ||
| 24 | }; | ||
| 25 | |||
| 26 | #define LOWER MO(_LOWER) | 17 | #define LOWER MO(_LOWER) |
| 27 | #define RAISE MO(_RAISE) | 18 | #define RAISE MO(_RAISE) |
| 28 | 19 | ||
| 20 | #define QWERTY PDF(_QWERTY) | ||
| 21 | #define COLEMAK PDF(_COLEMAK) | ||
| 22 | #define DVORAK PDF(_DVORAK) | ||
| 23 | |||
| 29 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 24 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 30 | 25 | ||
| 31 | /* Qwerty | 26 | /* Qwerty |
| @@ -160,24 +155,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 160 | layer_state_t layer_state_set_user(layer_state_t state) { | 155 | layer_state_t layer_state_set_user(layer_state_t state) { |
| 161 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 156 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 162 | } | 157 | } |
| 163 | |||
| 164 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 165 | switch (keycode) { | ||
| 166 | case QWERTY: | ||
| 167 | if (record->event.pressed) { | ||
| 168 | set_single_persistent_default_layer(_QWERTY); | ||
| 169 | } | ||
| 170 | return false; | ||
| 171 | case COLEMAK: | ||
| 172 | if (record->event.pressed) { | ||
| 173 | set_single_persistent_default_layer(_COLEMAK); | ||
| 174 | } | ||
| 175 | return false; | ||
| 176 | case DVORAK: | ||
| 177 | if (record->event.pressed) { | ||
| 178 | set_single_persistent_default_layer(_DVORAK); | ||
| 179 | } | ||
| 180 | return false; | ||
| 181 | } | ||
| 182 | return true; | ||
| 183 | } | ||
diff --git a/keyboards/fractal/keymaps/default/keymap.c b/keyboards/fractal/keymaps/default/keymap.c index ec54dfb78d..fea90ba2f3 100644 --- a/keyboards/fractal/keymaps/default/keymap.c +++ b/keyboards/fractal/keymaps/default/keymap.c | |||
| @@ -28,14 +28,15 @@ enum preonic_layers { | |||
| 28 | }; | 28 | }; |
| 29 | 29 | ||
| 30 | enum preonic_keycodes { | 30 | enum preonic_keycodes { |
| 31 | QWERTY = SAFE_RANGE, | 31 | LOWER = SAFE_RANGE, |
| 32 | COLEMAK, | ||
| 33 | DVORAK, | ||
| 34 | LOWER, | ||
| 35 | RAISE, | 32 | RAISE, |
| 36 | BACKLIT | 33 | BACKLIT |
| 37 | }; | 34 | }; |
| 38 | 35 | ||
| 36 | #define QWERTY PDF(_QWERTY) | ||
| 37 | #define COLEMAK PDF(_COLEMAK) | ||
| 38 | #define DVORAK PDF(_DVORAK) | ||
| 39 | |||
| 39 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 40 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 40 | 41 | ||
| 41 | /* Qwerty | 42 | /* Qwerty |
| @@ -169,24 +170,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 169 | 170 | ||
| 170 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 171 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 171 | switch (keycode) { | 172 | switch (keycode) { |
| 172 | case QWERTY: | ||
| 173 | if (record->event.pressed) { | ||
| 174 | set_single_persistent_default_layer(_QWERTY); | ||
| 175 | } | ||
| 176 | return false; | ||
| 177 | break; | ||
| 178 | case COLEMAK: | ||
| 179 | if (record->event.pressed) { | ||
| 180 | set_single_persistent_default_layer(_COLEMAK); | ||
| 181 | } | ||
| 182 | return false; | ||
| 183 | break; | ||
| 184 | case DVORAK: | ||
| 185 | if (record->event.pressed) { | ||
| 186 | set_single_persistent_default_layer(_DVORAK); | ||
| 187 | } | ||
| 188 | return false; | ||
| 189 | break; | ||
| 190 | case LOWER: | 173 | case LOWER: |
| 191 | if (record->event.pressed) { | 174 | if (record->event.pressed) { |
| 192 | layer_on(_LOWER); | 175 | layer_on(_LOWER); |
diff --git a/keyboards/hadron/ver2/keymaps/default/keymap.c b/keyboards/hadron/ver2/keymaps/default/keymap.c index 65d6ef91f9..951cacb423 100644 --- a/keyboards/hadron/ver2/keymaps/default/keymap.c +++ b/keyboards/hadron/ver2/keymaps/default/keymap.c | |||
| @@ -16,10 +16,7 @@ extern rgblight_config_t rgblight_config; | |||
| 16 | #define _ADJUST 6 | 16 | #define _ADJUST 6 |
| 17 | 17 | ||
| 18 | enum preonic_keycodes { | 18 | enum preonic_keycodes { |
| 19 | QWERTY = SAFE_RANGE, | 19 | LOWER = SAFE_RANGE, |
| 20 | COLEMAK, | ||
| 21 | DVORAK, | ||
| 22 | LOWER, | ||
| 23 | RAISE, | 20 | RAISE, |
| 24 | BACKLIT, | 21 | BACKLIT, |
| 25 | RGBLED_TOGGLE, | 22 | RGBLED_TOGGLE, |
| @@ -42,6 +39,9 @@ enum preonic_keycodes { | |||
| 42 | #define LT_MC(kc) LT(_MOUSECURSOR, kc) // L-ayer T-ap M-ouse C-ursor | 39 | #define LT_MC(kc) LT(_MOUSECURSOR, kc) // L-ayer T-ap M-ouse C-ursor |
| 43 | #define LT_RAI(kc) LT(_RAISE, kc) // L-ayer T-ap to Raise | 40 | #define LT_RAI(kc) LT(_RAISE, kc) // L-ayer T-ap to Raise |
| 44 | 41 | ||
| 42 | #define QWERTY PDF(_QWERTY) | ||
| 43 | #define COLEMAK PDF(_COLEMAK) | ||
| 44 | #define DVORAK PDF(_DVORAK) | ||
| 45 | 45 | ||
| 46 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 46 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 47 | 47 | ||
| @@ -213,18 +213,6 @@ void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) { | |||
| 213 | 213 | ||
| 214 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 214 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 215 | switch (keycode) { | 215 | switch (keycode) { |
| 216 | case QWERTY: | ||
| 217 | if (record->event.pressed) { | ||
| 218 | set_single_persistent_default_layer(_QWERTY); | ||
| 219 | } | ||
| 220 | return false; | ||
| 221 | break; | ||
| 222 | case COLEMAK: | ||
| 223 | if (record->event.pressed) { | ||
| 224 | set_single_persistent_default_layer(_COLEMAK); | ||
| 225 | } | ||
| 226 | return false; | ||
| 227 | break; | ||
| 228 | case LOWER: | 216 | case LOWER: |
| 229 | if (record->event.pressed) { | 217 | if (record->event.pressed) { |
| 230 | //not sure how to have keyboard check mode and set it to a variable, so my work around | 218 | //not sure how to have keyboard check mode and set it to a variable, so my work around |
diff --git a/keyboards/hadron/ver2/keymaps/side_numpad/keymap.c b/keyboards/hadron/ver2/keymaps/side_numpad/keymap.c index a4a96b20b6..1e8523d94c 100644 --- a/keyboards/hadron/ver2/keymaps/side_numpad/keymap.c +++ b/keyboards/hadron/ver2/keymaps/side_numpad/keymap.c | |||
| @@ -16,10 +16,7 @@ extern rgblight_config_t rgblight_config; | |||
| 16 | #define _ADJUST 6 | 16 | #define _ADJUST 6 |
| 17 | 17 | ||
| 18 | enum preonic_keycodes { | 18 | enum preonic_keycodes { |
| 19 | QWERTY = SAFE_RANGE, | 19 | LOWER = SAFE_RANGE, |
| 20 | COLEMAK, | ||
| 21 | DVORAK, | ||
| 22 | LOWER, | ||
| 23 | RAISE, | 20 | RAISE, |
| 24 | BACKLIT, | 21 | BACKLIT, |
| 25 | RGBLED_TOGGLE, | 22 | RGBLED_TOGGLE, |
| @@ -181,7 +178,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 181 | * |------+------+------+------+------+------+------+------+------+------+------+------+--------------------. | 178 | * |------+------+------+------+------+------+------+------+------+------+------+------+--------------------. |
| 182 | * | |RGB TG|RGB ST|RGBH -|RGBH +|RGBS -|RGBS +|RGBV -|RGBV +| | | Del | | | | | 179 | * | |RGB TG|RGB ST|RGBH -|RGBH +|RGBS -|RGBS +|RGBV -|RGBV +| | | Del | | | | |
| 183 | * |------+------+------+------+------+------+------+------+------+------+------+------+------+------+------| | 180 | * |------+------+------+------+------+------+------+------+------+------+------+------+------+------+------| |
| 184 | * | | | |Aud on|Audoff|AGnorm|AGswap|Qwerty| | | | | | | | | 181 | * | | | |Aud on|Audoff|AGnorm|AGswap| | | | | | | | | |
| 185 | * |------+------+------+------+------+------+------+------+------+------+------+------+------+------+------| | 182 | * |------+------+------+------+------+------+------+------+------+------+------+------+------+------+------| |
| 186 | * | |Voice-|Voice+|Mus on|Musoff|MIDIon|MIDIof| | BL + |BL ST |BLSTEP| BL TG| | | | | 183 | * | |Voice-|Voice+|Mus on|Musoff|MIDIon|MIDIof| | BL + |BL ST |BLSTEP| BL TG| | | | |
| 187 | * |------+------+------+------+------+------+------+------+------+------+------+------+------+------+------| | 184 | * |------+------+------+------+------+------+------+------+------+------+------+------+------+------+------| |
| @@ -191,7 +188,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 191 | [_ADJUST] = LAYOUT( | 188 | [_ADJUST] = LAYOUT( |
| 192 | QK_BOOT, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_VOLD, KC_VOLU, KC_MUTE, | 189 | QK_BOOT, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_VOLD, KC_VOLU, KC_MUTE, |
| 193 | _______, UG_TOGG, UG_NEXT, UG_HUEU, UG_HUED, UG_SATU, UG_SATD, UG_VALU, UG_VALD, _______, _______, KC_DEL, _______, _______, _______, | 190 | _______, UG_TOGG, UG_NEXT, UG_HUEU, UG_HUED, UG_SATU, UG_SATD, UG_VALU, UG_VALD, _______, _______, KC_DEL, _______, _______, _______, |
| 194 | _______, _______, _______, AU_ON, AU_OFF, AG_NORM, AG_SWAP, QWERTY, _______, _______, _______, _______, _______, _______, _______, | 191 | _______, _______, _______, AU_ON, AU_OFF, AG_NORM, AG_SWAP, _______, _______, _______, _______, _______, _______, _______, _______, |
| 195 | _______, AU_PREV, AU_NEXT, MU_ON, MU_OFF, MI_ON, MI_OFF, _______, BL_DOWN, BL_UP, BL_STEP, BL_TOGG, _______, _______, _______, | 192 | _______, AU_PREV, AU_NEXT, MU_ON, MU_OFF, MI_ON, MI_OFF, _______, BL_DOWN, BL_UP, BL_STEP, BL_TOGG, _______, _______, _______, |
| 196 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ | 193 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ |
| 197 | ) | 194 | ) |
| @@ -218,12 +215,6 @@ void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) { | |||
| 218 | 215 | ||
| 219 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 216 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 220 | switch (keycode) { | 217 | switch (keycode) { |
| 221 | case QWERTY: | ||
| 222 | if (record->event.pressed) { | ||
| 223 | set_single_persistent_default_layer(_QWERTY); | ||
| 224 | } | ||
| 225 | return false; | ||
| 226 | break; | ||
| 227 | case LOWER: | 218 | case LOWER: |
| 228 | if (record->event.pressed) { | 219 | if (record->event.pressed) { |
| 229 | //not sure how to have keyboard check mode and set it to a variable, so my work around | 220 | //not sure how to have keyboard check mode and set it to a variable, so my work around |
diff --git a/keyboards/hadron/ver3/keymaps/default/keymap.c b/keyboards/hadron/ver3/keymaps/default/keymap.c index d130745dc6..1e3f3191c2 100644 --- a/keyboards/hadron/ver3/keymaps/default/keymap.c +++ b/keyboards/hadron/ver3/keymaps/default/keymap.c | |||
| @@ -13,10 +13,7 @@ | |||
| 13 | #define _ADJUST 6 | 13 | #define _ADJUST 6 |
| 14 | 14 | ||
| 15 | enum preonic_keycodes { | 15 | enum preonic_keycodes { |
| 16 | QWERTY = SAFE_RANGE, | 16 | LOWER = SAFE_RANGE, |
| 17 | COLEMAK, | ||
| 18 | DVORAK, | ||
| 19 | LOWER, | ||
| 20 | RAISE, | 17 | RAISE, |
| 21 | BACKLIT, | 18 | BACKLIT, |
| 22 | RGBLED_TOGGLE, | 19 | RGBLED_TOGGLE, |
| @@ -39,6 +36,10 @@ enum preonic_keycodes { | |||
| 39 | #define LT_MC(kc) LT(_MOUSECURSOR, kc) // L-ayer T-ap M-ouse C-ursor | 36 | #define LT_MC(kc) LT(_MOUSECURSOR, kc) // L-ayer T-ap M-ouse C-ursor |
| 40 | #define LT_RAI(kc) LT(_RAISE, kc) // L-ayer T-ap to Raise | 37 | #define LT_RAI(kc) LT(_RAISE, kc) // L-ayer T-ap to Raise |
| 41 | 38 | ||
| 39 | #define QWERTY PDF(_QWERTY) | ||
| 40 | #define COLEMAK PDF(_COLEMAK) | ||
| 41 | #define DVORAK PDF(_DVORAK) | ||
| 42 | |||
| 42 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 43 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 43 | 44 | ||
| 44 | /* Qwerty | 45 | /* Qwerty |
| @@ -200,18 +201,6 @@ layer_state_t layer_state_set_user(layer_state_t state) { | |||
| 200 | 201 | ||
| 201 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 202 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 202 | switch (keycode) { | 203 | switch (keycode) { |
| 203 | case QWERTY: | ||
| 204 | if (record->event.pressed) { | ||
| 205 | set_single_persistent_default_layer(_QWERTY); | ||
| 206 | } | ||
| 207 | return false; | ||
| 208 | break; | ||
| 209 | case COLEMAK: | ||
| 210 | if (record->event.pressed) { | ||
| 211 | set_single_persistent_default_layer(_COLEMAK); | ||
| 212 | } | ||
| 213 | return false; | ||
| 214 | break; | ||
| 215 | case LOWER: | 204 | case LOWER: |
| 216 | if (record->event.pressed) { | 205 | if (record->event.pressed) { |
| 217 | //not sure how to have keyboard check mode and set it to a variable, so my work around | 206 | //not sure how to have keyboard check mode and set it to a variable, so my work around |
diff --git a/keyboards/handwired/ortho5x14/keymaps/2u/keymap.c b/keyboards/handwired/ortho5x14/keymaps/2u/keymap.c index 568427e52c..752eda0fde 100644 --- a/keyboards/handwired/ortho5x14/keymaps/2u/keymap.c +++ b/keyboards/handwired/ortho5x14/keymaps/2u/keymap.c | |||
| @@ -48,15 +48,14 @@ enum custom_layer { | |||
| 48 | }; | 48 | }; |
| 49 | 49 | ||
| 50 | enum custom_keycodes { | 50 | enum custom_keycodes { |
| 51 | QWERTY = SAFE_RANGE, | 51 | LOWER = SAFE_RANGE, |
| 52 | ALT, | ||
| 53 | CTRL, | ||
| 54 | LOWER, | ||
| 55 | RAISE, | 52 | RAISE, |
| 56 | MOUSE, | ||
| 57 | ADJUST | 53 | ADJUST |
| 58 | }; | 54 | }; |
| 59 | 55 | ||
| 56 | #define QWERTY PDF(_QWERTY) | ||
| 57 | #define MOUSE PDF(_MOUSE) | ||
| 58 | |||
| 60 | // TAP DANCE *********************************************************** | 59 | // TAP DANCE *********************************************************** |
| 61 | //Tap Dance Declarations | 60 | //Tap Dance Declarations |
| 62 | enum { | 61 | enum { |
| @@ -569,12 +568,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 569 | return false; | 568 | return false; |
| 570 | } | 569 | } |
| 571 | return true; | 570 | return true; |
| 572 | case QWERTY: | ||
| 573 | if (record->event.pressed) { | ||
| 574 | set_single_persistent_default_layer(_QWERTY); | ||
| 575 | } | ||
| 576 | return false; | ||
| 577 | break; | ||
| 578 | case LOWER: | 571 | case LOWER: |
| 579 | if (record->event.pressed) { | 572 | if (record->event.pressed) { |
| 580 | layer_on(_LOWER); | 573 | layer_on(_LOWER); |
| @@ -584,7 +577,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 584 | update_tri_layer(_LOWER, _RAISE, _ADJUST); | 577 | update_tri_layer(_LOWER, _RAISE, _ADJUST); |
| 585 | } | 578 | } |
| 586 | return false; | 579 | return false; |
| 587 | break; | ||
| 588 | case RAISE: | 580 | case RAISE: |
| 589 | if (record->event.pressed) { | 581 | if (record->event.pressed) { |
| 590 | layer_on(_RAISE); | 582 | layer_on(_RAISE); |
| @@ -594,13 +586,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 594 | update_tri_layer(_LOWER, _RAISE, _ADJUST); | 586 | update_tri_layer(_LOWER, _RAISE, _ADJUST); |
| 595 | } | 587 | } |
| 596 | return false; | 588 | return false; |
| 597 | break; | ||
| 598 | case MOUSE: | ||
| 599 | if (record->event.pressed) { | ||
| 600 | set_single_persistent_default_layer(_MOUSE); | ||
| 601 | } | ||
| 602 | return false; | ||
| 603 | break; | ||
| 604 | } | 589 | } |
| 605 | return true; | 590 | return true; |
| 606 | }; | 591 | }; |
diff --git a/keyboards/handwired/ortho5x14/keymaps/default/keymap.c b/keyboards/handwired/ortho5x14/keymaps/default/keymap.c index 3c0720e1b0..a2f7befd9f 100644 --- a/keyboards/handwired/ortho5x14/keymaps/default/keymap.c +++ b/keyboards/handwired/ortho5x14/keymaps/default/keymap.c | |||
| @@ -30,10 +30,7 @@ enum custom_layer { | |||
| 30 | }; | 30 | }; |
| 31 | 31 | ||
| 32 | enum custom_keycodes { | 32 | enum custom_keycodes { |
| 33 | QWERTY = SAFE_RANGE, | 33 | LOWER = SAFE_RANGE, |
| 34 | COLEMAK, | ||
| 35 | DVORAK, | ||
| 36 | LOWER, | ||
| 37 | RAISE, | 34 | RAISE, |
| 38 | BACKLIT | 35 | BACKLIT |
| 39 | }; | 36 | }; |
| @@ -189,7 +186,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 189 | * |------+------+------+------+------+------+------+------+------+------+------+------+------+------| | 186 | * |------+------+------+------+------+------+------+------+------+------+------+------+------+------| |
| 190 | * | | | | Reset| | | | | | | | | | Del | | 187 | * | | | | Reset| | | | | | | | | | Del | |
| 191 | * |------+------+------+------+------+------+------+-------------+------+------+------+------+------| | 188 | * |------+------+------+------+------+------+------+-------------+------+------+------+------+------| |
| 192 | * | | | | | |Audoff|Aud on|AGnorm|AGswap|Qwerty|Colemk|Dvorak| | | | 189 | * | | | | | |Audoff|Aud on|AGnorm|AGswap| | | | | | |
| 193 | * |------+------+------+------+------+------+------+------|------+------+------+------+------+------| | 190 | * |------+------+------+------+------+------+------+------|------+------+------+------+------+------| |
| 194 | * | | | |Voice-|Voice+|Musoff|Mus on| | | | | | | | | 191 | * | | | |Voice-|Voice+|Musoff|Mus on| | | | | | | | |
| 195 | * |------+------+------+------+------+------+------+------+------+------+------+------+------+------| | 192 | * |------+------+------+------+------+------+------+------+------+------+------+------+------+------| |
| @@ -199,7 +196,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 199 | [_ADJUST] = LAYOUT( | 196 | [_ADJUST] = LAYOUT( |
| 200 | _______, _______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, | 197 | _______, _______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, |
| 201 | XXXXXXX, XXXXXXX, XXXXXXX, QK_BOOT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_DEL, | 198 | XXXXXXX, XXXXXXX, XXXXXXX, QK_BOOT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_DEL, |
| 202 | XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, AU_ON, AU_OFF, AG_NORM, AG_SWAP, QWERTY, XXXXXXX, XXXXXXX, XXXXXXX, _______, | 199 | XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, AU_ON, AU_OFF, AG_NORM, AG_SWAP, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______, |
| 203 | XXXXXXX, XXXXXXX, XXXXXXX, AU_PREV, AU_NEXT, MU_ON, MU_OFF, MI_ON, MI_OFF, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, | 200 | XXXXXXX, XXXXXXX, XXXXXXX, AU_PREV, AU_NEXT, MU_ON, MU_OFF, MI_ON, MI_OFF, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, |
| 204 | XXXXXXX, _______, _______, _______, _______, _______, _______, _______,_______,_______, _______, _______ | 201 | XXXXXXX, _______, _______, _______, _______, _______, _______, _______,_______,_______, _______, _______ |
| 205 | ) | 202 | ) |
| @@ -209,15 +206,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 209 | 206 | ||
| 210 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 207 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 211 | switch (keycode) { | 208 | switch (keycode) { |
| 212 | case QWERTY: | ||
| 213 | if (record->event.pressed) { | ||
| 214 | #ifdef AUDIO_ENABLE | ||
| 215 | PLAY_SONG(tone_qwerty); | ||
| 216 | #endif | ||
| 217 | set_single_persistent_default_layer(_QWERTY); | ||
| 218 | } | ||
| 219 | return false; | ||
| 220 | break; | ||
| 221 | case LOWER: | 209 | case LOWER: |
| 222 | if (record->event.pressed) { | 210 | if (record->event.pressed) { |
| 223 | layer_on(_LOWER); | 211 | layer_on(_LOWER); |
diff --git a/keyboards/handwired/ortho5x14/keymaps/split1/keymap.c b/keyboards/handwired/ortho5x14/keymaps/split1/keymap.c index 733e3f3d4b..a5222eecfa 100644 --- a/keyboards/handwired/ortho5x14/keymaps/split1/keymap.c +++ b/keyboards/handwired/ortho5x14/keymaps/split1/keymap.c | |||
| @@ -47,15 +47,14 @@ enum custom_layer { | |||
| 47 | }; | 47 | }; |
| 48 | 48 | ||
| 49 | enum custom_keycodes { | 49 | enum custom_keycodes { |
| 50 | QWERTY = SAFE_RANGE, | 50 | LOWER = SAFE_RANGE, |
| 51 | ALT, | ||
| 52 | CTRL, | ||
| 53 | LOWER, | ||
| 54 | RAISE, | 51 | RAISE, |
| 55 | MOUSE, | ||
| 56 | ADJUST | 52 | ADJUST |
| 57 | }; | 53 | }; |
| 58 | 54 | ||
| 55 | #define QWERTY PDF(_QWERTY) | ||
| 56 | #define MOUSE PDF(_MOUSE) | ||
| 57 | |||
| 59 | // TAP DANCE *********************************************************** | 58 | // TAP DANCE *********************************************************** |
| 60 | //Tap Dance Declarations | 59 | //Tap Dance Declarations |
| 61 | enum { | 60 | enum { |
| @@ -499,12 +498,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 499 | return false; | 498 | return false; |
| 500 | } | 499 | } |
| 501 | return true; | 500 | return true; |
| 502 | case QWERTY: | ||
| 503 | if (record->event.pressed) { | ||
| 504 | set_single_persistent_default_layer(_QWERTY); | ||
| 505 | } | ||
| 506 | return false; | ||
| 507 | break; | ||
| 508 | case LOWER: | 501 | case LOWER: |
| 509 | if (record->event.pressed) { | 502 | if (record->event.pressed) { |
| 510 | layer_on(_LOWER); | 503 | layer_on(_LOWER); |
| @@ -514,7 +507,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 514 | update_tri_layer(_LOWER, _RAISE, _ADJUST); | 507 | update_tri_layer(_LOWER, _RAISE, _ADJUST); |
| 515 | } | 508 | } |
| 516 | return false; | 509 | return false; |
| 517 | break; | ||
| 518 | case RAISE: | 510 | case RAISE: |
| 519 | if (record->event.pressed) { | 511 | if (record->event.pressed) { |
| 520 | layer_on(_RAISE); | 512 | layer_on(_RAISE); |
| @@ -524,13 +516,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 524 | update_tri_layer(_LOWER, _RAISE, _ADJUST); | 516 | update_tri_layer(_LOWER, _RAISE, _ADJUST); |
| 525 | } | 517 | } |
| 526 | return false; | 518 | return false; |
| 527 | break; | ||
| 528 | case MOUSE: | ||
| 529 | if (record->event.pressed) { | ||
| 530 | set_single_persistent_default_layer(_MOUSE); | ||
| 531 | } | ||
| 532 | return false; | ||
| 533 | break; | ||
| 534 | } | 519 | } |
| 535 | return true; | 520 | return true; |
| 536 | }; | 521 | }; |
diff --git a/keyboards/handwired/ortho_brass/keymaps/default/keymap.c b/keyboards/handwired/ortho_brass/keymaps/default/keymap.c index d5ab0ba398..fc43167211 100644 --- a/keyboards/handwired/ortho_brass/keymaps/default/keymap.c +++ b/keyboards/handwired/ortho_brass/keymaps/default/keymap.c | |||
| @@ -27,16 +27,17 @@ enum ortho_brass_layers { | |||
| 27 | }; | 27 | }; |
| 28 | 28 | ||
| 29 | enum ortho_brass_keycodes { | 29 | enum ortho_brass_keycodes { |
| 30 | QWERTY = SAFE_RANGE, | 30 | PLOVER = SAFE_RANGE, |
| 31 | COLEMAK, | ||
| 32 | DVORAK, | ||
| 33 | PLOVER, | ||
| 34 | EXT_PLV | 31 | EXT_PLV |
| 35 | }; | 32 | }; |
| 36 | 33 | ||
| 37 | #define LOWER MO(_LOWER) | 34 | #define LOWER MO(_LOWER) |
| 38 | #define RAISE MO(_RAISE) | 35 | #define RAISE MO(_RAISE) |
| 39 | 36 | ||
| 37 | #define QWERTY PDF(_QWERTY) | ||
| 38 | #define COLEMAK PDF(_COLEMAK) | ||
| 39 | #define DVORAK PDF(_DVORAK) | ||
| 40 | |||
| 40 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 41 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 41 | 42 | ||
| 42 | /* Qwerty | 43 | /* Qwerty |
| @@ -172,24 +173,6 @@ layer_state_t layer_state_set_user(layer_state_t state) { return update_tri_laye | |||
| 172 | 173 | ||
| 173 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 174 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 174 | switch (keycode) { | 175 | switch (keycode) { |
| 175 | case QWERTY: | ||
| 176 | if (record->event.pressed) { | ||
| 177 | set_single_persistent_default_layer(_QWERTY); | ||
| 178 | } | ||
| 179 | return false; | ||
| 180 | break; | ||
| 181 | case COLEMAK: | ||
| 182 | if (record->event.pressed) { | ||
| 183 | set_single_persistent_default_layer(_COLEMAK); | ||
| 184 | } | ||
| 185 | return false; | ||
| 186 | break; | ||
| 187 | case DVORAK: | ||
| 188 | if (record->event.pressed) { | ||
| 189 | set_single_persistent_default_layer(_DVORAK); | ||
| 190 | } | ||
| 191 | return false; | ||
| 192 | break; | ||
| 193 | case PLOVER: | 176 | case PLOVER: |
| 194 | if (record->event.pressed) { | 177 | if (record->event.pressed) { |
| 195 | layer_off(_RAISE); | 178 | layer_off(_RAISE); |
diff --git a/keyboards/handwired/riblee_f401/keymaps/default/keymap.c b/keyboards/handwired/riblee_f401/keymaps/default/keymap.c index f39f439c50..7c8bd5b8b4 100644 --- a/keyboards/handwired/riblee_f401/keymaps/default/keymap.c +++ b/keyboards/handwired/riblee_f401/keymaps/default/keymap.c | |||
| @@ -27,15 +27,16 @@ enum preonic_layers { | |||
| 27 | }; | 27 | }; |
| 28 | 28 | ||
| 29 | enum preonic_keycodes { | 29 | enum preonic_keycodes { |
| 30 | QWERTY = SAFE_RANGE, | 30 | BACKLIT = SAFE_RANGE, |
| 31 | COLEMAK, | ||
| 32 | DVORAK, | ||
| 33 | BACKLIT | ||
| 34 | }; | 31 | }; |
| 35 | 32 | ||
| 36 | #define LOWER MO(_LOWER) | 33 | #define LOWER MO(_LOWER) |
| 37 | #define RAISE MO(_RAISE) | 34 | #define RAISE MO(_RAISE) |
| 38 | 35 | ||
| 36 | #define QWERTY PDF(_QWERTY) | ||
| 37 | #define COLEMAK PDF(_COLEMAK) | ||
| 38 | #define DVORAK PDF(_DVORAK) | ||
| 39 | |||
| 39 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 40 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 40 | 41 | ||
| 41 | /* Qwerty | 42 | /* Qwerty |
| @@ -172,24 +173,6 @@ layer_state_t layer_state_set_user(layer_state_t state) { | |||
| 172 | 173 | ||
| 173 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 174 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 174 | switch (keycode) { | 175 | switch (keycode) { |
| 175 | case QWERTY: | ||
| 176 | if (record->event.pressed) { | ||
| 177 | set_single_persistent_default_layer(_QWERTY); | ||
| 178 | } | ||
| 179 | return false; | ||
| 180 | break; | ||
| 181 | case COLEMAK: | ||
| 182 | if (record->event.pressed) { | ||
| 183 | set_single_persistent_default_layer(_COLEMAK); | ||
| 184 | } | ||
| 185 | return false; | ||
| 186 | break; | ||
| 187 | case DVORAK: | ||
| 188 | if (record->event.pressed) { | ||
| 189 | set_single_persistent_default_layer(_DVORAK); | ||
| 190 | } | ||
| 191 | return false; | ||
| 192 | break; | ||
| 193 | case BACKLIT: | 176 | case BACKLIT: |
| 194 | if (record->event.pressed) { | 177 | if (record->event.pressed) { |
| 195 | register_code(keycode_config(KC_LGUI)); | 178 | register_code(keycode_config(KC_LGUI)); |
| @@ -200,7 +183,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 200 | unregister_code(keycode_config(KC_LGUI)); | 183 | unregister_code(keycode_config(KC_LGUI)); |
| 201 | } | 184 | } |
| 202 | return false; | 185 | return false; |
| 203 | break; | ||
| 204 | } | 186 | } |
| 205 | return true; | 187 | return true; |
| 206 | }; | 188 | }; |
diff --git a/keyboards/handwired/riblee_f411/keymaps/default/keymap.c b/keyboards/handwired/riblee_f411/keymaps/default/keymap.c index 74308a1c19..15c706089d 100644 --- a/keyboards/handwired/riblee_f411/keymaps/default/keymap.c +++ b/keyboards/handwired/riblee_f411/keymaps/default/keymap.c | |||
| @@ -27,15 +27,16 @@ enum layer_names { | |||
| 27 | }; | 27 | }; |
| 28 | 28 | ||
| 29 | enum custom_keycodes { | 29 | enum custom_keycodes { |
| 30 | QWERTY = SAFE_RANGE, | 30 | BACKLIT = SAFE_RANGE, |
| 31 | COLEMAK, | ||
| 32 | DVORAK, | ||
| 33 | BACKLIT | ||
| 34 | }; | 31 | }; |
| 35 | 32 | ||
| 36 | #define LOWER MO(_LOWER) | 33 | #define LOWER MO(_LOWER) |
| 37 | #define RAISE MO(_RAISE) | 34 | #define RAISE MO(_RAISE) |
| 38 | 35 | ||
| 36 | #define QWERTY PDF(_QWERTY) | ||
| 37 | #define COLEMAK PDF(_COLEMAK) | ||
| 38 | #define DVORAK PDF(_DVORAK) | ||
| 39 | |||
| 39 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 40 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 40 | 41 | ||
| 41 | /* Qwerty | 42 | /* Qwerty |
| @@ -172,24 +173,6 @@ layer_state_t layer_state_set_user(layer_state_t state) { | |||
| 172 | 173 | ||
| 173 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 174 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 174 | switch (keycode) { | 175 | switch (keycode) { |
| 175 | case QWERTY: | ||
| 176 | if (record->event.pressed) { | ||
| 177 | set_single_persistent_default_layer(_QWERTY); | ||
| 178 | } | ||
| 179 | return false; | ||
| 180 | break; | ||
| 181 | case COLEMAK: | ||
| 182 | if (record->event.pressed) { | ||
| 183 | set_single_persistent_default_layer(_COLEMAK); | ||
| 184 | } | ||
| 185 | return false; | ||
| 186 | break; | ||
| 187 | case DVORAK: | ||
| 188 | if (record->event.pressed) { | ||
| 189 | set_single_persistent_default_layer(_DVORAK); | ||
| 190 | } | ||
| 191 | return false; | ||
| 192 | break; | ||
| 193 | case BACKLIT: | 176 | case BACKLIT: |
| 194 | if (record->event.pressed) { | 177 | if (record->event.pressed) { |
| 195 | register_code(keycode_config(KC_LGUI)); | 178 | register_code(keycode_config(KC_LGUI)); |
| @@ -200,7 +183,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 200 | unregister_code(keycode_config(KC_LGUI)); | 183 | unregister_code(keycode_config(KC_LGUI)); |
| 201 | } | 184 | } |
| 202 | return false; | 185 | return false; |
| 203 | break; | ||
| 204 | } | 186 | } |
| 205 | return true; | 187 | return true; |
| 206 | }; | 188 | }; |
diff --git a/keyboards/handwired/rs60/keymaps/default/keymap.c b/keyboards/handwired/rs60/keymaps/default/keymap.c index 5dae734be6..7dfe43fc4c 100644 --- a/keyboards/handwired/rs60/keymaps/default/keymap.c +++ b/keyboards/handwired/rs60/keymaps/default/keymap.c | |||
| @@ -26,13 +26,14 @@ enum layers { | |||
| 26 | }; | 26 | }; |
| 27 | 27 | ||
| 28 | enum keycodes { | 28 | enum keycodes { |
| 29 | QWERTY = SAFE_RANGE, | 29 | LOWER = SAFE_RANGE, |
| 30 | COLEMAK, | ||
| 31 | DVORAK, | ||
| 32 | LOWER, | ||
| 33 | RAISE, | 30 | RAISE, |
| 34 | }; | 31 | }; |
| 35 | 32 | ||
| 33 | #define QWERTY PDF(_QWERTY) | ||
| 34 | #define COLEMAK PDF(_COLEMAK) | ||
| 35 | #define DVORAK PDF(_DVORAK) | ||
| 36 | |||
| 36 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 37 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 37 | 38 | ||
| 38 | /* Qwerty | 39 | /* Qwerty |
| @@ -164,24 +165,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 164 | 165 | ||
| 165 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 166 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 166 | switch (keycode) { | 167 | switch (keycode) { |
| 167 | case QWERTY: | ||
| 168 | if (record->event.pressed) { | ||
| 169 | set_single_persistent_default_layer(_QWERTY); | ||
| 170 | } | ||
| 171 | return false; | ||
| 172 | break; | ||
| 173 | case COLEMAK: | ||
| 174 | if (record->event.pressed) { | ||
| 175 | set_single_persistent_default_layer(_COLEMAK); | ||
| 176 | } | ||
| 177 | return false; | ||
| 178 | break; | ||
| 179 | case DVORAK: | ||
| 180 | if (record->event.pressed) { | ||
| 181 | set_single_persistent_default_layer(_DVORAK); | ||
| 182 | } | ||
| 183 | return false; | ||
| 184 | break; | ||
| 185 | case LOWER: | 168 | case LOWER: |
| 186 | if (record->event.pressed) { | 169 | if (record->event.pressed) { |
| 187 | layer_on(_LOWER); | 170 | layer_on(_LOWER); |
diff --git a/keyboards/handwired/split_cloud/keymaps/default/keymap.c b/keyboards/handwired/split_cloud/keymaps/default/keymap.c index ad7e64e6ad..01ffe92dda 100644 --- a/keyboards/handwired/split_cloud/keymaps/default/keymap.c +++ b/keyboards/handwired/split_cloud/keymaps/default/keymap.c | |||
| @@ -29,13 +29,14 @@ enum layer_names { | |||
| 29 | }; | 29 | }; |
| 30 | 30 | ||
| 31 | enum custom_keycodes { | 31 | enum custom_keycodes { |
| 32 | QWERTY = SAFE_RANGE, | 32 | PLOVER = SAFE_RANGE, |
| 33 | COLEMAK, | ||
| 34 | DVORAK, | ||
| 35 | PLOVER, | ||
| 36 | EXT_PLV | 33 | EXT_PLV |
| 37 | }; | 34 | }; |
| 38 | 35 | ||
| 36 | #define QWERTY PDF(_QWERTY) | ||
| 37 | #define COLEMAK PDF(_COLEMAK) | ||
| 38 | #define DVORAK PDF(_DVORAK) | ||
| 39 | |||
| 39 | #define ST_BOLT QK_STENO_BOLT | 40 | #define ST_BOLT QK_STENO_BOLT |
| 40 | #define ST_GEM QK_STENO_GEMINI | 41 | #define ST_GEM QK_STENO_GEMINI |
| 41 | 42 | ||
| @@ -195,21 +196,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 195 | 196 | ||
| 196 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 197 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 197 | switch (keycode) { | 198 | switch (keycode) { |
| 198 | case QWERTY: | ||
| 199 | if (record->event.pressed) { | ||
| 200 | set_single_persistent_default_layer(_QWERTY); | ||
| 201 | } | ||
| 202 | return false; | ||
| 203 | case COLEMAK: | ||
| 204 | if (record->event.pressed) { | ||
| 205 | set_single_persistent_default_layer(_COLEMAK); | ||
| 206 | } | ||
| 207 | return false; | ||
| 208 | case DVORAK: | ||
| 209 | if (record->event.pressed) { | ||
| 210 | set_single_persistent_default_layer(_DVORAK); | ||
| 211 | } | ||
| 212 | return false; | ||
| 213 | case PLOVER: | 199 | case PLOVER: |
| 214 | if (!record->event.pressed) { | 200 | if (!record->event.pressed) { |
| 215 | layer_on(_PLOVER); | 201 | layer_on(_PLOVER); |
diff --git a/keyboards/handwired/terminus_mini/keymaps/default/keymap.c b/keyboards/handwired/terminus_mini/keymaps/default/keymap.c index e6d8bb6f05..8659b49544 100644 --- a/keyboards/handwired/terminus_mini/keymaps/default/keymap.c +++ b/keyboards/handwired/terminus_mini/keymaps/default/keymap.c | |||
| @@ -33,10 +33,7 @@ enum terminus_mini_layers { | |||
| 33 | }; | 33 | }; |
| 34 | 34 | ||
| 35 | enum terminus_mini_keycodes { | 35 | enum terminus_mini_keycodes { |
| 36 | COLEMAK = SAFE_RANGE, | 36 | LOWER = SAFE_RANGE, |
| 37 | QWERTY, | ||
| 38 | DVORAK, | ||
| 39 | LOWER, | ||
| 40 | RAISE, | 37 | RAISE, |
| 41 | FUNCTION, | 38 | FUNCTION, |
| 42 | MOUSE, | 39 | MOUSE, |
| @@ -48,6 +45,10 @@ enum terminus_mini_keycodes { | |||
| 48 | #define SPC_LW LT(_LOWER, KC_SPC) | 45 | #define SPC_LW LT(_LOWER, KC_SPC) |
| 49 | #define ENT_RS LT(_RAISE, KC_ENT) | 46 | #define ENT_RS LT(_RAISE, KC_ENT) |
| 50 | 47 | ||
| 48 | #define QWERTY PDF(_QWERTY) | ||
| 49 | #define COLEMAK PDF(_COLEMAK) | ||
| 50 | #define DVORAK PDF(_DVORAK) | ||
| 51 | |||
| 51 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 52 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 52 | /* Colemak - | 53 | /* Colemak - |
| 53 | * ,----------------------------------------------------------------------------------. | 54 | * ,----------------------------------------------------------------------------------. |
| @@ -204,24 +205,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 204 | // Cases to switch default layer to QWERTY, COLEMAK or DVORAK and to access ADJUST layer | 205 | // Cases to switch default layer to QWERTY, COLEMAK or DVORAK and to access ADJUST layer |
| 205 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 206 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 206 | switch (keycode) { | 207 | switch (keycode) { |
| 207 | case QWERTY: | ||
| 208 | if (record->event.pressed) { | ||
| 209 | set_single_persistent_default_layer(_QWERTY); | ||
| 210 | } | ||
| 211 | return false; | ||
| 212 | break; | ||
| 213 | case COLEMAK: | ||
| 214 | if (record->event.pressed) { | ||
| 215 | set_single_persistent_default_layer(_COLEMAK); | ||
| 216 | } | ||
| 217 | return false; | ||
| 218 | break; | ||
| 219 | case DVORAK: | ||
| 220 | if (record->event.pressed) { | ||
| 221 | set_single_persistent_default_layer(_DVORAK); | ||
| 222 | } | ||
| 223 | return false; | ||
| 224 | break; | ||
| 225 | case LOWER: | 208 | case LOWER: |
| 226 | if (record->event.pressed) { | 209 | if (record->event.pressed) { |
| 227 | layer_on(_LOWER); | 210 | layer_on(_LOWER); |
diff --git a/keyboards/handwired/unk/keymaps/default/keymap.c b/keyboards/handwired/unk/keymaps/default/keymap.c index 73d005983e..c0432dcddd 100644 --- a/keyboards/handwired/unk/keymaps/default/keymap.c +++ b/keyboards/handwired/unk/keymaps/default/keymap.c | |||
| @@ -8,14 +8,12 @@ enum layer_names { | |||
| 8 | _ADJUST, | 8 | _ADJUST, |
| 9 | }; | 9 | }; |
| 10 | 10 | ||
| 11 | enum custom_keycodes { | ||
| 12 | QWERTY = SAFE_RANGE, | ||
| 13 | COLEMAK, | ||
| 14 | }; | ||
| 15 | |||
| 16 | #define LOWER MO(_LOWER) | 11 | #define LOWER MO(_LOWER) |
| 17 | #define RAISE MO(_RAISE) | 12 | #define RAISE MO(_RAISE) |
| 18 | 13 | ||
| 14 | #define QWERTY PDF(_QWERTY) | ||
| 15 | #define COLEMAK PDF(_COLEMAK) | ||
| 16 | |||
| 19 | // Each layer gets a name for readability, which is then used in the keymap matrix below. | 17 | // Each layer gets a name for readability, which is then used in the keymap matrix below. |
| 20 | // The underscores don't mean anything - you can have a layer called STUFF or any other name. | 18 | // The underscores don't mean anything - you can have a layer called STUFF or any other name. |
| 21 | // Layer names don't all need to be of the same length, obviously, and you can also skip them | 19 | // Layer names don't all need to be of the same length, obviously, and you can also skip them |
| @@ -65,19 +63,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 65 | layer_state_t layer_state_set_user(layer_state_t state) { | 63 | layer_state_t layer_state_set_user(layer_state_t state) { |
| 66 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 64 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 67 | } | 65 | } |
| 68 | |||
| 69 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 70 | switch (keycode) { | ||
| 71 | case QWERTY: | ||
| 72 | if (record->event.pressed) { | ||
| 73 | set_single_persistent_default_layer(_QWERTY); | ||
| 74 | } | ||
| 75 | return false; | ||
| 76 | case COLEMAK: | ||
| 77 | if (record->event.pressed) { | ||
| 78 | set_single_persistent_default_layer(_COLEMAK); | ||
| 79 | } | ||
| 80 | return false; | ||
| 81 | } | ||
| 82 | return true; | ||
| 83 | } | ||
diff --git a/keyboards/jian/keymaps/default/keymap.c b/keyboards/jian/keymaps/default/keymap.c index a9a7cb3f54..f3583e5249 100644 --- a/keyboards/jian/keymaps/default/keymap.c +++ b/keyboards/jian/keymaps/default/keymap.c | |||
| @@ -11,16 +11,14 @@ enum jian_layers { | |||
| 11 | _BCKLT_ADJ | 11 | _BCKLT_ADJ |
| 12 | }; | 12 | }; |
| 13 | 13 | ||
| 14 | enum jian_keycodes { | ||
| 15 | QWERTY = SAFE_RANGE, | ||
| 16 | DVORAK, | ||
| 17 | COLEMAK, | ||
| 18 | WORKMAN | ||
| 19 | }; | ||
| 20 | |||
| 21 | #define RAISE_T(kc) LT(_RAISE, kc) | 14 | #define RAISE_T(kc) LT(_RAISE, kc) |
| 22 | #define LOWER_T(kc) LT(_LOWER, kc) | 15 | #define LOWER_T(kc) LT(_LOWER, kc) |
| 23 | 16 | ||
| 17 | #define QWERTY PDF(_QWERTY) | ||
| 18 | #define COLEMAK PDF(_COLEMAK) | ||
| 19 | #define DVORAK PDF(_DVORAK) | ||
| 20 | #define WORKMAN PDF(_WORKMAN) | ||
| 21 | |||
| 24 | #ifdef SWAP_HANDS_ENABLE | 22 | #ifdef SWAP_HANDS_ENABLE |
| 25 | #define SW_TG SH_TOGG | 23 | #define SW_TG SH_TOGG |
| 26 | #else | 24 | #else |
| @@ -92,29 +90,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 92 | layer_state_t layer_state_set_user(layer_state_t state) { | 90 | layer_state_t layer_state_set_user(layer_state_t state) { |
| 93 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 91 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 94 | } | 92 | } |
| 95 | |||
| 96 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 97 | switch (keycode) { | ||
| 98 | case QWERTY: | ||
| 99 | if (record->event.pressed) { | ||
| 100 | set_single_persistent_default_layer(_QWERTY); | ||
| 101 | } | ||
| 102 | return false; | ||
| 103 | case DVORAK: | ||
| 104 | if (record->event.pressed) { | ||
| 105 | set_single_persistent_default_layer(_DVORAK); | ||
| 106 | } | ||
| 107 | return false; | ||
| 108 | case COLEMAK: | ||
| 109 | if (record->event.pressed) { | ||
| 110 | set_single_persistent_default_layer(_COLEMAK); | ||
| 111 | } | ||
| 112 | return false; | ||
| 113 | case WORKMAN: | ||
| 114 | if (record->event.pressed) { | ||
| 115 | set_single_persistent_default_layer(_WORKMAN); | ||
| 116 | } | ||
| 117 | return false; | ||
| 118 | } | ||
| 119 | return true; | ||
| 120 | } | ||
diff --git a/keyboards/jones/v03/keymaps/default_jp/keymap.c b/keyboards/jones/v03/keymaps/default_jp/keymap.c index 9b09b57bbd..b38b01c748 100644 --- a/keyboards/jones/v03/keymaps/default_jp/keymap.c +++ b/keyboards/jones/v03/keymaps/default_jp/keymap.c | |||
| @@ -63,12 +63,6 @@ uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) { | |||
| 63 | } | 63 | } |
| 64 | } | 64 | } |
| 65 | 65 | ||
| 66 | // Defines the keycodes used by our macros in process_record_user | ||
| 67 | enum custom_keycodes { | ||
| 68 | MAC = SAFE_RANGE, | ||
| 69 | WIN, | ||
| 70 | }; | ||
| 71 | |||
| 72 | // Key Macro | 66 | // Key Macro |
| 73 | #define ESC_NUM TD(TD_ESC_NUM) | 67 | #define ESC_NUM TD(TD_ESC_NUM) |
| 74 | #define S_CAP TD(TD_LSFT_CAPS) | 68 | #define S_CAP TD(TD_LSFT_CAPS) |
| @@ -82,7 +76,8 @@ enum custom_keycodes { | |||
| 82 | #define ALT_GRV LALT(KC_GRV) | 76 | #define ALT_GRV LALT(KC_GRV) |
| 83 | #define LOWER MO(_LOWER) | 77 | #define LOWER MO(_LOWER) |
| 84 | #define NUM TG(_NUM) | 78 | #define NUM TG(_NUM) |
| 85 | 79 | #define MAC PDF(_MAC) | |
| 80 | #define WIN PDF(_WIN) | ||
| 86 | 81 | ||
| 87 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 82 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 88 | [_MAC] = LAYOUT_jp( | 83 | [_MAC] = LAYOUT_jp( |
| @@ -146,26 +141,6 @@ const uint8_t music_map[MATRIX_ROWS][MATRIX_COLS] = LAYOUT_jp( | |||
| 146 | ); | 141 | ); |
| 147 | #endif | 142 | #endif |
| 148 | 143 | ||
| 149 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 150 | switch (keycode) { | ||
| 151 | case MAC: // Change default ayer --> Write to EEPROM | ||
| 152 | if (record->event.pressed) { | ||
| 153 | set_single_persistent_default_layer(_MAC); | ||
| 154 | } | ||
| 155 | return false; | ||
| 156 | break; | ||
| 157 | case WIN: // Change default ayer --> Write to EEPROM | ||
| 158 | if (record->event.pressed) { | ||
| 159 | set_single_persistent_default_layer(_WIN); | ||
| 160 | } | ||
| 161 | return false; | ||
| 162 | break; | ||
| 163 | default: | ||
| 164 | break; | ||
| 165 | } | ||
| 166 | return true; | ||
| 167 | } | ||
| 168 | |||
| 169 | //------------------------------------------------------------------------------ | 144 | //------------------------------------------------------------------------------ |
| 170 | // RGB Light settings | 145 | // RGB Light settings |
| 171 | #ifdef RGBLIGHT_LAYERS | 146 | #ifdef RGBLIGHT_LAYERS |
diff --git a/keyboards/jones/v03_1/keymaps/default_ansi/keymap.c b/keyboards/jones/v03_1/keymaps/default_ansi/keymap.c index b4611439b3..b60e26d961 100644 --- a/keyboards/jones/v03_1/keymaps/default_ansi/keymap.c +++ b/keyboards/jones/v03_1/keymaps/default_ansi/keymap.c | |||
| @@ -62,12 +62,6 @@ uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) { | |||
| 62 | } | 62 | } |
| 63 | } | 63 | } |
| 64 | 64 | ||
| 65 | // Defines the keycodes used by our macros in process_record_user | ||
| 66 | enum custom_keycodes { | ||
| 67 | MAC = SAFE_RANGE, | ||
| 68 | WIN, | ||
| 69 | }; | ||
| 70 | |||
| 71 | // Key Macro | 65 | // Key Macro |
| 72 | #define ESC_NUM TD(TD_ESC_NUM) | 66 | #define ESC_NUM TD(TD_ESC_NUM) |
| 73 | #define S_CAP TD(TD_LSFT_CAPS) | 67 | #define S_CAP TD(TD_LSFT_CAPS) |
| @@ -80,7 +74,8 @@ enum custom_keycodes { | |||
| 80 | #define ALT_GRV LALT(KC_GRV) | 74 | #define ALT_GRV LALT(KC_GRV) |
| 81 | #define LOWER MO(_LOWER) | 75 | #define LOWER MO(_LOWER) |
| 82 | #define NUM TG(_NUM) | 76 | #define NUM TG(_NUM) |
| 83 | 77 | #define MAC PDF(_MAC) | |
| 78 | #define WIN PDF(_WIN) | ||
| 84 | 79 | ||
| 85 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 80 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 86 | [_MAC] = LAYOUT_ansi( | 81 | [_MAC] = LAYOUT_ansi( |
| @@ -134,26 +129,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 134 | ) | 129 | ) |
| 135 | }; | 130 | }; |
| 136 | 131 | ||
| 137 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 138 | switch (keycode) { | ||
| 139 | case MAC: // Change default ayer --> Write to EEPROM | ||
| 140 | if (record->event.pressed) { | ||
| 141 | set_single_persistent_default_layer(_MAC); | ||
| 142 | } | ||
| 143 | return false; | ||
| 144 | break; | ||
| 145 | case WIN: // Change default ayer --> Write to EEPROM | ||
| 146 | if (record->event.pressed) { | ||
| 147 | set_single_persistent_default_layer(_WIN); | ||
| 148 | } | ||
| 149 | return false; | ||
| 150 | break; | ||
| 151 | default: | ||
| 152 | break; | ||
| 153 | } | ||
| 154 | return true; | ||
| 155 | } | ||
| 156 | |||
| 157 | //------------------------------------------------------------------------------ | 132 | //------------------------------------------------------------------------------ |
| 158 | // RGB Light settings | 133 | // RGB Light settings |
| 159 | #ifdef RGBLIGHT_LAYERS | 134 | #ifdef RGBLIGHT_LAYERS |
diff --git a/keyboards/jones/v03_1/keymaps/default_jp/keymap.c b/keyboards/jones/v03_1/keymaps/default_jp/keymap.c index f44b5a1330..78fb06aad1 100644 --- a/keyboards/jones/v03_1/keymaps/default_jp/keymap.c +++ b/keyboards/jones/v03_1/keymaps/default_jp/keymap.c | |||
| @@ -63,12 +63,6 @@ uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) { | |||
| 63 | } | 63 | } |
| 64 | } | 64 | } |
| 65 | 65 | ||
| 66 | // Defines the keycodes used by our macros in process_record_user | ||
| 67 | enum custom_keycodes { | ||
| 68 | MAC = SAFE_RANGE, | ||
| 69 | WIN, | ||
| 70 | }; | ||
| 71 | |||
| 72 | // Key Macro | 66 | // Key Macro |
| 73 | #define ESC_NUM TD(TD_ESC_NUM) | 67 | #define ESC_NUM TD(TD_ESC_NUM) |
| 74 | #define S_CAP TD(TD_LSFT_CAPS) | 68 | #define S_CAP TD(TD_LSFT_CAPS) |
| @@ -82,7 +76,8 @@ enum custom_keycodes { | |||
| 82 | #define ALT_GRV LALT(KC_GRV) | 76 | #define ALT_GRV LALT(KC_GRV) |
| 83 | #define LOWER MO(_LOWER) | 77 | #define LOWER MO(_LOWER) |
| 84 | #define NUM TG(_NUM) | 78 | #define NUM TG(_NUM) |
| 85 | 79 | #define MAC PDF(_MAC) | |
| 80 | #define WIN PDF(_WIN) | ||
| 86 | 81 | ||
| 87 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 82 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 88 | [_MAC] = LAYOUT_jp( | 83 | [_MAC] = LAYOUT_jp( |
| @@ -136,26 +131,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 136 | ) | 131 | ) |
| 137 | }; | 132 | }; |
| 138 | 133 | ||
| 139 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 140 | switch (keycode) { | ||
| 141 | case MAC: // Change default ayer --> Write to EEPROM | ||
| 142 | if (record->event.pressed) { | ||
| 143 | set_single_persistent_default_layer(_MAC); | ||
| 144 | } | ||
| 145 | return false; | ||
| 146 | break; | ||
| 147 | case WIN: // Change default ayer --> Write to EEPROM | ||
| 148 | if (record->event.pressed) { | ||
| 149 | set_single_persistent_default_layer(_WIN); | ||
| 150 | } | ||
| 151 | return false; | ||
| 152 | break; | ||
| 153 | default: | ||
| 154 | break; | ||
| 155 | } | ||
| 156 | return true; | ||
| 157 | } | ||
| 158 | |||
| 159 | //------------------------------------------------------------------------------ | 134 | //------------------------------------------------------------------------------ |
| 160 | // RGB Light settings | 135 | // RGB Light settings |
| 161 | #ifdef RGBLIGHT_LAYERS | 136 | #ifdef RGBLIGHT_LAYERS |
diff --git a/keyboards/kagizaraya/chidori/keymaps/default/keymap.c b/keyboards/kagizaraya/chidori/keymaps/default/keymap.c index bd52119d96..f02959d9f5 100644 --- a/keyboards/kagizaraya/chidori/keymaps/default/keymap.c +++ b/keyboards/kagizaraya/chidori/keymaps/default/keymap.c | |||
| @@ -19,13 +19,14 @@ | |||
| 19 | 19 | ||
| 20 | enum layer_number { _QWERTY = 0, _COLEMAK, _DVORAK, _LOWER, _RAISE, _ADJUST }; | 20 | enum layer_number { _QWERTY = 0, _COLEMAK, _DVORAK, _LOWER, _RAISE, _ADJUST }; |
| 21 | 21 | ||
| 22 | // Defines the keycodes used by our macros in process_record_user | ||
| 23 | enum custom_keycodes { QWERTY = SAFE_RANGE, COLEMAK, DVORAK }; | ||
| 24 | |||
| 25 | #define LOWER MO(_LOWER) | 22 | #define LOWER MO(_LOWER) |
| 26 | #define RAISE MO(_RAISE) | 23 | #define RAISE MO(_RAISE) |
| 27 | #define ADJUST MO(_ADJUST) | 24 | #define ADJUST MO(_ADJUST) |
| 28 | 25 | ||
| 26 | #define QWERTY PDF(_QWERTY) | ||
| 27 | #define COLEMAK PDF(_COLEMAK) | ||
| 28 | #define DVORAK PDF(_DVORAK) | ||
| 29 | |||
| 29 | // clang-format off | 30 | // clang-format off |
| 30 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 31 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 31 | /* Qwerty | 32 | /* Qwerty |
| @@ -141,27 +142,6 @@ layer_state_t layer_state_set_user(layer_state_t state) { | |||
| 141 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 142 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 142 | } | 143 | } |
| 143 | 144 | ||
| 144 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 145 | switch (keycode) { | ||
| 146 | case QWERTY: | ||
| 147 | if (record->event.pressed) { | ||
| 148 | set_single_persistent_default_layer(_QWERTY); | ||
| 149 | } | ||
| 150 | return false; | ||
| 151 | case COLEMAK: | ||
| 152 | if (record->event.pressed) { | ||
| 153 | set_single_persistent_default_layer(_COLEMAK); | ||
| 154 | } | ||
| 155 | return false; | ||
| 156 | case DVORAK: | ||
| 157 | if (record->event.pressed) { | ||
| 158 | set_single_persistent_default_layer(_DVORAK); | ||
| 159 | } | ||
| 160 | return false; | ||
| 161 | } | ||
| 162 | return true; | ||
| 163 | } | ||
| 164 | |||
| 165 | bool led_update_user(led_t led_state) { | 145 | bool led_update_user(led_t led_state) { |
| 166 | board_set_led_by_index(0, LED_YELLOW, led_state.caps_lock); | 146 | board_set_led_by_index(0, LED_YELLOW, led_state.caps_lock); |
| 167 | board_set_led_by_index(1, LED_YELLOW, led_state.scroll_lock); | 147 | board_set_led_by_index(1, LED_YELLOW, led_state.scroll_lock); |
diff --git a/keyboards/kagizaraya/chidori/keymaps/extended/keymap.c b/keyboards/kagizaraya/chidori/keymaps/extended/keymap.c index a1f0f6d082..5e777f9074 100644 --- a/keyboards/kagizaraya/chidori/keymaps/extended/keymap.c +++ b/keyboards/kagizaraya/chidori/keymaps/extended/keymap.c | |||
| @@ -19,13 +19,14 @@ | |||
| 19 | 19 | ||
| 20 | enum layer_number { _QWERTY = 0, _COLEMAK, _DVORAK, _LOWER, _RAISE, _ADJUST }; | 20 | enum layer_number { _QWERTY = 0, _COLEMAK, _DVORAK, _LOWER, _RAISE, _ADJUST }; |
| 21 | 21 | ||
| 22 | // Defines the keycodes used by our macros in process_record_user | ||
| 23 | enum custom_keycodes { QWERTY = SAFE_RANGE, COLEMAK, DVORAK }; | ||
| 24 | |||
| 25 | #define LOWER MO(_LOWER) | 22 | #define LOWER MO(_LOWER) |
| 26 | #define RAISE MO(_RAISE) | 23 | #define RAISE MO(_RAISE) |
| 27 | #define ADJUST MO(_ADJUST) | 24 | #define ADJUST MO(_ADJUST) |
| 28 | 25 | ||
| 26 | #define QWERTY PDF(_QWERTY) | ||
| 27 | #define COLEMAK PDF(_COLEMAK) | ||
| 28 | #define DVORAK PDF(_DVORAK) | ||
| 29 | |||
| 29 | // clang-format off | 30 | // clang-format off |
| 30 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 31 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 31 | /* Qwerty | 32 | /* Qwerty |
| @@ -141,27 +142,6 @@ layer_state_t layer_state_set_user(layer_state_t state) { | |||
| 141 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 142 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 142 | } | 143 | } |
| 143 | 144 | ||
| 144 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 145 | switch (keycode) { | ||
| 146 | case QWERTY: | ||
| 147 | if (record->event.pressed) { | ||
| 148 | set_single_persistent_default_layer(_QWERTY); | ||
| 149 | } | ||
| 150 | return false; | ||
| 151 | case COLEMAK: | ||
| 152 | if (record->event.pressed) { | ||
| 153 | set_single_persistent_default_layer(_COLEMAK); | ||
| 154 | } | ||
| 155 | return false; | ||
| 156 | case DVORAK: | ||
| 157 | if (record->event.pressed) { | ||
| 158 | set_single_persistent_default_layer(_DVORAK); | ||
| 159 | } | ||
| 160 | return false; | ||
| 161 | } | ||
| 162 | return true; | ||
| 163 | } | ||
| 164 | |||
| 165 | bool led_update_user(led_t led_state) { | 145 | bool led_update_user(led_t led_state) { |
| 166 | board_set_led_by_index(0, LED_YELLOW, led_state.caps_lock); | 146 | board_set_led_by_index(0, LED_YELLOW, led_state.caps_lock); |
| 167 | board_set_led_by_index(1, LED_YELLOW, led_state.scroll_lock); | 147 | board_set_led_by_index(1, LED_YELLOW, led_state.scroll_lock); |
diff --git a/keyboards/keebio/viterbi/keymaps/default/keymap.c b/keyboards/keebio/viterbi/keymaps/default/keymap.c index bc7cd5d3f0..e37fc8f790 100644 --- a/keyboards/keebio/viterbi/keymaps/default/keymap.c +++ b/keyboards/keebio/viterbi/keymaps/default/keymap.c | |||
| @@ -13,8 +13,7 @@ enum layer_names { | |||
| 13 | }; | 13 | }; |
| 14 | 14 | ||
| 15 | enum custom_keycodes { | 15 | enum custom_keycodes { |
| 16 | QWERTY = SAFE_RANGE, | 16 | LOWER = SAFE_RANGE, |
| 17 | LOWER, | ||
| 18 | RAISE, | 17 | RAISE, |
| 19 | ADJUST, | 18 | ADJUST, |
| 20 | }; | 19 | }; |
| @@ -88,7 +87,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 88 | [_ADJUST] = LAYOUT_ortho_5x14( | 87 | [_ADJUST] = LAYOUT_ortho_5x14( |
| 89 | _______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, _______, | 88 | _______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, _______, |
| 90 | _______, _______, QK_BOOT, UG_TOGG, UG_NEXT, UG_HUED, UG_HUEU, UG_SATD, UG_SATU, UG_VALD, UG_VALU, _______, KC_DEL, _______, | 89 | _______, _______, QK_BOOT, UG_TOGG, UG_NEXT, UG_HUED, UG_HUEU, UG_SATD, UG_SATU, UG_VALD, UG_VALU, _______, KC_DEL, _______, |
| 91 | _______, _______, _______, _______, AU_ON, AU_OFF, AG_NORM, AG_SWAP, QWERTY, _______, _______, _______, _______, _______, | 90 | _______, _______, _______, _______, AU_ON, AU_OFF, AG_NORM, AG_SWAP, _______, _______, _______, _______, _______, _______, |
| 92 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | 91 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, |
| 93 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ | 92 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ |
| 94 | ) | 93 | ) |
| @@ -98,12 +97,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 98 | 97 | ||
| 99 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 98 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 100 | switch (keycode) { | 99 | switch (keycode) { |
| 101 | case QWERTY: | ||
| 102 | if (record->event.pressed) { | ||
| 103 | set_single_persistent_default_layer(_QWERTY); | ||
| 104 | } | ||
| 105 | return false; | ||
| 106 | break; | ||
| 107 | case LOWER: | 100 | case LOWER: |
| 108 | if (record->event.pressed) { | 101 | if (record->event.pressed) { |
| 109 | layer_on(_LOWER); | 102 | layer_on(_LOWER); |
diff --git a/keyboards/keycapsss/o4l_5x12/keymaps/2x2u/keymap.c b/keyboards/keycapsss/o4l_5x12/keymaps/2x2u/keymap.c index ab5b9de62f..1e12efc1c1 100644 --- a/keyboards/keycapsss/o4l_5x12/keymaps/2x2u/keymap.c +++ b/keyboards/keycapsss/o4l_5x12/keymaps/2x2u/keymap.c | |||
| @@ -5,11 +5,6 @@ enum layer_names { | |||
| 5 | _LOWER | 5 | _LOWER |
| 6 | }; | 6 | }; |
| 7 | 7 | ||
| 8 | enum custom_keycodes { | ||
| 9 | QWERTY = SAFE_RANGE, | ||
| 10 | LOWER | ||
| 11 | }; | ||
| 12 | |||
| 13 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 8 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 14 | /* Qwerty | 9 | /* Qwerty |
| 15 | * ,-----------------------------------------------------------------------------------. | 10 | * ,-----------------------------------------------------------------------------------. |
| @@ -29,7 +24,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 29 | QK_GESC, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, | 24 | QK_GESC, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, |
| 30 | KC_TAB, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, | 25 | KC_TAB, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, |
| 31 | KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT, | 26 | KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT, |
| 32 | KC_LCTL, KC_LALT, KC_LGUI, LOWER, KC_ENT, KC_SPC, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT | 27 | KC_LCTL, KC_LALT, KC_LGUI, MO(_LOWER), KC_ENT, KC_SPC, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT |
| 33 | ), | 28 | ), |
| 34 | 29 | ||
| 35 | /* Lower | 30 | /* Lower |
| @@ -53,21 +48,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 53 | UG_TOGG, QK_BOOT, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY | 48 | UG_TOGG, QK_BOOT, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY |
| 54 | ) | 49 | ) |
| 55 | }; | 50 | }; |
| 56 | |||
| 57 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 58 | switch (keycode) { | ||
| 59 | case QWERTY: | ||
| 60 | if (record->event.pressed) { | ||
| 61 | set_single_persistent_default_layer(_QWERTY); | ||
| 62 | } | ||
| 63 | return false; | ||
| 64 | case LOWER: | ||
| 65 | if (record->event.pressed) { | ||
| 66 | layer_on(_LOWER); | ||
| 67 | } else { | ||
| 68 | layer_off(_LOWER); | ||
| 69 | } | ||
| 70 | return false; | ||
| 71 | } | ||
| 72 | return true; | ||
| 73 | }; | ||
diff --git a/keyboards/keycapsss/o4l_5x12/keymaps/default/keymap.c b/keyboards/keycapsss/o4l_5x12/keymaps/default/keymap.c index 2833201d97..e775008bd4 100644 --- a/keyboards/keycapsss/o4l_5x12/keymaps/default/keymap.c +++ b/keyboards/keycapsss/o4l_5x12/keymaps/default/keymap.c | |||
| @@ -8,8 +8,7 @@ enum layer_names { | |||
| 8 | }; | 8 | }; |
| 9 | 9 | ||
| 10 | enum custom_keycodes { | 10 | enum custom_keycodes { |
| 11 | QWERTY = SAFE_RANGE, | 11 | LOWER = SAFE_RANGE, |
| 12 | LOWER, | ||
| 13 | RAISE | 12 | RAISE |
| 14 | }; | 13 | }; |
| 15 | 14 | ||
| @@ -83,7 +82,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 83 | * |------+------+------+------+------+------+------+------+------+------+------+------| | 82 | * |------+------+------+------+------+------+------+------+------+------+------+------| |
| 84 | * | | Reset| | | | | | | | | | Del | | 83 | * | | Reset| | | | | | | | | | Del | |
| 85 | * |------+------+------+------+------+-------------+------+------+------+------+------| | 84 | * |------+------+------+------+------+-------------+------+------+------+------+------| |
| 86 | * | | | |Aud on|AudOff|AGnorm|AGswap|Qwerty| | | | | | 85 | * | | | |Aud on|AudOff|AGnorm|AGswap| | | | | | |
| 87 | * |------+------+------+------+------+------|------+------+------+------+------+------| | 86 | * |------+------+------+------+------+------|------+------+------+------+------+------| |
| 88 | * | |Voice-|Voice+|Mus on|MusOff|MidiOn|MidOff| | | | | | | 87 | * | |Voice-|Voice+|Mus on|MusOff|MidiOn|MidOff| | | | | | |
| 89 | * |------+------+------+------+------+------+------+------+------+------+------+------| | 88 | * |------+------+------+------+------+------+------+------+------+------+------+------| |
| @@ -93,7 +92,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 93 | [_ADJUST] = LAYOUT_ortho_5x12( | 92 | [_ADJUST] = LAYOUT_ortho_5x12( |
| 94 | KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, | 93 | KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, |
| 95 | _______, QK_BOOT, DB_TOGG, _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL, | 94 | _______, QK_BOOT, DB_TOGG, _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL, |
| 96 | _______, _______, MU_NEXT, AU_ON, AU_OFF, AG_NORM, AG_SWAP, QWERTY, _______, _______, _______, _______, | 95 | _______, _______, MU_NEXT, AU_ON, AU_OFF, AG_NORM, AG_SWAP, _______, _______, _______, _______, _______, |
| 97 | _______, AU_PREV, AU_NEXT, MU_ON, MU_OFF, MI_ON, MI_OFF, _______, _______, _______, _______, _______, | 96 | _______, AU_PREV, AU_NEXT, MU_ON, MU_OFF, MI_ON, MI_OFF, _______, _______, _______, _______, _______, |
| 98 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ | 97 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ |
| 99 | ) | 98 | ) |
| @@ -101,11 +100,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 101 | 100 | ||
| 102 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 101 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 103 | switch (keycode) { | 102 | switch (keycode) { |
| 104 | case QWERTY: | ||
| 105 | if (record->event.pressed) { | ||
| 106 | set_single_persistent_default_layer(_QWERTY); | ||
| 107 | } | ||
| 108 | return false; | ||
| 109 | case LOWER: | 103 | case LOWER: |
| 110 | if (record->event.pressed) { | 104 | if (record->event.pressed) { |
| 111 | layer_on(_LOWER); | 105 | layer_on(_LOWER); |
diff --git a/keyboards/keyprez/bison/keymaps/default/keymap.c b/keyboards/keyprez/bison/keymaps/default/keymap.c index fc1f346647..d66b1a487b 100644 --- a/keyboards/keyprez/bison/keymaps/default/keymap.c +++ b/keyboards/keyprez/bison/keymaps/default/keymap.c | |||
| @@ -26,10 +26,7 @@ enum layer_names { | |||
| 26 | }; | 26 | }; |
| 27 | 27 | ||
| 28 | enum custom_keycodes { | 28 | enum custom_keycodes { |
| 29 | KC_QWRTY = SAFE_RANGE, | 29 | KC_PRVWD = SAFE_RANGE, |
| 30 | KC_COLMK, | ||
| 31 | KC_HRM, | ||
| 32 | KC_PRVWD, | ||
| 33 | KC_NXTWD | 30 | KC_NXTWD |
| 34 | }; | 31 | }; |
| 35 | 32 | ||
| @@ -46,6 +43,10 @@ enum custom_keycodes { | |||
| 46 | #define HRM_RC MT(MOD_RCTL, KC_K) | 43 | #define HRM_RC MT(MOD_RCTL, KC_K) |
| 47 | #define HRM_RS MT(MOD_RSFT, KC_J) | 44 | #define HRM_RS MT(MOD_RSFT, KC_J) |
| 48 | 45 | ||
| 46 | #define KC_QWRTY PDF(_QWERTY) | ||
| 47 | #define KC_COLMK PDF(_COLEMAK) | ||
| 48 | #define KC_HRM PDF(_HRM) | ||
| 49 | |||
| 49 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 50 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 50 | /* | 51 | /* |
| 51 | * QWERTY | 52 | * QWERTY |
| @@ -188,21 +189,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 188 | 189 | ||
| 189 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 190 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 190 | switch (keycode) { | 191 | switch (keycode) { |
| 191 | case KC_QWRTY: | ||
| 192 | if (record->event.pressed) { | ||
| 193 | set_single_persistent_default_layer(_QWERTY); | ||
| 194 | } | ||
| 195 | return false; | ||
| 196 | case KC_COLMK: | ||
| 197 | if (record->event.pressed) { | ||
| 198 | set_single_persistent_default_layer(_COLEMAK); | ||
| 199 | } | ||
| 200 | return false; | ||
| 201 | case KC_HRM: | ||
| 202 | if (record->event.pressed) { | ||
| 203 | set_single_persistent_default_layer(_HRM); | ||
| 204 | } | ||
| 205 | return false; | ||
| 206 | case KC_PRVWD: | 192 | case KC_PRVWD: |
| 207 | if (record->event.pressed) { | 193 | if (record->event.pressed) { |
| 208 | register_mods(mod_config(MOD_LCTL)); | 194 | register_mods(mod_config(MOD_LCTL)); |
diff --git a/keyboards/keyprez/bison/keymaps/default_6_6/keymap.c b/keyboards/keyprez/bison/keymaps/default_6_6/keymap.c index 816cd2fda6..a51fd87c01 100644 --- a/keyboards/keyprez/bison/keymaps/default_6_6/keymap.c +++ b/keyboards/keyprez/bison/keymaps/default_6_6/keymap.c | |||
| @@ -26,10 +26,7 @@ enum layer_names { | |||
| 26 | }; | 26 | }; |
| 27 | 27 | ||
| 28 | enum custom_keycodes { | 28 | enum custom_keycodes { |
| 29 | KC_QWRTY = SAFE_RANGE, | 29 | KC_PRVWD = SAFE_RANGE, |
| 30 | KC_COLMK, | ||
| 31 | KC_HRM, | ||
| 32 | KC_PRVWD, | ||
| 33 | KC_NXTWD | 30 | KC_NXTWD |
| 34 | }; | 31 | }; |
| 35 | 32 | ||
| @@ -46,6 +43,10 @@ enum custom_keycodes { | |||
| 46 | #define HRM_RC MT(MOD_RCTL, KC_K) | 43 | #define HRM_RC MT(MOD_RCTL, KC_K) |
| 47 | #define HRM_RS MT(MOD_RSFT, KC_J) | 44 | #define HRM_RS MT(MOD_RSFT, KC_J) |
| 48 | 45 | ||
| 46 | #define KC_QWRTY PDF(_QWERTY) | ||
| 47 | #define KC_COLMK PDF(_COLEMAK) | ||
| 48 | #define KC_HRM PDF(_HRM) | ||
| 49 | |||
| 49 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 50 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 50 | /* | 51 | /* |
| 51 | * QWERTY | 52 | * QWERTY |
| @@ -188,21 +189,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 188 | 189 | ||
| 189 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 190 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 190 | switch (keycode) { | 191 | switch (keycode) { |
| 191 | case KC_QWRTY: | ||
| 192 | if (record->event.pressed) { | ||
| 193 | set_single_persistent_default_layer(_QWERTY); | ||
| 194 | } | ||
| 195 | return false; | ||
| 196 | case KC_COLMK: | ||
| 197 | if (record->event.pressed) { | ||
| 198 | set_single_persistent_default_layer(_COLEMAK); | ||
| 199 | } | ||
| 200 | return false; | ||
| 201 | case KC_HRM: | ||
| 202 | if (record->event.pressed) { | ||
| 203 | set_single_persistent_default_layer(_HRM); | ||
| 204 | } | ||
| 205 | return false; | ||
| 206 | case KC_PRVWD: | 192 | case KC_PRVWD: |
| 207 | if (record->event.pressed) { | 193 | if (record->event.pressed) { |
| 208 | register_mods(mod_config(MOD_LCTL)); | 194 | register_mods(mod_config(MOD_LCTL)); |
diff --git a/keyboards/keyprez/bison/keymaps/default_6_8/keymap.c b/keyboards/keyprez/bison/keymaps/default_6_8/keymap.c index c42ee631db..c6d4676384 100644 --- a/keyboards/keyprez/bison/keymaps/default_6_8/keymap.c +++ b/keyboards/keyprez/bison/keymaps/default_6_8/keymap.c | |||
| @@ -26,10 +26,7 @@ enum layer_names { | |||
| 26 | }; | 26 | }; |
| 27 | 27 | ||
| 28 | enum custom_keycodes { | 28 | enum custom_keycodes { |
| 29 | KC_QWRTY = SAFE_RANGE, | 29 | KC_PRVWD = SAFE_RANGE, |
| 30 | KC_COLMK, | ||
| 31 | KC_HRM, | ||
| 32 | KC_PRVWD, | ||
| 33 | KC_NXTWD | 30 | KC_NXTWD |
| 34 | }; | 31 | }; |
| 35 | 32 | ||
| @@ -46,6 +43,10 @@ enum custom_keycodes { | |||
| 46 | #define HRM_RC MT(MOD_RCTL, KC_K) | 43 | #define HRM_RC MT(MOD_RCTL, KC_K) |
| 47 | #define HRM_RS MT(MOD_RSFT, KC_J) | 44 | #define HRM_RS MT(MOD_RSFT, KC_J) |
| 48 | 45 | ||
| 46 | #define KC_QWRTY PDF(_QWERTY) | ||
| 47 | #define KC_COLMK PDF(_COLEMAK) | ||
| 48 | #define KC_HRM PDF(_HRM) | ||
| 49 | |||
| 49 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 50 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 50 | /* | 51 | /* |
| 51 | * QWERTY | 52 | * QWERTY |
| @@ -188,21 +189,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 188 | 189 | ||
| 189 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 190 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 190 | switch (keycode) { | 191 | switch (keycode) { |
| 191 | case KC_QWRTY: | ||
| 192 | if (record->event.pressed) { | ||
| 193 | set_single_persistent_default_layer(_QWERTY); | ||
| 194 | } | ||
| 195 | return false; | ||
| 196 | case KC_COLMK: | ||
| 197 | if (record->event.pressed) { | ||
| 198 | set_single_persistent_default_layer(_COLEMAK); | ||
| 199 | } | ||
| 200 | return false; | ||
| 201 | case KC_HRM: | ||
| 202 | if (record->event.pressed) { | ||
| 203 | set_single_persistent_default_layer(_HRM); | ||
| 204 | } | ||
| 205 | return false; | ||
| 206 | case KC_PRVWD: | 192 | case KC_PRVWD: |
| 207 | if (record->event.pressed) { | 193 | if (record->event.pressed) { |
| 208 | register_mods(mod_config(MOD_LCTL)); | 194 | register_mods(mod_config(MOD_LCTL)); |
diff --git a/keyboards/keyprez/bison/keymaps/default_8_6/keymap.c b/keyboards/keyprez/bison/keymaps/default_8_6/keymap.c index 173b9bc387..5566539c08 100644 --- a/keyboards/keyprez/bison/keymaps/default_8_6/keymap.c +++ b/keyboards/keyprez/bison/keymaps/default_8_6/keymap.c | |||
| @@ -26,10 +26,7 @@ enum layer_names { | |||
| 26 | }; | 26 | }; |
| 27 | 27 | ||
| 28 | enum custom_keycodes { | 28 | enum custom_keycodes { |
| 29 | KC_QWRTY = SAFE_RANGE, | 29 | KC_PRVWD = SAFE_RANGE, |
| 30 | KC_COLMK, | ||
| 31 | KC_HRM, | ||
| 32 | KC_PRVWD, | ||
| 33 | KC_NXTWD | 30 | KC_NXTWD |
| 34 | }; | 31 | }; |
| 35 | 32 | ||
| @@ -46,6 +43,10 @@ enum custom_keycodes { | |||
| 46 | #define HRM_RC MT(MOD_RCTL, KC_K) | 43 | #define HRM_RC MT(MOD_RCTL, KC_K) |
| 47 | #define HRM_RS MT(MOD_RSFT, KC_J) | 44 | #define HRM_RS MT(MOD_RSFT, KC_J) |
| 48 | 45 | ||
| 46 | #define KC_QWRTY PDF(_QWERTY) | ||
| 47 | #define KC_COLMK PDF(_COLEMAK) | ||
| 48 | #define KC_HRM PDF(_HRM) | ||
| 49 | |||
| 49 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 50 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 50 | /* | 51 | /* |
| 51 | * QWERTY | 52 | * QWERTY |
| @@ -188,21 +189,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 188 | 189 | ||
| 189 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 190 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 190 | switch (keycode) { | 191 | switch (keycode) { |
| 191 | case KC_QWRTY: | ||
| 192 | if (record->event.pressed) { | ||
| 193 | set_single_persistent_default_layer(_QWERTY); | ||
| 194 | } | ||
| 195 | return false; | ||
| 196 | case KC_COLMK: | ||
| 197 | if (record->event.pressed) { | ||
| 198 | set_single_persistent_default_layer(_COLEMAK); | ||
| 199 | } | ||
| 200 | return false; | ||
| 201 | case KC_HRM: | ||
| 202 | if (record->event.pressed) { | ||
| 203 | set_single_persistent_default_layer(_HRM); | ||
| 204 | } | ||
| 205 | return false; | ||
| 206 | case KC_PRVWD: | 192 | case KC_PRVWD: |
| 207 | if (record->event.pressed) { | 193 | if (record->event.pressed) { |
| 208 | register_mods(mod_config(MOD_LCTL)); | 194 | register_mods(mod_config(MOD_LCTL)); |
diff --git a/keyboards/keyprez/corgi/keymaps/default/keymap.c b/keyboards/keyprez/corgi/keymaps/default/keymap.c index 757b3fd1db..3e55671bc9 100644 --- a/keyboards/keyprez/corgi/keymaps/default/keymap.c +++ b/keyboards/keyprez/corgi/keymaps/default/keymap.c | |||
| @@ -26,15 +26,13 @@ enum layer_names { | |||
| 26 | _CMD, | 26 | _CMD, |
| 27 | }; | 27 | }; |
| 28 | 28 | ||
| 29 | enum corgi_keycodes { | ||
| 30 | QWERTY = SAFE_RANGE, | ||
| 31 | COLEMAK | ||
| 32 | }; | ||
| 33 | |||
| 34 | #define LOWER MO(_LOWER) | 29 | #define LOWER MO(_LOWER) |
| 35 | #define RAISE MO(_RAISE) | 30 | #define RAISE MO(_RAISE) |
| 36 | #define CMD MO(_CMD) | 31 | #define CMD MO(_CMD) |
| 37 | 32 | ||
| 33 | #define QWERTY PDF(_QWERTY) | ||
| 34 | #define COLEMAK PDF(_COLEMAK) | ||
| 35 | |||
| 38 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 36 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 39 | /* Qwerty | 37 | /* Qwerty |
| 40 | * ,-----------------------------------------------------------------------------------. | 38 | * ,-----------------------------------------------------------------------------------. |
| @@ -136,21 +134,3 @@ bool encoder_update_user(uint8_t index, bool clockwise) { | |||
| 136 | tap_code(clockwise ? KC_VOLU : KC_VOLD); | 134 | tap_code(clockwise ? KC_VOLU : KC_VOLD); |
| 137 | return true; | 135 | return true; |
| 138 | } | 136 | } |
| 139 | |||
| 140 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 141 | switch (keycode) { | ||
| 142 | case QWERTY: | ||
| 143 | if (record->event.pressed) { | ||
| 144 | set_single_persistent_default_layer(_QWERTY); | ||
| 145 | } | ||
| 146 | return false; | ||
| 147 | break; | ||
| 148 | case COLEMAK: | ||
| 149 | if (record->event.pressed) { | ||
| 150 | set_single_persistent_default_layer(_COLEMAK); | ||
| 151 | } | ||
| 152 | return false; | ||
| 153 | break; | ||
| 154 | } | ||
| 155 | return true; | ||
| 156 | } | ||
diff --git a/keyboards/kprepublic/jj50/keymaps/default/keymap.c b/keyboards/kprepublic/jj50/keymaps/default/keymap.c index f6df7b92f6..7bc5663600 100644 --- a/keyboards/kprepublic/jj50/keymaps/default/keymap.c +++ b/keyboards/kprepublic/jj50/keymaps/default/keymap.c | |||
| @@ -28,17 +28,15 @@ enum layers { | |||
| 28 | _FN | 28 | _FN |
| 29 | }; | 29 | }; |
| 30 | 30 | ||
| 31 | enum keycodes { | ||
| 32 | QWERTY = SAFE_RANGE, | ||
| 33 | WORKMAN, | ||
| 34 | COLEMAK, | ||
| 35 | DVORAK | ||
| 36 | }; | ||
| 37 | |||
| 38 | #define FN MO(_FN) | 31 | #define FN MO(_FN) |
| 39 | #define LOWER MO(_LOWER) | 32 | #define LOWER MO(_LOWER) |
| 40 | #define RAISE MO(_RAISE) | 33 | #define RAISE MO(_RAISE) |
| 41 | 34 | ||
| 35 | #define QWERTY PDF(_QWERTY) | ||
| 36 | #define WORKMAN PDF(_WORKMAN) | ||
| 37 | #define COLEMAK PDF(_COLEMAK) | ||
| 38 | #define DVORAK PDF(_DVORAK) | ||
| 39 | |||
| 42 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 40 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 43 | 41 | ||
| 44 | /* Qwerty | 42 | /* Qwerty |
| @@ -213,29 +211,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 213 | layer_state_t layer_state_set_user(layer_state_t state) { | 211 | layer_state_t layer_state_set_user(layer_state_t state) { |
| 214 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 212 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 215 | } | 213 | } |
| 216 | |||
| 217 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 218 | switch (keycode) { | ||
| 219 | case QWERTY: | ||
| 220 | if (record->event.pressed) { | ||
| 221 | set_single_persistent_default_layer(_QWERTY); | ||
| 222 | } | ||
| 223 | return false; | ||
| 224 | case WORKMAN: | ||
| 225 | if (record->event.pressed) { | ||
| 226 | set_single_persistent_default_layer(_WORKMAN); | ||
| 227 | } | ||
| 228 | return false; | ||
| 229 | case COLEMAK: | ||
| 230 | if (record->event.pressed) { | ||
| 231 | set_single_persistent_default_layer(_COLEMAK); | ||
| 232 | } | ||
| 233 | return false; | ||
| 234 | case DVORAK: | ||
| 235 | if (record->event.pressed) { | ||
| 236 | set_single_persistent_default_layer(_DVORAK); | ||
| 237 | } | ||
| 238 | return false; | ||
| 239 | } | ||
| 240 | return true; | ||
| 241 | }; | ||
diff --git a/keyboards/lets_split/keymaps/default/keymap.c b/keyboards/lets_split/keymaps/default/keymap.c index 4eec2e02ac..1c7405f2ac 100644 --- a/keyboards/lets_split/keymaps/default/keymap.c +++ b/keyboards/lets_split/keymaps/default/keymap.c | |||
| @@ -13,16 +13,14 @@ enum layer_names { | |||
| 13 | _ADJUST | 13 | _ADJUST |
| 14 | }; | 14 | }; |
| 15 | 15 | ||
| 16 | enum custom_keycodes { | ||
| 17 | QWERTY = SAFE_RANGE, | ||
| 18 | COLEMAK, | ||
| 19 | DVORAK | ||
| 20 | }; | ||
| 21 | |||
| 22 | #define LOWER MO(_LOWER) | 16 | #define LOWER MO(_LOWER) |
| 23 | #define RAISE MO(_RAISE) | 17 | #define RAISE MO(_RAISE) |
| 24 | #define ADJUST MO(_ADJUST) | 18 | #define ADJUST MO(_ADJUST) |
| 25 | 19 | ||
| 20 | #define QWERTY PDF(_QWERTY) | ||
| 21 | #define COLEMAK PDF(_COLEMAK) | ||
| 22 | #define DVORAK PDF(_DVORAK) | ||
| 23 | |||
| 26 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 24 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 27 | /* Qwerty | 25 | /* Qwerty |
| 28 | * ,-----------------------------------------------------------------------------------. | 26 | * ,-----------------------------------------------------------------------------------. |
| @@ -138,24 +136,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 138 | layer_state_t layer_state_set_user(layer_state_t state) { | 136 | layer_state_t layer_state_set_user(layer_state_t state) { |
| 139 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 137 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 140 | } | 138 | } |
| 141 | |||
| 142 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 143 | switch (keycode) { | ||
| 144 | case QWERTY: | ||
| 145 | if (record->event.pressed) { | ||
| 146 | set_single_persistent_default_layer(_QWERTY); | ||
| 147 | } | ||
| 148 | return false; | ||
| 149 | case COLEMAK: | ||
| 150 | if (record->event.pressed) { | ||
| 151 | set_single_persistent_default_layer(_COLEMAK); | ||
| 152 | } | ||
| 153 | return false; | ||
| 154 | case DVORAK: | ||
| 155 | if (record->event.pressed) { | ||
| 156 | set_single_persistent_default_layer(_DVORAK); | ||
| 157 | } | ||
| 158 | return false; | ||
| 159 | } | ||
| 160 | return true; | ||
| 161 | } | ||
diff --git a/keyboards/lime/keymaps/default/keymap.c b/keyboards/lime/keymaps/default/keymap.c index e3e5d5a323..8f4e6eb8a4 100644 --- a/keyboards/lime/keymaps/default/keymap.c +++ b/keyboards/lime/keymaps/default/keymap.c | |||
| @@ -30,9 +30,7 @@ enum lime_layers { | |||
| 30 | }; | 30 | }; |
| 31 | 31 | ||
| 32 | enum custom_keycodes { | 32 | enum custom_keycodes { |
| 33 | KC_QWERTY = SAFE_RANGE, | 33 | KC_LOWER = SAFE_RANGE, |
| 34 | KC_COLEMAK, | ||
| 35 | KC_LOWER, | ||
| 36 | KC_RAISE, | 34 | KC_RAISE, |
| 37 | KC_ADJUST, | 35 | KC_ADJUST, |
| 38 | KC_PRVWD, | 36 | KC_PRVWD, |
| @@ -47,6 +45,9 @@ enum custom_keycodes { | |||
| 47 | KC_JOYSTICK_DEBUG, | 45 | KC_JOYSTICK_DEBUG, |
| 48 | }; | 46 | }; |
| 49 | 47 | ||
| 48 | #define KC_QWERTY PDF(_QWERTY) | ||
| 49 | #define KC_COLEMAK PDF(_COLEMAK) | ||
| 50 | |||
| 50 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 51 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 51 | /* | 52 | /* |
| 52 | * QWERTY | 53 | * QWERTY |
| @@ -480,16 +481,6 @@ bool showedJump = true; | |||
| 480 | 481 | ||
| 481 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 482 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 482 | switch (keycode) { | 483 | switch (keycode) { |
| 483 | case KC_QWERTY: | ||
| 484 | if (record->event.pressed) { | ||
| 485 | set_single_persistent_default_layer(_QWERTY); | ||
| 486 | } | ||
| 487 | return false; | ||
| 488 | case KC_COLEMAK: | ||
| 489 | if (record->event.pressed) { | ||
| 490 | set_single_persistent_default_layer(_COLEMAK); | ||
| 491 | } | ||
| 492 | return false; | ||
| 493 | case KC_LOWER: | 484 | case KC_LOWER: |
| 494 | if (record->event.pressed) { | 485 | if (record->event.pressed) { |
| 495 | layer_on(_LOWER); | 486 | layer_on(_LOWER); |
diff --git a/keyboards/makrosu/keymaps/default/keymap.c b/keyboards/makrosu/keymaps/default/keymap.c index 3de4f71df3..1e60e357ba 100644 --- a/keyboards/makrosu/keymaps/default/keymap.c +++ b/keyboards/makrosu/keymaps/default/keymap.c | |||
| @@ -24,15 +24,11 @@ enum planck_layers { | |||
| 24 | 24 | ||
| 25 | }; | 25 | }; |
| 26 | 26 | ||
| 27 | 27 | #define L1 PDF(_1) | |
| 28 | enum planck_keycodes { | 28 | #define L2 PDF(_2) |
| 29 | L1 = SAFE_RANGE, | 29 | #define L3 PDF(_3) |
| 30 | L2, | ||
| 31 | L3 | ||
| 32 | |||
| 33 | }; | ||
| 34 | |||
| 35 | #define LOWER MO(_4) | 30 | #define LOWER MO(_4) |
| 31 | |||
| 36 | #define IND_1 D4 | 32 | #define IND_1 D4 |
| 37 | #define IND_2 C6 | 33 | #define IND_2 C6 |
| 38 | #define IND_3 D7 | 34 | #define IND_3 D7 |
| @@ -66,27 +62,6 @@ layer_state_t layer_state_set_user(layer_state_t state) { | |||
| 66 | return state; | 62 | return state; |
| 67 | } | 63 | } |
| 68 | 64 | ||
| 69 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 70 | switch (keycode) { | ||
| 71 | case L1: | ||
| 72 | if (record->event.pressed) { | ||
| 73 | set_single_persistent_default_layer(_1); | ||
| 74 | } | ||
| 75 | return false; | ||
| 76 | case L2: | ||
| 77 | if (record->event.pressed) { | ||
| 78 | set_single_persistent_default_layer(_2); | ||
| 79 | } | ||
| 80 | return false; | ||
| 81 | case L3: | ||
| 82 | if (record->event.pressed) { | ||
| 83 | set_single_persistent_default_layer(_3); | ||
| 84 | } | ||
| 85 | return false; | ||
| 86 | } | ||
| 87 | return true; | ||
| 88 | } | ||
| 89 | |||
| 90 | void matrix_init_user(void) { | 65 | void matrix_init_user(void) { |
| 91 | //init the Pro Micro on-board LEDs | 66 | //init the Pro Micro on-board LEDs |
| 92 | gpio_set_pin_output(IND_1); | 67 | gpio_set_pin_output(IND_1); |
diff --git a/keyboards/montsinger/rebound/rev1/keymaps/default/keymap.c b/keyboards/montsinger/rebound/rev1/keymaps/default/keymap.c index 9b2369ce31..3eff1ad041 100644 --- a/keyboards/montsinger/rebound/rev1/keymaps/default/keymap.c +++ b/keyboards/montsinger/rebound/rev1/keymaps/default/keymap.c | |||
| @@ -15,16 +15,14 @@ enum layer_names | |||
| 15 | _ADJUST | 15 | _ADJUST |
| 16 | }; | 16 | }; |
| 17 | 17 | ||
| 18 | enum custom_keycodes { | ||
| 19 | QWERTY = SAFE_RANGE, | ||
| 20 | COLEMAK, | ||
| 21 | DVORAK | ||
| 22 | }; | ||
| 23 | |||
| 24 | #define LOWER MO(_LOWER) | 18 | #define LOWER MO(_LOWER) |
| 25 | #define RAISE MO(_RAISE) | 19 | #define RAISE MO(_RAISE) |
| 26 | #define ADJUST MO(_ADJUST) | 20 | #define ADJUST MO(_ADJUST) |
| 27 | 21 | ||
| 22 | #define QWERTY PDF(_QWERTY) | ||
| 23 | #define COLEMAK PDF(_COLEMAK) | ||
| 24 | #define DVORAK PDF(_DVORAK) | ||
| 25 | |||
| 28 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 26 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 29 | /* Qwerty | 27 | /* Qwerty |
| 30 | * ,-----------------------------------------------------------------------------------. | 28 | * ,-----------------------------------------------------------------------------------. |
| @@ -140,24 +138,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 140 | layer_state_t layer_state_set_user(layer_state_t state) { | 138 | layer_state_t layer_state_set_user(layer_state_t state) { |
| 141 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 139 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 142 | } | 140 | } |
| 143 | |||
| 144 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 145 | switch (keycode) { | ||
| 146 | case QWERTY: | ||
| 147 | if (record->event.pressed) { | ||
| 148 | set_single_persistent_default_layer(_QWERTY); | ||
| 149 | } | ||
| 150 | return false; | ||
| 151 | case COLEMAK: | ||
| 152 | if (record->event.pressed) { | ||
| 153 | set_single_persistent_default_layer(_COLEMAK); | ||
| 154 | } | ||
| 155 | return false; | ||
| 156 | case DVORAK: | ||
| 157 | if (record->event.pressed) { | ||
| 158 | set_single_persistent_default_layer(_DVORAK); | ||
| 159 | } | ||
| 160 | return false; | ||
| 161 | } | ||
| 162 | return true; | ||
| 163 | } | ||
diff --git a/keyboards/montsinger/rebound/rev2/keymaps/default/keymap.c b/keyboards/montsinger/rebound/rev2/keymaps/default/keymap.c index d430a7877f..25d9476912 100644 --- a/keyboards/montsinger/rebound/rev2/keymaps/default/keymap.c +++ b/keyboards/montsinger/rebound/rev2/keymaps/default/keymap.c | |||
| @@ -14,16 +14,14 @@ enum layer_names { | |||
| 14 | _ADJUST | 14 | _ADJUST |
| 15 | }; | 15 | }; |
| 16 | 16 | ||
| 17 | enum custom_keycodes { | ||
| 18 | QWERTY = SAFE_RANGE, | ||
| 19 | COLEMAK, | ||
| 20 | DVORAK | ||
| 21 | }; | ||
| 22 | |||
| 23 | #define LOWER MO(_LOWER) | 17 | #define LOWER MO(_LOWER) |
| 24 | #define RAISE MO(_RAISE) | 18 | #define RAISE MO(_RAISE) |
| 25 | #define ADJUST MO(_ADJUST) | 19 | #define ADJUST MO(_ADJUST) |
| 26 | 20 | ||
| 21 | #define QWERTY PDF(_QWERTY) | ||
| 22 | #define COLEMAK PDF(_COLEMAK) | ||
| 23 | #define DVORAK PDF(_DVORAK) | ||
| 24 | |||
| 27 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 25 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 28 | /* Qwerty | 26 | /* Qwerty |
| 29 | * ,-----------------------------------------------------------------------------------. | 27 | * ,-----------------------------------------------------------------------------------. |
| @@ -139,23 +137,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 139 | layer_state_t layer_state_set_user(layer_state_t state) { | 137 | layer_state_t layer_state_set_user(layer_state_t state) { |
| 140 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 138 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 141 | } | 139 | } |
| 142 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 143 | switch (keycode) { | ||
| 144 | case QWERTY: | ||
| 145 | if (record->event.pressed) { | ||
| 146 | set_single_persistent_default_layer(_QWERTY); | ||
| 147 | } | ||
| 148 | break; | ||
| 149 | case COLEMAK: | ||
| 150 | if (record->event.pressed) { | ||
| 151 | set_single_persistent_default_layer(_COLEMAK); | ||
| 152 | } | ||
| 153 | break; | ||
| 154 | case DVORAK: | ||
| 155 | if (record->event.pressed) { | ||
| 156 | set_single_persistent_default_layer(_DVORAK); | ||
| 157 | } | ||
| 158 | break; | ||
| 159 | } | ||
| 160 | return true; | ||
| 161 | } | ||
diff --git a/keyboards/montsinger/rebound/rev3/keymaps/default/keymap.c b/keyboards/montsinger/rebound/rev3/keymaps/default/keymap.c index aadbde3672..dd2fedd987 100644 --- a/keyboards/montsinger/rebound/rev3/keymaps/default/keymap.c +++ b/keyboards/montsinger/rebound/rev3/keymaps/default/keymap.c | |||
| @@ -14,16 +14,14 @@ enum layer_names { | |||
| 14 | _ADJUST | 14 | _ADJUST |
| 15 | }; | 15 | }; |
| 16 | 16 | ||
| 17 | enum custom_keycodes { | ||
| 18 | QWERTY = SAFE_RANGE, | ||
| 19 | COLEMAK, | ||
| 20 | DVORAK | ||
| 21 | }; | ||
| 22 | |||
| 23 | #define LOWER MO(_LOWER) | 17 | #define LOWER MO(_LOWER) |
| 24 | #define RAISE MO(_RAISE) | 18 | #define RAISE MO(_RAISE) |
| 25 | #define ADJUST MO(_ADJUST) | 19 | #define ADJUST MO(_ADJUST) |
| 26 | 20 | ||
| 21 | #define QWERTY PDF(_QWERTY) | ||
| 22 | #define COLEMAK PDF(_COLEMAK) | ||
| 23 | #define DVORAK PDF(_DVORAK) | ||
| 24 | |||
| 27 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 25 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 28 | 26 | ||
| 29 | [_QWERTY] = LAYOUT_all( | 27 | [_QWERTY] = LAYOUT_all( |
| @@ -72,26 +70,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 72 | layer_state_t layer_state_set_user(layer_state_t state) { | 70 | layer_state_t layer_state_set_user(layer_state_t state) { |
| 73 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 71 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 74 | } | 72 | } |
| 75 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 76 | switch (keycode) { | ||
| 77 | case QWERTY: | ||
| 78 | if (record->event.pressed) { | ||
| 79 | set_single_persistent_default_layer(_QWERTY); | ||
| 80 | } | ||
| 81 | break; | ||
| 82 | case COLEMAK: | ||
| 83 | if (record->event.pressed) { | ||
| 84 | set_single_persistent_default_layer(_COLEMAK); | ||
| 85 | } | ||
| 86 | break; | ||
| 87 | case DVORAK: | ||
| 88 | if (record->event.pressed) { | ||
| 89 | set_single_persistent_default_layer(_DVORAK); | ||
| 90 | } | ||
| 91 | break; | ||
| 92 | } | ||
| 93 | return true; | ||
| 94 | } | ||
| 95 | 73 | ||
| 96 | bool encoder_update_user(uint8_t index, bool clockwise) { | 74 | bool encoder_update_user(uint8_t index, bool clockwise) { |
| 97 | if (clockwise) { | 75 | if (clockwise) { |
diff --git a/keyboards/montsinger/rebound/rev4/keymaps/default/keymap.c b/keyboards/montsinger/rebound/rev4/keymaps/default/keymap.c index aadbde3672..dd2fedd987 100644 --- a/keyboards/montsinger/rebound/rev4/keymaps/default/keymap.c +++ b/keyboards/montsinger/rebound/rev4/keymaps/default/keymap.c | |||
| @@ -14,16 +14,14 @@ enum layer_names { | |||
| 14 | _ADJUST | 14 | _ADJUST |
| 15 | }; | 15 | }; |
| 16 | 16 | ||
| 17 | enum custom_keycodes { | ||
| 18 | QWERTY = SAFE_RANGE, | ||
| 19 | COLEMAK, | ||
| 20 | DVORAK | ||
| 21 | }; | ||
| 22 | |||
| 23 | #define LOWER MO(_LOWER) | 17 | #define LOWER MO(_LOWER) |
| 24 | #define RAISE MO(_RAISE) | 18 | #define RAISE MO(_RAISE) |
| 25 | #define ADJUST MO(_ADJUST) | 19 | #define ADJUST MO(_ADJUST) |
| 26 | 20 | ||
| 21 | #define QWERTY PDF(_QWERTY) | ||
| 22 | #define COLEMAK PDF(_COLEMAK) | ||
| 23 | #define DVORAK PDF(_DVORAK) | ||
| 24 | |||
| 27 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 25 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 28 | 26 | ||
| 29 | [_QWERTY] = LAYOUT_all( | 27 | [_QWERTY] = LAYOUT_all( |
| @@ -72,26 +70,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 72 | layer_state_t layer_state_set_user(layer_state_t state) { | 70 | layer_state_t layer_state_set_user(layer_state_t state) { |
| 73 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 71 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 74 | } | 72 | } |
| 75 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 76 | switch (keycode) { | ||
| 77 | case QWERTY: | ||
| 78 | if (record->event.pressed) { | ||
| 79 | set_single_persistent_default_layer(_QWERTY); | ||
| 80 | } | ||
| 81 | break; | ||
| 82 | case COLEMAK: | ||
| 83 | if (record->event.pressed) { | ||
| 84 | set_single_persistent_default_layer(_COLEMAK); | ||
| 85 | } | ||
| 86 | break; | ||
| 87 | case DVORAK: | ||
| 88 | if (record->event.pressed) { | ||
| 89 | set_single_persistent_default_layer(_DVORAK); | ||
| 90 | } | ||
| 91 | break; | ||
| 92 | } | ||
| 93 | return true; | ||
| 94 | } | ||
| 95 | 73 | ||
| 96 | bool encoder_update_user(uint8_t index, bool clockwise) { | 74 | bool encoder_update_user(uint8_t index, bool clockwise) { |
| 97 | if (clockwise) { | 75 | if (clockwise) { |
diff --git a/keyboards/newgame40/keymaps/default/keymap.c b/keyboards/newgame40/keymaps/default/keymap.c index 056afed011..39921d2a38 100644 --- a/keyboards/newgame40/keymaps/default/keymap.c +++ b/keyboards/newgame40/keymaps/default/keymap.c | |||
| @@ -27,18 +27,13 @@ enum layers { | |||
| 27 | _ADJUST, | 27 | _ADJUST, |
| 28 | }; | 28 | }; |
| 29 | 29 | ||
| 30 | enum custom_keycodes { | 30 | #define LOWER MO(_LOWER) |
| 31 | QWERTY = SAFE_RANGE, | 31 | #define RAISE MO(_RAISE) |
| 32 | COLEMAK, | ||
| 33 | DVORAK, | ||
| 34 | LOWER, | ||
| 35 | RAISE, | ||
| 36 | EUCALYN, | ||
| 37 | ADJUST, | ||
| 38 | }; | ||
| 39 | 32 | ||
| 40 | #define LOWER MO(_LOWER) | 33 | #define QWERTY PDF(_QWERTY) |
| 41 | #define RAISE MO(_RAISE) | 34 | #define COLEMAK PDF(_COLEMAK) |
| 35 | #define DVORAK PDF(_DVORAK) | ||
| 36 | #define EUCALYN PDF(_EUCALYN) | ||
| 42 | 37 | ||
| 43 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 38 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 44 | 39 | ||
| @@ -174,33 +169,3 @@ enum layers { | |||
| 174 | layer_state_t layer_state_set_user(layer_state_t state) { | 169 | layer_state_t layer_state_set_user(layer_state_t state) { |
| 175 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 170 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 176 | } | 171 | } |
| 177 | |||
| 178 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 179 | switch (keycode) { | ||
| 180 | case QWERTY: | ||
| 181 | if (record->event.pressed) { | ||
| 182 | set_single_persistent_default_layer(_QWERTY); | ||
| 183 | } | ||
| 184 | return false; | ||
| 185 | break; | ||
| 186 | case COLEMAK: | ||
| 187 | if (record->event.pressed) { | ||
| 188 | set_single_persistent_default_layer(_COLEMAK); | ||
| 189 | } | ||
| 190 | return false; | ||
| 191 | break; | ||
| 192 | case DVORAK: | ||
| 193 | if (record->event.pressed) { | ||
| 194 | set_single_persistent_default_layer(_DVORAK); | ||
| 195 | } | ||
| 196 | return false; | ||
| 197 | break; | ||
| 198 | case EUCALYN: | ||
| 199 | if (record->event.pressed) { | ||
| 200 | set_single_persistent_default_layer(_EUCALYN); | ||
| 201 | } | ||
| 202 | return false; | ||
| 203 | break; | ||
| 204 | } | ||
| 205 | return true; | ||
| 206 | } | ||
diff --git a/keyboards/obosob/arch_36/keymaps/obosob/keymap.c b/keyboards/obosob/arch_36/keymaps/obosob/keymap.c index c36b5601b0..1dd68fa10c 100644 --- a/keyboards/obosob/arch_36/keymaps/obosob/keymap.c +++ b/keyboards/obosob/arch_36/keymaps/obosob/keymap.c | |||
| @@ -39,11 +39,12 @@ enum layer_names { | |||
| 39 | #define OS_GUI OSM(MOD_LGUI) | 39 | #define OS_GUI OSM(MOD_LGUI) |
| 40 | #define OS_ALT OSM(MOD_LALT) | 40 | #define OS_ALT OSM(MOD_LALT) |
| 41 | 41 | ||
| 42 | #define QWERTY PDF(_QWERTY) | ||
| 43 | #define COLEMAK PDF(_COLMAK) | ||
| 44 | |||
| 42 | enum keycodes { | 45 | enum keycodes { |
| 43 | QWERTY = SAFE_RANGE, | ||
| 44 | COLEMAK, | ||
| 45 | // layers | 46 | // layers |
| 46 | SYM, | 47 | SYM = SAFE_RANGE, |
| 47 | MISC, | 48 | MISC, |
| 48 | // special keys | 49 | // special keys |
| 49 | ENC_PRS, | 50 | ENC_PRS, |
| @@ -233,16 +234,6 @@ uint16_t last_rgb_char = 0; | |||
| 233 | 234 | ||
| 234 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 235 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 235 | switch (keycode) { | 236 | switch (keycode) { |
| 236 | case QWERTY: | ||
| 237 | if (record->event.pressed) { | ||
| 238 | set_single_persistent_default_layer(_QWERTY); | ||
| 239 | } | ||
| 240 | return false; | ||
| 241 | case COLEMAK: | ||
| 242 | if (record->event.pressed) { | ||
| 243 | set_single_persistent_default_layer(_COLMAK); | ||
| 244 | } | ||
| 245 | return false; | ||
| 246 | case SYM: | 237 | case SYM: |
| 247 | if (record->event.pressed) { | 238 | if (record->event.pressed) { |
| 248 | layer_on(_SYM); | 239 | layer_on(_SYM); |
diff --git a/keyboards/omkbd/runner3680/3x6/keymaps/default/keymap.c b/keyboards/omkbd/runner3680/3x6/keymaps/default/keymap.c index ec38d8c2ff..b6163a42bc 100644 --- a/keyboards/omkbd/runner3680/3x6/keymaps/default/keymap.c +++ b/keyboards/omkbd/runner3680/3x6/keymaps/default/keymap.c | |||
| @@ -13,8 +13,7 @@ enum layer_number { | |||
| 13 | }; | 13 | }; |
| 14 | 14 | ||
| 15 | enum custom_keycodes { | 15 | enum custom_keycodes { |
| 16 | QWERTY = SAFE_RANGE, | 16 | ADJUST = SAFE_RANGE, |
| 17 | ADJUST, | ||
| 18 | RGBRST | 17 | RGBRST |
| 19 | }; | 18 | }; |
| 20 | 19 | ||
| @@ -56,13 +55,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 56 | 55 | ||
| 57 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 56 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 58 | switch (keycode) { | 57 | switch (keycode) { |
| 59 | case QWERTY: | ||
| 60 | if (record->event.pressed) { | ||
| 61 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 62 | set_single_persistent_default_layer(_QWERTY); | ||
| 63 | } | ||
| 64 | break; | ||
| 65 | |||
| 66 | case ADJUST: | 58 | case ADJUST: |
| 67 | if (record->event.pressed) { | 59 | if (record->event.pressed) { |
| 68 | layer_on(_ADJUST); | 60 | layer_on(_ADJUST); |
diff --git a/keyboards/omkbd/runner3680/3x7/keymaps/default/keymap.c b/keyboards/omkbd/runner3680/3x7/keymaps/default/keymap.c index 8dc742ed78..51c668064e 100644 --- a/keyboards/omkbd/runner3680/3x7/keymaps/default/keymap.c +++ b/keyboards/omkbd/runner3680/3x7/keymaps/default/keymap.c | |||
| @@ -13,8 +13,7 @@ enum layer_number { | |||
| 13 | }; | 13 | }; |
| 14 | 14 | ||
| 15 | enum custom_keycodes { | 15 | enum custom_keycodes { |
| 16 | QWERTY = SAFE_RANGE, | 16 | ADJUST = SAFE_RANGE, |
| 17 | ADJUST, | ||
| 18 | RGBRST | 17 | RGBRST |
| 19 | }; | 18 | }; |
| 20 | 19 | ||
| @@ -56,13 +55,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 56 | 55 | ||
| 57 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 56 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 58 | switch (keycode) { | 57 | switch (keycode) { |
| 59 | case QWERTY: | ||
| 60 | if (record->event.pressed) { | ||
| 61 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 62 | set_single_persistent_default_layer(_QWERTY); | ||
| 63 | } | ||
| 64 | break; | ||
| 65 | |||
| 66 | case ADJUST: | 58 | case ADJUST: |
| 67 | if (record->event.pressed) { | 59 | if (record->event.pressed) { |
| 68 | layer_on(_ADJUST); | 60 | layer_on(_ADJUST); |
diff --git a/keyboards/omkbd/runner3680/3x8/keymaps/default/keymap.c b/keyboards/omkbd/runner3680/3x8/keymaps/default/keymap.c index b858cc2aed..0b57cdc55a 100644 --- a/keyboards/omkbd/runner3680/3x8/keymaps/default/keymap.c +++ b/keyboards/omkbd/runner3680/3x8/keymaps/default/keymap.c | |||
| @@ -13,8 +13,7 @@ enum layer_number { | |||
| 13 | }; | 13 | }; |
| 14 | 14 | ||
| 15 | enum custom_keycodes { | 15 | enum custom_keycodes { |
| 16 | QWERTY = SAFE_RANGE, | 16 | ADJUST = SAFE_RANGE, |
| 17 | ADJUST, | ||
| 18 | RGBRST | 17 | RGBRST |
| 19 | }; | 18 | }; |
| 20 | 19 | ||
| @@ -58,13 +57,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 58 | 57 | ||
| 59 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 58 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 60 | switch (keycode) { | 59 | switch (keycode) { |
| 61 | case QWERTY: | ||
| 62 | if (record->event.pressed) { | ||
| 63 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 64 | set_single_persistent_default_layer(_QWERTY); | ||
| 65 | } | ||
| 66 | break; | ||
| 67 | |||
| 68 | case ADJUST: | 60 | case ADJUST: |
| 69 | if (record->event.pressed) { | 61 | if (record->event.pressed) { |
| 70 | layer_on(_ADJUST); | 62 | layer_on(_ADJUST); |
diff --git a/keyboards/omkbd/runner3680/4x6/keymaps/default/keymap.c b/keyboards/omkbd/runner3680/4x6/keymaps/default/keymap.c index 3fadd6961c..dc50cdcd83 100644 --- a/keyboards/omkbd/runner3680/4x6/keymaps/default/keymap.c +++ b/keyboards/omkbd/runner3680/4x6/keymaps/default/keymap.c | |||
| @@ -13,8 +13,7 @@ enum layer_number { | |||
| 13 | }; | 13 | }; |
| 14 | 14 | ||
| 15 | enum custom_keycodes { | 15 | enum custom_keycodes { |
| 16 | QWERTY = SAFE_RANGE, | 16 | ADJUST = SAFE_RANGE, |
| 17 | ADJUST, | ||
| 18 | RGBRST | 17 | RGBRST |
| 19 | }; | 18 | }; |
| 20 | 19 | ||
| @@ -62,13 +61,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 62 | 61 | ||
| 63 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 62 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 64 | switch (keycode) { | 63 | switch (keycode) { |
| 65 | case QWERTY: | ||
| 66 | if (record->event.pressed) { | ||
| 67 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 68 | set_single_persistent_default_layer(_QWERTY); | ||
| 69 | } | ||
| 70 | break; | ||
| 71 | |||
| 72 | case ADJUST: | 64 | case ADJUST: |
| 73 | if (record->event.pressed) { | 65 | if (record->event.pressed) { |
| 74 | layer_on(_ADJUST); | 66 | layer_on(_ADJUST); |
diff --git a/keyboards/omkbd/runner3680/4x7/keymaps/default/keymap.c b/keyboards/omkbd/runner3680/4x7/keymaps/default/keymap.c index e898b42cd5..de162dba88 100644 --- a/keyboards/omkbd/runner3680/4x7/keymaps/default/keymap.c +++ b/keyboards/omkbd/runner3680/4x7/keymaps/default/keymap.c | |||
| @@ -13,8 +13,7 @@ enum layer_number { | |||
| 13 | }; | 13 | }; |
| 14 | 14 | ||
| 15 | enum custom_keycodes { | 15 | enum custom_keycodes { |
| 16 | QWERTY = SAFE_RANGE, | 16 | ADJUST = SAFE_RANGE, |
| 17 | ADJUST, | ||
| 18 | RGBRST | 17 | RGBRST |
| 19 | }; | 18 | }; |
| 20 | 19 | ||
| @@ -62,13 +61,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 62 | 61 | ||
| 63 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 62 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 64 | switch (keycode) { | 63 | switch (keycode) { |
| 65 | case QWERTY: | ||
| 66 | if (record->event.pressed) { | ||
| 67 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 68 | set_single_persistent_default_layer(_QWERTY); | ||
| 69 | } | ||
| 70 | break; | ||
| 71 | |||
| 72 | case ADJUST: | 64 | case ADJUST: |
| 73 | if (record->event.pressed) { | 65 | if (record->event.pressed) { |
| 74 | layer_on(_ADJUST); | 66 | layer_on(_ADJUST); |
diff --git a/keyboards/omkbd/runner3680/4x8/keymaps/default/keymap.c b/keyboards/omkbd/runner3680/4x8/keymaps/default/keymap.c index f8d095ce16..c2b4a5e6d1 100644 --- a/keyboards/omkbd/runner3680/4x8/keymaps/default/keymap.c +++ b/keyboards/omkbd/runner3680/4x8/keymaps/default/keymap.c | |||
| @@ -13,8 +13,7 @@ enum layer_number { | |||
| 13 | }; | 13 | }; |
| 14 | 14 | ||
| 15 | enum custom_keycodes { | 15 | enum custom_keycodes { |
| 16 | QWERTY = SAFE_RANGE, | 16 | ADJUST = SAFE_RANGE, |
| 17 | ADJUST, | ||
| 18 | RGBRST | 17 | RGBRST |
| 19 | }; | 18 | }; |
| 20 | 19 | ||
| @@ -62,13 +61,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 62 | 61 | ||
| 63 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 62 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 64 | switch (keycode) { | 63 | switch (keycode) { |
| 65 | case QWERTY: | ||
| 66 | if (record->event.pressed) { | ||
| 67 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 68 | set_single_persistent_default_layer(_QWERTY); | ||
| 69 | } | ||
| 70 | break; | ||
| 71 | |||
| 72 | case ADJUST: | 64 | case ADJUST: |
| 73 | if (record->event.pressed) { | 65 | if (record->event.pressed) { |
| 74 | layer_on(_ADJUST); | 66 | layer_on(_ADJUST); |
diff --git a/keyboards/omkbd/runner3680/5x6/keymaps/default/keymap.c b/keyboards/omkbd/runner3680/5x6/keymaps/default/keymap.c index 9eda782a2f..75f034da0d 100644 --- a/keyboards/omkbd/runner3680/5x6/keymaps/default/keymap.c +++ b/keyboards/omkbd/runner3680/5x6/keymaps/default/keymap.c | |||
| @@ -13,8 +13,7 @@ enum layer_number { | |||
| 13 | }; | 13 | }; |
| 14 | 14 | ||
| 15 | enum custom_keycodes { | 15 | enum custom_keycodes { |
| 16 | QWERTY = SAFE_RANGE, | 16 | ADJUST = SAFE_RANGE, |
| 17 | ADJUST, | ||
| 18 | RGBRST | 17 | RGBRST |
| 19 | }; | 18 | }; |
| 20 | 19 | ||
| @@ -68,13 +67,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 68 | 67 | ||
| 69 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 68 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 70 | switch (keycode) { | 69 | switch (keycode) { |
| 71 | case QWERTY: | ||
| 72 | if (record->event.pressed) { | ||
| 73 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 74 | set_single_persistent_default_layer(_QWERTY); | ||
| 75 | } | ||
| 76 | break; | ||
| 77 | |||
| 78 | case ADJUST: | 70 | case ADJUST: |
| 79 | if (record->event.pressed) { | 71 | if (record->event.pressed) { |
| 80 | layer_on(_ADJUST); | 72 | layer_on(_ADJUST); |
diff --git a/keyboards/omkbd/runner3680/5x7/keymaps/default/keymap.c b/keyboards/omkbd/runner3680/5x7/keymaps/default/keymap.c index 599be9334e..acf89f7fed 100644 --- a/keyboards/omkbd/runner3680/5x7/keymaps/default/keymap.c +++ b/keyboards/omkbd/runner3680/5x7/keymaps/default/keymap.c | |||
| @@ -13,8 +13,7 @@ enum layer_number { | |||
| 13 | }; | 13 | }; |
| 14 | 14 | ||
| 15 | enum custom_keycodes { | 15 | enum custom_keycodes { |
| 16 | QWERTY = SAFE_RANGE, | 16 | ADJUST = SAFE_RANGE, |
| 17 | ADJUST, | ||
| 18 | RGBRST | 17 | RGBRST |
| 19 | }; | 18 | }; |
| 20 | 19 | ||
| @@ -68,13 +67,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 68 | 67 | ||
| 69 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 68 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 70 | switch (keycode) { | 69 | switch (keycode) { |
| 71 | case QWERTY: | ||
| 72 | if (record->event.pressed) { | ||
| 73 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 74 | set_single_persistent_default_layer(_QWERTY); | ||
| 75 | } | ||
| 76 | break; | ||
| 77 | |||
| 78 | case ADJUST: | 70 | case ADJUST: |
| 79 | if (record->event.pressed) { | 71 | if (record->event.pressed) { |
| 80 | layer_on(_ADJUST); | 72 | layer_on(_ADJUST); |
diff --git a/keyboards/omkbd/runner3680/5x8/keymaps/JIS/keymap.c b/keyboards/omkbd/runner3680/5x8/keymaps/JIS/keymap.c index 929de444fa..d43c5012e6 100644 --- a/keyboards/omkbd/runner3680/5x8/keymaps/JIS/keymap.c +++ b/keyboards/omkbd/runner3680/5x8/keymaps/JIS/keymap.c | |||
| @@ -15,8 +15,7 @@ enum layer_number { | |||
| 15 | }; | 15 | }; |
| 16 | 16 | ||
| 17 | enum custom_keycodes { | 17 | enum custom_keycodes { |
| 18 | QWERTY = SAFE_RANGE, | 18 | ADJUST = SAFE_RANGE, |
| 19 | ADJUST, | ||
| 20 | RGBRST | 19 | RGBRST |
| 21 | }; | 20 | }; |
| 22 | 21 | ||
| @@ -70,13 +69,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 70 | 69 | ||
| 71 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 70 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 72 | switch (keycode) { | 71 | switch (keycode) { |
| 73 | case QWERTY: | ||
| 74 | if (record->event.pressed) { | ||
| 75 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 76 | set_single_persistent_default_layer(_QWERTY); | ||
| 77 | } | ||
| 78 | break; | ||
| 79 | |||
| 80 | case ADJUST: | 72 | case ADJUST: |
| 81 | if (record->event.pressed) { | 73 | if (record->event.pressed) { |
| 82 | layer_on(_ADJUST); | 74 | layer_on(_ADJUST); |
diff --git a/keyboards/omkbd/runner3680/5x8/keymaps/default/keymap.c b/keyboards/omkbd/runner3680/5x8/keymaps/default/keymap.c index 14abc88da7..659287f5bd 100644 --- a/keyboards/omkbd/runner3680/5x8/keymaps/default/keymap.c +++ b/keyboards/omkbd/runner3680/5x8/keymaps/default/keymap.c | |||
| @@ -13,8 +13,7 @@ enum layer_number { | |||
| 13 | }; | 13 | }; |
| 14 | 14 | ||
| 15 | enum custom_keycodes { | 15 | enum custom_keycodes { |
| 16 | QWERTY = SAFE_RANGE, | 16 | ADJUST = SAFE_RANGE, |
| 17 | ADJUST, | ||
| 18 | RGBRST | 17 | RGBRST |
| 19 | }; | 18 | }; |
| 20 | 19 | ||
| @@ -68,13 +67,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 68 | 67 | ||
| 69 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 68 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 70 | switch (keycode) { | 69 | switch (keycode) { |
| 71 | case QWERTY: | ||
| 72 | if (record->event.pressed) { | ||
| 73 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 74 | set_single_persistent_default_layer(_QWERTY); | ||
| 75 | } | ||
| 76 | break; | ||
| 77 | |||
| 78 | case ADJUST: | 70 | case ADJUST: |
| 79 | if (record->event.pressed) { | 71 | if (record->event.pressed) { |
| 80 | layer_on(_ADJUST); | 72 | layer_on(_ADJUST); |
diff --git a/keyboards/ortho5by12/keymaps/default/keymap.c b/keyboards/ortho5by12/keymaps/default/keymap.c index f3fcb85d14..798680dfd0 100644 --- a/keyboards/ortho5by12/keymaps/default/keymap.c +++ b/keyboards/ortho5by12/keymaps/default/keymap.c | |||
| @@ -26,14 +26,15 @@ enum preonic_layers { | |||
| 26 | }; | 26 | }; |
| 27 | 27 | ||
| 28 | enum preonic_keycodes { | 28 | enum preonic_keycodes { |
| 29 | QWERTY = SAFE_RANGE, | 29 | LOWER = SAFE_RANGE, |
| 30 | COLEMAK, | ||
| 31 | DVORAK, | ||
| 32 | LOWER, | ||
| 33 | RAISE, | 30 | RAISE, |
| 34 | BACKLIT | 31 | BACKLIT |
| 35 | }; | 32 | }; |
| 36 | 33 | ||
| 34 | #define QWERTY PDF(_QWERTY) | ||
| 35 | #define COLEMAK PDF(_COLEMAK) | ||
| 36 | #define DVORAK PDF(_DVORAK) | ||
| 37 | |||
| 37 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 38 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 38 | 39 | ||
| 39 | /* Qwerty | 40 | /* Qwerty |
| @@ -167,21 +168,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 167 | 168 | ||
| 168 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 169 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 169 | switch (keycode) { | 170 | switch (keycode) { |
| 170 | case QWERTY: | ||
| 171 | if (record->event.pressed) { | ||
| 172 | set_single_persistent_default_layer(_QWERTY); | ||
| 173 | } | ||
| 174 | return false; | ||
| 175 | case COLEMAK: | ||
| 176 | if (record->event.pressed) { | ||
| 177 | set_single_persistent_default_layer(_COLEMAK); | ||
| 178 | } | ||
| 179 | return false; | ||
| 180 | case DVORAK: | ||
| 181 | if (record->event.pressed) { | ||
| 182 | set_single_persistent_default_layer(_DVORAK); | ||
| 183 | } | ||
| 184 | return false; | ||
| 185 | case LOWER: | 171 | case LOWER: |
| 186 | if (record->event.pressed) { | 172 | if (record->event.pressed) { |
| 187 | layer_on(_LOWER); | 173 | layer_on(_LOWER); |
diff --git a/keyboards/orthodox/keymaps/default/keymap.c b/keyboards/orthodox/keymaps/default/keymap.c index d9826c9288..39c3084aae 100644 --- a/keyboards/orthodox/keymaps/default/keymap.c +++ b/keyboards/orthodox/keymaps/default/keymap.c | |||
| @@ -34,16 +34,14 @@ enum layer_names { | |||
| 34 | _ADJUST | 34 | _ADJUST |
| 35 | }; | 35 | }; |
| 36 | 36 | ||
| 37 | enum custom_keycodes { | ||
| 38 | QWERTY = SAFE_RANGE, | ||
| 39 | COLEMAK, | ||
| 40 | DVORAK | ||
| 41 | }; | ||
| 42 | |||
| 43 | #define LS__SPC MT(MOD_LSFT, KC_SPC) | 37 | #define LS__SPC MT(MOD_LSFT, KC_SPC) |
| 44 | #define LOWER MO(_LOWER) | 38 | #define LOWER MO(_LOWER) |
| 45 | #define RAISE MO(_RAISE) | 39 | #define RAISE MO(_RAISE) |
| 46 | 40 | ||
| 41 | #define QWERTY PDF(_QWERTY) | ||
| 42 | #define COLEMAK PDF(_COLEMAK) | ||
| 43 | #define DVORAK PDF(_DVORAK) | ||
| 44 | |||
| 47 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 45 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 48 | 46 | ||
| 49 | [_QWERTY] = LAYOUT( | 47 | [_QWERTY] = LAYOUT( |
| @@ -88,27 +86,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 88 | layer_state_t layer_state_set_user(layer_state_t state) { | 86 | layer_state_t layer_state_set_user(layer_state_t state) { |
| 89 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); | 87 | return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); |
| 90 | } | 88 | } |
| 91 | |||
| 92 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 93 | switch (keycode) { | ||
| 94 | case QWERTY: | ||
| 95 | if (record->event.pressed) { | ||
| 96 | set_single_persistent_default_layer(_QWERTY); | ||
| 97 | } | ||
| 98 | return false; | ||
| 99 | break; | ||
| 100 | case COLEMAK: | ||
| 101 | if (record->event.pressed) { | ||
| 102 | set_single_persistent_default_layer(_COLEMAK); | ||
| 103 | } | ||
| 104 | return false; | ||
| 105 | break; | ||
| 106 | case DVORAK: | ||
| 107 | if (record->event.pressed) { | ||
| 108 | set_single_persistent_default_layer(_DVORAK); | ||
| 109 | } | ||
| 110 | return false; | ||
| 111 | break; | ||
| 112 | } | ||
| 113 | return true; | ||
| 114 | } | ||
diff --git a/keyboards/palette1202/keymaps/default/keymap.c b/keyboards/palette1202/keymaps/default/keymap.c index 70f2ba311c..0f49e46661 100644 --- a/keyboards/palette1202/keymaps/default/keymap.c +++ b/keyboards/palette1202/keymaps/default/keymap.c | |||
| @@ -19,13 +19,6 @@ | |||
| 19 | #include "lib/oled_helper.h" | 19 | #include "lib/oled_helper.h" |
| 20 | #endif | 20 | #endif |
| 21 | 21 | ||
| 22 | enum custom_keycode { | ||
| 23 | Mac_CS = SAFE_RANGE, | ||
| 24 | Mac_PS, | ||
| 25 | Win_CS, | ||
| 26 | Win_PS, | ||
| 27 | IOS_CS, | ||
| 28 | }; | ||
| 29 | enum layerID { | 22 | enum layerID { |
| 30 | MAC_CS_1 = 0, | 23 | MAC_CS_1 = 0, |
| 31 | MAC_CS_2, | 24 | MAC_CS_2, |
| @@ -40,6 +33,12 @@ enum layerID { | |||
| 40 | SETTING, | 33 | SETTING, |
| 41 | }; | 34 | }; |
| 42 | 35 | ||
| 36 | #define Mac_CS PDF(MAC_CS_1) | ||
| 37 | #define Mac_PS PDF(MAC_PS_1) | ||
| 38 | #define Win_CS PDF(WIN_CS_1) | ||
| 39 | #define Win_PS PDF(WIN_PS_1) | ||
| 40 | #define IOS_CS PDF(IOS_CS_1) | ||
| 41 | |||
| 43 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 42 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 44 | // Mac | 43 | // Mac |
| 45 | // Clip Studio | 44 | // Clip Studio |
| @@ -234,44 +233,6 @@ bool encoder_update_user(uint8_t index, bool clockwise) { | |||
| 234 | return true; | 233 | return true; |
| 235 | } | 234 | } |
| 236 | 235 | ||
| 237 | // custom keycode | ||
| 238 | // switch default layer | ||
| 239 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 240 | switch (keycode) { | ||
| 241 | case Mac_CS: | ||
| 242 | if (record->event.pressed) { | ||
| 243 | set_single_persistent_default_layer(MAC_CS_1); | ||
| 244 | } | ||
| 245 | return false; | ||
| 246 | break; | ||
| 247 | case Mac_PS: | ||
| 248 | if (record->event.pressed) { | ||
| 249 | set_single_persistent_default_layer(MAC_PS_1); | ||
| 250 | } | ||
| 251 | return false; | ||
| 252 | break; | ||
| 253 | case Win_CS: | ||
| 254 | if (record->event.pressed) { | ||
| 255 | set_single_persistent_default_layer(WIN_CS_1); | ||
| 256 | } | ||
| 257 | return false; | ||
| 258 | break; | ||
| 259 | case Win_PS: | ||
| 260 | if (record->event.pressed) { | ||
| 261 | set_single_persistent_default_layer(WIN_PS_1); | ||
| 262 | } | ||
| 263 | return false; | ||
| 264 | break; | ||
| 265 | case IOS_CS: | ||
| 266 | if (record->event.pressed) { | ||
| 267 | set_single_persistent_default_layer(IOS_CS_1); | ||
| 268 | } | ||
| 269 | return false; | ||
| 270 | break; | ||
| 271 | } | ||
| 272 | return true; | ||
| 273 | } | ||
| 274 | |||
| 275 | // OLED Display | 236 | // OLED Display |
| 276 | #ifdef OLED_ENABLE | 237 | #ifdef OLED_ENABLE |
| 277 | bool oled_task_user(void) { | 238 | bool oled_task_user(void) { |
diff --git a/keyboards/planck/keymaps/default/keymap.c b/keyboards/planck/keymaps/default/keymap.c index a1ad5c65d6..cc8a69ceca 100644 --- a/keyboards/planck/keymaps/default/keymap.c +++ b/keyboards/planck/keymaps/default/keymap.c | |||
| @@ -31,10 +31,7 @@ enum planck_layers { | |||
| 31 | }; | 31 | }; |
| 32 | 32 | ||
| 33 | enum planck_keycodes { | 33 | enum planck_keycodes { |
| 34 | QWERTY = SAFE_RANGE, | 34 | PLOVER = SAFE_RANGE, |
| 35 | COLEMAK, | ||
| 36 | DVORAK, | ||
| 37 | PLOVER, | ||
| 38 | BACKLIT, | 35 | BACKLIT, |
| 39 | EXT_PLV | 36 | EXT_PLV |
| 40 | }; | 37 | }; |
| @@ -42,6 +39,10 @@ enum planck_keycodes { | |||
| 42 | #define LOWER MO(_LOWER) | 39 | #define LOWER MO(_LOWER) |
| 43 | #define RAISE MO(_RAISE) | 40 | #define RAISE MO(_RAISE) |
| 44 | 41 | ||
| 42 | #define QWERTY PDF(_QWERTY) | ||
| 43 | #define COLEMAK PDF(_COLEMAK) | ||
| 44 | #define DVORAK PDF(_DVORAK) | ||
| 45 | |||
| 45 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 46 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 46 | 47 | ||
| 47 | /* Qwerty | 48 | /* Qwerty |
| @@ -184,25 +185,6 @@ layer_state_t layer_state_set_user(layer_state_t state) { | |||
| 184 | 185 | ||
| 185 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 186 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 186 | switch (keycode) { | 187 | switch (keycode) { |
| 187 | case QWERTY: | ||
| 188 | if (record->event.pressed) { | ||
| 189 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 190 | set_single_persistent_default_layer(_QWERTY); | ||
| 191 | } | ||
| 192 | return false; | ||
| 193 | break; | ||
| 194 | case COLEMAK: | ||
| 195 | if (record->event.pressed) { | ||
| 196 | set_single_persistent_default_layer(_COLEMAK); | ||
| 197 | } | ||
| 198 | return false; | ||
| 199 | break; | ||
| 200 | case DVORAK: | ||
| 201 | if (record->event.pressed) { | ||
| 202 | set_single_persistent_default_layer(_DVORAK); | ||
| 203 | } | ||
| 204 | return false; | ||
| 205 | break; | ||
| 206 | case BACKLIT: | 188 | case BACKLIT: |
| 207 | if (record->event.pressed) { | 189 | if (record->event.pressed) { |
| 208 | register_code(KC_RSFT); | 190 | register_code(KC_RSFT); |
diff --git a/keyboards/planck/rev7/keymaps/default/keymap.c b/keyboards/planck/rev7/keymaps/default/keymap.c index 85f5097332..47ded8aba5 100644 --- a/keyboards/planck/rev7/keymaps/default/keymap.c +++ b/keyboards/planck/rev7/keymaps/default/keymap.c | |||
| @@ -18,11 +18,15 @@ | |||
| 18 | 18 | ||
| 19 | enum planck_layers { _QWERTY, _COLEMAK, _DVORAK, _LOWER, _RAISE, _PLOVER, _ADJUST }; | 19 | enum planck_layers { _QWERTY, _COLEMAK, _DVORAK, _LOWER, _RAISE, _PLOVER, _ADJUST }; |
| 20 | 20 | ||
| 21 | enum planck_keycodes { QWERTY = SAFE_RANGE, COLEMAK, DVORAK, PLOVER, BACKLIT, EXT_PLV }; | 21 | enum planck_keycodes { PLOVER = SAFE_RANGE, BACKLIT, EXT_PLV }; |
| 22 | 22 | ||
| 23 | #define LOWER MO(_LOWER) | 23 | #define LOWER MO(_LOWER) |
| 24 | #define RAISE MO(_RAISE) | 24 | #define RAISE MO(_RAISE) |
| 25 | 25 | ||
| 26 | #define QWERTY PDF(_QWERTY) | ||
| 27 | #define COLEMAK PDF(_COLEMAK) | ||
| 28 | #define DVORAK PDF(_DVORAK) | ||
| 29 | |||
| 26 | /* clang-format off */ | 30 | /* clang-format off */ |
| 27 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 31 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 28 | 32 | ||
| @@ -230,25 +234,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 230 | } | 234 | } |
| 231 | #endif | 235 | #endif |
| 232 | switch (keycode) { | 236 | switch (keycode) { |
| 233 | case QWERTY: | ||
| 234 | if (record->event.pressed) { | ||
| 235 | print("mode just switched to qwerty and this is a huge string\n"); | ||
| 236 | set_single_persistent_default_layer(_QWERTY); | ||
| 237 | } | ||
| 238 | return false; | ||
| 239 | break; | ||
| 240 | case COLEMAK: | ||
| 241 | if (record->event.pressed) { | ||
| 242 | set_single_persistent_default_layer(_COLEMAK); | ||
| 243 | } | ||
| 244 | return false; | ||
| 245 | break; | ||
| 246 | case DVORAK: | ||
| 247 | if (record->event.pressed) { | ||
| 248 | set_single_persistent_default_layer(_DVORAK); | ||
| 249 | } | ||
| 250 | return false; | ||
| 251 | break; | ||
| 252 | case BACKLIT: | 237 | case BACKLIT: |
| 253 | if (record->event.pressed) { | 238 | if (record->event.pressed) { |
| 254 | register_code(KC_RSFT); | 239 | register_code(KC_RSFT); |
diff --git a/keyboards/preonic/keymaps/default/keymap.c b/keyboards/preonic/keymaps/default/keymap.c index 511ac41f20..08e92ef0d3 100644 --- a/keyboards/preonic/keymaps/default/keymap.c +++ b/keyboards/preonic/keymaps/default/keymap.c | |||
| @@ -27,14 +27,15 @@ enum preonic_layers { | |||
| 27 | }; | 27 | }; |
| 28 | 28 | ||
| 29 | enum preonic_keycodes { | 29 | enum preonic_keycodes { |
| 30 | QWERTY = SAFE_RANGE, | 30 | LOWER = SAFE_RANGE, |
| 31 | COLEMAK, | ||
| 32 | DVORAK, | ||
| 33 | LOWER, | ||
| 34 | RAISE, | 31 | RAISE, |
| 35 | BACKLIT | 32 | BACKLIT |
| 36 | }; | 33 | }; |
| 37 | 34 | ||
| 35 | #define QWERTY PDF(_QWERTY) | ||
| 36 | #define COLEMAK PDF(_COLEMAK) | ||
| 37 | #define DVORAK PDF(_DVORAK) | ||
| 38 | |||
| 38 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 39 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 39 | 40 | ||
| 40 | /* Qwerty | 41 | /* Qwerty |
| @@ -168,24 +169,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 168 | 169 | ||
| 169 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 170 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 170 | switch (keycode) { | 171 | switch (keycode) { |
| 171 | case QWERTY: | ||
| 172 | if (record->event.pressed) { | ||
| 173 | set_single_persistent_default_layer(_QWERTY); | ||
| 174 | } | ||
| 175 | return false; | ||
| 176 | break; | ||
| 177 | case COLEMAK: | ||
| 178 | if (record->event.pressed) { | ||
| 179 | set_single_persistent_default_layer(_COLEMAK); | ||
| 180 | } | ||
| 181 | return false; | ||
| 182 | break; | ||
| 183 | case DVORAK: | ||
| 184 | if (record->event.pressed) { | ||
| 185 | set_single_persistent_default_layer(_DVORAK); | ||
| 186 | } | ||
| 187 | return false; | ||
| 188 | break; | ||
| 189 | case LOWER: | 172 | case LOWER: |
| 190 | if (record->event.pressed) { | 173 | if (record->event.pressed) { |
| 191 | layer_on(_LOWER); | 174 | layer_on(_LOWER); |
diff --git a/keyboards/rgbkb/zygomorph/keymaps/5x6pad/keymap.c b/keyboards/rgbkb/zygomorph/keymaps/5x6pad/keymap.c index a7026b0d77..24e578c026 100644 --- a/keyboards/rgbkb/zygomorph/keymaps/5x6pad/keymap.c +++ b/keyboards/rgbkb/zygomorph/keymaps/5x6pad/keymap.c | |||
| @@ -25,9 +25,7 @@ enum layer_number { | |||
| 25 | }; | 25 | }; |
| 26 | 26 | ||
| 27 | enum custom_keycodes { | 27 | enum custom_keycodes { |
| 28 | QWERTY = SAFE_RANGE, | 28 | FN = SAFE_RANGE, |
| 29 | MACROPAD, | ||
| 30 | FN, | ||
| 31 | ADJ, | 29 | ADJ, |
| 32 | BACKLIT, | 30 | BACKLIT, |
| 33 | RGBRST | 31 | RGBRST |
| @@ -37,7 +35,8 @@ enum macro_keycodes { | |||
| 37 | KC_SAMPLEMACRO, | 35 | KC_SAMPLEMACRO, |
| 38 | }; | 36 | }; |
| 39 | 37 | ||
| 40 | 38 | #define QWERT PDF(_QWERTY) | |
| 39 | #define MACROPAD PDF(_MACROPAD) | ||
| 41 | 40 | ||
| 42 | #define FN_ESC LT(_FN, KC_ESC) | 41 | #define FN_ESC LT(_FN, KC_ESC) |
| 43 | #define FN_CAPS LT(_FN, KC_CAPS) | 42 | #define FN_CAPS LT(_FN, KC_CAPS) |
| @@ -109,18 +108,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 109 | //uint8_t shifted = get_mods() & (MOD_BIT(KC_LSFT) | MOD_BIT(KC_RSFT)); | 108 | //uint8_t shifted = get_mods() & (MOD_BIT(KC_LSFT) | MOD_BIT(KC_RSFT)); |
| 110 | 109 | ||
| 111 | switch (keycode) { | 110 | switch (keycode) { |
| 112 | case QWERTY: | ||
| 113 | if (record->event.pressed) { | ||
| 114 | set_single_persistent_default_layer(_QWERTY); | ||
| 115 | } | ||
| 116 | return false; | ||
| 117 | break; | ||
| 118 | case MACROPAD: | ||
| 119 | if(record->event.pressed) { | ||
| 120 | set_single_persistent_default_layer(_MACROPAD); | ||
| 121 | } | ||
| 122 | return false; | ||
| 123 | break; | ||
| 124 | case FN: | 111 | case FN: |
| 125 | if (record->event.pressed) { | 112 | if (record->event.pressed) { |
| 126 | //not sure how to have keyboard check mode and set it to a variable, so my work around | 113 | //not sure how to have keyboard check mode and set it to a variable, so my work around |
diff --git a/keyboards/rgbkb/zygomorph/keymaps/default/keymap.c b/keyboards/rgbkb/zygomorph/keymaps/default/keymap.c index f8af28ffc8..12e21e65db 100644 --- a/keyboards/rgbkb/zygomorph/keymaps/default/keymap.c +++ b/keyboards/rgbkb/zygomorph/keymaps/default/keymap.c | |||
| @@ -17,15 +17,16 @@ enum layer_number { | |||
| 17 | }; | 17 | }; |
| 18 | 18 | ||
| 19 | enum custom_keycodes { | 19 | enum custom_keycodes { |
| 20 | QWERTY = SAFE_RANGE, | 20 | FN = SAFE_RANGE, |
| 21 | COLEMAK, | ||
| 22 | FN, | ||
| 23 | ADJ, | 21 | ADJ, |
| 24 | RGBRST | 22 | RGBRST |
| 25 | }; | 23 | }; |
| 26 | 24 | ||
| 27 | #define FN_CAPS LT(_FN, KC_CAPS) | 25 | #define FN_CAPS LT(_FN, KC_CAPS) |
| 28 | 26 | ||
| 27 | #define QWERTY PDF(_QWERTY) | ||
| 28 | #define COLEMAK PDF(_COLEMAK) | ||
| 29 | |||
| 29 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 30 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 30 | /* / QWERTY \ | 31 | /* / QWERTY \ |
| 31 | * /-----------------------------------------\ /-----------------------------------------\ | 32 | * /-----------------------------------------\ /-----------------------------------------\ |
| @@ -131,16 +132,6 @@ bool encoder_update_user(uint8_t index, bool clockwise) { | |||
| 131 | 132 | ||
| 132 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 133 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 133 | switch (keycode) { | 134 | switch (keycode) { |
| 134 | case QWERTY: | ||
| 135 | if (record->event.pressed) { | ||
| 136 | set_single_persistent_default_layer(_QWERTY); | ||
| 137 | } | ||
| 138 | return false; | ||
| 139 | case COLEMAK: | ||
| 140 | if(record->event.pressed) { | ||
| 141 | set_single_persistent_default_layer(_COLEMAK); | ||
| 142 | } | ||
| 143 | return false; | ||
| 144 | case FN: | 135 | case FN: |
| 145 | if (record->event.pressed) { | 136 | if (record->event.pressed) { |
| 146 | layer_on(_FN); | 137 | layer_on(_FN); |
diff --git a/keyboards/rgbkb/zygomorph/keymaps/default_oled/keymap.c b/keyboards/rgbkb/zygomorph/keymaps/default_oled/keymap.c index 4f2f6c9a48..b5db1c37d3 100644 --- a/keyboards/rgbkb/zygomorph/keymaps/default_oled/keymap.c +++ b/keyboards/rgbkb/zygomorph/keymaps/default_oled/keymap.c | |||
| @@ -17,15 +17,16 @@ enum layer_number { | |||
| 17 | }; | 17 | }; |
| 18 | 18 | ||
| 19 | enum custom_keycodes { | 19 | enum custom_keycodes { |
| 20 | QWERTY = SAFE_RANGE, | 20 | FN = SAFE_RANGE, |
| 21 | COLEMAK, | ||
| 22 | FN, | ||
| 23 | ADJ, | 21 | ADJ, |
| 24 | RGBRST | 22 | RGBRST |
| 25 | }; | 23 | }; |
| 26 | 24 | ||
| 27 | #define FN_CAPS LT(_FN, KC_CAPS) | 25 | #define FN_CAPS LT(_FN, KC_CAPS) |
| 28 | 26 | ||
| 27 | #define QWERTY PDF(_QWERTY) | ||
| 28 | #define COLEMAK PDF(_COLEMAK) | ||
| 29 | |||
| 29 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 30 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 30 | /* / QWERTY \ | 31 | /* / QWERTY \ |
| 31 | * /-----------------------------------------\ /-----------------------------------------\ | 32 | * /-----------------------------------------\ /-----------------------------------------\ |
| @@ -131,16 +132,6 @@ bool encoder_update_user(uint8_t index, bool clockwise) { | |||
| 131 | 132 | ||
| 132 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 133 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 133 | switch (keycode) { | 134 | switch (keycode) { |
| 134 | case QWERTY: | ||
| 135 | if (record->event.pressed) { | ||
| 136 | set_single_persistent_default_layer(_QWERTY); | ||
| 137 | } | ||
| 138 | return false; | ||
| 139 | case COLEMAK: | ||
| 140 | if(record->event.pressed) { | ||
| 141 | set_single_persistent_default_layer(_COLEMAK); | ||
| 142 | } | ||
| 143 | return false; | ||
| 144 | case FN: | 135 | case FN: |
| 145 | if (record->event.pressed) { | 136 | if (record->event.pressed) { |
| 146 | layer_on(_FN); | 137 | layer_on(_FN); |
diff --git a/keyboards/satt/comet46/keymaps/default-rgbled/keymap.c b/keyboards/satt/comet46/keymaps/default-rgbled/keymap.c index 225c3c8084..704eb2dd70 100644 --- a/keyboards/satt/comet46/keymaps/default-rgbled/keymap.c +++ b/keyboards/satt/comet46/keymaps/default-rgbled/keymap.c | |||
| @@ -17,17 +17,13 @@ enum comet46_layers | |||
| 17 | _ADJUST, | 17 | _ADJUST, |
| 18 | }; | 18 | }; |
| 19 | 19 | ||
| 20 | enum custom_keycodes { | ||
| 21 | QWERTY = SAFE_RANGE, | ||
| 22 | COLEMAK, | ||
| 23 | DVORAK, | ||
| 24 | LOWER, | ||
| 25 | RAISE, | ||
| 26 | }; | ||
| 27 | |||
| 28 | #define LOWER MO(_LOWER) | 20 | #define LOWER MO(_LOWER) |
| 29 | #define RAISE MO(_RAISE) | 21 | #define RAISE MO(_RAISE) |
| 30 | 22 | ||
| 23 | #define QWERTY PDF(_QWERTY) | ||
| 24 | #define COLEMAK PDF(_COLEMAK) | ||
| 25 | #define DVORAK PDF(_DVORAK) | ||
| 26 | |||
| 31 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 27 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 32 | 28 | ||
| 33 | /* Qwerty | 29 | /* Qwerty |
| @@ -202,24 +198,3 @@ void matrix_scan_user(void) { | |||
| 202 | break; | 198 | break; |
| 203 | } | 199 | } |
| 204 | }; | 200 | }; |
| 205 | |||
| 206 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 207 | switch (keycode) { | ||
| 208 | case QWERTY: | ||
| 209 | if (record->event.pressed) { | ||
| 210 | set_single_persistent_default_layer(_QWERTY); | ||
| 211 | } | ||
| 212 | break; | ||
| 213 | case COLEMAK: | ||
| 214 | if (record->event.pressed) { | ||
| 215 | set_single_persistent_default_layer(_COLEMAK); | ||
| 216 | } | ||
| 217 | break; | ||
| 218 | case DVORAK: | ||
| 219 | if (record->event.pressed) { | ||
| 220 | set_single_persistent_default_layer(_DVORAK); | ||
| 221 | } | ||
| 222 | break; | ||
| 223 | } | ||
| 224 | return true; | ||
| 225 | } | ||
diff --git a/keyboards/satt/comet46/keymaps/default/keymap.c b/keyboards/satt/comet46/keymaps/default/keymap.c index 84dd07f02a..c8c58951c8 100644 --- a/keyboards/satt/comet46/keymaps/default/keymap.c +++ b/keyboards/satt/comet46/keymaps/default/keymap.c | |||
| @@ -18,17 +18,13 @@ enum comet46_layers | |||
| 18 | _ADJUST, | 18 | _ADJUST, |
| 19 | }; | 19 | }; |
| 20 | 20 | ||
| 21 | enum custom_keycodes { | ||
| 22 | QWERTY = SAFE_RANGE, | ||
| 23 | COLEMAK, | ||
| 24 | DVORAK, | ||
| 25 | LOWER, | ||
| 26 | RAISE, | ||
| 27 | }; | ||
| 28 | |||
| 29 | #define LOWER MO(_LOWER) | 21 | #define LOWER MO(_LOWER) |
| 30 | #define RAISE MO(_RAISE) | 22 | #define RAISE MO(_RAISE) |
| 31 | 23 | ||
| 24 | #define QWERTY PDF(_QWERTY) | ||
| 25 | #define COLEMAK PDF(_COLEMAK) | ||
| 26 | #define DVORAK PDF(_DVORAK) | ||
| 27 | |||
| 32 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 28 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 33 | 29 | ||
| 34 | /* Qwerty | 30 | /* Qwerty |
| @@ -207,22 +203,5 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 207 | set_keylog(keycode); | 203 | set_keylog(keycode); |
| 208 | } | 204 | } |
| 209 | #endif | 205 | #endif |
| 210 | switch (keycode) { | ||
| 211 | case QWERTY: | ||
| 212 | if (record->event.pressed) { | ||
| 213 | set_single_persistent_default_layer(_QWERTY); | ||
| 214 | } | ||
| 215 | break; | ||
| 216 | case COLEMAK: | ||
| 217 | if (record->event.pressed) { | ||
| 218 | set_single_persistent_default_layer(_COLEMAK); | ||
| 219 | } | ||
| 220 | break; | ||
| 221 | case DVORAK: | ||
| 222 | if (record->event.pressed) { | ||
| 223 | set_single_persistent_default_layer(_DVORAK); | ||
| 224 | } | ||
| 225 | break; | ||
| 226 | } | ||
| 227 | return true; | 206 | return true; |
| 228 | } | 207 | } |
diff --git a/keyboards/sofle/keymaps/default/keymap.c b/keyboards/sofle/keymaps/default/keymap.c index 37996c3e41..564a624c58 100644 --- a/keyboards/sofle/keymaps/default/keymap.c +++ b/keyboards/sofle/keymaps/default/keymap.c | |||
| @@ -12,14 +12,15 @@ enum sofle_layers { | |||
| 12 | }; | 12 | }; |
| 13 | 13 | ||
| 14 | enum custom_keycodes { | 14 | enum custom_keycodes { |
| 15 | KC_QWERTY = QK_USER, | 15 | KC_PRVWD = QK_USER, |
| 16 | KC_COLEMAK, | ||
| 17 | KC_PRVWD, | ||
| 18 | KC_NXTWD, | 16 | KC_NXTWD, |
| 19 | KC_LSTRT, | 17 | KC_LSTRT, |
| 20 | KC_LEND | 18 | KC_LEND |
| 21 | }; | 19 | }; |
| 22 | 20 | ||
| 21 | #define KC_QWERTY PDF(_QWERTY) | ||
| 22 | #define KC_COLEMAK PDF(_COLEMAK) | ||
| 23 | |||
| 23 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 24 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 24 | /* | 25 | /* |
| 25 | * QWERTY | 26 | * QWERTY |
| @@ -134,16 +135,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 134 | 135 | ||
| 135 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 136 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 136 | switch (keycode) { | 137 | switch (keycode) { |
| 137 | case KC_QWERTY: | ||
| 138 | if (record->event.pressed) { | ||
| 139 | set_single_persistent_default_layer(_QWERTY); | ||
| 140 | } | ||
| 141 | return false; | ||
| 142 | case KC_COLEMAK: | ||
| 143 | if (record->event.pressed) { | ||
| 144 | set_single_persistent_default_layer(_COLEMAK); | ||
| 145 | } | ||
| 146 | return false; | ||
| 147 | case KC_PRVWD: | 138 | case KC_PRVWD: |
| 148 | if (record->event.pressed) { | 139 | if (record->event.pressed) { |
| 149 | if (keymap_config.swap_lctl_lgui) { | 140 | if (keymap_config.swap_lctl_lgui) { |
diff --git a/keyboards/sofle/keymaps/rgb_default/keymap.c b/keyboards/sofle/keymaps/rgb_default/keymap.c index fd2346e10b..e992cf9adb 100644 --- a/keyboards/sofle/keymaps/rgb_default/keymap.c +++ b/keyboards/sofle/keymaps/rgb_default/keymap.c | |||
| @@ -76,15 +76,16 @@ enum sofle_layers { | |||
| 76 | }; | 76 | }; |
| 77 | 77 | ||
| 78 | enum custom_keycodes { | 78 | enum custom_keycodes { |
| 79 | KC_QWERTY = SAFE_RANGE, | 79 | KC_LOWER = SAFE_RANGE, |
| 80 | KC_COLEMAK, | ||
| 81 | KC_COLEMAKDH, | ||
| 82 | KC_LOWER, | ||
| 83 | KC_RAISE, | 80 | KC_RAISE, |
| 84 | KC_ADJUST, | 81 | KC_ADJUST, |
| 85 | KC_D_MUTE | 82 | KC_D_MUTE |
| 86 | }; | 83 | }; |
| 87 | 84 | ||
| 85 | #define KC_QWERTY PDF(_QWERTY) | ||
| 86 | #define KC_COLEMAK PDF(_COLEMAK) | ||
| 87 | #define KC_COLEMAKDH PDF(_COLEMAKDH) | ||
| 88 | |||
| 88 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 89 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 89 | /* | 90 | /* |
| 90 | * QWERTY | 91 | * QWERTY |
| @@ -478,21 +479,6 @@ bool oled_task_user(void) { | |||
| 478 | 479 | ||
| 479 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 480 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 480 | switch (keycode) { | 481 | switch (keycode) { |
| 481 | case KC_QWERTY: | ||
| 482 | if (record->event.pressed) { | ||
| 483 | set_single_persistent_default_layer(_QWERTY); | ||
| 484 | } | ||
| 485 | return false; | ||
| 486 | case KC_COLEMAK: | ||
| 487 | if (record->event.pressed) { | ||
| 488 | set_single_persistent_default_layer(_COLEMAK); | ||
| 489 | } | ||
| 490 | return false; | ||
| 491 | case KC_COLEMAKDH: | ||
| 492 | if (record->event.pressed) { | ||
| 493 | set_single_persistent_default_layer(_COLEMAKDH); | ||
| 494 | } | ||
| 495 | return false; | ||
| 496 | case KC_LOWER: | 482 | case KC_LOWER: |
| 497 | if (record->event.pressed) { | 483 | if (record->event.pressed) { |
| 498 | layer_on(_LOWER); | 484 | layer_on(_LOWER); |
diff --git a/keyboards/subatomic/keymaps/default/keymap.c b/keyboards/subatomic/keymaps/default/keymap.c index 9d579ac937..fb85228fd8 100644 --- a/keyboards/subatomic/keymaps/default/keymap.c +++ b/keyboards/subatomic/keymaps/default/keymap.c | |||
| @@ -14,14 +14,15 @@ enum layer_names { | |||
| 14 | }; | 14 | }; |
| 15 | 15 | ||
| 16 | enum subatomic_keycodes { | 16 | enum subatomic_keycodes { |
| 17 | QWERTY = SAFE_RANGE, | 17 | LOWER = SAFE_RANGE, |
| 18 | COLEMAK, | ||
| 19 | DVORAK, | ||
| 20 | LOWER, | ||
| 21 | RAISE, | 18 | RAISE, |
| 22 | BACKLIT | 19 | BACKLIT |
| 23 | }; | 20 | }; |
| 24 | 21 | ||
| 22 | #define QWERTY PDF(_QWERTY) | ||
| 23 | #define COLEMAK PDF(_COLEMAK) | ||
| 24 | #define DVORAK PDF(_DVORAK) | ||
| 25 | |||
| 25 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 26 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 26 | 27 | ||
| 27 | /* Qwerty | 28 | /* Qwerty |
| @@ -154,24 +155,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 154 | 155 | ||
| 155 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 156 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 156 | switch (keycode) { | 157 | switch (keycode) { |
| 157 | case QWERTY: | ||
| 158 | if (record->event.pressed) { | ||
| 159 | set_single_persistent_default_layer(_QWERTY); | ||
| 160 | } | ||
| 161 | return false; | ||
| 162 | break; | ||
| 163 | case COLEMAK: | ||
| 164 | if (record->event.pressed) { | ||
| 165 | set_single_persistent_default_layer(_COLEMAK); | ||
| 166 | } | ||
| 167 | return false; | ||
| 168 | break; | ||
| 169 | case DVORAK: | ||
| 170 | if (record->event.pressed) { | ||
| 171 | set_single_persistent_default_layer(_DVORAK); | ||
| 172 | } | ||
| 173 | return false; | ||
| 174 | break; | ||
| 175 | case LOWER: | 158 | case LOWER: |
| 176 | if (record->event.pressed) { | 159 | if (record->event.pressed) { |
| 177 | layer_on(_LOWER); | 160 | layer_on(_LOWER); |
diff --git a/keyboards/thevankeyboards/minivan/keymaps/default/keymap.c b/keyboards/thevankeyboards/minivan/keymaps/default/keymap.c index fadf9990cd..221c66750a 100644 --- a/keyboards/thevankeyboards/minivan/keymaps/default/keymap.c +++ b/keyboards/thevankeyboards/minivan/keymaps/default/keymap.c | |||
| @@ -18,11 +18,9 @@ | |||
| 18 | #define L_CURBR LSFT(KC_LBRC) | 18 | #define L_CURBR LSFT(KC_LBRC) |
| 19 | #define R_CURBR LSFT(KC_RBRC) | 19 | #define R_CURBR LSFT(KC_RBRC) |
| 20 | 20 | ||
| 21 | enum custom_keycodes { | 21 | #define QWERTY PDF(_QW) |
| 22 | DVORAK = SAFE_RANGE, | 22 | #define COLEMAK PDF(_CM) |
| 23 | QWERTY, | 23 | #define DVORAK PDF(_DV) |
| 24 | COLEMAK | ||
| 25 | }; | ||
| 26 | 24 | ||
| 27 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 25 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 28 | [_QW] = LAYOUT( /* Qwerty */ | 26 | [_QW] = LAYOUT( /* Qwerty */ |
| @@ -62,26 +60,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 62 | _______, KC_LSFT, KC_B, KC_SPC, KC_C, _______, _______, _______ | 60 | _______, KC_LSFT, KC_B, KC_SPC, KC_C, _______, _______, _______ |
| 63 | ) | 61 | ) |
| 64 | }; | 62 | }; |
| 65 | |||
| 66 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 67 | switch(keycode) { | ||
| 68 | case DVORAK: | ||
| 69 | if (record->event.pressed) { | ||
| 70 | set_single_persistent_default_layer(_DV); | ||
| 71 | } | ||
| 72 | return false; | ||
| 73 | case QWERTY: | ||
| 74 | if (record->event.pressed) { | ||
| 75 | set_single_persistent_default_layer(_QW); | ||
| 76 | } | ||
| 77 | return false; | ||
| 78 | case COLEMAK: | ||
| 79 | if (record->event.pressed) { | ||
| 80 | set_single_persistent_default_layer(_CM); | ||
| 81 | } | ||
| 82 | return false; | ||
| 83 | default: | ||
| 84 | return true; | ||
| 85 | } | ||
| 86 | return true; | ||
| 87 | }; | ||
diff --git a/keyboards/tkw/grandiceps/keymaps/default/keymap.c b/keyboards/tkw/grandiceps/keymaps/default/keymap.c index 7c2cd09506..eb9ca69353 100644 --- a/keyboards/tkw/grandiceps/keymaps/default/keymap.c +++ b/keyboards/tkw/grandiceps/keymaps/default/keymap.c | |||
| @@ -26,9 +26,7 @@ enum grandiceps_layers { | |||
| 26 | }; | 26 | }; |
| 27 | 27 | ||
| 28 | enum custom_keycodes { | 28 | enum custom_keycodes { |
| 29 | KC_QWERTY = SAFE_RANGE, | 29 | KC_LOWER = SAFE_RANGE, |
| 30 | KC_COLEMAK, | ||
| 31 | KC_LOWER, | ||
| 32 | KC_RAISE, | 30 | KC_RAISE, |
| 33 | KC_ADJUST, | 31 | KC_ADJUST, |
| 34 | KC_PRVWD, | 32 | KC_PRVWD, |
| @@ -39,7 +37,8 @@ enum custom_keycodes { | |||
| 39 | KC_TEAMS | 37 | KC_TEAMS |
| 40 | }; | 38 | }; |
| 41 | 39 | ||
| 42 | 40 | #define KC_QWERTY PDF(_QWERTY) | |
| 41 | #define KC_COLEMAK PDF(_COLEMAK) | ||
| 43 | 42 | ||
| 44 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 43 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 45 | /* | 44 | /* |
| @@ -154,19 +153,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 154 | }; | 153 | }; |
| 155 | 154 | ||
| 156 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 155 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 157 | |||
| 158 | |||
| 159 | switch (keycode) { | 156 | switch (keycode) { |
| 160 | case KC_QWERTY: | ||
| 161 | if (record->event.pressed) { | ||
| 162 | set_single_persistent_default_layer(_QWERTY); | ||
| 163 | } | ||
| 164 | return false; | ||
| 165 | case KC_COLEMAK: | ||
| 166 | if (record->event.pressed) { | ||
| 167 | set_single_persistent_default_layer(_COLEMAK); | ||
| 168 | } | ||
| 169 | return false; | ||
| 170 | case KC_LOWER: | 157 | case KC_LOWER: |
| 171 | if (record->event.pressed) { | 158 | if (record->event.pressed) { |
| 172 | layer_on(_LOWER); | 159 | layer_on(_LOWER); |
diff --git a/keyboards/vitamins_included/keymaps/default/keymap.c b/keyboards/vitamins_included/keymaps/default/keymap.c index 1d282e1d86..268226ae1c 100644 --- a/keyboards/vitamins_included/keymaps/default/keymap.c +++ b/keyboards/vitamins_included/keymaps/default/keymap.c | |||
| @@ -10,14 +10,15 @@ enum layer_names { | |||
| 10 | }; | 10 | }; |
| 11 | 11 | ||
| 12 | enum custom_keycodes { | 12 | enum custom_keycodes { |
| 13 | QWERTY = SAFE_RANGE, | 13 | LOWER = SAFE_RANGE, |
| 14 | COLEMAK, | ||
| 15 | DVORAK, | ||
| 16 | LOWER, | ||
| 17 | RAISE, | 14 | RAISE, |
| 18 | ADJUST | 15 | ADJUST |
| 19 | }; | 16 | }; |
| 20 | 17 | ||
| 18 | #define QWERTY PDF(_QWERTY) | ||
| 19 | #define COLEMAK PDF(_COLEMAK) | ||
| 20 | #define DVORAK PDF(_DVORAK) | ||
| 21 | |||
| 21 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 22 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| 22 | 23 | ||
| 23 | /* Qwerty | 24 | /* Qwerty |
| @@ -134,24 +135,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 134 | 135 | ||
| 135 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 136 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 136 | switch (keycode) { | 137 | switch (keycode) { |
| 137 | case QWERTY: | ||
| 138 | if (record->event.pressed) { | ||
| 139 | set_single_persistent_default_layer(_QWERTY); | ||
| 140 | } | ||
| 141 | return false; | ||
| 142 | break; | ||
| 143 | case COLEMAK: | ||
| 144 | if (record->event.pressed) { | ||
| 145 | set_single_persistent_default_layer(_COLEMAK); | ||
| 146 | } | ||
| 147 | return false; | ||
| 148 | break; | ||
| 149 | case DVORAK: | ||
| 150 | if (record->event.pressed) { | ||
| 151 | set_single_persistent_default_layer(_DVORAK); | ||
| 152 | } | ||
| 153 | return false; | ||
| 154 | break; | ||
| 155 | case LOWER: | 138 | case LOWER: |
| 156 | if (record->event.pressed) { | 139 | if (record->event.pressed) { |
| 157 | layer_on(_LOWER); | 140 | layer_on(_LOWER); |
diff --git a/keyboards/waldo/keymaps/default_split_shft_bck/keymap.c b/keyboards/waldo/keymaps/default_split_shft_bck/keymap.c index 4972754d28..1f49641e7c 100644 --- a/keyboards/waldo/keymaps/default_split_shft_bck/keymap.c +++ b/keyboards/waldo/keymaps/default_split_shft_bck/keymap.c | |||
| @@ -24,8 +24,7 @@ enum waldo_layers { | |||
| 24 | }; | 24 | }; |
| 25 | 25 | ||
| 26 | enum waldo_keycodes { | 26 | enum waldo_keycodes { |
| 27 | QWERTY = SAFE_RANGE, | 27 | BACKLIT = SAFE_RANGE, |
| 28 | BACKLIT | ||
| 29 | }; | 28 | }; |
| 30 | 29 | ||
| 31 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | 30 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
| @@ -78,12 +77,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 78 | 77 | ||
| 79 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 78 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 80 | switch (keycode) { | 79 | switch (keycode) { |
| 81 | case QWERTY: | ||
| 82 | if (record->event.pressed) { | ||
| 83 | set_single_persistent_default_layer(_QWERTY); | ||
| 84 | } | ||
| 85 | return false; | ||
| 86 | break; | ||
| 87 | case BACKLIT: | 80 | case BACKLIT: |
| 88 | if (record->event.pressed) { | 81 | if (record->event.pressed) { |
| 89 | #ifdef BACKLIGHT_ENABLE | 82 | #ifdef BACKLIGHT_ENABLE |
