diff options
Diffstat (limited to 'keyboards')
104 files changed, 0 insertions, 1761 deletions
diff --git a/keyboards/1upkeyboards/1up60rgb/keymaps/raffle/keymap.c b/keyboards/1upkeyboards/1up60rgb/keymaps/raffle/keymap.c index f4dd36d6d..cba9a205c 100644 --- a/keyboards/1upkeyboards/1up60rgb/keymaps/raffle/keymap.c +++ b/keyboards/1upkeyboards/1up60rgb/keymaps/raffle/keymap.c | |||
| @@ -110,21 +110,3 @@ void led_set_user(uint8_t usb_led) { | |||
| 110 | } | 110 | } |
| 111 | 111 | ||
| 112 | } | 112 | } |
| 113 | |||
| 114 | //*********** Empty fxns from default map that I'm not modifying ***********// | ||
| 115 | // onboard macro support | ||
| 116 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 117 | ; | ||
| 118 | |||
| 119 | switch (id) { | ||
| 120 | |||
| 121 | } | ||
| 122 | return MACRO_NONE; | ||
| 123 | } | ||
| 124 | |||
| 125 | // initialize matrix | ||
| 126 | void matrix_init_user(void) { | ||
| 127 | } | ||
| 128 | |||
| 129 | |||
| 130 | |||
diff --git a/keyboards/alf/x2/keymaps/hhkb_60/keymap.c b/keyboards/alf/x2/keymaps/hhkb_60/keymap.c index 8baba1ae9..0abde6243 100644 --- a/keyboards/alf/x2/keymaps/hhkb_60/keymap.c +++ b/keyboards/alf/x2/keymaps/hhkb_60/keymap.c | |||
| @@ -19,20 +19,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 19 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), | 19 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), |
| 20 | }; | 20 | }; |
| 21 | 21 | ||
| 22 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 23 | return MACRO_NONE; | ||
| 24 | } | ||
| 25 | |||
| 26 | void matrix_init_user(void) { | ||
| 27 | } | ||
| 28 | |||
| 29 | void matrix_scan_user(void) { | ||
| 30 | } | ||
| 31 | |||
| 32 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 33 | return true; | ||
| 34 | } | ||
| 35 | |||
| 36 | void led_set_user(uint8_t usb_led) { | 22 | void led_set_user(uint8_t usb_led) { |
| 37 | if (usb_led & (1 << USB_LED_CAPS_LOCK)) { | 23 | if (usb_led & (1 << USB_LED_CAPS_LOCK)) { |
| 38 | DDRB |= (1 << 2); PORTB &= ~(1 << 2); | 24 | DDRB |= (1 << 2); PORTB &= ~(1 << 2); |
diff --git a/keyboards/alu84/keymaps/turbomech/keymap.c b/keyboards/alu84/keymaps/turbomech/keymap.c index b204a6865..80006d0db 100644 --- a/keyboards/alu84/keymaps/turbomech/keymap.c +++ b/keyboards/alu84/keymaps/turbomech/keymap.c | |||
| @@ -88,25 +88,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 88 | 88 | ||
| 89 | }; | 89 | }; |
| 90 | 90 | ||
| 91 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 92 | //switch (id) { | ||
| 93 | // case _FLIP: | ||
| 94 | // if (record->event.pressed) | ||
| 95 | |||
| 96 | //SEND_STRING("(╯°□°)╯︵ ┻━┻"); | ||
| 97 | // } | ||
| 98 | // return false; | ||
| 99 | // break; | ||
| 100 | // } | ||
| 101 | |||
| 102 | return MACRO_NONE; | ||
| 103 | }; | ||
| 104 | |||
| 105 | |||
| 106 | |||
| 107 | void matrix_scan_user(void) { | ||
| 108 | } | ||
| 109 | |||
| 110 | void led_set_user(uint8_t usb_led) { | 91 | void led_set_user(uint8_t usb_led) { |
| 111 | 92 | ||
| 112 | if (usb_led & (1 << USB_LED_NUM_LOCK)) { | 93 | if (usb_led & (1 << USB_LED_NUM_LOCK)) { |
diff --git a/keyboards/atomic/keymaps/abienz.c b/keyboards/atomic/keymaps/abienz.c index 5bc00aa82..7cc27d71a 100644 --- a/keyboards/atomic/keymaps/abienz.c +++ b/keyboards/atomic/keymaps/abienz.c | |||
| @@ -16,13 +16,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 16 | KC_TRNS, KC_TRNS, KC_NO, KC_TRNS, MO(1), KC_TRNS, KC_NO, KC_TRNS, MO(1), KC_TRNS, KC_NO, KC_TRNS, KC_MPRV, KC_VOLD, KC_MNXT, | 16 | KC_TRNS, KC_TRNS, KC_NO, KC_TRNS, MO(1), KC_TRNS, KC_NO, KC_TRNS, MO(1), KC_TRNS, KC_NO, KC_TRNS, KC_MPRV, KC_VOLD, KC_MNXT, |
| 17 | ), | 17 | ), |
| 18 | }; | 18 | }; |
| 19 | |||
| 20 | const macro_t * action_get_macro(keyrecord_t * record, uint8_t id, uint8_t opt) { | ||
| 21 | // MACRODOWN only works in this function | ||
| 22 | switch (id) { | ||
| 23 | case 0: | ||
| 24 | return MACRODOWN(TYPE(KC_T), END); | ||
| 25 | break; | ||
| 26 | } | ||
| 27 | return MACRO_NONE; | ||
| 28 | }; | ||
diff --git a/keyboards/atomic/keymaps/michelle.c b/keyboards/atomic/keymaps/michelle.c index 61953bf66..6dd2de279 100644 --- a/keyboards/atomic/keymaps/michelle.c +++ b/keyboards/atomic/keymaps/michelle.c | |||
| @@ -167,13 +167,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 167 | // └────────────────────────────────────────────────────────┴──────────┴──────────┴──────────┴──────────┴───────────┘ | 167 | // └────────────────────────────────────────────────────────┴──────────┴──────────┴──────────┴──────────┴───────────┘ |
| 168 | ), | 168 | ), |
| 169 | }; | 169 | }; |
| 170 | |||
| 171 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 172 | // MACRODOWN only works in this function | ||
| 173 | switch(id) { | ||
| 174 | case 0: | ||
| 175 | return MACRODOWN(TYPE(KC_T), END); | ||
| 176 | break; | ||
| 177 | } | ||
| 178 | return MACRO_NONE; | ||
| 179 | }; | ||
diff --git a/keyboards/atreus/keymaps/classic/keymap.c b/keyboards/atreus/keymaps/classic/keymap.c index 3feeb97cf..5837bcfe7 100644 --- a/keyboards/atreus/keymaps/classic/keymap.c +++ b/keyboards/atreus/keymaps/classic/keymap.c | |||
| @@ -30,18 +30,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 30 | KC_TRNS, KC_TRNS, KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC, DF(_QW), KC_TRNS, KC_TRNS, RESET | 30 | KC_TRNS, KC_TRNS, KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC, DF(_QW), KC_TRNS, KC_TRNS, RESET |
| 31 | ), | 31 | ), |
| 32 | }; | 32 | }; |
| 33 | |||
| 34 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 35 | { | ||
| 36 | // MACRODOWN only works in this function | ||
| 37 | switch(id) { | ||
| 38 | case 0: | ||
| 39 | if (record->event.pressed) { | ||
| 40 | register_code(KC_RSFT); | ||
| 41 | } else { | ||
| 42 | unregister_code(KC_RSFT); | ||
| 43 | } | ||
| 44 | break; | ||
| 45 | } | ||
| 46 | return MACRO_NONE; | ||
| 47 | }; | ||
diff --git a/keyboards/atreus/keymaps/erlandsona/keymap.c b/keyboards/atreus/keymaps/erlandsona/keymap.c index e25f4f089..151288edc 100644 --- a/keyboards/atreus/keymaps/erlandsona/keymap.c +++ b/keyboards/atreus/keymaps/erlandsona/keymap.c | |||
| @@ -41,17 +41,3 @@ const uint16_t PROGMEM fn_actions[] = { | |||
| 41 | [BASE] = ACTION_LAYER_OFF(2, 1), // switch back to layer 0 | 41 | [BASE] = ACTION_LAYER_OFF(2, 1), // switch back to layer 0 |
| 42 | [MOUS] = ACTION_LAYER_ON(2, 1) // switch to layer 2 | 42 | [MOUS] = ACTION_LAYER_ON(2, 1) // switch to layer 2 |
| 43 | }; | 43 | }; |
| 44 | |||
| 45 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 46 | // MACRODOWN only works in this function | ||
| 47 | switch(id) { | ||
| 48 | case 0: | ||
| 49 | if (record->event.pressed) { | ||
| 50 | register_code(KC_RSFT); | ||
| 51 | } else { | ||
| 52 | unregister_code(KC_RSFT); | ||
| 53 | } | ||
| 54 | break; | ||
| 55 | } | ||
| 56 | return MACRO_NONE; | ||
| 57 | }; | ||
diff --git a/keyboards/atreus/keymaps/gerb/keymap.c b/keyboards/atreus/keymaps/gerb/keymap.c index f858aa49c..f6ff7330d 100644 --- a/keyboards/atreus/keymaps/gerb/keymap.c +++ b/keyboards/atreus/keymaps/gerb/keymap.c | |||
| @@ -45,17 +45,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 45 | KC_TRNS, KC_TRNS, KC_LGUI, KC_LSFT, KC_BSPC, KC_LALT, KC_RCTL, KC_SPC, KC_TRNS, KC_TRNS, KC_TRNS, RESET | 45 | KC_TRNS, KC_TRNS, KC_LGUI, KC_LSFT, KC_BSPC, KC_LALT, KC_RCTL, KC_SPC, KC_TRNS, KC_TRNS, KC_TRNS, RESET |
| 46 | ), | 46 | ), |
| 47 | }; | 47 | }; |
| 48 | |||
| 49 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 50 | // MACRODOWN only works in this function | ||
| 51 | switch(id) { | ||
| 52 | case 0: | ||
| 53 | if (record->event.pressed) { | ||
| 54 | register_code(KC_RSFT); | ||
| 55 | } else { | ||
| 56 | unregister_code(KC_RSFT); | ||
| 57 | } | ||
| 58 | break; | ||
| 59 | } | ||
| 60 | return MACRO_NONE; | ||
| 61 | }; | ||
diff --git a/keyboards/atreus/keymaps/jeremy/keymap.c b/keyboards/atreus/keymaps/jeremy/keymap.c index e875af3cc..de2bedaa7 100644 --- a/keyboards/atreus/keymaps/jeremy/keymap.c +++ b/keyboards/atreus/keymaps/jeremy/keymap.c | |||
| @@ -54,9 +54,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 54 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS | 54 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS |
| 55 | ), | 55 | ), |
| 56 | }; | 56 | }; |
| 57 | |||
| 58 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 59 | switch(id) {} | ||
| 60 | |||
| 61 | return MACRO_NONE; | ||
| 62 | }; | ||
diff --git a/keyboards/atreus/keymaps/kejadlen/keymap.c b/keyboards/atreus/keymaps/kejadlen/keymap.c index 34a057c24..3f6d01a59 100644 --- a/keyboards/atreus/keymaps/kejadlen/keymap.c +++ b/keyboards/atreus/keymaps/kejadlen/keymap.c | |||
| @@ -30,11 +30,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 30 | KC_TRNS, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO | 30 | KC_TRNS, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO |
| 31 | ), | 31 | ), |
| 32 | }; | 32 | }; |
| 33 | |||
| 34 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 35 | switch(id) { | ||
| 36 | case TEENSY: | ||
| 37 | break; | ||
| 38 | } | ||
| 39 | return MACRO_NONE; | ||
| 40 | }; | ||
diff --git a/keyboards/atreus/keymaps/nojjan/keymap.c b/keyboards/atreus/keymaps/nojjan/keymap.c index a6872f995..42204b13e 100644 --- a/keyboards/atreus/keymaps/nojjan/keymap.c +++ b/keyboards/atreus/keymaps/nojjan/keymap.c | |||
| @@ -40,18 +40,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 40 | KC_NO, KC_VOLU, KC_NO, KC_NO, RESET, KC_NO, KC_F1, KC_F2, KC_F3, KC_F12 , | 40 | KC_NO, KC_VOLU, KC_NO, KC_NO, RESET, KC_NO, KC_F1, KC_F2, KC_F3, KC_F12 , |
| 41 | KC_NO, KC_VOLD, KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC, TO(_QW), KC_PSCR, KC_SLCK, KC_PAUS ) | 41 | KC_NO, KC_VOLD, KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC, TO(_QW), KC_PSCR, KC_SLCK, KC_PAUS ) |
| 42 | }; | 42 | }; |
| 43 | |||
| 44 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 45 | { | ||
| 46 | // MACRODOWN only works in this function | ||
| 47 | switch(id) { | ||
| 48 | case 0: | ||
| 49 | if (record->event.pressed) { | ||
| 50 | register_code(KC_RSFT); | ||
| 51 | } else { | ||
| 52 | unregister_code(KC_RSFT); | ||
| 53 | } | ||
| 54 | break; | ||
| 55 | } | ||
| 56 | return MACRO_NONE; | ||
| 57 | }; | ||
diff --git a/keyboards/atreus62/keymaps/atreus52/keymap.c b/keyboards/atreus62/keymaps/atreus52/keymap.c index 31a01ccd8..2abd49b11 100644 --- a/keyboards/atreus62/keymaps/atreus52/keymap.c +++ b/keyboards/atreus62/keymaps/atreus52/keymap.c | |||
| @@ -63,21 +63,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 63 | ) | 63 | ) |
| 64 | }; | 64 | }; |
| 65 | 65 | ||
| 66 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 67 | // MACRODOWN only works in this function | ||
| 68 | switch (id) { | ||
| 69 | case 0: | ||
| 70 | if (record->event.pressed) { | ||
| 71 | register_code(KC_RSFT); | ||
| 72 | } | ||
| 73 | else { | ||
| 74 | unregister_code(KC_RSFT); | ||
| 75 | } | ||
| 76 | break; | ||
| 77 | } | ||
| 78 | return MACRO_NONE; | ||
| 79 | }; | ||
| 80 | |||
| 81 | static uint8_t qw_dv_swap_state = 0; | 66 | static uint8_t qw_dv_swap_state = 0; |
| 82 | 67 | ||
| 83 | bool process_record_user (uint16_t keycode, keyrecord_t *record) { | 68 | bool process_record_user (uint16_t keycode, keyrecord_t *record) { |
diff --git a/keyboards/atreus62/keymaps/mfluid/keymap.c b/keyboards/atreus62/keymaps/mfluid/keymap.c index 206a4655b..3c25a4b82 100644 --- a/keyboards/atreus62/keymaps/mfluid/keymap.c +++ b/keyboards/atreus62/keymaps/mfluid/keymap.c | |||
| @@ -37,19 +37,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 37 | _______, _______, _______, OOOOOOO, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ | 37 | _______, _______, _______, OOOOOOO, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ |
| 38 | ) | 38 | ) |
| 39 | }; | 39 | }; |
| 40 | |||
| 41 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 42 | // MACRODOWN only works in this function | ||
| 43 | switch (id) { | ||
| 44 | case 0: | ||
| 45 | if (record->event.pressed) { | ||
| 46 | register_code(KC_RSFT); | ||
| 47 | } | ||
| 48 | else { | ||
| 49 | unregister_code(KC_RSFT); | ||
| 50 | } | ||
| 51 | break; | ||
| 52 | } | ||
| 53 | return MACRO_NONE; | ||
| 54 | }; | ||
| 55 | |||
diff --git a/keyboards/atreus62/keymaps/pcewing/keymap.c b/keyboards/atreus62/keymaps/pcewing/keymap.c index eee22271f..709903c6c 100644 --- a/keyboards/atreus62/keymaps/pcewing/keymap.c +++ b/keyboards/atreus62/keymaps/pcewing/keymap.c | |||
| @@ -74,19 +74,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 74 | ), | 74 | ), |
| 75 | */ | 75 | */ |
| 76 | }; | 76 | }; |
| 77 | |||
| 78 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 79 | { | ||
| 80 | // MACRODOWN only works in this function | ||
| 81 | switch (id) { | ||
| 82 | case 0: | ||
| 83 | if (record->event.pressed) { | ||
| 84 | register_code(KC_RSFT); | ||
| 85 | } | ||
| 86 | else { | ||
| 87 | unregister_code(KC_RSFT); | ||
| 88 | } | ||
| 89 | break; | ||
| 90 | } | ||
| 91 | return MACRO_NONE; | ||
| 92 | }; | ||
diff --git a/keyboards/bigseries/1key/keymaps/8ball/keymap.c b/keyboards/bigseries/1key/keymaps/8ball/keymap.c index 1097eb94a..33a5428fe 100755 --- a/keyboards/bigseries/1key/keymaps/8ball/keymap.c +++ b/keyboards/bigseries/1key/keymaps/8ball/keymap.c | |||
| @@ -61,10 +61,6 @@ void reset_rgb(void); | |||
| 61 | bool initialized = 0; | 61 | bool initialized = 0; |
| 62 | uint32_t lastTime = 0; | 62 | uint32_t lastTime = 0; |
| 63 | 63 | ||
| 64 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 65 | return MACRO_NONE ; | ||
| 66 | } | ||
| 67 | |||
| 68 | void matrix_init_user(void) { | 64 | void matrix_init_user(void) { |
| 69 | if (!initialized){ | 65 | if (!initialized){ |
| 70 | dprintf("Initializing in matrix_scan_user"); | 66 | dprintf("Initializing in matrix_scan_user"); |
diff --git a/keyboards/bigseries/1key/keymaps/leddance/keymap.c b/keyboards/bigseries/1key/keymaps/leddance/keymap.c index 3cd8f1db7..c77e57902 100755 --- a/keyboards/bigseries/1key/keymaps/leddance/keymap.c +++ b/keyboards/bigseries/1key/keymaps/leddance/keymap.c | |||
| @@ -74,54 +74,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 74 | 74 | ||
| 75 | 75 | ||
| 76 | }; | 76 | }; |
| 77 | |||
| 78 | |||
| 79 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 80 | return MACRO_NONE ; | ||
| 81 | } | ||
| 82 | |||
| 83 | |||
| 84 | void matrix_init_user(void) { | ||
| 85 | } | ||
| 86 | |||
| 87 | void matrix_scan_user(void) { | ||
| 88 | } | ||
| 89 | |||
| 90 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 91 | // Nothing here, see dance_toggle | ||
| 92 | return true; | ||
| 93 | } | ||
| 94 | |||
| 95 | void led_set_user(uint8_t usb_led) { | ||
| 96 | |||
| 97 | if (usb_led & (1 << USB_LED_NUM_LOCK)) { | ||
| 98 | |||
| 99 | } else { | ||
| 100 | |||
| 101 | } | ||
| 102 | |||
| 103 | if (usb_led & (1 << USB_LED_CAPS_LOCK)) { | ||
| 104 | |||
| 105 | } else { | ||
| 106 | |||
| 107 | } | ||
| 108 | |||
| 109 | if (usb_led & (1 << USB_LED_SCROLL_LOCK)) { | ||
| 110 | |||
| 111 | } else { | ||
| 112 | |||
| 113 | } | ||
| 114 | |||
| 115 | if (usb_led & (1 << USB_LED_COMPOSE)) { | ||
| 116 | |||
| 117 | } else { | ||
| 118 | |||
| 119 | } | ||
| 120 | |||
| 121 | if (usb_led & (1 << USB_LED_KANA)) { | ||
| 122 | |||
| 123 | } else { | ||
| 124 | |||
| 125 | } | ||
| 126 | |||
| 127 | } | ||
diff --git a/keyboards/duck/eagle_viper/v2/keymaps/profanum429/keymap.c b/keyboards/duck/eagle_viper/v2/keymaps/profanum429/keymap.c index a0163ad6a..6c6cfbd2f 100644 --- a/keyboards/duck/eagle_viper/v2/keymaps/profanum429/keymap.c +++ b/keyboards/duck/eagle_viper/v2/keymaps/profanum429/keymap.c | |||
| @@ -33,7 +33,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 33 | _______, _______, _______, _______, _______ \ | 33 | _______, _______, _______, _______, _______ \ |
| 34 | ), | 34 | ), |
| 35 | }; | 35 | }; |
| 36 | |||
| 37 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 38 | return MACRO_NONE; | ||
| 39 | }; | ||
diff --git a/keyboards/dz60/keymaps/256k_HHKB/keymap.c b/keyboards/dz60/keymaps/256k_HHKB/keymap.c index 1448e4ddc..c670e06c6 100644 --- a/keyboards/dz60/keymaps/256k_HHKB/keymap.c +++ b/keyboards/dz60/keymaps/256k_HHKB/keymap.c | |||
| @@ -238,12 +238,3 @@ KC_MS_ACCEL1 -> KC_ACL1 -> Set mouse acceleration to 1 | |||
| 238 | KC_MS_ACCEL2 -> KC_ACL2 -> Set mouse acceleration to 2 | 238 | KC_MS_ACCEL2 -> KC_ACL2 -> Set mouse acceleration to 2 |
| 239 | 239 | ||
| 240 | */ | 240 | */ |
| 241 | |||
| 242 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 243 | |||
| 244 | |||
| 245 | switch (id) { | ||
| 246 | |||
| 247 | } | ||
| 248 | return MACRO_NONE; | ||
| 249 | } | ||
diff --git a/keyboards/dz60/keymaps/LEdiodes/keymap.c b/keyboards/dz60/keymaps/LEdiodes/keymap.c index 3ac0047a3..9fb859dfe 100644 --- a/keyboards/dz60/keymaps/LEdiodes/keymap.c +++ b/keyboards/dz60/keymaps/LEdiodes/keymap.c | |||
| @@ -100,25 +100,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 100 | 100 | ||
| 101 | }; | 101 | }; |
| 102 | 102 | ||
| 103 | // Macros | ||
| 104 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 105 | |||
| 106 | // MACRODOWN only works in this function | ||
| 107 | switch(id) { | ||
| 108 | case 0: | ||
| 109 | if (record->event.pressed) { register_code(KC_RSFT); } | ||
| 110 | else { unregister_code(KC_RSFT); } | ||
| 111 | break; | ||
| 112 | } | ||
| 113 | |||
| 114 | return MACRO_NONE; | ||
| 115 | }; | ||
| 116 | |||
| 117 | // Loop | ||
| 118 | void matrix_scan_user(void) { | ||
| 119 | // Empty | ||
| 120 | }; | ||
| 121 | |||
| 122 | //Tap Dance Definitions | 103 | //Tap Dance Definitions |
| 123 | qk_tap_dance_action_t tap_dance_actions[] = { | 104 | qk_tap_dance_action_t tap_dance_actions[] = { |
| 124 | 105 | ||
diff --git a/keyboards/dz60/keymaps/itsaferbie/keymap.c b/keyboards/dz60/keymaps/itsaferbie/keymap.c index de30e0538..51345a2bc 100644 --- a/keyboards/dz60/keymaps/itsaferbie/keymap.c +++ b/keyboards/dz60/keymaps/itsaferbie/keymap.c | |||
| @@ -31,12 +31,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 31 | ______, ______, ______, ______, ______), | 31 | ______, ______, ______, ______, ______), |
| 32 | 32 | ||
| 33 | }; | 33 | }; |
| 34 | |||
| 35 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 36 | |||
| 37 | |||
| 38 | switch (id) { | ||
| 39 | |||
| 40 | } | ||
| 41 | return MACRO_NONE; | ||
| 42 | } | ||
diff --git a/keyboards/ergodone/keymaps/eozaki/keymap.c b/keyboards/ergodone/keymaps/eozaki/keymap.c index 917790124..09854ee89 100644 --- a/keyboards/ergodone/keymaps/eozaki/keymap.c +++ b/keyboards/ergodone/keymaps/eozaki/keymap.c | |||
| @@ -143,24 +143,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 143 | ), | 143 | ), |
| 144 | }; | 144 | }; |
| 145 | 145 | ||
| 146 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 147 | { | ||
| 148 | // MACRODOWN only works in this function | ||
| 149 | switch(id) { | ||
| 150 | case 0: | ||
| 151 | if (record->event.pressed) { | ||
| 152 | SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); | ||
| 153 | } | ||
| 154 | break; | ||
| 155 | case 1: | ||
| 156 | if (record->event.pressed) { // For resetting EEPROM | ||
| 157 | eeconfig_init(); | ||
| 158 | } | ||
| 159 | break; | ||
| 160 | } | ||
| 161 | return MACRO_NONE; | ||
| 162 | }; | ||
| 163 | |||
| 164 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 146 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 165 | switch (keycode) { | 147 | switch (keycode) { |
| 166 | // dynamically generate these. | 148 | // dynamically generate these. |
diff --git a/keyboards/ergodone/keymaps/kloki/keymap.c b/keyboards/ergodone/keymaps/kloki/keymap.c index 3303b7b40..87e96d20f 100644 --- a/keyboards/ergodone/keymaps/kloki/keymap.c +++ b/keyboards/ergodone/keymaps/kloki/keymap.c | |||
| @@ -162,24 +162,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 162 | ), | 162 | ), |
| 163 | }; | 163 | }; |
| 164 | 164 | ||
| 165 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 166 | { | ||
| 167 | // MACRODOWN only works in this function | ||
| 168 | switch(id) { | ||
| 169 | case 0: | ||
| 170 | if (record->event.pressed) { | ||
| 171 | SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); | ||
| 172 | } | ||
| 173 | break; | ||
| 174 | case 1: | ||
| 175 | if (record->event.pressed) { // For resetting EEPROM | ||
| 176 | eeconfig_init(); | ||
| 177 | } | ||
| 178 | break; | ||
| 179 | } | ||
| 180 | return MACRO_NONE; | ||
| 181 | }; | ||
| 182 | |||
| 183 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 165 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 184 | switch (keycode) { | 166 | switch (keycode) { |
| 185 | // dynamically generate these. | 167 | // dynamically generate these. |
diff --git a/keyboards/ergodox_ez/keymaps/blakedietz/keymap.c b/keyboards/ergodox_ez/keymaps/blakedietz/keymap.c index 28f45bc3c..5c08d3072 100644 --- a/keyboards/ergodox_ez/keymaps/blakedietz/keymap.c +++ b/keyboards/ergodox_ez/keymaps/blakedietz/keymap.c | |||
| @@ -198,26 +198,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 198 | ), | 198 | ), |
| 199 | }; | 199 | }; |
| 200 | 200 | ||
| 201 | // MACRODOWN only works in this function | ||
| 202 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 203 | { | ||
| 204 | switch(id) { | ||
| 205 | case 0: | ||
| 206 | if (record->event.pressed) { | ||
| 207 | register_code(KC_RSFT); | ||
| 208 | } else { | ||
| 209 | unregister_code(KC_RSFT); | ||
| 210 | } | ||
| 211 | break; | ||
| 212 | } | ||
| 213 | return MACRO_NONE; | ||
| 214 | }; | ||
| 215 | |||
| 216 | // Runs just one time when the keyboard initializes. | ||
| 217 | void matrix_init_user(void) { | ||
| 218 | |||
| 219 | }; | ||
| 220 | |||
| 221 | // Runs constantly in the background, in a loop. | 201 | // Runs constantly in the background, in a loop. |
| 222 | void matrix_scan_user(void) { | 202 | void matrix_scan_user(void) { |
| 223 | uint8_t layer = biton32(layer_state); | 203 | uint8_t layer = biton32(layer_state); |
diff --git a/keyboards/ergodox_ez/keymaps/kou/keymap.c b/keyboards/ergodox_ez/keymaps/kou/keymap.c index 5e49dca25..c8d0a6b5d 100644 --- a/keyboards/ergodox_ez/keymaps/kou/keymap.c +++ b/keyboards/ergodox_ez/keymaps/kou/keymap.c | |||
| @@ -248,24 +248,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 248 | ), | 248 | ), |
| 249 | }; | 249 | }; |
| 250 | 250 | ||
| 251 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 252 | { | ||
| 253 | // MACRODOWN only works in this function | ||
| 254 | switch(id) { | ||
| 255 | case 0: | ||
| 256 | if (record->event.pressed) { | ||
| 257 | SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); | ||
| 258 | } | ||
| 259 | break; | ||
| 260 | case 1: | ||
| 261 | if (record->event.pressed) { // For resetting EEPROM | ||
| 262 | eeconfig_init(); | ||
| 263 | } | ||
| 264 | break; | ||
| 265 | } | ||
| 266 | return MACRO_NONE; | ||
| 267 | }; | ||
| 268 | |||
| 269 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 251 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 270 | switch (keycode) { | 252 | switch (keycode) { |
| 271 | // dynamically generate these. | 253 | // dynamically generate these. |
diff --git a/keyboards/ergodox_ez/keymaps/matrixman/keymap.c b/keyboards/ergodox_ez/keymaps/matrixman/keymap.c index f5d0a0cf7..10b6567cd 100644 --- a/keyboards/ergodox_ez/keymaps/matrixman/keymap.c +++ b/keyboards/ergodox_ez/keymaps/matrixman/keymap.c | |||
| @@ -162,26 +162,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 162 | ), | 162 | ), |
| 163 | }; | 163 | }; |
| 164 | 164 | ||
| 165 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 166 | { | ||
| 167 | // MACRODOWN only works in this function | ||
| 168 | switch(id) { | ||
| 169 | case 0: | ||
| 170 | if (record->event.pressed) { | ||
| 171 | register_code(KC_RSFT); | ||
| 172 | } else { | ||
| 173 | unregister_code(KC_RSFT); | ||
| 174 | } | ||
| 175 | break; | ||
| 176 | } | ||
| 177 | return MACRO_NONE; | ||
| 178 | }; | ||
| 179 | |||
| 180 | // Runs just one time when the keyboard initializes. | ||
| 181 | void matrix_init_user(void) { | ||
| 182 | |||
| 183 | }; | ||
| 184 | |||
| 185 | // Runs constantly in the background, in a loop. | 165 | // Runs constantly in the background, in a loop. |
| 186 | void matrix_scan_user(void) { | 166 | void matrix_scan_user(void) { |
| 187 | 167 | ||
diff --git a/keyboards/ergodox_ez/keymaps/pvinis/keymap.c b/keyboards/ergodox_ez/keymaps/pvinis/keymap.c index c4b1b3b82..024cefd27 100644 --- a/keyboards/ergodox_ez/keymaps/pvinis/keymap.c +++ b/keyboards/ergodox_ez/keymaps/pvinis/keymap.c | |||
| @@ -265,13 +265,6 @@ uint32_t layer_state_set_user_keymap(uint32_t state) { | |||
| 265 | return state; | 265 | return state; |
| 266 | } | 266 | } |
| 267 | 267 | ||
| 268 | // extra keys | ||
| 269 | // const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 270 | // switch (id) { | ||
| 271 | // } | ||
| 272 | // return MACRO_NONE; | ||
| 273 | // } | ||
| 274 | |||
| 275 | // tap dances | 268 | // tap dances |
| 276 | 269 | ||
| 277 | // flash keyboard on 4x tap, with leds | 270 | // flash keyboard on 4x tap, with leds |
diff --git a/keyboards/ergodox_ez/keymaps/skug/keymap.c b/keyboards/ergodox_ez/keymaps/skug/keymap.c index a9be5d55c..bebb8c6a6 100644 --- a/keyboards/ergodox_ez/keymaps/skug/keymap.c +++ b/keyboards/ergodox_ez/keymaps/skug/keymap.c | |||
| @@ -195,24 +195,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 195 | 195 | ||
| 196 | }; | 196 | }; |
| 197 | 197 | ||
| 198 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 199 | { | ||
| 200 | // MACRODOWN only works in this function | ||
| 201 | switch(id) { | ||
| 202 | case 0: | ||
| 203 | if (record->event.pressed) { | ||
| 204 | SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); | ||
| 205 | } | ||
| 206 | break; | ||
| 207 | case 1: | ||
| 208 | if (record->event.pressed) { // For resetting EEPROM | ||
| 209 | eeconfig_init(); | ||
| 210 | } | ||
| 211 | break; | ||
| 212 | } | ||
| 213 | return MACRO_NONE; | ||
| 214 | }; | ||
| 215 | |||
| 216 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 198 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 217 | switch (keycode) { | 199 | switch (keycode) { |
| 218 | // dynamically generate these. | 200 | // dynamically generate these. |
diff --git a/keyboards/ergodox_ez/keymaps/smurmann/keymap.c b/keyboards/ergodox_ez/keymaps/smurmann/keymap.c index 9194c041c..42ac13775 100644 --- a/keyboards/ergodox_ez/keymaps/smurmann/keymap.c +++ b/keyboards/ergodox_ez/keymaps/smurmann/keymap.c | |||
| @@ -103,24 +103,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 103 | ), | 103 | ), |
| 104 | }; | 104 | }; |
| 105 | 105 | ||
| 106 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 107 | { | ||
| 108 | // MACRODOWN only works in this function | ||
| 109 | switch(id) { | ||
| 110 | case 0: | ||
| 111 | if (record->event.pressed) { | ||
| 112 | SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); | ||
| 113 | } | ||
| 114 | break; | ||
| 115 | case 1: | ||
| 116 | if (record->event.pressed) { // For resetting EEPROM | ||
| 117 | eeconfig_init(); | ||
| 118 | } | ||
| 119 | break; | ||
| 120 | } | ||
| 121 | return MACRO_NONE; | ||
| 122 | }; | ||
| 123 | |||
| 124 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 106 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 125 | switch (keycode) { | 107 | switch (keycode) { |
| 126 | // dynamically generate these. | 108 | // dynamically generate these. |
diff --git a/keyboards/ergodox_ez/keymaps/vim/keymap.c b/keyboards/ergodox_ez/keymaps/vim/keymap.c index 2823a7b4e..948f2b479 100644 --- a/keyboards/ergodox_ez/keymaps/vim/keymap.c +++ b/keyboards/ergodox_ez/keymaps/vim/keymap.c | |||
| @@ -153,15 +153,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 153 | ), | 153 | ), |
| 154 | }; | 154 | }; |
| 155 | 155 | ||
| 156 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 157 | switch(id) { | ||
| 158 | case 0: | ||
| 159 | if (record->event.pressed) { SEND_STRING (VERSION_STRING); } | ||
| 160 | break; | ||
| 161 | } | ||
| 162 | return MACRO_NONE; | ||
| 163 | }; | ||
| 164 | |||
| 165 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 156 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 166 | bool SHIFTED = (keyboard_report->mods & MOD_BIT(KC_LSFT)) | | 157 | bool SHIFTED = (keyboard_report->mods & MOD_BIT(KC_LSFT)) | |
| 167 | (keyboard_report->mods & MOD_BIT(KC_RSFT)); | 158 | (keyboard_report->mods & MOD_BIT(KC_RSFT)); |
diff --git a/keyboards/ergodox_infinity/keymaps/dudeofawesome/keymap.c b/keyboards/ergodox_infinity/keymaps/dudeofawesome/keymap.c index 26de392f9..c3ea48654 100644 --- a/keyboards/ergodox_infinity/keymaps/dudeofawesome/keymap.c +++ b/keyboards/ergodox_infinity/keymaps/dudeofawesome/keymap.c | |||
| @@ -470,24 +470,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 470 | 470 | ||
| 471 | }; | 471 | }; |
| 472 | 472 | ||
| 473 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 474 | { | ||
| 475 | // MACRODOWN only works in this function | ||
| 476 | switch(id) { | ||
| 477 | case 0: | ||
| 478 | if (record->event.pressed) { | ||
| 479 | SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); | ||
| 480 | } | ||
| 481 | break; | ||
| 482 | case 1: | ||
| 483 | if (record->event.pressed) { // For resetting EEPROM | ||
| 484 | eeconfig_init(); | ||
| 485 | } | ||
| 486 | break; | ||
| 487 | } | ||
| 488 | return MACRO_NONE; | ||
| 489 | }; | ||
| 490 | |||
| 491 | void matrix_init_user() { | 473 | void matrix_init_user() { |
| 492 | backlight_enable(); | 474 | backlight_enable(); |
| 493 | backlight_level(BACKLIGHT_LEVELS); | 475 | backlight_level(BACKLIGHT_LEVELS); |
diff --git a/keyboards/ergodox_infinity/keymaps/halfkeyboard/keymap.c b/keyboards/ergodox_infinity/keymaps/halfkeyboard/keymap.c index 7f829b243..3870dd8ff 100644 --- a/keyboards/ergodox_infinity/keymaps/halfkeyboard/keymap.c +++ b/keyboards/ergodox_infinity/keymaps/halfkeyboard/keymap.c | |||
| @@ -456,24 +456,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 456 | 456 | ||
| 457 | }; | 457 | }; |
| 458 | 458 | ||
| 459 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 460 | { | ||
| 461 | // MACRODOWN only works in this function | ||
| 462 | switch(id) { | ||
| 463 | case 0: | ||
| 464 | if (record->event.pressed) { | ||
| 465 | SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); | ||
| 466 | } | ||
| 467 | break; | ||
| 468 | case 1: | ||
| 469 | if (record->event.pressed) { // For resetting EEPROM | ||
| 470 | eeconfig_init(); | ||
| 471 | } | ||
| 472 | break; | ||
| 473 | } | ||
| 474 | return MACRO_NONE; | ||
| 475 | }; | ||
| 476 | |||
| 477 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 459 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 478 | switch (keycode) { | 460 | switch (keycode) { |
| 479 | // dynamically generate these. | 461 | // dynamically generate these. |
diff --git a/keyboards/ergodox_infinity/keymaps/input_club/keymap.c b/keyboards/ergodox_infinity/keymaps/input_club/keymap.c index 2aa74c419..545429fca 100644 --- a/keyboards/ergodox_infinity/keymaps/input_club/keymap.c +++ b/keyboards/ergodox_infinity/keymaps/input_club/keymap.c | |||
| @@ -187,24 +187,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 187 | ), | 187 | ), |
| 188 | }; | 188 | }; |
| 189 | 189 | ||
| 190 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 191 | { | ||
| 192 | // MACRODOWN only works in this function | ||
| 193 | switch(id) { | ||
| 194 | case 0: | ||
| 195 | if (record->event.pressed) { | ||
| 196 | SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); | ||
| 197 | } | ||
| 198 | break; | ||
| 199 | case 1: | ||
| 200 | if (record->event.pressed) { // For resetting EEPROM | ||
| 201 | eeconfig_init(); | ||
| 202 | } | ||
| 203 | break; | ||
| 204 | } | ||
| 205 | return MACRO_NONE; | ||
| 206 | }; | ||
| 207 | |||
| 208 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 190 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 209 | switch (keycode) { | 191 | switch (keycode) { |
| 210 | // dynamically generate these. | 192 | // dynamically generate these. |
diff --git a/keyboards/ergodox_infinity/keymaps/nordic_ergo/keymap.c b/keyboards/ergodox_infinity/keymaps/nordic_ergo/keymap.c index be96f0db0..d08b96cc6 100644 --- a/keyboards/ergodox_infinity/keymaps/nordic_ergo/keymap.c +++ b/keyboards/ergodox_infinity/keymaps/nordic_ergo/keymap.c | |||
| @@ -194,23 +194,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 194 | ), | 194 | ), |
| 195 | }; | 195 | }; |
| 196 | 196 | ||
| 197 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 198 | // MACRODOWN only works in this function | ||
| 199 | switch (id) { | ||
| 200 | case 0: | ||
| 201 | if (record->event.pressed) { | ||
| 202 | SEND_STRING(QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); | ||
| 203 | } | ||
| 204 | break; | ||
| 205 | case 1: | ||
| 206 | if (record->event.pressed) { // For resetting EEPROM | ||
| 207 | eeconfig_init(); | ||
| 208 | } | ||
| 209 | break; | ||
| 210 | } | ||
| 211 | return MACRO_NONE; | ||
| 212 | }; | ||
| 213 | |||
| 214 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 197 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 215 | switch (keycode) { | 198 | switch (keycode) { |
| 216 | case VRSN: | 199 | case VRSN: |
diff --git a/keyboards/ergodox_infinity/keymaps/rask/keymap.c b/keyboards/ergodox_infinity/keymaps/rask/keymap.c index 990081f2f..e31c1c5d6 100644 --- a/keyboards/ergodox_infinity/keymaps/rask/keymap.c +++ b/keyboards/ergodox_infinity/keymaps/rask/keymap.c | |||
| @@ -143,24 +143,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 143 | ), | 143 | ), |
| 144 | }; | 144 | }; |
| 145 | 145 | ||
| 146 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 147 | { | ||
| 148 | // MACRODOWN only works in this function | ||
| 149 | switch(id) { | ||
| 150 | case 0: | ||
| 151 | if (record->event.pressed) { | ||
| 152 | SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); | ||
| 153 | } | ||
| 154 | break; | ||
| 155 | case 1: | ||
| 156 | if (record->event.pressed) { // For resetting EEPROM | ||
| 157 | eeconfig_init(); | ||
| 158 | } | ||
| 159 | break; | ||
| 160 | } | ||
| 161 | return MACRO_NONE; | ||
| 162 | }; | ||
| 163 | |||
| 164 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 146 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 165 | switch (keycode) { | 147 | switch (keycode) { |
| 166 | // dynamically generate these. | 148 | // dynamically generate these. |
diff --git a/keyboards/ergodox_infinity/keymaps/trulyergonomic/keymap.c b/keyboards/ergodox_infinity/keymaps/trulyergonomic/keymap.c index b288bd557..02f409ad9 100644 --- a/keyboards/ergodox_infinity/keymaps/trulyergonomic/keymap.c +++ b/keyboards/ergodox_infinity/keymaps/trulyergonomic/keymap.c | |||
| @@ -101,24 +101,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 101 | ), | 101 | ), |
| 102 | }; | 102 | }; |
| 103 | 103 | ||
| 104 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 105 | { | ||
| 106 | // MACRODOWN only works in this function | ||
| 107 | switch(id) { | ||
| 108 | case 0: | ||
| 109 | if (record->event.pressed) { | ||
| 110 | SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); | ||
| 111 | } | ||
| 112 | break; | ||
| 113 | case 1: | ||
| 114 | if (record->event.pressed) { // For resetting EEPROM | ||
| 115 | eeconfig_init(); | ||
| 116 | } | ||
| 117 | break; | ||
| 118 | } | ||
| 119 | return MACRO_NONE; | ||
| 120 | }; | ||
| 121 | |||
| 122 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 104 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 123 | switch (keycode) { | 105 | switch (keycode) { |
| 124 | // dynamically generate these. | 106 | // dynamically generate these. |
diff --git a/keyboards/gh60/revc/keymaps/dbroqua/keymap.c b/keyboards/gh60/revc/keymaps/dbroqua/keymap.c index 2030355a7..9666199f3 100644 --- a/keyboards/gh60/revc/keymaps/dbroqua/keymap.c +++ b/keyboards/gh60/revc/keymaps/dbroqua/keymap.c | |||
| @@ -100,12 +100,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 100 | ) | 100 | ) |
| 101 | }; | 101 | }; |
| 102 | 102 | ||
| 103 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 104 | { | ||
| 105 | // MACRODOWN only works in this function | ||
| 106 | return MACRO_NONE; | ||
| 107 | }; | ||
| 108 | |||
| 109 | enum function_id { | 103 | enum function_id { |
| 110 | RGBLED_TOGGLE, | 104 | RGBLED_TOGGLE, |
| 111 | RGBLED_STEP_MODE, | 105 | RGBLED_STEP_MODE, |
diff --git a/keyboards/gh60/revc/keymaps/dbroqua_7U/keymap.c b/keyboards/gh60/revc/keymaps/dbroqua_7U/keymap.c index 74ff97a93..5b58d7686 100644 --- a/keyboards/gh60/revc/keymaps/dbroqua_7U/keymap.c +++ b/keyboards/gh60/revc/keymaps/dbroqua_7U/keymap.c | |||
| @@ -52,12 +52,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 52 | ) | 52 | ) |
| 53 | }; | 53 | }; |
| 54 | 54 | ||
| 55 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 56 | { | ||
| 57 | // MACRODOWN only works in this function | ||
| 58 | return MACRO_NONE; | ||
| 59 | }; | ||
| 60 | |||
| 61 | enum function_id { | 55 | enum function_id { |
| 62 | LED_TOGGLE | 56 | LED_TOGGLE |
| 63 | }; | 57 | }; |
diff --git a/keyboards/gh60/revc/keymaps/sethbc/keymap.c b/keyboards/gh60/revc/keymaps/sethbc/keymap.c index f2802827a..09a8d49ee 100644 --- a/keyboards/gh60/revc/keymaps/sethbc/keymap.c +++ b/keyboards/gh60/revc/keymaps/sethbc/keymap.c | |||
| @@ -28,25 +28,6 @@ const uint16_t PROGMEM fn_actions[] = { | |||
| 28 | [0] = ACTION_FUNCTION(SHIFT_ESC), | 28 | [0] = ACTION_FUNCTION(SHIFT_ESC), |
| 29 | }; | 29 | }; |
| 30 | 30 | ||
| 31 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 32 | { | ||
| 33 | // MACRODOWN only works in this function | ||
| 34 | switch(id) { | ||
| 35 | case 0: | ||
| 36 | if (record->event.pressed) { | ||
| 37 | register_code(KC_RSFT); | ||
| 38 | } else { | ||
| 39 | unregister_code(KC_RSFT); | ||
| 40 | } | ||
| 41 | break; | ||
| 42 | } | ||
| 43 | return MACRO_NONE; | ||
| 44 | }; | ||
| 45 | |||
| 46 | void matrix_scan_user(void) { | ||
| 47 | |||
| 48 | } | ||
| 49 | |||
| 50 | void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { | 31 | void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { |
| 51 | static uint8_t shift_esc_shift_mask; | 32 | static uint8_t shift_esc_shift_mask; |
| 52 | switch (id) { | 33 | switch (id) { |
diff --git a/keyboards/gh60/satan/keymaps/dbroqua/keymap.c b/keyboards/gh60/satan/keymaps/dbroqua/keymap.c index d1dc4c3c3..a9a54bf76 100644 --- a/keyboards/gh60/satan/keymaps/dbroqua/keymap.c +++ b/keyboards/gh60/satan/keymaps/dbroqua/keymap.c | |||
| @@ -77,12 +77,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 77 | ) | 77 | ) |
| 78 | }; | 78 | }; |
| 79 | 79 | ||
| 80 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 81 | { | ||
| 82 | // MACRODOWN only works in this function | ||
| 83 | return MACRO_NONE; | ||
| 84 | }; | ||
| 85 | |||
| 86 | enum function_id { | 80 | enum function_id { |
| 87 | RGBLED_TOGGLE, | 81 | RGBLED_TOGGLE, |
| 88 | RGBLED_STEP_MODE, | 82 | RGBLED_STEP_MODE, |
diff --git a/keyboards/handwired/dactyl/keymaps/dvorak/keymap.c b/keyboards/handwired/dactyl/keymaps/dvorak/keymap.c index cc6fc52e5..40ef3b019 100644 --- a/keyboards/handwired/dactyl/keymaps/dvorak/keymap.c +++ b/keyboards/handwired/dactyl/keymaps/dvorak/keymap.c | |||
| @@ -137,24 +137,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 137 | ), | 137 | ), |
| 138 | }; | 138 | }; |
| 139 | 139 | ||
| 140 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 141 | { | ||
| 142 | // MACRODOWN only works in this function | ||
| 143 | switch(id) { | ||
| 144 | case 0: | ||
| 145 | if (record->event.pressed) { | ||
| 146 | SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); | ||
| 147 | } | ||
| 148 | break; | ||
| 149 | case 1: | ||
| 150 | if (record->event.pressed) { // For resetting EEPROM | ||
| 151 | eeconfig_init(); | ||
| 152 | } | ||
| 153 | break; | ||
| 154 | } | ||
| 155 | return MACRO_NONE; | ||
| 156 | }; | ||
| 157 | |||
| 158 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 140 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 159 | switch (keycode) { | 141 | switch (keycode) { |
| 160 | case VRSN: | 142 | case VRSN: |
| @@ -166,12 +148,3 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 166 | } | 148 | } |
| 167 | return true; | 149 | return true; |
| 168 | } | 150 | } |
| 169 | |||
| 170 | // Runs just one time when the keyboard initializes. | ||
| 171 | void matrix_init_user(void) { | ||
| 172 | |||
| 173 | }; | ||
| 174 | |||
| 175 | |||
| 176 | // Runs constantly in the background, in a loop. | ||
| 177 | void matrix_scan_user(void) {}; | ||
diff --git a/keyboards/handwired/ibm122m/keymaps/lukaus/keymap.c b/keyboards/handwired/ibm122m/keymaps/lukaus/keymap.c index 130465e8d..9f37798ed 100644 --- a/keyboards/handwired/ibm122m/keymaps/lukaus/keymap.c +++ b/keyboards/handwired/ibm122m/keymaps/lukaus/keymap.c | |||
| @@ -137,30 +137,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 137 | ),*/ | 137 | ),*/ |
| 138 | }; | 138 | }; |
| 139 | 139 | ||
| 140 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 141 | { | ||
| 142 | // MACRODOWN only works in this function | ||
| 143 | switch(id) { | ||
| 144 | case 0: | ||
| 145 | if (record->event.pressed) { | ||
| 146 | register_code(KC_RSFT); | ||
| 147 | } else { | ||
| 148 | unregister_code(KC_RSFT); | ||
| 149 | } | ||
| 150 | break; | ||
| 151 | } | ||
| 152 | return MACRO_NONE; | ||
| 153 | }; | ||
| 154 | |||
| 155 | |||
| 156 | void matrix_init_user(void) { | ||
| 157 | |||
| 158 | } | ||
| 159 | |||
| 160 | void matrix_scan_user(void) { | ||
| 161 | |||
| 162 | } | ||
| 163 | |||
| 164 | bool left_shift_down = false; | 140 | bool left_shift_down = false; |
| 165 | bool right_shift_down = false; | 141 | bool right_shift_down = false; |
| 166 | 142 | ||
diff --git a/keyboards/hhkb/ansi/keymaps/blakedietz/keymap.c b/keyboards/hhkb/ansi/keymaps/blakedietz/keymap.c index a9146a4a0..1d84f383c 100644 --- a/keyboards/hhkb/ansi/keymaps/blakedietz/keymap.c +++ b/keyboards/hhkb/ansi/keymaps/blakedietz/keymap.c | |||
| @@ -104,22 +104,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 104 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_MPRV, KC_MNXT, KC_MUTE, KC_TRNS, KC_MPLY, KC_TRNS, | 104 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_MPRV, KC_MNXT, KC_MUTE, KC_TRNS, KC_MPLY, KC_TRNS, |
| 105 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_VOLD, KC_VOLU, KC_TRNS, KC_TRNS, KC_TRNS, TG(DEV), | 105 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_VOLD, KC_VOLU, KC_TRNS, KC_TRNS, KC_TRNS, TG(DEV), |
| 106 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)}; | 106 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)}; |
| 107 | |||
| 108 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 109 | { | ||
| 110 | // MACRODOWN only works in this function | ||
| 111 | switch (id) | ||
| 112 | { | ||
| 113 | case 0: | ||
| 114 | if (record->event.pressed) | ||
| 115 | { | ||
| 116 | register_code(KC_RSFT); | ||
| 117 | } | ||
| 118 | else | ||
| 119 | { | ||
| 120 | unregister_code(KC_RSFT); | ||
| 121 | } | ||
| 122 | break; | ||
| 123 | } | ||
| 124 | return MACRO_NONE; | ||
| 125 | }; | ||
diff --git a/keyboards/hhkb/ansi/keymaps/cinaeco/keymap.c b/keyboards/hhkb/ansi/keymaps/cinaeco/keymap.c index c27e37d8a..55d482e06 100644 --- a/keyboards/hhkb/ansi/keymaps/cinaeco/keymap.c +++ b/keyboards/hhkb/ansi/keymaps/cinaeco/keymap.c | |||
| @@ -162,11 +162,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 162 | 162 | ||
| 163 | }; | 163 | }; |
| 164 | 164 | ||
| 165 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 166 | { | ||
| 167 | return MACRO_NONE; | ||
| 168 | }; | ||
| 169 | |||
| 170 | // For Dynamic Macros. | 165 | // For Dynamic Macros. |
| 171 | bool process_record_user(uint16_t keycode, keyrecord_t *record) | 166 | bool process_record_user(uint16_t keycode, keyrecord_t *record) |
| 172 | { | 167 | { |
diff --git a/keyboards/hhkb/ansi/keymaps/dbroqua/keymap.c b/keyboards/hhkb/ansi/keymaps/dbroqua/keymap.c index e230a87fb..04ff80486 100644 --- a/keyboards/hhkb/ansi/keymaps/dbroqua/keymap.c +++ b/keyboards/hhkb/ansi/keymaps/dbroqua/keymap.c | |||
| @@ -68,22 +68,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 68 | KC_TRNS, KC_VOLD, KC_VOLU, KC_MUTE, KC_EJCT, KC_TRNS, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP, KC_LEFT, KC_RGHT, KC_TRNS, | 68 | KC_TRNS, KC_VOLD, KC_VOLU, KC_MUTE, KC_EJCT, KC_TRNS, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP, KC_LEFT, KC_RGHT, KC_TRNS, |
| 69 | KC_TRNS, KC_MPRV, KC_MPLY, KC_MNXT, KC_TRNS, KC_TRNS, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, KC_TRNS, KC_TRNS, | 69 | KC_TRNS, KC_MPRV, KC_MPLY, KC_MNXT, KC_TRNS, KC_TRNS, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, KC_TRNS, KC_TRNS, |
| 70 | DF(_DEFAULT), DF(_ALTERNATE), KC_TRNS, KC_MSTP, KC_TRNS)}; | 70 | DF(_DEFAULT), DF(_ALTERNATE), KC_TRNS, KC_MSTP, KC_TRNS)}; |
| 71 | |||
| 72 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 73 | { | ||
| 74 | // MACRODOWN only works in this function | ||
| 75 | switch (id) | ||
| 76 | { | ||
| 77 | case 0: | ||
| 78 | if (record->event.pressed) | ||
| 79 | { | ||
| 80 | register_code(KC_RSFT); | ||
| 81 | } | ||
| 82 | else | ||
| 83 | { | ||
| 84 | unregister_code(KC_RSFT); | ||
| 85 | } | ||
| 86 | break; | ||
| 87 | } | ||
| 88 | return MACRO_NONE; | ||
| 89 | }; | ||
diff --git a/keyboards/hhkb/ansi/keymaps/eric/keymap.c b/keyboards/hhkb/ansi/keymaps/eric/keymap.c index bf788b2ff..2cfc9785b 100644 --- a/keyboards/hhkb/ansi/keymaps/eric/keymap.c +++ b/keyboards/hhkb/ansi/keymaps/eric/keymap.c | |||
| @@ -52,22 +52,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 52 | KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_END, KC_ASTR, KC_TRNS, KC_TRNS, KC_PGUP, KC_HOME, KC_LEFT, KC_RGHT, KC_TRNS, | 52 | KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_END, KC_ASTR, KC_TRNS, KC_TRNS, KC_PGUP, KC_HOME, KC_LEFT, KC_RGHT, KC_TRNS, |
| 53 | KC_TRNS, KC_UNDS, KC_PLUS, KC_LPRN, KC_RPRN, KC_PIPE, KC_TRNS, KC_TRNS, KC_PGDN, KC_END, KC_DOWN, KC_TRNS, KC_TRNS, | 53 | KC_TRNS, KC_UNDS, KC_PLUS, KC_LPRN, KC_RPRN, KC_PIPE, KC_TRNS, KC_TRNS, KC_PGDN, KC_END, KC_DOWN, KC_TRNS, KC_TRNS, |
| 54 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)}; | 54 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)}; |
| 55 | |||
| 56 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 57 | { | ||
| 58 | // MACRODOWN only works in this function | ||
| 59 | switch (id) | ||
| 60 | { | ||
| 61 | case 0: | ||
| 62 | if (record->event.pressed) | ||
| 63 | { | ||
| 64 | register_code(KC_RSFT); | ||
| 65 | } | ||
| 66 | else | ||
| 67 | { | ||
| 68 | unregister_code(KC_RSFT); | ||
| 69 | } | ||
| 70 | break; | ||
| 71 | } | ||
| 72 | return MACRO_NONE; | ||
| 73 | }; | ||
diff --git a/keyboards/hhkb/ansi/keymaps/krusli/keymap.c b/keyboards/hhkb/ansi/keymaps/krusli/keymap.c index af6102f10..c63ef6a57 100644 --- a/keyboards/hhkb/ansi/keymaps/krusli/keymap.c +++ b/keyboards/hhkb/ansi/keymaps/krusli/keymap.c | |||
| @@ -54,22 +54,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 54 | KC_TRNS, KC_VOLD, KC_VOLU, KC_MUTE, KC_TRNS, KC_TRNS, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP, KC_LEFT, KC_RGHT, KC_PENT, | 54 | KC_TRNS, KC_VOLD, KC_VOLU, KC_MUTE, KC_TRNS, KC_TRNS, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP, KC_LEFT, KC_RGHT, KC_PENT, |
| 55 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, KC_TRNS, KC_TRNS, | 55 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, KC_TRNS, KC_TRNS, |
| 56 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)}; | 56 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)}; |
| 57 | |||
| 58 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 59 | { | ||
| 60 | // MACRODOWN only works in this function | ||
| 61 | switch (id) | ||
| 62 | { | ||
| 63 | case 0: | ||
| 64 | if (record->event.pressed) | ||
| 65 | { | ||
| 66 | register_code(KC_RSFT); | ||
| 67 | } | ||
| 68 | else | ||
| 69 | { | ||
| 70 | unregister_code(KC_RSFT); | ||
| 71 | } | ||
| 72 | break; | ||
| 73 | } | ||
| 74 | return MACRO_NONE; | ||
| 75 | }; | ||
diff --git a/keyboards/hhkb/ansi/keymaps/lxol/keymap.c b/keyboards/hhkb/ansi/keymaps/lxol/keymap.c index 462a98047..7496c542e 100644 --- a/keyboards/hhkb/ansi/keymaps/lxol/keymap.c +++ b/keyboards/hhkb/ansi/keymaps/lxol/keymap.c | |||
| @@ -179,22 +179,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 179 | KC_LCTL, LT(LGUILEV, KC_A), LT(LALTLEV, KC_S), KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, LT(RALTLEV, KC_L), LT(RGUILEV, KC_SCLN), KC_QUOT, MT(MOD_RCTL, KC_ENT), | 179 | KC_LCTL, LT(LGUILEV, KC_A), LT(LALTLEV, KC_S), KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, LT(RALTLEV, KC_L), LT(RGUILEV, KC_SCLN), KC_QUOT, MT(MOD_RCTL, KC_ENT), |
| 180 | KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, MO(HHKB), | 180 | KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, MO(HHKB), |
| 181 | KC_RGUI, KC_RALT, KC_SPC, KC_RALT, KC_RGUI)}; | 181 | KC_RGUI, KC_RALT, KC_SPC, KC_RALT, KC_RGUI)}; |
| 182 | |||
| 183 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 184 | { | ||
| 185 | // MACRODOWN only works in this function | ||
| 186 | switch (id) | ||
| 187 | { | ||
| 188 | case 0: | ||
| 189 | if (record->event.pressed) | ||
| 190 | { | ||
| 191 | register_code(KC_RSFT); | ||
| 192 | } | ||
| 193 | else | ||
| 194 | { | ||
| 195 | unregister_code(KC_RSFT); | ||
| 196 | } | ||
| 197 | break; | ||
| 198 | } | ||
| 199 | return MACRO_NONE; | ||
| 200 | }; | ||
diff --git a/keyboards/hhkb/ansi/keymaps/mjt/keymap.c b/keyboards/hhkb/ansi/keymaps/mjt/keymap.c index b62676edd..1ed2cb155 100644 --- a/keyboards/hhkb/ansi/keymaps/mjt/keymap.c +++ b/keyboards/hhkb/ansi/keymaps/mjt/keymap.c | |||
| @@ -81,25 +81,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 81 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PGDN, KC_TRNS, KC_TRNS, | 81 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PGDN, KC_TRNS, KC_TRNS, |
| 82 | KC_TRNS, KC_TRNS, DYN_REC_STOP, KC_TRNS, KC_TRNS)}; | 82 | KC_TRNS, KC_TRNS, DYN_REC_STOP, KC_TRNS, KC_TRNS)}; |
| 83 | 83 | ||
| 84 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 85 | { | ||
| 86 | // MACRODOWN only works in this function | ||
| 87 | switch (id) | ||
| 88 | { | ||
| 89 | case 0: | ||
| 90 | if (record->event.pressed) | ||
| 91 | { | ||
| 92 | register_code(KC_RSFT); | ||
| 93 | } | ||
| 94 | else | ||
| 95 | { | ||
| 96 | unregister_code(KC_RSFT); | ||
| 97 | } | ||
| 98 | break; | ||
| 99 | } | ||
| 100 | return MACRO_NONE; | ||
| 101 | }; | ||
| 102 | |||
| 103 | bool process_record_user(uint16_t keycode, keyrecord_t *record) | 84 | bool process_record_user(uint16_t keycode, keyrecord_t *record) |
| 104 | { | 85 | { |
| 105 | uint16_t macro_kc = (keycode == MO(DYN) ? DYN_REC_STOP : keycode); | 86 | uint16_t macro_kc = (keycode == MO(DYN) ? DYN_REC_STOP : keycode); |
diff --git a/keyboards/hhkb/ansi/keymaps/smt/keymap.c b/keyboards/hhkb/ansi/keymaps/smt/keymap.c index e1d8bae2e..317a8faf5 100644 --- a/keyboards/hhkb/ansi/keymaps/smt/keymap.c +++ b/keyboards/hhkb/ansi/keymaps/smt/keymap.c | |||
| @@ -117,25 +117,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 117 | _______, _______, QWERTY, COLEMAK, DVORAK, _______, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, _______, _______, | 117 | _______, _______, QWERTY, COLEMAK, DVORAK, _______, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, _______, _______, |
| 118 | _______, _______, _______, _______, _______)}; | 118 | _______, _______, _______, _______, _______)}; |
| 119 | 119 | ||
| 120 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 121 | { | ||
| 122 | // MACRODOWN only works in this function | ||
| 123 | switch (id) | ||
| 124 | { | ||
| 125 | case 0: | ||
| 126 | if (record->event.pressed) | ||
| 127 | { | ||
| 128 | register_code(KC_RSFT); | ||
| 129 | } | ||
| 130 | else | ||
| 131 | { | ||
| 132 | unregister_code(KC_RSFT); | ||
| 133 | } | ||
| 134 | break; | ||
| 135 | } | ||
| 136 | return MACRO_NONE; | ||
| 137 | }; | ||
| 138 | |||
| 139 | void persistent_default_layer_set(uint16_t default_layer) | 120 | void persistent_default_layer_set(uint16_t default_layer) |
| 140 | { | 121 | { |
| 141 | eeconfig_update_default_layer(default_layer); | 122 | eeconfig_update_default_layer(default_layer); |
diff --git a/keyboards/hhkb/jp/keymaps/default/keymap.c b/keyboards/hhkb/jp/keymaps/default/keymap.c index 6fd06638c..1c7d677cc 100644 --- a/keyboards/hhkb/jp/keymaps/default/keymap.c +++ b/keyboards/hhkb/jp/keymaps/default/keymap.c | |||
| @@ -42,8 +42,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 42 | _______, KC_VOLD, KC_VOLU, KC_MUTE, KC_PWR, _______, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP, KC_LEFT, KC_RGHT, _______, KC_PENT, | 42 | _______, KC_VOLD, KC_VOLU, KC_MUTE, KC_PWR, _______, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP, KC_LEFT, KC_RGHT, _______, KC_PENT, |
| 43 | _______, _______, _______, _______, _______, _______, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, _______, _______, _______, | 43 | _______, _______, _______, _______, _______, _______, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, _______, _______, _______, |
| 44 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______)}; | 44 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______)}; |
| 45 | |||
| 46 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t macro_id, uint8_t opt) | ||
| 47 | { | ||
| 48 | return MACRO_NONE; | ||
| 49 | } | ||
diff --git a/keyboards/hhkb/jp/keymaps/default_mac/keymap.c b/keyboards/hhkb/jp/keymaps/default_mac/keymap.c index f3ef3d6af..17127690f 100644 --- a/keyboards/hhkb/jp/keymaps/default_mac/keymap.c +++ b/keyboards/hhkb/jp/keymaps/default_mac/keymap.c | |||
| @@ -42,8 +42,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 42 | _______, KC_VOLD, KC_VOLU, KC_MUTE, KC_PWR, _______, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP, KC_LEFT, KC_RGHT, _______, KC_PENT, | 42 | _______, KC_VOLD, KC_VOLU, KC_MUTE, KC_PWR, _______, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP, KC_LEFT, KC_RGHT, _______, KC_PENT, |
| 43 | _______, _______, _______, _______, _______, _______, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, _______, _______, _______, | 43 | _______, _______, _______, _______, _______, _______, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, _______, _______, _______, |
| 44 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL, _______, _______)}; | 44 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL, _______, _______)}; |
| 45 | |||
| 46 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t macro_id, uint8_t opt) | ||
| 47 | { | ||
| 48 | return MACRO_NONE; | ||
| 49 | } | ||
diff --git a/keyboards/hhkb/jp/keymaps/enoch_jp/keymap.c b/keyboards/hhkb/jp/keymaps/enoch_jp/keymap.c index 15dc29773..4ebdcf86d 100644 --- a/keyboards/hhkb/jp/keymaps/enoch_jp/keymap.c +++ b/keyboards/hhkb/jp/keymaps/enoch_jp/keymap.c | |||
| @@ -43,11 +43,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 43 | _______, _______, _______, _______, _______, _______, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, _______, _______, _______, | 43 | _______, _______, _______, _______, _______, _______, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, _______, _______, _______, |
| 44 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______)}; | 44 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______)}; |
| 45 | 45 | ||
| 46 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 47 | { | ||
| 48 | return MACRO_NONE; | ||
| 49 | }; | ||
| 50 | |||
| 51 | /*void matrix_scan_user(void) { | 46 | /*void matrix_scan_user(void) { |
| 52 | LEADER_DICTIONARY() { | 47 | LEADER_DICTIONARY() { |
| 53 | leading = false; | 48 | leading = false; |
diff --git a/keyboards/hhkb/jp/keymaps/rdg_jp/keymap.c b/keyboards/hhkb/jp/keymaps/rdg_jp/keymap.c index f40df74e8..c893495ef 100644 --- a/keyboards/hhkb/jp/keymaps/rdg_jp/keymap.c +++ b/keyboards/hhkb/jp/keymaps/rdg_jp/keymap.c | |||
| @@ -48,8 +48,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 48 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | 48 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, |
| 49 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | 49 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, |
| 50 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______)}; | 50 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______)}; |
| 51 | |||
| 52 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t macro_id, uint8_t opt) | ||
| 53 | { | ||
| 54 | return MACRO_NONE; | ||
| 55 | } | ||
diff --git a/keyboards/hhkb/jp/keymaps/sh_jp/keymap.c b/keyboards/hhkb/jp/keymaps/sh_jp/keymap.c index 79515c5a6..097a01752 100644 --- a/keyboards/hhkb/jp/keymaps/sh_jp/keymap.c +++ b/keyboards/hhkb/jp/keymaps/sh_jp/keymap.c | |||
| @@ -43,8 +43,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 43 | _______, KC_VOLD, KC_VOLU, KC_MUTE, KC_PWR, _______, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP, KC_LEFT, KC_RGHT, _______, KC_PENT, | 43 | _______, KC_VOLD, KC_VOLU, KC_MUTE, KC_PWR, _______, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP, KC_LEFT, KC_RGHT, _______, KC_PENT, |
| 44 | _______, _______, _______, _______, _______, _______, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, _______, _______, _______, | 44 | _______, _______, _______, _______, _______, _______, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, _______, _______, _______, |
| 45 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______)}; | 45 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______)}; |
| 46 | |||
| 47 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t macro_id, uint8_t opt) | ||
| 48 | { | ||
| 49 | return MACRO_NONE; | ||
| 50 | } | ||
diff --git a/keyboards/hhkb/jp/keymaps/via/keymap.c b/keyboards/hhkb/jp/keymaps/via/keymap.c index cb1ba76fb..64323309b 100644 --- a/keyboards/hhkb/jp/keymaps/via/keymap.c +++ b/keyboards/hhkb/jp/keymaps/via/keymap.c | |||
| @@ -51,8 +51,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 51 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS | 51 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS |
| 52 | ) | 52 | ) |
| 53 | }; | 53 | }; |
| 54 | |||
| 55 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t macro_id, uint8_t opt) | ||
| 56 | { | ||
| 57 | return MACRO_NONE; | ||
| 58 | } | ||
diff --git a/keyboards/hid_liber/keymaps/bakageta/keymap.c b/keyboards/hid_liber/keymaps/bakageta/keymap.c index dab702e10..5fa3cf6c0 100755 --- a/keyboards/hid_liber/keymaps/bakageta/keymap.c +++ b/keyboards/hid_liber/keymaps/bakageta/keymap.c | |||
| @@ -54,35 +54,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 54 | _______, _______, _______, KC_P0, KC_PDOT, KC_PENT, _______, _______, _______, _______, _______ \ | 54 | _______, _______, _______, KC_P0, KC_PDOT, KC_PENT, _______, _______, _______, _______, _______ \ |
| 55 | ), | 55 | ), |
| 56 | }; | 56 | }; |
| 57 | |||
| 58 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 59 | { | ||
| 60 | // MACRODOWN only works in this function | ||
| 61 | switch(id) { | ||
| 62 | case 0: | ||
| 63 | if (record->event.pressed) { | ||
| 64 | register_code(KC_RSFT); | ||
| 65 | } else { | ||
| 66 | unregister_code(KC_RSFT); | ||
| 67 | } | ||
| 68 | break; | ||
| 69 | } | ||
| 70 | return MACRO_NONE; | ||
| 71 | }; | ||
| 72 | |||
| 73 | |||
| 74 | void matrix_init_user(void) { | ||
| 75 | |||
| 76 | } | ||
| 77 | |||
| 78 | void matrix_scan_user(void) { | ||
| 79 | |||
| 80 | } | ||
| 81 | |||
| 82 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 83 | return true; | ||
| 84 | } | ||
| 85 | |||
| 86 | void led_set_user(uint8_t usb_led) { | ||
| 87 | |||
| 88 | } | ||
diff --git a/keyboards/infinity60/keymaps/jpetermans/keymap.c b/keyboards/infinity60/keymaps/jpetermans/keymap.c index a169d658f..c34d56ec8 100644 --- a/keyboards/infinity60/keymaps/jpetermans/keymap.c +++ b/keyboards/infinity60/keymaps/jpetermans/keymap.c | |||
| @@ -228,16 +228,6 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { | |||
| 228 | } | 228 | } |
| 229 | } | 229 | } |
| 230 | 230 | ||
| 231 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 232 | { | ||
| 233 | return MACRO_NONE; | ||
| 234 | }; | ||
| 235 | |||
| 236 | |||
| 237 | bool process_record_user (uint16_t keycode, keyrecord_t *record) { | ||
| 238 | return true; | ||
| 239 | } | ||
| 240 | |||
| 241 | // Runs just one time when the keyboard initializes. | 231 | // Runs just one time when the keyboard initializes. |
| 242 | void matrix_init_user(void) { | 232 | void matrix_init_user(void) { |
| 243 | 233 | ||
diff --git a/keyboards/jj40/keymaps/fun40/keymap.c b/keyboards/jj40/keymaps/fun40/keymap.c index bbe6279e3..c15ba47eb 100644 --- a/keyboards/jj40/keymaps/fun40/keymap.c +++ b/keyboards/jj40/keymaps/fun40/keymap.c | |||
| @@ -96,28 +96,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 96 | * `-----------------------------------------------------------------------------------' | 96 | * `-----------------------------------------------------------------------------------' |
| 97 | */ | 97 | */ |
| 98 | }; | 98 | }; |
| 99 | |||
| 100 | // Macro actions for each corresponding ID. | ||
| 101 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 102 | { | ||
| 103 | // MACRODOWN only works in this function | ||
| 104 | switch (id) { | ||
| 105 | case 0: | ||
| 106 | if (record->event.pressed) { | ||
| 107 | register_code(KC_RSFT); | ||
| 108 | #ifdef BACKLIGHT_ENABLE | ||
| 109 | backlight_step(); | ||
| 110 | #endif | ||
| 111 | } | ||
| 112 | else { | ||
| 113 | unregister_code(KC_RSFT); | ||
| 114 | } | ||
| 115 | break; | ||
| 116 | } | ||
| 117 | return MACRO_NONE; | ||
| 118 | }; | ||
| 119 | |||
| 120 | // Loop | ||
| 121 | void matrix_scan_user(void) { | ||
| 122 | // Empty | ||
| 123 | }; | ||
diff --git a/keyboards/kbdfans/kbd75/keymaps/adit/keymap.c b/keyboards/kbdfans/kbd75/keymaps/adit/keymap.c index b7cae4810..778515788 100644 --- a/keyboards/kbdfans/kbd75/keymaps/adit/keymap.c +++ b/keyboards/kbdfans/kbd75/keymaps/adit/keymap.c | |||
| @@ -24,25 +24,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 24 | 24 | ||
| 25 | }; | 25 | }; |
| 26 | 26 | ||
| 27 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 28 | |||
| 29 | |||
| 30 | switch (id) { | ||
| 31 | |||
| 32 | } | ||
| 33 | return MACRO_NONE; | ||
| 34 | } | ||
| 35 | |||
| 36 | void matrix_init_user(void) { | ||
| 37 | } | ||
| 38 | |||
| 39 | void matrix_scan_user(void) { | ||
| 40 | } | ||
| 41 | |||
| 42 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 43 | return true; | ||
| 44 | } | ||
| 45 | |||
| 46 | enum function_id { | 27 | enum function_id { |
| 47 | SHIFT_ESC, | 28 | SHIFT_ESC, |
| 48 | }; | 29 | }; |
diff --git a/keyboards/kc60/keymaps/dbroqua/keymap.c b/keyboards/kc60/keymaps/dbroqua/keymap.c index f7aa36dab..9cb9bbd8b 100644 --- a/keyboards/kc60/keymaps/dbroqua/keymap.c +++ b/keyboards/kc60/keymaps/dbroqua/keymap.c | |||
| @@ -80,9 +80,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 80 | ______, ______, ______, ______, ______, ______, KC_HOME,KC_PGDN,KC_END \ | 80 | ______, ______, ______, ______, ______, ______, KC_HOME,KC_PGDN,KC_END \ |
| 81 | ), | 81 | ), |
| 82 | }; | 82 | }; |
| 83 | |||
| 84 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 85 | { | ||
| 86 | // MACRODOWN only works in this function | ||
| 87 | return MACRO_NONE; | ||
| 88 | }; | ||
diff --git a/keyboards/kc60/keymaps/dbroqua_hhkb/keymap.c b/keyboards/kc60/keymaps/dbroqua_hhkb/keymap.c index fe5a9c4a8..35ea6386e 100644 --- a/keyboards/kc60/keymaps/dbroqua_hhkb/keymap.c +++ b/keyboards/kc60/keymaps/dbroqua_hhkb/keymap.c | |||
| @@ -50,9 +50,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 50 | ______, ______, ______, ______, KC_DEL, KC_MSTP, ______, ______, ______ \ | 50 | ______, ______, ______, ______, KC_DEL, KC_MSTP, ______, ______, ______ \ |
| 51 | ) | 51 | ) |
| 52 | }; | 52 | }; |
| 53 | |||
| 54 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 55 | { | ||
| 56 | // MACRODOWN only works in this function | ||
| 57 | return MACRO_NONE; | ||
| 58 | }; | ||
diff --git a/keyboards/kc60/keymaps/sgoodwin/keymap.c b/keyboards/kc60/keymaps/sgoodwin/keymap.c index c78e3108f..79b0b8af4 100644 --- a/keyboards/kc60/keymaps/sgoodwin/keymap.c +++ b/keyboards/kc60/keymaps/sgoodwin/keymap.c | |||
| @@ -28,9 +28,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 28 | KC_TRNS, KC_TRNS, KC_TRNS, KC_SPC, KC_NO, DEBUG, RESET, KC_TRNS, KC_NO \ | 28 | KC_TRNS, KC_TRNS, KC_TRNS, KC_SPC, KC_NO, DEBUG, RESET, KC_TRNS, KC_NO \ |
| 29 | ), | 29 | ), |
| 30 | }; | 30 | }; |
| 31 | |||
| 32 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 33 | { | ||
| 34 | // MACRODOWN only works in this function | ||
| 35 | return MACRO_NONE; | ||
| 36 | }; | ||
diff --git a/keyboards/kc60/keymaps/wigguno/keymap.c b/keyboards/kc60/keymaps/wigguno/keymap.c index aa730c22f..00cf19433 100644 --- a/keyboards/kc60/keymaps/wigguno/keymap.c +++ b/keyboards/kc60/keymaps/wigguno/keymap.c | |||
| @@ -50,9 +50,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 50 | RESET, KC_TRNS, KC_TRNS, BL_TOGG, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS \ | 50 | RESET, KC_TRNS, KC_TRNS, BL_TOGG, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS \ |
| 51 | ), | 51 | ), |
| 52 | }; | 52 | }; |
| 53 | |||
| 54 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 55 | { | ||
| 56 | // MACRODOWN only works in this function | ||
| 57 | return MACRO_NONE; | ||
| 58 | }; | ||
diff --git a/keyboards/kinesis/keymaps/dvorak/keymap.c b/keyboards/kinesis/keymaps/dvorak/keymap.c index 868c9ad55..ff67eb9fc 100644 --- a/keyboards/kinesis/keymaps/dvorak/keymap.c +++ b/keyboards/kinesis/keymaps/dvorak/keymap.c | |||
| @@ -54,35 +54,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 54 | KC_TRNS, KC_ENT, KC_NO | 54 | KC_TRNS, KC_ENT, KC_NO |
| 55 | ) | 55 | ) |
| 56 | }; | 56 | }; |
| 57 | |||
| 58 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 59 | { | ||
| 60 | // MACRODOWN only works in this function | ||
| 61 | switch(id) { | ||
| 62 | case 0: | ||
| 63 | if (record->event.pressed) { | ||
| 64 | register_code(KC_RSFT); | ||
| 65 | } else { | ||
| 66 | unregister_code(KC_RSFT); | ||
| 67 | } | ||
| 68 | break; | ||
| 69 | } | ||
| 70 | return MACRO_NONE; | ||
| 71 | }; | ||
| 72 | |||
| 73 | |||
| 74 | void matrix_init_user(void) { | ||
| 75 | |||
| 76 | } | ||
| 77 | |||
| 78 | void matrix_scan_user(void) { | ||
| 79 | |||
| 80 | } | ||
| 81 | |||
| 82 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 83 | return true; | ||
| 84 | } | ||
| 85 | |||
| 86 | void led_set_user(uint8_t usb_led) { | ||
| 87 | |||
| 88 | } | ||
diff --git a/keyboards/lfkeyboards/lfk78/keymaps/ca178858/keymap.c b/keyboards/lfkeyboards/lfk78/keymaps/ca178858/keymap.c index 5461f718c..4e5e84722 100644 --- a/keyboards/lfkeyboards/lfk78/keymaps/ca178858/keymap.c +++ b/keyboards/lfkeyboards/lfk78/keymaps/ca178858/keymap.c | |||
| @@ -159,19 +159,6 @@ const uint16_t PROGMEM fn_actions[] = { | |||
| 159 | ACTION_FUNCTION(LFK_DEBUG_SETTINGS), // FN12 - prints LED and click settings to HID | 159 | ACTION_FUNCTION(LFK_DEBUG_SETTINGS), // FN12 - prints LED and click settings to HID |
| 160 | }; | 160 | }; |
| 161 | 161 | ||
| 162 | |||
| 163 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 164 | { | ||
| 165 | // MACRODOWN only works in this function | ||
| 166 | switch(id) { | ||
| 167 | } | ||
| 168 | return MACRO_NONE; | ||
| 169 | }; | ||
| 170 | |||
| 171 | void matrix_init_user(void) { | ||
| 172 | |||
| 173 | } | ||
| 174 | |||
| 175 | void matrix_scan_user(void) { | 162 | void matrix_scan_user(void) { |
| 176 | if(spam_space && !(get_mods() & (MOD_BIT(KC_LGUI)))){ | 163 | if(spam_space && !(get_mods() & (MOD_BIT(KC_LGUI)))){ |
| 177 | register_code(KC_SPC); | 164 | register_code(KC_SPC); |
| @@ -188,7 +175,3 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 188 | } | 175 | } |
| 189 | return true; | 176 | return true; |
| 190 | } | 177 | } |
| 191 | |||
| 192 | void led_set_user(uint8_t usb_led) { | ||
| 193 | |||
| 194 | } | ||
diff --git a/keyboards/lfkeyboards/lfk87/keymaps/ca178858/keymap.c b/keyboards/lfkeyboards/lfk87/keymaps/ca178858/keymap.c index 59ee51c25..7f5ae4a72 100644 --- a/keyboards/lfkeyboards/lfk87/keymaps/ca178858/keymap.c +++ b/keyboards/lfkeyboards/lfk87/keymaps/ca178858/keymap.c | |||
| @@ -192,24 +192,6 @@ const uint16_t PROGMEM fn_actions[] = { | |||
| 192 | ACTION_FUNCTION(LFK_PLAY_ONEUP), | 192 | ACTION_FUNCTION(LFK_PLAY_ONEUP), |
| 193 | }; | 193 | }; |
| 194 | 194 | ||
| 195 | |||
| 196 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 197 | { | ||
| 198 | // MACRODOWN only works in this function | ||
| 199 | switch(id) { | ||
| 200 | } | ||
| 201 | return MACRO_NONE; | ||
| 202 | }; | ||
| 203 | |||
| 204 | |||
| 205 | void matrix_init_user(void) { | ||
| 206 | |||
| 207 | } | ||
| 208 | |||
| 209 | void matrix_scan_user(void) { | ||
| 210 | |||
| 211 | } | ||
| 212 | |||
| 213 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 195 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 214 | if((layer_state & (1 << CS_GO)) && (keycode == 44)){ | 196 | if((layer_state & (1 << CS_GO)) && (keycode == 44)){ |
| 215 | if(get_mods() & (MOD_BIT(KC_LGUI))){ | 197 | if(get_mods() & (MOD_BIT(KC_LGUI))){ |
| @@ -218,7 +200,3 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 218 | } | 200 | } |
| 219 | return true; | 201 | return true; |
| 220 | } | 202 | } |
| 221 | |||
| 222 | void led_set_user(uint8_t usb_led) { | ||
| 223 | |||
| 224 | } | ||
diff --git a/keyboards/lfkeyboards/lfk87/keymaps/gbchk/keymap.c b/keyboards/lfkeyboards/lfk87/keymaps/gbchk/keymap.c index 89c5d8f8d..5c9dfb522 100644 --- a/keyboards/lfkeyboards/lfk87/keymaps/gbchk/keymap.c +++ b/keyboards/lfkeyboards/lfk87/keymaps/gbchk/keymap.c | |||
| @@ -100,16 +100,6 @@ const uint16_t PROGMEM fn_actions[] = { | |||
| 100 | ACTION_FUNCTION(LFK_CLICK_TOGGLE), // FN5 - Toggle audio click | 100 | ACTION_FUNCTION(LFK_CLICK_TOGGLE), // FN5 - Toggle audio click |
| 101 | }; | 101 | }; |
| 102 | 102 | ||
| 103 | |||
| 104 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 105 | { | ||
| 106 | // MACRODOWN only works in this function | ||
| 107 | switch(id) { | ||
| 108 | } | ||
| 109 | return MACRO_NONE; | ||
| 110 | }; | ||
| 111 | |||
| 112 | |||
| 113 | void matrix_init_user(void) { | 103 | void matrix_init_user(void) { |
| 114 | // This keymap only has a single base layer, so reset the default if needed | 104 | // This keymap only has a single base layer, so reset the default if needed |
| 115 | if(eeconfig_read_default_layer() > 1){ | 105 | if(eeconfig_read_default_layer() > 1){ |
| @@ -117,15 +107,3 @@ void matrix_init_user(void) { | |||
| 117 | default_layer_set(1); | 107 | default_layer_set(1); |
| 118 | } | 108 | } |
| 119 | } | 109 | } |
| 120 | |||
| 121 | void matrix_scan_user(void) { | ||
| 122 | |||
| 123 | } | ||
| 124 | |||
| 125 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 126 | return true; | ||
| 127 | } | ||
| 128 | |||
| 129 | void led_set_user(uint8_t usb_led) { | ||
| 130 | |||
| 131 | } | ||
diff --git a/keyboards/lfkeyboards/mini1800/keymaps/ca178858/keymap.c b/keyboards/lfkeyboards/mini1800/keymaps/ca178858/keymap.c index eadc6eb59..479862fe7 100644 --- a/keyboards/lfkeyboards/mini1800/keymaps/ca178858/keymap.c +++ b/keyboards/lfkeyboards/mini1800/keymaps/ca178858/keymap.c | |||
| @@ -120,16 +120,6 @@ const uint16_t PROGMEM fn_actions[] = { | |||
| 120 | ACTION_FUNCTION(LFK_CLICK_TOGGLE), // FN5 - Toggle audio click | 120 | ACTION_FUNCTION(LFK_CLICK_TOGGLE), // FN5 - Toggle audio click |
| 121 | }; | 121 | }; |
| 122 | 122 | ||
| 123 | |||
| 124 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 125 | { | ||
| 126 | // MACRODOWN only works in this function | ||
| 127 | switch(id) { | ||
| 128 | } | ||
| 129 | return MACRO_NONE; | ||
| 130 | }; | ||
| 131 | |||
| 132 | |||
| 133 | void matrix_init_user(void) { | 123 | void matrix_init_user(void) { |
| 134 | // This keymap only has a single base layer, so reset the default if needed | 124 | // This keymap only has a single base layer, so reset the default if needed |
| 135 | if(eeconfig_read_default_layer() > 1){ | 125 | if(eeconfig_read_default_layer() > 1){ |
| @@ -137,15 +127,3 @@ void matrix_init_user(void) { | |||
| 137 | default_layer_set(1); | 127 | default_layer_set(1); |
| 138 | } | 128 | } |
| 139 | } | 129 | } |
| 140 | |||
| 141 | void matrix_scan_user(void) { | ||
| 142 | |||
| 143 | } | ||
| 144 | |||
| 145 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 146 | return true; | ||
| 147 | } | ||
| 148 | |||
| 149 | void led_set_user(uint8_t usb_led) { | ||
| 150 | |||
| 151 | } | ||
diff --git a/keyboards/mechmini/v2/keymaps/625_space/keymap.c b/keyboards/mechmini/v2/keymaps/625_space/keymap.c index 60d4d32d1..0746b8aec 100755 --- a/keyboards/mechmini/v2/keymaps/625_space/keymap.c +++ b/keyboards/mechmini/v2/keymaps/625_space/keymap.c | |||
| @@ -28,59 +28,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 28 | 28 | ||
| 29 | }; | 29 | }; |
| 30 | 30 | ||
| 31 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 32 | |||
| 33 | |||
| 34 | switch (id) { | ||
| 35 | |||
| 36 | } | ||
| 37 | return MACRO_NONE; | ||
| 38 | } | ||
| 39 | |||
| 40 | void matrix_init_user(void) { | ||
| 41 | } | ||
| 42 | |||
| 43 | void matrix_scan_user(void) { | ||
| 44 | } | ||
| 45 | |||
| 46 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 47 | return true; | ||
| 48 | } | ||
| 49 | |||
| 50 | void led_set_user(uint8_t usb_led) { | ||
| 51 | |||
| 52 | if (usb_led & (1 << USB_LED_NUM_LOCK)) { | ||
| 53 | |||
| 54 | } else { | ||
| 55 | |||
| 56 | } | ||
| 57 | |||
| 58 | if (usb_led & (1 << USB_LED_CAPS_LOCK)) { | ||
| 59 | |||
| 60 | } else { | ||
| 61 | |||
| 62 | } | ||
| 63 | |||
| 64 | if (usb_led & (1 << USB_LED_SCROLL_LOCK)) { | ||
| 65 | |||
| 66 | } else { | ||
| 67 | |||
| 68 | } | ||
| 69 | |||
| 70 | if (usb_led & (1 << USB_LED_COMPOSE)) { | ||
| 71 | |||
| 72 | } else { | ||
| 73 | |||
| 74 | } | ||
| 75 | |||
| 76 | if (usb_led & (1 << USB_LED_KANA)) { | ||
| 77 | |||
| 78 | } else { | ||
| 79 | |||
| 80 | } | ||
| 81 | |||
| 82 | } | ||
| 83 | |||
| 84 | enum function_id { | 31 | enum function_id { |
| 85 | SHIFT_ESC, | 32 | SHIFT_ESC, |
| 86 | }; | 33 | }; |
diff --git a/keyboards/mechmini/v2/keymaps/split_space/keymap.c b/keyboards/mechmini/v2/keymaps/split_space/keymap.c index e35f25ee4..e332c641a 100755 --- a/keyboards/mechmini/v2/keymaps/split_space/keymap.c +++ b/keyboards/mechmini/v2/keymaps/split_space/keymap.c | |||
| @@ -27,59 +27,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 27 | 27 | ||
| 28 | }; | 28 | }; |
| 29 | 29 | ||
| 30 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 31 | |||
| 32 | |||
| 33 | switch (id) { | ||
| 34 | |||
| 35 | } | ||
| 36 | return MACRO_NONE; | ||
| 37 | } | ||
| 38 | |||
| 39 | void matrix_init_user(void) { | ||
| 40 | } | ||
| 41 | |||
| 42 | void matrix_scan_user(void) { | ||
| 43 | } | ||
| 44 | |||
| 45 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 46 | return true; | ||
| 47 | } | ||
| 48 | |||
| 49 | void led_set_user(uint8_t usb_led) { | ||
| 50 | |||
| 51 | if (usb_led & (1 << USB_LED_NUM_LOCK)) { | ||
| 52 | |||
| 53 | } else { | ||
| 54 | |||
| 55 | } | ||
| 56 | |||
| 57 | if (usb_led & (1 << USB_LED_CAPS_LOCK)) { | ||
| 58 | |||
| 59 | } else { | ||
| 60 | |||
| 61 | } | ||
| 62 | |||
| 63 | if (usb_led & (1 << USB_LED_SCROLL_LOCK)) { | ||
| 64 | |||
| 65 | } else { | ||
| 66 | |||
| 67 | } | ||
| 68 | |||
| 69 | if (usb_led & (1 << USB_LED_COMPOSE)) { | ||
| 70 | |||
| 71 | } else { | ||
| 72 | |||
| 73 | } | ||
| 74 | |||
| 75 | if (usb_led & (1 << USB_LED_KANA)) { | ||
| 76 | |||
| 77 | } else { | ||
| 78 | |||
| 79 | } | ||
| 80 | |||
| 81 | } | ||
| 82 | |||
| 83 | enum function_id { | 30 | enum function_id { |
| 84 | SHIFT_ESC, | 31 | SHIFT_ESC, |
| 85 | }; | 32 | }; |
diff --git a/keyboards/meira/keymaps/cole/keymap.c b/keyboards/meira/keymaps/cole/keymap.c index 71c8d9711..14581aa57 100644 --- a/keyboards/meira/keymaps/cole/keymap.c +++ b/keyboards/meira/keymaps/cole/keymap.c | |||
| @@ -130,30 +130,6 @@ void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) { | |||
| 130 | } | 130 | } |
| 131 | } | 131 | } |
| 132 | 132 | ||
| 133 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 134 | { | ||
| 135 | // MACRODOWN only works in this function | ||
| 136 | switch(id) { | ||
| 137 | case 0: | ||
| 138 | if (record->event.pressed) { | ||
| 139 | register_code(KC_RSFT); | ||
| 140 | } else { | ||
| 141 | unregister_code(KC_RSFT); | ||
| 142 | } | ||
| 143 | break; | ||
| 144 | } | ||
| 145 | return MACRO_NONE; | ||
| 146 | }; | ||
| 147 | |||
| 148 | |||
| 149 | void matrix_init_user(void) { | ||
| 150 | |||
| 151 | } | ||
| 152 | |||
| 153 | void matrix_scan_user(void) { | ||
| 154 | |||
| 155 | } | ||
| 156 | |||
| 157 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 133 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 158 | switch (keycode) { | 134 | switch (keycode) { |
| 159 | case LOWER: | 135 | case LOWER: |
diff --git a/keyboards/meira/keymaps/grahampheath/keymap.c b/keyboards/meira/keymaps/grahampheath/keymap.c index ace172a2a..ca47b8913 100644 --- a/keyboards/meira/keymaps/grahampheath/keymap.c +++ b/keyboards/meira/keymaps/grahampheath/keymap.c | |||
| @@ -204,21 +204,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 204 | ) | 204 | ) |
| 205 | }; | 205 | }; |
| 206 | 206 | ||
| 207 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 208 | { | ||
| 209 | // MACRODOWN only works in this function | ||
| 210 | switch(id) { | ||
| 211 | case 0: | ||
| 212 | if (record->event.pressed) { | ||
| 213 | register_code(KC_RSFT); | ||
| 214 | } else { | ||
| 215 | unregister_code(KC_RSFT); | ||
| 216 | } | ||
| 217 | break; | ||
| 218 | } | ||
| 219 | return MACRO_NONE; | ||
| 220 | }; | ||
| 221 | |||
| 222 | #ifdef AUDIO_ENABLE | 207 | #ifdef AUDIO_ENABLE |
| 223 | 208 | ||
| 224 | float tone_qwerty[][2] = SONG(QWERTY_SOUND); | 209 | float tone_qwerty[][2] = SONG(QWERTY_SOUND); |
| @@ -230,14 +215,6 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | |||
| 230 | float plover_gb_song[][2] = SONG(PLOVER_GOODBYE_SOUND); | 215 | float plover_gb_song[][2] = SONG(PLOVER_GOODBYE_SOUND); |
| 231 | #endif | 216 | #endif |
| 232 | 217 | ||
| 233 | void matrix_init_user(void) { | ||
| 234 | |||
| 235 | } | ||
| 236 | |||
| 237 | void matrix_scan_user(void) { | ||
| 238 | |||
| 239 | } | ||
| 240 | |||
| 241 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 218 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 242 | switch (keycode) { | 219 | switch (keycode) { |
| 243 | case QWERTY: | 220 | case QWERTY: |
diff --git a/keyboards/meira/keymaps/takmiya/keymap.c b/keyboards/meira/keymaps/takmiya/keymap.c index bf693d8ad..171b4f43a 100644 --- a/keyboards/meira/keymaps/takmiya/keymap.c +++ b/keyboards/meira/keymaps/takmiya/keymap.c | |||
| @@ -124,30 +124,6 @@ void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) { | |||
| 124 | } | 124 | } |
| 125 | } | 125 | } |
| 126 | 126 | ||
| 127 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 128 | { | ||
| 129 | // MACRODOWN only works in this function | ||
| 130 | switch(id) { | ||
| 131 | case 0: | ||
| 132 | if (record->event.pressed) { | ||
| 133 | register_code(KC_RSFT); | ||
| 134 | } else { | ||
| 135 | unregister_code(KC_RSFT); | ||
| 136 | } | ||
| 137 | break; | ||
| 138 | } | ||
| 139 | return MACRO_NONE; | ||
| 140 | }; | ||
| 141 | |||
| 142 | |||
| 143 | void matrix_init_user(void) { | ||
| 144 | |||
| 145 | } | ||
| 146 | |||
| 147 | void matrix_scan_user(void) { | ||
| 148 | |||
| 149 | } | ||
| 150 | |||
| 151 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 127 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 152 | switch (keycode) { | 128 | switch (keycode) { |
| 153 | case QWERTY: | 129 | case QWERTY: |
diff --git a/keyboards/melody96/keymaps/crilith/keymap.c b/keyboards/melody96/keymaps/crilith/keymap.c index 4c5e27668..40ae69143 100644 --- a/keyboards/melody96/keymaps/crilith/keymap.c +++ b/keyboards/melody96/keymaps/crilith/keymap.c | |||
| @@ -30,16 +30,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 30 | _______, _______, _______, KC_PLAY, _______, KC_REC, KC_DONE, _______, _______, _______, _______, _______, _______), | 30 | _______, _______, _______, KC_PLAY, _______, KC_REC, KC_DONE, _______, _______, _______, _______, _______, _______), |
| 31 | }; | 31 | }; |
| 32 | 32 | ||
| 33 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 34 | return MACRO_NONE; | ||
| 35 | } | ||
| 36 | |||
| 37 | void matrix_init_user(void) { | ||
| 38 | } | ||
| 39 | |||
| 40 | void matrix_scan_user(void) { | ||
| 41 | } | ||
| 42 | |||
| 43 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 33 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 44 | if (!process_record_dynamic_macro(keycode, record)) { | 34 | if (!process_record_dynamic_macro(keycode, record)) { |
| 45 | return false; | 35 | return false; |
diff --git a/keyboards/mint60/keymaps/eucalyn/keymap.c b/keyboards/mint60/keymaps/eucalyn/keymap.c index 93979a131..b7e658091 100644 --- a/keyboards/mint60/keymaps/eucalyn/keymap.c +++ b/keyboards/mint60/keymaps/eucalyn/keymap.c | |||
| @@ -52,22 +52,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 52 | bool TOG_STATUS = false; | 52 | bool TOG_STATUS = false; |
| 53 | int RGB_current_mode; | 53 | int RGB_current_mode; |
| 54 | 54 | ||
| 55 | |||
| 56 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 57 | { | ||
| 58 | // MACRODOWN only works in this function | ||
| 59 | switch(id) { | ||
| 60 | case 0: | ||
| 61 | if (record->event.pressed) { | ||
| 62 | register_code(KC_RSFT); | ||
| 63 | } else { | ||
| 64 | unregister_code(KC_RSFT); | ||
| 65 | } | ||
| 66 | break; | ||
| 67 | } | ||
| 68 | return MACRO_NONE; | ||
| 69 | }; | ||
| 70 | |||
| 71 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | 55 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { |
| 72 | switch (keycode) { | 56 | switch (keycode) { |
| 73 | case RGBRST: | 57 | case RGBRST: |
| @@ -82,15 +66,3 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 82 | } | 66 | } |
| 83 | return true; | 67 | return true; |
| 84 | } | 68 | } |
| 85 | |||
| 86 | void matrix_init_user(void) { | ||
| 87 | |||
| 88 | } | ||
| 89 | |||
| 90 | void matrix_scan_user(void) { | ||
| 91 | |||
| 92 | } | ||
| 93 | |||
| 94 | void led_set_user(uint8_t usb_led) { | ||
| 95 | |||
| 96 | } | ||
diff --git a/keyboards/miuni32/keymaps/adam-lee/keymap.c b/keyboards/miuni32/keymaps/adam-lee/keymap.c index 754c20f7d..87519de54 100644 --- a/keyboards/miuni32/keymaps/adam-lee/keymap.c +++ b/keyboards/miuni32/keymaps/adam-lee/keymap.c | |||
| @@ -58,62 +58,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 58 | _______, _______, _______, _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12 | 58 | _______, _______, _______, _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12 |
| 59 | ) | 59 | ) |
| 60 | }; | 60 | }; |
| 61 | |||
| 62 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 63 | { | ||
| 64 | // MACRODOWN only works in this function | ||
| 65 | switch(id) { | ||
| 66 | case 0: | ||
| 67 | if (record->event.pressed) { | ||
| 68 | register_code(KC_RSFT); | ||
| 69 | } else { | ||
| 70 | unregister_code(KC_RSFT); | ||
| 71 | } | ||
| 72 | break; | ||
| 73 | } | ||
| 74 | return MACRO_NONE; | ||
| 75 | }; | ||
| 76 | |||
| 77 | void matrix_init_user(void) { | ||
| 78 | } | ||
| 79 | |||
| 80 | void matrix_scan_user(void) { | ||
| 81 | } | ||
| 82 | |||
| 83 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 84 | return true; | ||
| 85 | } | ||
| 86 | |||
| 87 | void led_set_user(uint8_t usb_led) { | ||
| 88 | |||
| 89 | if (usb_led & (1 << USB_LED_NUM_LOCK)) { | ||
| 90 | |||
| 91 | } else { | ||
| 92 | |||
| 93 | } | ||
| 94 | |||
| 95 | if (usb_led & (1 << USB_LED_CAPS_LOCK)) { | ||
| 96 | |||
| 97 | } else { | ||
| 98 | |||
| 99 | } | ||
| 100 | |||
| 101 | if (usb_led & (1 << USB_LED_SCROLL_LOCK)) { | ||
| 102 | |||
| 103 | } else { | ||
| 104 | |||
| 105 | } | ||
| 106 | |||
| 107 | if (usb_led & (1 << USB_LED_COMPOSE)) { | ||
| 108 | |||
| 109 | } else { | ||
| 110 | |||
| 111 | } | ||
| 112 | |||
| 113 | if (usb_led & (1 << USB_LED_KANA)) { | ||
| 114 | |||
| 115 | } else { | ||
| 116 | |||
| 117 | } | ||
| 118 | |||
| 119 | } | ||
diff --git a/keyboards/novelpad/keymaps/0xdec/keymap.c b/keyboards/novelpad/keymaps/0xdec/keymap.c index 429e6c5b3..bb8c977c9 100755 --- a/keyboards/novelpad/keymaps/0xdec/keymap.c +++ b/keyboards/novelpad/keymaps/0xdec/keymap.c | |||
| @@ -36,19 +36,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 36 | 36 | ||
| 37 | }; | 37 | }; |
| 38 | 38 | ||
| 39 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 40 | return MACRO_NONE; | ||
| 41 | } | ||
| 42 | |||
| 43 | void matrix_init_user(void) {} | ||
| 44 | |||
| 45 | void matrix_scan_user(void) {} | ||
| 46 | |||
| 47 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 48 | switch (keycode) {} | ||
| 49 | return true; | ||
| 50 | } | ||
| 51 | |||
| 52 | void led_set_user(uint8_t usb_led) { | 39 | void led_set_user(uint8_t usb_led) { |
| 53 | if (usb_led & (1 << USB_LED_NUM_LOCK)) { | 40 | if (usb_led & (1 << USB_LED_NUM_LOCK)) { |
| 54 | // Illuminate the LED under the Num Lock key | 41 | // Illuminate the LED under the Num Lock key |
diff --git a/keyboards/planck/keymaps/bone2planck/keymap.c b/keyboards/planck/keymaps/bone2planck/keymap.c index 81ba356d3..18b71bfc4 100644 --- a/keyboards/planck/keymaps/bone2planck/keymap.c +++ b/keyboards/planck/keymaps/bone2planck/keymap.c | |||
| @@ -133,22 +133,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 133 | _______, _______, _______, XXXXXXX, _______, _______, _______, _______, XXXXXXX, _______, _______, _______ | 133 | _______, _______, _______, XXXXXXX, _______, _______, _______, _______, XXXXXXX, _______, _______, _______ |
| 134 | ) | 134 | ) |
| 135 | }; | 135 | }; |
| 136 | |||
| 137 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 138 | { | ||
| 139 | // MACRODOWN only works in this function | ||
| 140 | switch (id) { | ||
| 141 | case 0: | ||
| 142 | if (record->event.pressed) { | ||
| 143 | register_code(KC_RSFT); | ||
| 144 | #ifdef BACKLIGHT_ENABLE | ||
| 145 | backlight_step(); | ||
| 146 | #endif | ||
| 147 | } | ||
| 148 | else { | ||
| 149 | unregister_code(KC_RSFT); | ||
| 150 | } | ||
| 151 | break; | ||
| 152 | } | ||
| 153 | return MACRO_NONE; | ||
| 154 | }; | ||
diff --git a/keyboards/planck/keymaps/dc/keymap.c b/keyboards/planck/keymaps/dc/keymap.c index cab66434c..fdafd03a5 100644 --- a/keyboards/planck/keymaps/dc/keymap.c +++ b/keyboards/planck/keymaps/dc/keymap.c | |||
| @@ -26,15 +26,6 @@ enum tap_dance_codes { | |||
| 26 | CT_DEL_ESC | 26 | CT_DEL_ESC |
| 27 | }; | 27 | }; |
| 28 | 28 | ||
| 29 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 30 | //keyevent_t event = record->event; | ||
| 31 | |||
| 32 | switch (id) { | ||
| 33 | |||
| 34 | } | ||
| 35 | return MACRO_NONE; | ||
| 36 | } | ||
| 37 | |||
| 38 | qk_tap_dance_action_t tap_dance_actions[] = { | 29 | qk_tap_dance_action_t tap_dance_actions[] = { |
| 39 | [0] = ACTION_TAP_DANCE_DOUBLE(KC_SCLN, KC_LPRN), | 30 | [0] = ACTION_TAP_DANCE_DOUBLE(KC_SCLN, KC_LPRN), |
| 40 | [1] = ACTION_TAP_DANCE_DOUBLE(KC_Q, KC_LCBR), | 31 | [1] = ACTION_TAP_DANCE_DOUBLE(KC_Q, KC_LCBR), |
diff --git a/keyboards/planck/keymaps/gabriel/keymap.c b/keyboards/planck/keymaps/gabriel/keymap.c index d0f792c31..9e56724c1 100644 --- a/keyboards/planck/keymaps/gabriel/keymap.c +++ b/keyboards/planck/keymaps/gabriel/keymap.c | |||
| @@ -86,19 +86,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 86 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_PGDN, KC_PGUP, KC_END | 86 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_PGDN, KC_PGUP, KC_END |
| 87 | ) | 87 | ) |
| 88 | }; | 88 | }; |
| 89 | |||
| 90 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 91 | { | ||
| 92 | // MACRODOWN only works in this function | ||
| 93 | switch(id) { | ||
| 94 | case 0: | ||
| 95 | if (record->event.pressed) { | ||
| 96 | register_code(KC_RSFT); | ||
| 97 | backlight_step(); | ||
| 98 | } else { | ||
| 99 | unregister_code(KC_RSFT); | ||
| 100 | } | ||
| 101 | break; | ||
| 102 | } | ||
| 103 | return MACRO_NONE; | ||
| 104 | }; | ||
diff --git a/keyboards/planck/keymaps/johannes/keymap.c b/keyboards/planck/keymaps/johannes/keymap.c index 274a3b57f..294bfd85a 100644 --- a/keyboards/planck/keymaps/johannes/keymap.c +++ b/keyboards/planck/keymaps/johannes/keymap.c | |||
| @@ -85,8 +85,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 85 | ), | 85 | ), |
| 86 | 86 | ||
| 87 | }; | 87 | }; |
| 88 | |||
| 89 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 90 | { | ||
| 91 | return MACRO_NONE; | ||
| 92 | }; | ||
diff --git a/keyboards/planck/keymaps/matrixman/keymap.c b/keyboards/planck/keymaps/matrixman/keymap.c index 7525e345b..f13198cfa 100644 --- a/keyboards/planck/keymaps/matrixman/keymap.c +++ b/keyboards/planck/keymaps/matrixman/keymap.c | |||
| @@ -52,21 +52,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 52 | ,KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS | 52 | ,KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS |
| 53 | ) | 53 | ) |
| 54 | }; | 54 | }; |
| 55 | |||
| 56 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 57 | { | ||
| 58 | // MACRODOWN only works in this function | ||
| 59 | switch(id) { | ||
| 60 | case 0: | ||
| 61 | if (record->event.pressed) { | ||
| 62 | register_code(KC_RSFT); | ||
| 63 | #ifdef BACKLIGHT_ENABLE | ||
| 64 | backlight_step(); | ||
| 65 | #endif | ||
| 66 | } else { | ||
| 67 | unregister_code(KC_RSFT); | ||
| 68 | } | ||
| 69 | break; | ||
| 70 | } | ||
| 71 | return MACRO_NONE; | ||
| 72 | }; | ||
diff --git a/keyboards/planck/keymaps/neo2planck/keymap.c b/keyboards/planck/keymaps/neo2planck/keymap.c index 6579ad9bc..d09103c1e 100644 --- a/keyboards/planck/keymaps/neo2planck/keymap.c +++ b/keyboards/planck/keymaps/neo2planck/keymap.c | |||
| @@ -88,22 +88,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 88 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ | 88 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ |
| 89 | ), | 89 | ), |
| 90 | }; | 90 | }; |
| 91 | |||
| 92 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 93 | { | ||
| 94 | // MACRODOWN only works in this function | ||
| 95 | switch (id) { | ||
| 96 | case 0: | ||
| 97 | if (record->event.pressed) { | ||
| 98 | register_code(KC_RSFT); | ||
| 99 | #ifdef BACKLIGHT_ENABLE | ||
| 100 | backlight_step(); | ||
| 101 | #endif | ||
| 102 | } | ||
| 103 | else { | ||
| 104 | unregister_code(KC_RSFT); | ||
| 105 | } | ||
| 106 | break; | ||
| 107 | } | ||
| 108 | return MACRO_NONE; | ||
| 109 | }; | ||
diff --git a/keyboards/planck/keymaps/vifon/keymap.c b/keyboards/planck/keymaps/vifon/keymap.c index 6398accc2..9f4ee9d21 100644 --- a/keyboards/planck/keymaps/vifon/keymap.c +++ b/keyboards/planck/keymaps/vifon/keymap.c | |||
| @@ -207,8 +207,3 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| 207 | 207 | ||
| 208 | return true; | 208 | return true; |
| 209 | } | 209 | } |
| 210 | |||
| 211 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 212 | { | ||
| 213 | return MACRO_NONE; | ||
| 214 | } | ||
diff --git a/keyboards/rominronin/katana60/rev1/keymaps/colemak/keymap.c b/keyboards/rominronin/katana60/rev1/keymaps/colemak/keymap.c index 91128bd5c..bb1752ba1 100644 --- a/keyboards/rominronin/katana60/rev1/keymaps/colemak/keymap.c +++ b/keyboards/rominronin/katana60/rev1/keymaps/colemak/keymap.c | |||
| @@ -63,35 +63,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 63 | ) | 63 | ) |
| 64 | 64 | ||
| 65 | }; | 65 | }; |
| 66 | |||
| 67 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 68 | { | ||
| 69 | // MACRODOWN only works in this function | ||
| 70 | switch(id) { | ||
| 71 | case 0: | ||
| 72 | if (record->event.pressed) { | ||
| 73 | register_code(KC_RSFT); | ||
| 74 | } else { | ||
| 75 | unregister_code(KC_RSFT); | ||
| 76 | } | ||
| 77 | break; | ||
| 78 | } | ||
| 79 | return MACRO_NONE; | ||
| 80 | }; | ||
| 81 | |||
| 82 | |||
| 83 | void matrix_init_user(void) { | ||
| 84 | |||
| 85 | } | ||
| 86 | |||
| 87 | void matrix_scan_user(void) { | ||
| 88 | |||
| 89 | } | ||
| 90 | |||
| 91 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { | ||
| 92 | return true; | ||
| 93 | } | ||
| 94 | |||
| 95 | void led_set_user(uint8_t usb_led) { | ||
| 96 | |||
| 97 | } | ||
diff --git a/keyboards/sentraq/s60_x/keymaps/dbroqua/keymap.c b/keyboards/sentraq/s60_x/keymaps/dbroqua/keymap.c index 71cf93f00..944ba7555 100644 --- a/keyboards/sentraq/s60_x/keymaps/dbroqua/keymap.c +++ b/keyboards/sentraq/s60_x/keymaps/dbroqua/keymap.c | |||
| @@ -73,10 +73,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 73 | ) | 73 | ) |
| 74 | }; | 74 | }; |
| 75 | 75 | ||
| 76 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 77 | return MACRO_NONE; | ||
| 78 | } | ||
| 79 | |||
| 80 | enum function_id { | 76 | enum function_id { |
| 81 | RGBLED_TOGGLE, | 77 | RGBLED_TOGGLE, |
| 82 | RGBLED_STEP_MODE, | 78 | RGBLED_STEP_MODE, |
diff --git a/keyboards/staryu/keymaps/krusli/keymap.c b/keyboards/staryu/keymaps/krusli/keymap.c index cdfa9fe8f..9cd1cf829 100644 --- a/keyboards/staryu/keymaps/krusli/keymap.c +++ b/keyboards/staryu/keymaps/krusli/keymap.c | |||
| @@ -77,18 +77,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 77 | ) | 77 | ) |
| 78 | }; | 78 | }; |
| 79 | 79 | ||
| 80 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 81 | return MACRO_NONE ; | ||
| 82 | } | ||
| 83 | |||
| 84 | void matrix_init_user(void) { | 80 | void matrix_init_user(void) { |
| 85 | for (int i=0; i<5; i++) { | 81 | for (int i=0; i<5; i++) { |
| 86 | backlight_led_on(i); | 82 | backlight_led_on(i); |
| 87 | } | 83 | } |
| 88 | } | 84 | } |
| 89 | |||
| 90 | void matrix_scan_user(void) { | ||
| 91 | } | ||
| 92 | |||
| 93 | void led_set_user(uint8_t usb_led) { | ||
| 94 | } | ||
diff --git a/keyboards/v60_type_r/keymaps/vimouse/keymap.c b/keyboards/v60_type_r/keymaps/vimouse/keymap.c index 8b0019e7b..74e4b1309 100644 --- a/keyboards/v60_type_r/keymaps/vimouse/keymap.c +++ b/keyboards/v60_type_r/keymaps/vimouse/keymap.c | |||
| @@ -97,22 +97,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 97 | _____, _____, _____, _____, _____, _____, _____, _____), | 97 | _____, _____, _____, _____, _____, _____, _____, _____), |
| 98 | }; | 98 | }; |
| 99 | 99 | ||
| 100 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 101 | { | ||
| 102 | // MACRODOWN only works in this function | ||
| 103 | switch(id) { | ||
| 104 | case 0: | ||
| 105 | if (record->event.pressed) { | ||
| 106 | register_code(KC_RSFT); | ||
| 107 | } else { | ||
| 108 | unregister_code(KC_RSFT); | ||
| 109 | } | ||
| 110 | break; | ||
| 111 | } | ||
| 112 | return MACRO_NONE; | ||
| 113 | }; | ||
| 114 | |||
| 115 | |||
| 116 | void led_set_user(uint8_t usb_led) { | 100 | void led_set_user(uint8_t usb_led) { |
| 117 | if (usb_led & (1<<USB_LED_CAPS_LOCK)) { | 101 | if (usb_led & (1<<USB_LED_CAPS_LOCK)) { |
| 118 | // output low | 102 | // output low |
diff --git a/keyboards/xd60/keymaps/Jos/keymap.c b/keyboards/xd60/keymaps/Jos/keymap.c index 250becf74..c57f634f2 100644 --- a/keyboards/xd60/keymaps/Jos/keymap.c +++ b/keyboards/xd60/keymaps/Jos/keymap.c | |||
| @@ -74,26 +74,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 74 | / KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), */ | 74 | / KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), */ |
| 75 | }; | 75 | }; |
| 76 | 76 | ||
| 77 | // Macros | ||
| 78 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 79 | |||
| 80 | // MACRODOWN only works in this function | ||
| 81 | switch(id) { | ||
| 82 | case 0: | ||
| 83 | if (record->event.pressed) { register_code(KC_RSFT); } | ||
| 84 | else { unregister_code(KC_RSFT); } | ||
| 85 | break; | ||
| 86 | } | ||
| 87 | |||
| 88 | return MACRO_NONE; | ||
| 89 | }; | ||
| 90 | |||
| 91 | |||
| 92 | // Loop | ||
| 93 | void matrix_scan_user(void) { | ||
| 94 | // Empty | ||
| 95 | }; | ||
| 96 | |||
| 97 | // LGUI acts as F(1) if held or as a tapped LGUI if tapped. Adapted from https://goo.gl/WnqGNS | 77 | // LGUI acts as F(1) if held or as a tapped LGUI if tapped. Adapted from https://goo.gl/WnqGNS |
| 98 | // Commented lines are for the "sticky" layer on two presses. Left it here for reference. | 78 | // Commented lines are for the "sticky" layer on two presses. Left it here for reference. |
| 99 | static const int GUILAY = 2; // GUI Layer is layer #2 | 79 | static const int GUILAY = 2; // GUI Layer is layer #2 |
diff --git a/keyboards/xd60/keymaps/birkir/keymap.c b/keyboards/xd60/keymaps/birkir/keymap.c index 52f7086f2..560445054 100644 --- a/keyboards/xd60/keymaps/birkir/keymap.c +++ b/keyboards/xd60/keymaps/birkir/keymap.c | |||
| @@ -31,25 +31,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 31 | ) | 31 | ) |
| 32 | }; | 32 | }; |
| 33 | 33 | ||
| 34 | // Macros | ||
| 35 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 36 | |||
| 37 | // MACRODOWN only works in this function | ||
| 38 | switch(id) { | ||
| 39 | case 0: | ||
| 40 | if (record->event.pressed) { register_code(KC_RSFT); } | ||
| 41 | else { unregister_code(KC_RSFT); } | ||
| 42 | break; | ||
| 43 | } | ||
| 44 | |||
| 45 | return MACRO_NONE; | ||
| 46 | }; | ||
| 47 | |||
| 48 | // Loop | ||
| 49 | void matrix_scan_user(void) { | ||
| 50 | // empty | ||
| 51 | }; | ||
| 52 | |||
| 53 | bool edit = false; | 34 | bool edit = false; |
| 54 | uint32_t mode; | 35 | uint32_t mode; |
| 55 | uint16_t hue; | 36 | uint16_t hue; |
diff --git a/keyboards/xd60/keymaps/edulpn/keymap.c b/keyboards/xd60/keymaps/edulpn/keymap.c index 88032a384..e064dfb68 100644 --- a/keyboards/xd60/keymaps/edulpn/keymap.c +++ b/keyboards/xd60/keymaps/edulpn/keymap.c | |||
| @@ -20,22 +20,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 20 | KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, MO(1), KC_NO, KC_RGUI, KC_RCTL), | 20 | KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, MO(1), KC_NO, KC_RGUI, KC_RCTL), |
| 21 | 21 | ||
| 22 | }; | 22 | }; |
| 23 | |||
| 24 | // Macros | ||
| 25 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 26 | |||
| 27 | // MACRODOWN only works in this function | ||
| 28 | switch(id) { | ||
| 29 | case 0: | ||
| 30 | if (record->event.pressed) { register_code(KC_RSFT); } | ||
| 31 | else { unregister_code(KC_RSFT); } | ||
| 32 | break; | ||
| 33 | } | ||
| 34 | |||
| 35 | return MACRO_NONE; | ||
| 36 | }; | ||
| 37 | |||
| 38 | // Loop | ||
| 39 | void matrix_scan_user(void) { | ||
| 40 | // Empty | ||
| 41 | }; | ||
diff --git a/keyboards/xd60/keymaps/edulpn64/keymap.c b/keyboards/xd60/keymaps/edulpn64/keymap.c index d1ad6f1b6..189fcde17 100644 --- a/keyboards/xd60/keymaps/edulpn64/keymap.c +++ b/keyboards/xd60/keymaps/edulpn64/keymap.c | |||
| @@ -20,22 +20,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 20 | KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, MO(1), KC_RCTRL, KC_LEFT, KC_DOWN, KC_RIGHT), | 20 | KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, MO(1), KC_RCTRL, KC_LEFT, KC_DOWN, KC_RIGHT), |
| 21 | 21 | ||
| 22 | }; | 22 | }; |
| 23 | |||
| 24 | // Macros | ||
| 25 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 26 | |||
| 27 | // MACRODOWN only works in this function | ||
| 28 | switch(id) { | ||
| 29 | case 0: | ||
| 30 | if (record->event.pressed) { register_code(KC_RSFT); } | ||
| 31 | else { unregister_code(KC_RSFT); } | ||
| 32 | break; | ||
| 33 | } | ||
| 34 | |||
| 35 | return MACRO_NONE; | ||
| 36 | }; | ||
| 37 | |||
| 38 | // Loop | ||
| 39 | void matrix_scan_user(void) { | ||
| 40 | // Empty | ||
| 41 | }; | ||
diff --git a/keyboards/xd60/keymaps/kmontag42/keymap.c b/keyboards/xd60/keymaps/kmontag42/keymap.c index e23aef589..8e081c673 100644 --- a/keyboards/xd60/keymaps/kmontag42/keymap.c +++ b/keyboards/xd60/keymaps/kmontag42/keymap.c | |||
| @@ -22,23 +22,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 22 | 22 | ||
| 23 | }; | 23 | }; |
| 24 | 24 | ||
| 25 | // Macros | ||
| 26 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 27 | |||
| 28 | // MACRODOWN only works in this function | ||
| 29 | switch(id) { | ||
| 30 | case 0: | ||
| 31 | if (record->event.pressed) { | ||
| 32 | register_code(KC_RSFT); | ||
| 33 | rgblight_step(); | ||
| 34 | } | ||
| 35 | else { unregister_code(KC_RSFT); } | ||
| 36 | break; | ||
| 37 | } | ||
| 38 | |||
| 39 | return MACRO_NONE; | ||
| 40 | }; | ||
| 41 | |||
| 42 | // Loop | 25 | // Loop |
| 43 | void matrix_scan_user(void) { | 26 | void matrix_scan_user(void) { |
| 44 | static uint8_t old_layer = 255; | 27 | static uint8_t old_layer = 255; |
diff --git a/keyboards/xd60/keymaps/krusli/keymap.c b/keyboards/xd60/keymaps/krusli/keymap.c index 6b4dfdc33..697d6d7f1 100644 --- a/keyboards/xd60/keymaps/krusli/keymap.c +++ b/keyboards/xd60/keymaps/krusli/keymap.c | |||
| @@ -20,22 +20,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 20 | _______, KC_NO, _______, _______, _______, _______, _______, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, _______, _______, _______, \ | 20 | _______, KC_NO, _______, _______, _______, _______, _______, KC_PPLS, KC_PMNS, KC_END, KC_PGDN, KC_DOWN, _______, _______, _______, \ |
| 21 | _______, _______, _______, _______, _______, _______, _______, _______, _______), | 21 | _______, _______, _______, _______, _______, _______, _______, _______, _______), |
| 22 | }; | 22 | }; |
| 23 | |||
| 24 | // Macros | ||
| 25 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 26 | |||
| 27 | // MACRODOWN only works in this function | ||
| 28 | switch(id) { | ||
| 29 | case 0: | ||
| 30 | if (record->event.pressed) { register_code(KC_RSFT); } | ||
| 31 | else { unregister_code(KC_RSFT); } | ||
| 32 | break; | ||
| 33 | } | ||
| 34 | |||
| 35 | return MACRO_NONE; | ||
| 36 | }; | ||
| 37 | |||
| 38 | // Loop | ||
| 39 | void matrix_scan_user(void) { | ||
| 40 | // Empty | ||
| 41 | }; | ||
diff --git a/keyboards/xd60/keymaps/rooski/keymap.c b/keyboards/xd60/keymaps/rooski/keymap.c index 624c118bf..71d5451dc 100644 --- a/keyboards/xd60/keymaps/rooski/keymap.c +++ b/keyboards/xd60/keymaps/rooski/keymap.c | |||
| @@ -55,25 +55,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 55 | XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, TO(_BL), XXXXXXX, RGB_TOG, RGB_VAD, RGB_MOD), | 55 | XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, TO(_BL), XXXXXXX, RGB_TOG, RGB_VAD, RGB_MOD), |
| 56 | 56 | ||
| 57 | }; | 57 | }; |
| 58 | |||
| 59 | // Macros | ||
| 60 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 61 | |||
| 62 | // MACRODOWN only works in this function | ||
| 63 | switch(id) { | ||
| 64 | case 0: | ||
| 65 | if (record->event.pressed) { | ||
| 66 | register_code(KC_RSFT); | ||
| 67 | backlight_step(); | ||
| 68 | } | ||
| 69 | else { unregister_code(KC_RSFT); } | ||
| 70 | break; | ||
| 71 | } | ||
| 72 | |||
| 73 | return MACRO_NONE; | ||
| 74 | }; | ||
| 75 | |||
| 76 | // Loop | ||
| 77 | void matrix_scan_user(void) { | ||
| 78 | // Empty | ||
| 79 | }; | ||
diff --git a/keyboards/xd60/keymaps/split_bksp_arrows/keymap.c b/keyboards/xd60/keymaps/split_bksp_arrows/keymap.c index 005355cd2..9958cbfc4 100644 --- a/keyboards/xd60/keymaps/split_bksp_arrows/keymap.c +++ b/keyboards/xd60/keymaps/split_bksp_arrows/keymap.c | |||
| @@ -32,22 +32,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 32 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_PGDOWN, KC_END), | 32 | KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_PGDOWN, KC_END), |
| 33 | 33 | ||
| 34 | }; | 34 | }; |
| 35 | |||
| 36 | // Macros | ||
| 37 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 38 | |||
| 39 | // MACRODOWN only works in this function | ||
| 40 | switch(id) { | ||
| 41 | case 0: | ||
| 42 | if (record->event.pressed) { register_code(KC_RSFT); } | ||
| 43 | else { unregister_code(KC_RSFT); } | ||
| 44 | break; | ||
| 45 | } | ||
| 46 | |||
| 47 | return MACRO_NONE; | ||
| 48 | }; | ||
| 49 | |||
| 50 | // Loop | ||
| 51 | void matrix_scan_user(void) { | ||
| 52 | // Empty | ||
| 53 | }; | ||
diff --git a/keyboards/xd60/keymaps/stanleylai/keymap.c b/keyboards/xd60/keymaps/stanleylai/keymap.c index 9d7327ee6..a827744c1 100644 --- a/keyboards/xd60/keymaps/stanleylai/keymap.c +++ b/keyboards/xd60/keymaps/stanleylai/keymap.c | |||
| @@ -28,22 +28,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 28 | KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO), | 28 | KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO), |
| 29 | 29 | ||
| 30 | }; | 30 | }; |
| 31 | |||
| 32 | // Macros | ||
| 33 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 34 | |||
| 35 | // MACRODOWN only works in this function | ||
| 36 | switch(id) { | ||
| 37 | case 0: | ||
| 38 | if (record->event.pressed) { register_code(KC_RSFT); } | ||
| 39 | else { unregister_code(KC_RSFT); } | ||
| 40 | break; | ||
| 41 | } | ||
| 42 | |||
| 43 | return MACRO_NONE; | ||
| 44 | }; | ||
| 45 | |||
| 46 | // Loop | ||
| 47 | void matrix_scan_user(void) { | ||
| 48 | // Empty | ||
| 49 | }; | ||
diff --git a/keyboards/xd60/keymaps/supercoffee/keymap.c b/keyboards/xd60/keymaps/supercoffee/keymap.c index 4bf30398f..c31a948a8 100644 --- a/keyboards/xd60/keymaps/supercoffee/keymap.c +++ b/keyboards/xd60/keymaps/supercoffee/keymap.c | |||
| @@ -20,22 +20,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 20 | KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, MO(1), KC_RALT, KC_NO, KC_RGUI, KC_RCTL), | 20 | KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, MO(1), KC_RALT, KC_NO, KC_RGUI, KC_RCTL), |
| 21 | 21 | ||
| 22 | }; | 22 | }; |
| 23 | |||
| 24 | // Macros | ||
| 25 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { | ||
| 26 | |||
| 27 | // MACRODOWN only works in this function | ||
| 28 | switch(id) { | ||
| 29 | case 0: | ||
| 30 | if (record->event.pressed) { register_code(KC_RSFT); } | ||
| 31 | else { unregister_code(KC_RSFT); } | ||
| 32 | break; | ||
| 33 | } | ||
| 34 | |||
| 35 | return MACRO_NONE; | ||
| 36 | }; | ||
| 37 | |||
| 38 | // Loop | ||
| 39 | void matrix_scan_user(void) { | ||
| 40 | // Empty | ||
| 41 | }; | ||
diff --git a/keyboards/xd75/keymaps/boy_314/keymap.c b/keyboards/xd75/keymaps/boy_314/keymap.c index 01c3a3626..89d6569dd 100644 --- a/keyboards/xd75/keymaps/boy_314/keymap.c +++ b/keyboards/xd75/keymaps/boy_314/keymap.c | |||
| @@ -125,25 +125,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 125 | ) | 125 | ) |
| 126 | }; | 126 | }; |
| 127 | 127 | ||
| 128 | |||
| 129 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 130 | { | ||
| 131 | // MACRODOWN only works in this function | ||
| 132 | switch(id) { | ||
| 133 | case 0: | ||
| 134 | if (record->event.pressed) { | ||
| 135 | register_code(KC_RSFT); | ||
| 136 | #ifdef BACKLIGHT_ENABLE | ||
| 137 | backlight_step(); | ||
| 138 | #endif | ||
| 139 | } else { | ||
| 140 | unregister_code(KC_RSFT); | ||
| 141 | } | ||
| 142 | break; | ||
| 143 | } | ||
| 144 | return MACRO_NONE; | ||
| 145 | }; | ||
| 146 | |||
| 147 | void matrix_init_user(void) { | 128 | void matrix_init_user(void) { |
| 148 | if (!(host_keyboard_leds() & (1<<USB_LED_NUM_LOCK))) { | 129 | if (!(host_keyboard_leds() & (1<<USB_LED_NUM_LOCK))) { |
| 149 | register_code(KC_NUMLOCK); | 130 | register_code(KC_NUMLOCK); |
diff --git a/keyboards/xd75/keymaps/c4software_bepo/keymap.c b/keyboards/xd75/keymaps/c4software_bepo/keymap.c index 0eb202dd3..4571033c0 100644 --- a/keyboards/xd75/keymaps/c4software_bepo/keymap.c +++ b/keyboards/xd75/keymaps/c4software_bepo/keymap.c | |||
| @@ -66,21 +66,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 66 | RESET, KC_TRNS, MO(_FN), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_KP_0, KC_KP_0, KC_PDOT, MO(_FN), KC_TRNS, KC_END, KC_TRNS | 66 | RESET, KC_TRNS, MO(_FN), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_KP_0, KC_KP_0, KC_PDOT, MO(_FN), KC_TRNS, KC_END, KC_TRNS |
| 67 | ) | 67 | ) |
| 68 | }; | 68 | }; |
| 69 | |||
| 70 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 71 | { | ||
| 72 | // MACRODOWN only works in this function | ||
| 73 | switch(id) { | ||
| 74 | case 0: | ||
| 75 | if (record->event.pressed) { | ||
| 76 | register_code(KC_RSFT); | ||
| 77 | #ifdef BACKLIGHT_ENABLE | ||
| 78 | backlight_step(); | ||
| 79 | #endif | ||
| 80 | } else { | ||
| 81 | unregister_code(KC_RSFT); | ||
| 82 | } | ||
| 83 | break; | ||
| 84 | } | ||
| 85 | return MACRO_NONE; | ||
| 86 | }; | ||
diff --git a/keyboards/xd75/keymaps/dyn_macro_tap_dance/keymap.c b/keyboards/xd75/keymaps/dyn_macro_tap_dance/keymap.c index 220c85dde..679684976 100644 --- a/keyboards/xd75/keymaps/dyn_macro_tap_dance/keymap.c +++ b/keyboards/xd75/keymaps/dyn_macro_tap_dance/keymap.c | |||
| @@ -113,21 +113,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 113 | _______, _______, RGB_TOG, MO(_FN), RGB_RMOD,RGB_MOD, KC_P0, _______, KC_PDOT, KC_PENT, KC_PENT, MO(_FN), _______, _______, _______ | 113 | _______, _______, RGB_TOG, MO(_FN), RGB_RMOD,RGB_MOD, KC_P0, _______, KC_PDOT, KC_PENT, KC_PENT, MO(_FN), _______, _______, _______ |
| 114 | ) | 114 | ) |
| 115 | }; | 115 | }; |
| 116 | |||
| 117 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 118 | { | ||
| 119 | // MACRODOWN only works in this function | ||
| 120 | switch(id) { | ||
| 121 | case 0: | ||
| 122 | if (record->event.pressed) { | ||
| 123 | register_code(KC_RSFT); | ||
| 124 | #ifdef BACKLIGHT_ENABLE | ||
| 125 | backlight_step(); | ||
| 126 | #endif | ||
| 127 | } else { | ||
| 128 | unregister_code(KC_RSFT); | ||
| 129 | } | ||
| 130 | break; | ||
| 131 | } | ||
| 132 | return MACRO_NONE; | ||
| 133 | }; | ||
diff --git a/keyboards/xd75/keymaps/kim-kim-xd73/keymap.c b/keyboards/xd75/keymaps/kim-kim-xd73/keymap.c index edbcfe97b..fdcc47cab 100644 --- a/keyboards/xd75/keymaps/kim-kim-xd73/keymap.c +++ b/keyboards/xd75/keymaps/kim-kim-xd73/keymap.c | |||
| @@ -115,21 +115,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 115 | ) | 115 | ) |
| 116 | 116 | ||
| 117 | }; | 117 | }; |
| 118 | |||
| 119 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 120 | { | ||
| 121 | // MACRODOWN only works in this function | ||
| 122 | switch(id) { | ||
| 123 | case 0: | ||
| 124 | if (record->event.pressed) { | ||
| 125 | #ifdef BACKLIGHT_ENABLE | ||
| 126 | |||
| 127 | #endif | ||
| 128 | } else { | ||
| 129 | #ifdef BACKLIGHT_ENABLE | ||
| 130 | |||
| 131 | #endif | ||
| 132 | } | ||
| 133 | } | ||
| 134 | return MACRO_NONE; | ||
| 135 | }; | ||
diff --git a/keyboards/xd75/keymaps/kim-kim/keymap.c b/keyboards/xd75/keymaps/kim-kim/keymap.c index 0557074dc..486a3743a 100644 --- a/keyboards/xd75/keymaps/kim-kim/keymap.c +++ b/keyboards/xd75/keymaps/kim-kim/keymap.c | |||
| @@ -115,21 +115,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 115 | ) | 115 | ) |
| 116 | 116 | ||
| 117 | }; | 117 | }; |
| 118 | |||
| 119 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 120 | { | ||
| 121 | // MACRODOWN only works in this function | ||
| 122 | switch(id) { | ||
| 123 | case 0: | ||
| 124 | if (record->event.pressed) { | ||
| 125 | #ifdef BACKLIGHT_ENABLE | ||
| 126 | |||
| 127 | #endif | ||
| 128 | } else { | ||
| 129 | #ifdef BACKLIGHT_ENABLE | ||
| 130 | |||
| 131 | #endif | ||
| 132 | } | ||
| 133 | } | ||
| 134 | return MACRO_NONE; | ||
| 135 | }; | ||
diff --git a/keyboards/xd75/keymaps/kloki/keymap.c b/keyboards/xd75/keymaps/kloki/keymap.c index d9a67e8b7..a63001934 100644 --- a/keyboards/xd75/keymaps/kloki/keymap.c +++ b/keyboards/xd75/keymaps/kloki/keymap.c | |||
| @@ -65,24 +65,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| 65 | ) | 65 | ) |
| 66 | }; | 66 | }; |
| 67 | 67 | ||
| 68 | const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | ||
| 69 | { | ||
| 70 | // MACRODOWN only works in this function | ||
| 71 | switch(id) { | ||
| 72 | case 0: | ||
| 73 | if (record->event.pressed) { | ||
| 74 | register_code(KC_RSFT); | ||
| 75 | #ifdef BACKLIGHT_ENABLE | ||
| 76 | backlight_step(); | ||
| 77 | #endif | ||
| 78 | } else { | ||
| 79 | unregister_code(KC_RSFT); | ||
| 80 | } | ||
| 81 | break; | ||
| 82 | } | ||
| 83 | return MACRO_NONE; | ||
| 84 | }; | ||
| 85 | |||
| 86 | bool CTRLDOWN = false; | 68 | bool CTRLDOWN = false; |
| 87 | bool WINDOWN = false; | 69 | bool WINDOWN = false; |
| 88 | bool SHIFTDOWN = false; | 70 | bool SHIFTDOWN = false; |
