Compare commits

...

3 Commits

Author SHA1 Message Date
Jack Humbert 8ec77eb620 remove STOP_FEATURE
8 years ago
Jack Humbert 151b7a4ae5 updates all keymaps, restricts to two options
8 years ago
Jack Humbert 98ac10fd74 introduces new format [broken] [skip ci]
8 years ago

@ -36,16 +36,16 @@ enum my_keycodes {
## Programming The Behavior Of Any Keycode ## Programming The Behavior Of Any Keycode
When you want to override the behavior of an existing key, or define the behavior for a new key, you should use the `process_record_kb()` and `process_record_user()` functions. These are called by QMK during key processing before the actual key event is handled. If these functions return `true` QMK will process the keycodes as usual. That can be handy for extending the functionality of a key rather than replacing it. If these functions return `false` QMK will skip the normal key handling, and it will be up you to send any key up or down events that are required. When you want to override the behavior of an existing key, or define the behavior for a new key, you should use the `process_keyboard()` and `process_user()` functions. These are called by QMK during key processing before the actual key event is handled. If these functions return `true` QMK will process the keycodes as usual. That can be handy for extending the functionality of a key rather than replacing it. If these functions return `false` QMK will skip the normal key handling, and it will be up you to send any key up or down events that are required.
These function are called every time a key is pressed or released. These function are called every time a key is pressed or released.
### Example `process_record_user()` implementation ### Example `process_user()` implementation
This example does two things. It defines the behavior for a custom keycode called `FOO`, and it supplements our Enter key by playing a tone whenever it is pressed. This example does two things. It defines the behavior for a custom keycode called `FOO`, and it supplements our Enter key by playing a tone whenever it is pressed.
``` ```
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case FOO: case FOO:
if (record->event.pressed) { if (record->event.pressed) {
@ -53,21 +53,21 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
// Do something else when release // Do something else when release
} }
return false; // Skip all further processing of this key return STOP_PROCESSING; // Skip all further processing of this key
case KC_ENTER: case KC_ENTER:
// Play a tone when enter is pressed // Play a tone when enter is pressed
if (record->event.pressed) { if (record->event.pressed) {
PLAY_NOTE_ARRAY(tone_qwerty); PLAY_NOTE_ARRAY(tone_qwerty);
} }
return true; // Let QMK send the enter press/release events return CONTINUE_PROCESSING; // Let QMK send the enter press/release events
} }
} }
``` ```
### `process_record_*` Function documentation ### `process_record_*` Function documentation
* Keyboard/Revision: `bool process_record_kb(uint16_t keycode, keyrecord_t *record)` * Keyboard/Revision: `level_t process_kb(uint16_t keycode, keyrecord_t *record)`
* Keymap: `bool process_record_user(uint16_t keycode, keyrecord_t *record)` * Keymap: `level_t process_user(uint16_t keycode, keyrecord_t *record)`
The `keycode` argument is whatever is defined in your keymap, eg `MO(1)`, `KC_L`, etc. You should use a `switch...case` block to handle these events. The `keycode` argument is whatever is defined in your keymap, eg `MO(1)`, `KC_L`, etc. You should use a `switch...case` block to handle these events.

@ -337,10 +337,10 @@ enum my_keycodes {
}; };
``` ```
You can then use `process_record_user()` to do something with your keycode: You can then use `process_user()` to do something with your keycode:
``` ```
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case FOO: case FOO:
// Do something here // Do something here

@ -135,8 +135,8 @@ The `process_record()` function itself is deceptively simple, but hidden within
* [`void process_record(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/action.c#L128) * [`void process_record(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/action.c#L128)
* [`bool process_record_quantum(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L140) * [`bool process_record_quantum(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L140)
* [Map this record to a keycode](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L143) * [Map this record to a keycode](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L143)
* [`bool process_record_kb(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/cluecard.c#L20) * [`level_t process_kb(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/cluecard.c#L20)
* [`bool process_record_user(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/keymaps/default/keymap.c#L58) * [`level_t process_user(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/keymaps/default/keymap.c#L58)
* [`bool process_midi(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_midi.c#L102) * [`bool process_midi(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_midi.c#L102)
* [`bool process_audio(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_audio.c#L10) * [`bool process_audio(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_audio.c#L10)
* [`bool process_music(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_music.c#L69) * [`bool process_music(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_music.c#L69)
@ -150,7 +150,7 @@ The `process_record()` function itself is deceptively simple, but hidden within
* [`bool process_unicode_map(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_unicodemap.c#L47) * [`bool process_unicode_map(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_unicodemap.c#L47)
* [Identify and process quantum specific keycodes](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L211) * [Identify and process quantum specific keycodes](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L211)
At any step during this chain of events a function (such as `process_record_kb()`) can `return false` to halt all further processing. At any step during this chain of events a function (such as `process_kb()`) can `return false` to halt all further processing.
<!-- <!--
#### Mouse Handling #### Mouse Handling

@ -173,31 +173,31 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORMAC: case DVORMAC:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORMAC); persistent_default_layer_set(1UL<<_DVORMAC);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -207,7 +207,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -217,8 +217,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };

@ -78,7 +78,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
static uint8_t qw_dv_swap_state = 0; static uint8_t qw_dv_swap_state = 0;
bool process_record_user (uint16_t keycode, keyrecord_t *record) { level_t process_user (uint16_t keycode, keyrecord_t *record) {
if (keycode == KC_LGUI) { if (keycode == KC_LGUI) {
if (record->event.pressed) if (record->event.pressed)
qw_dv_swap_state |= 0b00000001; qw_dv_swap_state |= 0b00000001;
@ -95,5 +95,5 @@ bool process_record_user (uint16_t keycode, keyrecord_t *record) {
if (qw_dv_swap_state == 0b00000011) { if (qw_dv_swap_state == 0b00000011) {
layer_invert(DVORAK); layer_invert(DVORAK);
} }
return true; return CONTINUE_PROCESSING;
} }

@ -189,7 +189,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
}; };
// Custom keycodes // Custom keycodes
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
bool queue = true; bool queue = true;
//Cancle one-shot mods. //Cancle one-shot mods.
@ -201,7 +201,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
break; break;
} }
return queue; return queue ? CONTINUE_PROCESSING : STOP_PROCESSING;
} }
// TAP DANCE SETTINGS // TAP DANCE SETTINGS

@ -124,31 +124,31 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case WOW: case WOW:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_WOW); persistent_default_layer_set(1UL<<_WOW);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -158,7 +158,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -168,8 +168,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };

@ -156,26 +156,26 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -17,11 +17,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -55,8 +55,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -20,8 +20,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -261,50 +261,50 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
/* layout switcher */ /* layout switcher */
case LAY_QWE: case LAY_QWE:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<QWE); persistent_default_layer_set(1UL<<QWE);
} }
return false; return STOP_PROCESSING;
break; break;
case LAY_COL: case LAY_COL:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<COL); persistent_default_layer_set(1UL<<COL);
} }
return false; return STOP_PROCESSING;
break; break;
case LAY_WOR: case LAY_WOR:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<WOR); persistent_default_layer_set(1UL<<WOR);
} }
return false; return STOP_PROCESSING;
break; break;
case LAY_DVO: case LAY_DVO:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<DVO); persistent_default_layer_set(1UL<<DVO);
} }
return false; return STOP_PROCESSING;
break; break;
/* os switcher */ /* os switcher */
case OS_LIN: case OS_LIN:
set_unicode_input_mode(UC_LNX); set_unicode_input_mode(UC_LNX);
return false; return STOP_PROCESSING;
break; break;
case OS_WIN: case OS_WIN:
set_unicode_input_mode(UC_WINC); set_unicode_input_mode(UC_WINC);
return false; return STOP_PROCESSING;
break; break;
case OS_MAC: case OS_MAC:
set_unicode_input_mode(UC_OSX); set_unicode_input_mode(UC_OSX);
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user() { void matrix_init_user() {

@ -1,90 +1,90 @@
/* /*
Copyright 2012 Jun Wako <wakojun@gmail.com> Copyright 2012 Jun Wako <wakojun@gmail.com>
This program is free software: you can redistribute it and/or modify This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or the Free Software Foundation, either version 2 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef CONFIG_H #ifndef CONFIG_H
#define CONFIG_H #define CONFIG_H
#include "config_common.h" #include "config_common.h"
/* USB Device descriptor parameter */ /* USB Device descriptor parameter */
#define VENDOR_ID 0xFEED #define VENDOR_ID 0xFEED
#define PRODUCT_ID 0x3060 #define PRODUCT_ID 0x3060
#define DEVICE_VER 0x0001 #define DEVICE_VER 0x0001
#define MANUFACTURER xyxjj #define MANUFACTURER xyxjj
#define PRODUCT DeltaSplit75 #define PRODUCT DeltaSplit75
#define DESCRIPTION 75% split keyboard #define DESCRIPTION 75% split keyboard
/* key matrix size */ /* key matrix size */
// Rows are doubled-up // Rows are doubled-up
#define MATRIX_ROWS 14 #define MATRIX_ROWS 14
#define MATRIX_COLS 8 #define MATRIX_COLS 8
// wiring of each half // wiring of each half
#define MATRIX_ROW_PINS { F4, F5, F6, F7, B1, B3, B2 } #define MATRIX_ROW_PINS { F4, F5, F6, F7, B1, B3, B2 }
#define MATRIX_COL_PINS { B6, B5, B4, E6, D7, C6, D4, D1} #define MATRIX_COL_PINS { B6, B5, B4, E6, D7, C6, D4, D1}
#define CATERINA_BOOTLOADER #define CATERINA_BOOTLOADER
/* COL2ROW or ROW2COL */ /* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW #define DIODE_DIRECTION COL2ROW
/* define if matrix has ghost */ /* define if matrix has ghost */
//#define MATRIX_HAS_GHOST //#define MATRIX_HAS_GHOST
/* number of backlight levels */ /* number of backlight levels */
// #define BACKLIGHT_LEVELS 3 // #define BACKLIGHT_LEVELS 3
/* Set 0 if debouncing isn't needed */ /* Set 0 if debouncing isn't needed */
#define DEBOUNCING_DELAY 5 #define DEBOUNCING_DELAY 5
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */ /* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
#define LOCKING_SUPPORT_ENABLE #define LOCKING_SUPPORT_ENABLE
/* Locking resynchronize hack */ /* Locking resynchronize hack */
#define LOCKING_RESYNC_ENABLE #define LOCKING_RESYNC_ENABLE
/* key combination for command */ /* key combination for command */
#define IS_COMMAND() ( \ #define IS_COMMAND() ( \
keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \ keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
) )
/* ws2812 RGB LED */ /* ws2812 RGB LED */
#define RGB_DI_PIN D3 #define RGB_DI_PIN D3
#define RGBLIGHT_TIMER #define RGBLIGHT_TIMER
#define RGBLED_NUM 12 // Number of LEDs #define RGBLED_NUM 12 // Number of LEDs
#define ws2812_PORTREG PORTD #define ws2812_PORTREG PORTD
#define ws2812_DDRREG DDRD #define ws2812_DDRREG DDRD
/* /*
* Feature disable options * Feature disable options
* These options are also useful to firmware size reduction. * These options are also useful to firmware size reduction.
*/ */
/* disable debug print */ /* disable debug print */
// #define NO_DEBUG // #define NO_DEBUG
/* disable print */ /* disable print */
// #define NO_PRINT // #define NO_PRINT
/* disable action features */ /* disable action features */
//#define NO_ACTION_LAYER //#define NO_ACTION_LAYER
//#define NO_ACTION_TAPPING //#define NO_ACTION_TAPPING
//#define NO_ACTION_ONESHOT //#define NO_ACTION_ONESHOT
//#define NO_ACTION_MACRO //#define NO_ACTION_MACRO
//#define NO_ACTION_FUNCTION //#define NO_ACTION_FUNCTION
#endif #endif

@ -63,7 +63,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
) )
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case FN: case FN:
if (record->event.pressed) { if (record->event.pressed) {
@ -73,8 +73,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_FN); layer_off(_FN);
dk60_esc_led_off(); dk60_esc_led_off();
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -148,7 +148,7 @@ void persistant_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -157,7 +157,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistant_default_layer_set(1UL<<_QWERTY); persistant_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -167,7 +167,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -177,10 +177,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -258,10 +258,10 @@ void matrix_scan_user(void) {
} }
}; };
//bool process_record_user(uint16_t keycode, keyrecord_t *record) { //level_t process_user(uint16_t keycode, keyrecord_t *record) {
// switch (keycode) { // switch (keycode) {
// case QWERTY: // case QWERTY:
// return false // return STOP_PROCESSING
// break; // break;
// case LOWER: // case LOWER:
// if (record->event.pressed) { // if (record->event.pressed) {
@ -271,7 +271,7 @@ void matrix_scan_user(void) {
// layer_off(_LOWER); // layer_off(_LOWER);
// update_tri_layer(_LOWER, _RAISE, _ADJUST); // update_tri_layer(_LOWER, _RAISE, _ADJUST);
// } // }
// return false; // return STOP_PROCESSING;
// break; // break;
// case RAISE: // case RAISE:
// if (record->event.pressed) { // if (record->event.pressed) {
@ -281,9 +281,9 @@ void matrix_scan_user(void) {
// layer_off(_RAISE); // layer_off(_RAISE);
// update_tri_layer(_LOWER, _RAISE, _ADJUST); // update_tri_layer(_LOWER, _RAISE, _ADJUST);
// } // }
// return false; // return STOP_PROCESSING;
// break; // break;
// } // }
// return true; // return CONTINUE_PROCESSING;
//} //}

@ -267,7 +267,7 @@ void send_chord(void)
virtser_send(0); virtser_send(0);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) level_t process_user(uint16_t keycode, keyrecord_t *record)
{ {
// We need to track keypresses in all modes, in case the user // We need to track keypresses in all modes, in case the user
// changes mode whilst pressing other keys. // changes mode whilst pressing other keys.
@ -275,7 +275,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record)
pressed_count++; pressed_count++;
else else
pressed_count--; pressed_count--;
return true; return CONTINUE_PROCESSING;
} }
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)

@ -357,23 +357,23 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
return MACRO_NONE; return MACRO_NONE;
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
// dynamically generate these. // dynamically generate these.
case EPRM: case EPRM:
if (record->event.pressed) { if (record->event.pressed) {
eeconfig_init(); eeconfig_init();
} }
return false; return STOP_PROCESSING;
break; break;
case VRSN: case VRSN:
if (record->event.pressed) { if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
// Runs just one time when the keyboard initializes. // Runs just one time when the keyboard initializes.

@ -1043,7 +1043,7 @@ const qk_ucis_symbol_t ucis_symbol_table[] = UCIS_TABLE
UCIS_SYM("tm", 0x2122) UCIS_SYM("tm", 0x2122)
); );
bool process_record_user (uint16_t keycode, keyrecord_t *record) { level_t process_user (uint16_t keycode, keyrecord_t *record) {
#if KEYLOGGER_ENABLE #if KEYLOGGER_ENABLE
if (log_enable) { if (log_enable) {
uint8_t layer = biton32(layer_state); uint8_t layer = biton32(layer_state);
@ -1086,11 +1086,11 @@ bool process_record_user (uint16_t keycode, keyrecord_t *record) {
ang_tap (KC_4, KC_SPC, KC_D, KC_A, KC_Y, KC_S, KC_QUOT, 0); ang_tap (KC_4, KC_SPC, KC_D, KC_A, KC_Y, KC_S, KC_QUOT, 0);
return false; return STOP_PROCESSING;
} }
} }
return true; return CONTINUE_PROCESSING;
} }
void qk_ucis_symbol_fallback (void) { void qk_ucis_symbol_fallback (void) {

@ -247,7 +247,7 @@ void matrix_scan_user(void) {
} }
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case BEL_F0: case BEL_F0:
if(record->event.pressed){ if(record->event.pressed){
@ -260,7 +260,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(SWPH); layer_off(SWPH);
} }
return false; return STOP_PROCESSING;
} }
break; break;
case BEL_F1: case BEL_F1:
@ -268,7 +268,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(SYMB); layer_off(SYMB);
layer_off(NUMP); layer_off(NUMP);
return false; return STOP_PROCESSING;
} }
break; break;
case E_SHRUG: // ¯\_(ツ)_/¯ case E_SHRUG: // ¯\_(ツ)_/¯
@ -287,7 +287,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
tap(KC_SLSH); // Arm tap(KC_SLSH); // Arm
process_unicode((0x00AF|QK_UNICODE), record); // Hand process_unicode((0x00AF|QK_UNICODE), record); // Hand
} }
return false; return STOP_PROCESSING;
break; break;
case E_TFLIP: // (╯°□°)╯ ︵ ┻━┻ case E_TFLIP: // (╯°□°)╯ ︵ ┻━┻
if (record->event.pressed) { if (record->event.pressed) {
@ -309,7 +309,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
process_unicode((0x2501|QK_UNICODE), record); // Table process_unicode((0x2501|QK_UNICODE), record); // Table
process_unicode((0x253B|QK_UNICODE), record); // Table process_unicode((0x253B|QK_UNICODE), record); // Table
} }
return false; return STOP_PROCESSING;
break; break;
case E_TSET: // ┬──┬ ( ゜-゜ノ) case E_TSET: // ┬──┬ ( ゜-゜ノ)
if (record->event.pressed) { if (record->event.pressed) {
@ -331,11 +331,11 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
tap(KC_0); tap(KC_0);
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void belak_td_each(qk_tap_dance_state_t *state, void *user_data) { void belak_td_each(qk_tap_dance_state_t *state, void *user_data) {

@ -168,20 +168,20 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
return MACRO_NONE; return MACRO_NONE;
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
// dynamically generate these. // dynamically generate these.
case EPRM: case EPRM:
if (record->event.pressed) { if (record->event.pressed) {
eeconfig_init(); eeconfig_init();
} }
return false; return STOP_PROCESSING;
break; break;
case VRSN: case VRSN:
if (record->event.pressed) { if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
} }
return false; return STOP_PROCESSING;
break; break;
case RGB_SLD: case RGB_SLD:
if (record->event.pressed) { if (record->event.pressed) {
@ -189,10 +189,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_mode(1); rgblight_mode(1);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
// Runs just one time when the keyboard initializes. // Runs just one time when the keyboard initializes.

@ -165,20 +165,20 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
return MACRO_NONE; return MACRO_NONE;
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
// dynamically generate these. // dynamically generate these.
case EPRM: case EPRM:
if (record->event.pressed) { if (record->event.pressed) {
eeconfig_init(); eeconfig_init();
} }
return false; return STOP_PROCESSING;
break; break;
case VRSN: case VRSN:
if (record->event.pressed) { if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
} }
return false; return STOP_PROCESSING;
break; break;
case RGB_SLD: case RGB_SLD:
if (record->event.pressed) { if (record->event.pressed) {
@ -186,10 +186,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_mode(1); rgblight_mode(1);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
// Runs just one time when the keyboard initializes. // Runs just one time when the keyboard initializes.

@ -159,7 +159,7 @@ void matrix_init_user(void) {
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
// dynamically generate these. // dynamically generate these.
case RGB_FF00BB: case RGB_FF00BB:
@ -170,10 +170,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_setrgb(0xff,0x00,0xbb); rgblight_setrgb(0xff,0x00,0xbb);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
LEADER_EXTERNS(); LEADER_EXTERNS();

@ -165,20 +165,20 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
return MACRO_NONE; return MACRO_NONE;
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
// dynamically generate these. // dynamically generate these.
case EPRM: case EPRM:
if (record->event.pressed) { if (record->event.pressed) {
eeconfig_init(); eeconfig_init();
} }
return false; return STOP_PROCESSING;
break; break;
case VRSN: case VRSN:
if (record->event.pressed) { if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
} }
return false; return STOP_PROCESSING;
break; break;
case RGB_SLD: case RGB_SLD:
if (record->event.pressed) { if (record->event.pressed) {
@ -186,10 +186,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_mode(1); rgblight_mode(1);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
// Runs just one time when the keyboard initializes. // Runs just one time when the keyboard initializes.

@ -82,20 +82,20 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
return MACRO_NONE; return MACRO_NONE;
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
// dynamically generate these. // dynamically generate these.
case EPRM: case EPRM:
if (record->event.pressed) { if (record->event.pressed) {
eeconfig_init(); eeconfig_init();
} }
return false; return STOP_PROCESSING;
break; break;
case VRSN: case VRSN:
if (record->event.pressed) { if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
} }
return false; return STOP_PROCESSING;
break; break;
case RGB_SLD: case RGB_SLD:
if (record->event.pressed) { if (record->event.pressed) {
@ -103,10 +103,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_mode(1); rgblight_mode(1);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
// Runs just one time when the keyboard initializes. // Runs just one time when the keyboard initializes.

@ -62,7 +62,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
}; };
bool status_led1_on = false, status_led2_on = false, status_led3_on = false; bool status_led1_on = false, status_led2_on = false, status_led3_on = false;
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
// dynamically generate these. // dynamically generate these.
case RGB_FF0000: case RGB_FF0000:
@ -72,7 +72,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
register_code(KC_1); unregister_code(KC_1); register_code(KC_1); unregister_code(KC_1);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
case RGB_00FF00: case RGB_00FF00:
if (record->event.pressed) { if (record->event.pressed) {
@ -81,7 +81,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
register_code(KC_2); unregister_code(KC_2); register_code(KC_2); unregister_code(KC_2);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
case RGB_0000FF: case RGB_0000FF:
if (record->event.pressed) { if (record->event.pressed) {
@ -90,7 +90,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
register_code(KC_3); unregister_code(KC_3); register_code(KC_3); unregister_code(KC_3);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
case RGB_FFFFFF: case RGB_FFFFFF:
if (record->event.pressed) { if (record->event.pressed) {
@ -99,7 +99,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
register_code(KC_4); unregister_code(KC_4); register_code(KC_4); unregister_code(KC_4);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
case RGB_TOGGLE: case RGB_TOGGLE:
if (record->event.pressed) { if (record->event.pressed) {
@ -108,7 +108,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
register_code(KC_EQL); unregister_code(KC_EQL); register_code(KC_EQL); unregister_code(KC_EQL);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
case LED1: case LED1:
if (record->event.pressed) { if (record->event.pressed) {
@ -120,7 +120,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
status_led1_on = true; status_led1_on = true;
} }
} }
return false; return STOP_PROCESSING;
break; break;
case LED2: case LED2:
if (record->event.pressed) { if (record->event.pressed) {
@ -132,7 +132,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
status_led2_on = true; status_led2_on = true;
} }
} }
return false; return STOP_PROCESSING;
break; break;
case LED3: case LED3:
if (record->event.pressed) { if (record->event.pressed) {
@ -144,8 +144,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
status_led3_on = true; status_led3_on = true;
} }
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -189,20 +189,20 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
return MACRO_NONE; return MACRO_NONE;
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
// dynamically generate these. // dynamically generate these.
case EPRM: case EPRM:
if (record->event.pressed) { if (record->event.pressed) {
eeconfig_init(); eeconfig_init();
} }
return false; return STOP_PROCESSING;
break; break;
case VRSN: case VRSN:
if (record->event.pressed) { if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
} }
return false; return STOP_PROCESSING;
break; break;
case RGB_SLD: case RGB_SLD:
if (record->event.pressed) { if (record->event.pressed) {
@ -210,10 +210,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_mode(1); rgblight_mode(1);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
// Runs just one time when the keyboard initializes. // Runs just one time when the keyboard initializes.

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {
@ -54,8 +54,8 @@ void matrix_scan_user(void) {
} }
__attribute__ ((weak)) __attribute__ ((weak))
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
__attribute__ ((weak)) __attribute__ ((weak))

@ -132,8 +132,8 @@ void matrix_init_user(void) {
void matrix_scan_user(void) { void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -12,11 +12,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -250,7 +250,7 @@ void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
} }
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -259,7 +259,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistant_default_layer_set(1UL<<_QWERTY); persistant_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -268,7 +268,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistant_default_layer_set(1UL<<_COLEMAK); persistant_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -291,7 +291,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -314,7 +314,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
TOG_STATUS = false; TOG_STATUS = false;
update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -325,7 +325,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case RGB_MOD: case RGB_MOD:
//led operations - RGB mode change now updates the RGB_current_mode to allow the right RGB mode to be set after reactive keys are released //led operations - RGB mode change now updates the RGB_current_mode to allow the right RGB mode to be set after reactive keys are released
@ -334,10 +334,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_step(); rgblight_step();
RGB_current_mode = rgblight_config.mode; RGB_current_mode = rgblight_config.mode;
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -252,7 +252,7 @@ void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
} }
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -261,7 +261,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistant_default_layer_set(1UL<<_QWERTY); persistant_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -284,7 +284,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -307,7 +307,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
TOG_STATUS = false; TOG_STATUS = false;
update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -318,7 +318,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
//my attempt for RGB layer lock indication via changing the mode, still have to figure out how to not have other keypress not override this mode //my attempt for RGB layer lock indication via changing the mode, still have to figure out how to not have other keypress not override this mode
case TG_NUMLAY: case TG_NUMLAY:
@ -335,7 +335,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_mode(RGB_current_mode); rgblight_mode(RGB_current_mode);
layer_off(_NUMLAY); } layer_off(_NUMLAY); }
} }
return false; return STOP_PROCESSING;
break; break;
case RGB_MOD: case RGB_MOD:
//led operations - RGB mode change now updates the RGB_current_mode to allow the right RGB mode to be set after reactive keys are released //led operations - RGB mode change now updates the RGB_current_mode to allow the right RGB mode to be set after reactive keys are released
@ -344,10 +344,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_step(); rgblight_step();
RGB_current_mode = rgblight_config.mode; RGB_current_mode = rgblight_config.mode;
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -55,8 +55,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -150,7 +150,7 @@ float tone_colemak[][2] = SONG(COLEMAK_SOUND);
#endif #endif
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWR: case QWR:
if (record->event.pressed) { if (record->event.pressed) {
@ -159,7 +159,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
layer_off(_CDH); layer_off(_CDH);
} }
return false; return STOP_PROCESSING;
break; break;
case CDH: case CDH:
@ -169,7 +169,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
layer_on(_CDH); layer_on(_CDH);
} }
return false; return STOP_PROCESSING;
break; break;
case SYM: case SYM:
@ -178,11 +178,11 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
layer_off(_SYM); layer_off(_SYM);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -152,7 +152,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -161,7 +161,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -170,7 +170,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -179,7 +179,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -189,7 +189,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -199,7 +199,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -210,10 +210,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };
void matrix_init_user(void) { void matrix_init_user(void) {

@ -393,8 +393,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -45,7 +45,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
}; };
bool process_record_user (uint16_t keycode, keyrecord_t *record) { level_t process_user (uint16_t keycode, keyrecord_t *record) {
switch(keycode) { switch(keycode) {
case KC_FN0: case KC_FN0:
if (record->event.pressed) { if (record->event.pressed) {
@ -64,5 +64,5 @@ bool process_record_user (uint16_t keycode, keyrecord_t *record) {
} }
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -191,7 +191,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -200,7 +200,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -209,7 +209,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -218,7 +218,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -228,7 +228,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -238,7 +238,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -249,10 +249,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };
void matrix_init_user(void) { void matrix_init_user(void) {

@ -79,8 +79,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -1012,7 +1012,7 @@ uint32_t layer_state_set_kb(uint32_t state)
return state; return state;
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
static bool lshift = false; static bool lshift = false;
static bool rshift = false; static bool rshift = false;
static uint8_t layer = 0; static uint8_t layer = 0;
@ -1059,11 +1059,11 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// double-space enter space layer // double-space enter space layer
case LSPACE: case LSPACE:
process_doublespace(record->event.pressed, &lspace_active, &rspace_active, &lspace_emitted); process_doublespace(record->event.pressed, &lspace_active, &rspace_active, &lspace_emitted);
return false; return STOP_PROCESSING;
break; break;
case RSPACE: case RSPACE:
process_doublespace(record->event.pressed, &rspace_active, &lspace_active, &rspace_emitted); process_doublespace(record->event.pressed, &rspace_active, &lspace_active, &rspace_emitted);
return false; return STOP_PROCESSING;
break; break;
#endif #endif
@ -1116,7 +1116,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
unregister_code(KC_COMM); unregister_code(KC_COMM);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_DOT: case KC_DOT:
if (record->event.pressed) { if (record->event.pressed) {
@ -1128,7 +1128,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
unregister_code(KC_DOT); unregister_code(KC_DOT);
} }
} }
return false; return STOP_PROCESSING;
break; break;
// layout switchers // layout switchers
@ -1136,14 +1136,14 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
#ifdef LAYOUT_DVORAK #ifdef LAYOUT_DVORAK
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
#endif #endif
#ifdef LAYOUT_COLEMAK #ifdef LAYOUT_COLEMAK
@ -1151,7 +1151,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
#endif #endif
#ifdef LAYOUT_WORKMAN #ifdef LAYOUT_WORKMAN
@ -1159,7 +1159,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_WORKMAN); persistent_default_layer_set(1UL<<_WORKMAN);
} }
return false; return STOP_PROCESSING;
break; break;
#endif #endif
#ifdef LAYOUT_NORMAN #ifdef LAYOUT_NORMAN
@ -1167,7 +1167,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_NORMAN); persistent_default_layer_set(1UL<<_NORMAN);
} }
return false; return STOP_PROCESSING;
break; break;
#endif #endif
@ -1181,7 +1181,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
register_code(keycode); register_code(keycode);
unregister_code(keycode); unregister_code(keycode);
} }
return false; return STOP_PROCESSING;
break; break;
// layer switcher // layer switcher
@ -1199,7 +1199,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_GREEKU); layer_off(_GREEKU);
layer_off(_GREEKL); layer_off(_GREEKL);
} }
return false; return STOP_PROCESSING;
break; break;
// OS switchers // OS switchers
@ -1208,21 +1208,21 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#ifdef RGBSPS_ENABLE #ifdef RGBSPS_ENABLE
led_set_unicode_input_mode(); led_set_unicode_input_mode();
#endif #endif
return false; return STOP_PROCESSING;
break; break;
case WIN: case WIN:
set_unicode_input_mode(UC_WINC); set_unicode_input_mode(UC_WINC);
#ifdef RGBSPS_ENABLE #ifdef RGBSPS_ENABLE
led_set_unicode_input_mode(); led_set_unicode_input_mode();
#endif #endif
return false; return STOP_PROCESSING;
break; break;
case OSX: case OSX:
set_unicode_input_mode(UC_OSX); set_unicode_input_mode(UC_OSX);
#ifdef RGBSPS_ENABLE #ifdef RGBSPS_ENABLE
led_set_unicode_input_mode(); led_set_unicode_input_mode();
#endif #endif
return false; return STOP_PROCESSING;
break; break;
// glow mode changer // glow mode changer
@ -1236,7 +1236,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
led_reset(); led_reset();
rgbsps_send(); rgbsps_send();
} }
return false; return STOP_PROCESSING;
break; break;
#endif #endif
@ -1258,11 +1258,11 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#ifdef RGBSPS_DEMO_ENABLE #ifdef RGBSPS_DEMO_ENABLE
case RGBDEMO: case RGBDEMO:
led_demo(); led_demo();
return false; return STOP_PROCESSING;
break; break;
#endif #endif
} }
return true; return CONTINUE_PROCESSING;
} }
void set_output_user(uint8_t output) { void set_output_user(uint8_t output) {

@ -294,8 +294,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -45,11 +45,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -178,9 +178,9 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
}; };
// For Dynamic Macros. // For Dynamic Macros.
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
if (!process_record_dynamic_macro(keycode, record)) { if (!process_record_dynamic_macro(keycode, record)) {
return false; return STOP_PROCESSING;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -151,26 +151,26 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -241,8 +241,8 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
}; };
bool process_record_user (uint16_t keycode, keyrecord_t *record) { level_t process_user (uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
// Runs just one time when the keyboard initializes. // Runs just one time when the keyboard initializes.

@ -251,13 +251,13 @@ void persistant_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
default_layer_set(1UL<<_QWERTY); default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -267,7 +267,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -277,10 +277,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
/* /*

@ -288,25 +288,25 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
default_layer_set(1UL<<_QWERTY); default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
default_layer_set(1UL<<_COLEMAK); default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
default_layer_set(1UL<<_DVORAK); default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -316,7 +316,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -326,7 +326,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -337,7 +337,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case PLOVER: case PLOVER:
if (record->event.pressed) { if (record->event.pressed) {
@ -352,16 +352,16 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
keymap_config.nkro = 1; keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw); eeconfig_update_keymap(keymap_config.raw);
} }
return false; return STOP_PROCESSING;
break; break;
case EXT_PLV: case EXT_PLV:
if (record->event.pressed) { if (record->event.pressed) {
layer_off(_PLOVER); layer_off(_PLOVER);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
/* /*

@ -147,8 +147,8 @@ void matrix_init_user(void) {
void matrix_scan_user(void) { void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -78,11 +78,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -81,8 +81,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -84,8 +84,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -375,8 +375,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -42,8 +42,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -219,7 +219,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
} }
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
uint8_t layer; uint8_t layer;
layer = biton32(layer_state); layer = biton32(layer_state);
if (layer == PROG2) { if (layer == PROG2) {
@ -238,5 +238,5 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
} }
} }
return true; return CONTINUE_PROCESSING;
} }

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -88,8 +88,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -88,8 +88,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -29,11 +29,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_init_ports(void) { void led_init_ports(void) {

@ -201,7 +201,7 @@ void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
} }
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -210,7 +210,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -219,7 +219,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -228,7 +228,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -247,7 +247,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -266,7 +266,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
TOG_STATUS = false; TOG_STATUS = false;
update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -277,7 +277,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
//led operations - RGB mode change now updates the RGB_current_mode to allow the right RGB mode to be set after reactive keys are released //led operations - RGB mode change now updates the RGB_current_mode to allow the right RGB mode to be set after reactive keys are released
case RGB_MOD: case RGB_MOD:
@ -286,10 +286,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_step(); rgblight_step();
RGB_current_mode = rgblight_config.mode; RGB_current_mode = rgblight_config.mode;
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -152,7 +152,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -161,7 +161,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -170,7 +170,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -179,7 +179,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -189,7 +189,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -199,7 +199,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case ADJUST: case ADJUST:
if (record->event.pressed) { if (record->event.pressed) {
@ -207,8 +207,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
layer_off(_ADJUST); layer_off(_ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -152,7 +152,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -161,7 +161,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -170,7 +170,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -179,7 +179,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -189,7 +189,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -199,7 +199,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case ADJUST: case ADJUST:
if (record->event.pressed) { if (record->event.pressed) {
@ -207,8 +207,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
layer_off(_ADJUST); layer_off(_ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -143,7 +143,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -152,7 +152,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -161,7 +161,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -170,7 +170,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -180,7 +180,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -190,7 +190,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case ADJUST: case ADJUST:
if (record->event.pressed) { if (record->event.pressed) {
@ -198,8 +198,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
layer_off(_ADJUST); layer_off(_ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -173,7 +173,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -182,7 +182,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -191,7 +191,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -200,7 +200,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -210,7 +210,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -220,7 +220,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case ADJUST: case ADJUST:
if (record->event.pressed) { if (record->event.pressed) {
@ -228,8 +228,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
layer_off(_ADJUST); layer_off(_ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -157,7 +157,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -166,7 +166,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -175,7 +175,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -184,7 +184,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -194,7 +194,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -204,7 +204,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case ADJUST: case ADJUST:
if (record->event.pressed) { if (record->event.pressed) {
@ -212,8 +212,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
layer_off(_ADJUST); layer_off(_ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -146,25 +146,25 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -174,7 +174,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -184,8 +184,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -124,7 +124,7 @@ void persistant_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -133,7 +133,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistant_default_layer_set(1UL<<_QWERTY); persistant_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -143,7 +143,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -153,7 +153,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case ADJUST: case ADJUST:
if (record->event.pressed) { if (record->event.pressed) {
@ -161,8 +161,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
layer_off(_ADJUST); layer_off(_ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -132,7 +132,7 @@ void persistant_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -141,7 +141,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistant_default_layer_set(1UL<<_QWERTY); persistant_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -151,7 +151,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -161,7 +161,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case ADJUST: case ADJUST:
if (record->event.pressed) { if (record->event.pressed) {
@ -169,8 +169,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
layer_off(_ADJUST); layer_off(_ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -137,7 +137,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
static bool singular_key = false; static bool singular_key = false;
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
uint8_t layer; uint8_t layer;
layer = biton32(layer_state); // get the current layer layer = biton32(layer_state); // get the current layer
@ -155,7 +155,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
} }
update_tri_layer(_FUNCTION, _SHIFTED, _FUNCSHIFT); update_tri_layer(_FUNCTION, _SHIFTED, _FUNCSHIFT);
return false; return STOP_PROCESSING;
break; break;
//SHIFT is handled as LSHIFT in the general case //SHIFT is handled as LSHIFT in the general case
case SHIFT: case SHIFT:
@ -171,7 +171,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
} }
update_tri_layer(_FUNCTION, _SHIFTED, _FUNCSHIFT); update_tri_layer(_FUNCTION, _SHIFTED, _FUNCSHIFT);
return false; return STOP_PROCESSING;
break; break;
//If any other key was pressed during the layer mod hold period, //If any other key was pressed during the layer mod hold period,
@ -195,7 +195,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
} }
return true; return CONTINUE_PROCESSING;
}; };
void matrix_scan_user(void) { void matrix_scan_user(void) {

@ -80,8 +80,8 @@ void matrix_init_user(void) {
void matrix_scan_user(void) { void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -80,8 +80,8 @@ void matrix_init_user(void) {
void matrix_scan_user(void) { void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -142,8 +142,8 @@ void matrix_init_user(void) {
void matrix_scan_user(void) { void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -170,7 +170,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -179,7 +179,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -188,7 +188,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -197,7 +197,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -207,7 +207,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -217,7 +217,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case ADJUST: case ADJUST:
if (record->event.pressed) { if (record->event.pressed) {
@ -225,8 +225,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
layer_off(_ADJUST); layer_off(_ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -156,7 +156,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -165,7 +165,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -174,7 +174,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -183,7 +183,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -193,7 +193,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -203,7 +203,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case ADJUST: case ADJUST:
if (record->event.pressed) { if (record->event.pressed) {
@ -211,8 +211,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
layer_off(_ADJUST); layer_off(_ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -91,7 +91,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -100,7 +100,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -109,7 +109,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -118,7 +118,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -128,7 +128,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -138,7 +138,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case ADJUST: case ADJUST:
if (record->event.pressed) { if (record->event.pressed) {
@ -146,8 +146,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
layer_off(_ADJUST); layer_off(_ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -98,15 +98,15 @@ void matrix_scan_user(void)
} }
/* Mixes in KM_HAXHAX via RALT modifier without shadowing the RALT key combinations. */ /* Mixes in KM_HAXHAX via RALT modifier without shadowing the RALT key combinations. */
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
uint8_t modifiers = get_mods(); uint8_t modifiers = get_mods();
if (modifiers & MOD_BIT(KC_RALT) && record->event.pressed) { if (modifiers & MOD_BIT(KC_RALT) && record->event.pressed) {
uint16_t kc = keymap_key_to_keycode(KM_HAXHAX, record->event.key); uint16_t kc = keymap_key_to_keycode(KM_HAXHAX, record->event.key);
if (kc != KC_TRNS) { if (kc != KC_TRNS) {
register_code(kc); register_code(kc);
unregister_code(kc); unregister_code(kc);
return false; return STOP_PROCESSING;
} }
} }
return true; return CONTINUE_PROCESSING;
} }

@ -68,8 +68,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -68,8 +68,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -29,11 +29,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_init_ports(void) { void led_init_ports(void) {

@ -339,18 +339,18 @@ void plover_lookup(void) {
unregister_code(PV_RG); unregister_code(PV_RG);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
persistant_default_layer_set(1UL<<BASE_QWERTY_LAYER); persistant_default_layer_set(1UL<<BASE_QWERTY_LAYER);
} }
return false; return STOP_PROCESSING;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
persistant_default_layer_set(1UL<<BASE_COLEMAK_LAYER); persistant_default_layer_set(1UL<<BASE_COLEMAK_LAYER);
} }
return false; return STOP_PROCESSING;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
layer_on(LOWER_LAYER); layer_on(LOWER_LAYER);
@ -359,7 +359,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(LOWER_LAYER); layer_off(LOWER_LAYER);
update_tri_layer(LOWER_LAYER, RAISE_LAYER, KEYBOARD_LAYER); update_tri_layer(LOWER_LAYER, RAISE_LAYER, KEYBOARD_LAYER);
} }
return false; return STOP_PROCESSING;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
layer_on(RAISE_LAYER); layer_on(RAISE_LAYER);
@ -368,7 +368,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(RAISE_LAYER); layer_off(RAISE_LAYER);
update_tri_layer(LOWER_LAYER, RAISE_LAYER, KEYBOARD_LAYER); update_tri_layer(LOWER_LAYER, RAISE_LAYER, KEYBOARD_LAYER);
} }
return false; return STOP_PROCESSING;
case STENO: case STENO:
if (record->event.pressed) { if (record->event.pressed) {
layer_off(RAISE_LAYER); layer_off(RAISE_LAYER);
@ -383,20 +383,20 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
eeconfig_update_keymap(keymap_config.raw); eeconfig_update_keymap(keymap_config.raw);
plover_resume(); plover_resume();
} }
return false; return STOP_PROCESSING;
case PV_EXIT: case PV_EXIT:
if (record->event.pressed) { if (record->event.pressed) {
plover_suspend(); plover_suspend();
layer_off(BASE_STENO_LAYER); layer_off(BASE_STENO_LAYER);
} }
return false; return STOP_PROCESSING;
case PV_LOOK: case PV_LOOK:
if (record->event.pressed) { if (record->event.pressed) {
plover_lookup(); plover_lookup();
} }
return false; return STOP_PROCESSING;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -120,7 +120,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case MOVE: case MOVE:
if (record->event.pressed) { if (record->event.pressed) {
@ -130,7 +130,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_MOVE); layer_off(_MOVE);
update_tri_layer(_MOVE, _SYMB, _MOUSE); update_tri_layer(_MOVE, _SYMB, _MOUSE);
} }
return false; return STOP_PROCESSING;
break; break;
case SYMB: case SYMB:
if (record->event.pressed) { if (record->event.pressed) {
@ -140,7 +140,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_SYMB); layer_off(_SYMB);
update_tri_layer(_MOVE, _SYMB, _MOUSE); update_tri_layer(_MOVE, _SYMB, _MOUSE);
} }
return false; return STOP_PROCESSING;
break; break;
case FUNC: case FUNC:
if (record->event.pressed) { if (record->event.pressed) {
@ -148,8 +148,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
layer_off(_FUNC); layer_off(_FUNC);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -245,7 +245,7 @@ void persistant_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -254,7 +254,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistant_default_layer_set(1UL<<_QWERTY); persistant_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case NUMPAD: case NUMPAD:
if (record->event.pressed) { if (record->event.pressed) {
@ -263,13 +263,13 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_ADJUST); layer_off(_ADJUST);
layer_on(_NUMPAD); layer_on(_NUMPAD);
} }
return false; return STOP_PROCESSING;
break; break;
case EXT_NUM: case EXT_NUM:
if (record->event.pressed) { if (record->event.pressed) {
layer_off(_NUMPAD); layer_off(_NUMPAD);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -278,7 +278,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistant_default_layer_set(1UL<<_COLEMAK); persistant_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -287,7 +287,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistant_default_layer_set(1UL<<_DVORAK); persistant_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -297,7 +297,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -307,7 +307,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -318,7 +318,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case PLOVER: case PLOVER:
if (record->event.pressed) { if (record->event.pressed) {
@ -337,7 +337,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
keymap_config.nkro = 1; keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw); eeconfig_update_keymap(keymap_config.raw);
} }
return false; return STOP_PROCESSING;
break; break;
case EXT_PLV: case EXT_PLV:
if (record->event.pressed) { if (record->event.pressed) {
@ -346,10 +346,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
layer_off(_PLOVER); layer_off(_PLOVER);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -176,7 +176,7 @@ float tone_goodbye[][2] = SONG(GOODBYE_SOUND);
#endif #endif
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -187,7 +187,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_DVORAK); layer_off(_DVORAK);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -198,7 +198,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_on(_DVORAK); layer_on(_DVORAK);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case NUMBER: case NUMBER:
if (record->event.pressed) { if (record->event.pressed) {
@ -208,7 +208,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_NUMBER); layer_off(_NUMBER);
update_tri_layer(_NUMBER, _ACTION, _FUNCTN); update_tri_layer(_NUMBER, _ACTION, _FUNCTN);
} }
return false; return STOP_PROCESSING;
break; break;
case ACTION: case ACTION:
if (record->event.pressed) { if (record->event.pressed) {
@ -218,10 +218,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_ACTION); layer_off(_ACTION);
update_tri_layer(_NUMBER, _ACTION, _FUNCTN); update_tri_layer(_NUMBER, _ACTION, _FUNCTN);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -154,7 +154,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -163,7 +163,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -173,7 +173,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -183,7 +183,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -194,10 +194,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -177,25 +177,25 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
float plover_gb_song[][2] = SONG(PLOVER_GOODBYE_SOUND); float plover_gb_song[][2] = SONG(PLOVER_GOODBYE_SOUND);
#endif #endif
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
set_single_persistent_default_layer(_QWERTY); set_single_persistent_default_layer(_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
set_single_persistent_default_layer(_COLEMAK); set_single_persistent_default_layer(_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
set_single_persistent_default_layer(_DVORAK); set_single_persistent_default_layer(_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -205,7 +205,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -215,7 +215,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -226,7 +226,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case PLOVER: case PLOVER:
if (record->event.pressed) { if (record->event.pressed) {
@ -245,7 +245,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
keymap_config.nkro = 1; keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw); eeconfig_update_keymap(keymap_config.raw);
} }
return false; return STOP_PROCESSING;
break; break;
case EXT_PLV: case EXT_PLV:
if (record->event.pressed) { if (record->event.pressed) {
@ -254,8 +254,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
layer_off(_PLOVER); layer_off(_PLOVER);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -110,10 +110,10 @@ qk_tap_dance_action_t tap_dance_actions[] = {
[TDK_SLSH] = ACTION_TAP_DANCE_FN_KEYCODE (tap_dance_triple, KC_SLSH) [TDK_SLSH] = ACTION_TAP_DANCE_FN_KEYCODE (tap_dance_triple, KC_SLSH)
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
if (!process_record_dynamic_macro(keycode, record)) { if (!process_record_dynamic_macro(keycode, record)) {
return false; return STOP_PROCESSING;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -211,7 +211,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -221,7 +221,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
break; break;
return false; return STOP_PROCESSING;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
#ifdef AUDIO_ENABLE #ifdef AUDIO_ENABLE
@ -230,7 +230,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
break; break;
return false; return STOP_PROCESSING;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
#ifdef AUDIO_ENABLE #ifdef AUDIO_ENABLE
@ -239,7 +239,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
break; break;
return false; return STOP_PROCESSING;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
layer_on(_LOWER); layer_on(_LOWER);
@ -253,7 +253,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
break; break;
return false; return STOP_PROCESSING;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
layer_on(_RAISE); layer_on(_RAISE);
@ -267,7 +267,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
break; break;
return false; return STOP_PROCESSING;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
register_code(KC_RSFT); register_code(KC_RSFT);
@ -278,7 +278,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
break; break;
return false; return STOP_PROCESSING;
case PLOVER: case PLOVER:
if (!record->event.pressed) { if (!record->event.pressed) {
#ifdef AUDIO_ENABLE #ifdef AUDIO_ENABLE
@ -288,7 +288,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_on(_PLOVER); layer_on(_PLOVER);
} }
break; break;
return false; return STOP_PROCESSING;
case EXT_PLV: case EXT_PLV:
if (record->event.pressed) { if (record->event.pressed) {
#ifdef AUDIO_ENABLE #ifdef AUDIO_ENABLE
@ -297,61 +297,61 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_PLOVER); layer_off(_PLOVER);
} }
break; break;
return false; return STOP_PROCESSING;
case RGBLED_TOGGLE: case RGBLED_TOGGLE:
//led operations //led operations
if (record->event.pressed) { if (record->event.pressed) {
rgblight_toggle(); rgblight_toggle();
} }
return false; return STOP_PROCESSING;
break; break;
case RGBLED_INCREASE_HUE: case RGBLED_INCREASE_HUE:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_increase_hue(); rgblight_increase_hue();
} }
return false; return STOP_PROCESSING;
break; break;
case RGBLED_DECREASE_HUE: case RGBLED_DECREASE_HUE:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_decrease_hue(); rgblight_decrease_hue();
} }
return false; return STOP_PROCESSING;
break; break;
case RGBLED_INCREASE_SAT: case RGBLED_INCREASE_SAT:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_increase_sat(); rgblight_increase_sat();
} }
return false; return STOP_PROCESSING;
break; break;
case RGBLED_DECREASE_SAT: case RGBLED_DECREASE_SAT:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_decrease_sat(); rgblight_decrease_sat();
} }
return false; return STOP_PROCESSING;
break; break;
case RGBLED_INCREASE_VAL: case RGBLED_INCREASE_VAL:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_increase_val(); rgblight_increase_val();
} }
return false; return STOP_PROCESSING;
break; break;
case RGBLED_DECREASE_VAL: case RGBLED_DECREASE_VAL:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_decrease_val(); rgblight_decrease_val();
} }
return false; return STOP_PROCESSING;
break; break;
case RGBLED_STEP_MODE: case RGBLED_STEP_MODE:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_step(); rgblight_step();
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };
void matrix_init_user(void) { void matrix_init_user(void) {

@ -191,7 +191,7 @@ void persistant_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -200,7 +200,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistant_default_layer_set(1UL<<_QWERTY); persistant_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -209,7 +209,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistant_default_layer_set(1UL<<_COLEMAK); persistant_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
/*case DVORAK:*/ /*case DVORAK:*/
/*if (record->event.pressed) {*/ /*if (record->event.pressed) {*/
@ -218,7 +218,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
/*#endif*/ /*#endif*/
/*persistant_default_layer_set(1UL<<_DVORAK);*/ /*persistant_default_layer_set(1UL<<_DVORAK);*/
/*}*/ /*}*/
/*return false;*/ /*return STOP_PROCESSING;*/
/*break;*/ /*break;*/
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -228,7 +228,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -238,7 +238,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -249,7 +249,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
/*case PLOVER:*/ /*case PLOVER:*/
/*if (record->event.pressed) {*/ /*if (record->event.pressed) {*/
@ -268,7 +268,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
/*keymap_config.nkro = 1;*/ /*keymap_config.nkro = 1;*/
/*eeconfig_update_keymap(keymap_config.raw);*/ /*eeconfig_update_keymap(keymap_config.raw);*/
/*}*/ /*}*/
/*return false;*/ /*return STOP_PROCESSING;*/
/*break;*/ /*break;*/
/*case EXT_PLV:*/ /*case EXT_PLV:*/
/*if (record->event.pressed) {*/ /*if (record->event.pressed) {*/
@ -277,10 +277,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
/*#endif*/ /*#endif*/
/*layer_off(_PLOVER);*/ /*layer_off(_PLOVER);*/
/*}*/ /*}*/
/*return false;*/ /*return STOP_PROCESSING;*/
/*break;*/ /*break;*/
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -169,7 +169,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case WORKMAN: case WORKMAN:
if (record->event.pressed) { if (record->event.pressed) {
@ -178,7 +178,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_WORKMAN); persistent_default_layer_set(1UL<<_WORKMAN);
} }
return false; return STOP_PROCESSING;
break; break;
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -187,7 +187,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case PLOVER: case PLOVER:
if (record->event.pressed) { if (record->event.pressed) {
@ -202,10 +202,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
eeconfig_update_keymap(keymap_config.raw); eeconfig_update_keymap(keymap_config.raw);
persistent_default_layer_set(1UL<<_PLOVER); persistent_default_layer_set(1UL<<_PLOVER);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -275,7 +275,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -284,7 +284,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
default_layer_set(1UL<<_QWERTY); default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -293,7 +293,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
default_layer_set(1UL<<_COLEMAK); default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -302,7 +302,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
default_layer_set(1UL<<_DVORAK); default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -312,7 +312,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -322,7 +322,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -333,7 +333,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case PLOVER: case PLOVER:
if (record->event.pressed) { if (record->event.pressed) {
@ -352,7 +352,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
keymap_config.nkro = 1; keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw); eeconfig_update_keymap(keymap_config.raw);
} }
return false; return STOP_PROCESSING;
break; break;
case EXT_PLV: case EXT_PLV:
if (record->event.pressed) { if (record->event.pressed) {
@ -361,10 +361,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
layer_off(_PLOVER); layer_off(_PLOVER);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
/* /*

@ -85,7 +85,7 @@ void press_three_keys(uint16_t key1, uint16_t key2, uint16_t key3) {
unregister_code(key1); unregister_code(key1);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case MY_BELW: case MY_BELW:
if (record->event.pressed) { if (record->event.pressed) {
@ -93,7 +93,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_ENT); press_key(KC_ENT);
} }
return false; return STOP_PROCESSING;
case MY_ABVE: case MY_ABVE:
if (record->event.pressed) { if (record->event.pressed) {
@ -102,14 +102,14 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_UP); press_key(KC_UP);
} }
return false; return STOP_PROCESSING;
case MY_TERM: case MY_TERM:
if (record->event.pressed) { if (record->event.pressed) {
press_three_keys(KC_LGUI, KC_LSFT, KC_ENT); press_three_keys(KC_LGUI, KC_LSFT, KC_ENT);
} }
return false; return STOP_PROCESSING;
case MY_DEQL: // /= case MY_DEQL: // /=
if (record->event.pressed) { if (record->event.pressed) {
@ -117,7 +117,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_EQL); press_key(KC_EQL);
} }
return false; return STOP_PROCESSING;
case MY_MEQL: // *= case MY_MEQL: // *=
if (record->event.pressed) { if (record->event.pressed) {
@ -125,7 +125,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_EQL); press_key(KC_EQL);
} }
return false; return STOP_PROCESSING;
case MY_SEQL: // -= case MY_SEQL: // -=
if (record->event.pressed) { if (record->event.pressed) {
@ -133,7 +133,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_EQL); press_key(KC_EQL);
} }
return false; return STOP_PROCESSING;
case MY_PEQL: // += case MY_PEQL: // +=
if (record->event.pressed) { if (record->event.pressed) {
@ -141,7 +141,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_EQL); press_key(KC_EQL);
} }
return false; return STOP_PROCESSING;
case MY_NEQL: // != case MY_NEQL: // !=
if (record->event.pressed) { if (record->event.pressed) {
@ -149,7 +149,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_EQL); press_key(KC_EQL);
} }
return false; return STOP_PROCESSING;
case MY_LTGT: // <> case MY_LTGT: // <>
if (record->event.pressed) { if (record->event.pressed) {
@ -157,7 +157,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_two_keys(KC_LSFT, KC_RABK); press_two_keys(KC_LSFT, KC_RABK);
} }
return false; return STOP_PROCESSING;
case MY_DPIP: // || case MY_DPIP: // ||
if (record->event.pressed) { if (record->event.pressed) {
@ -165,7 +165,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_two_keys(KC_LSFT, KC_PIPE); press_two_keys(KC_LSFT, KC_PIPE);
} }
return false; return STOP_PROCESSING;
case MY_DAMP: // && case MY_DAMP: // &&
if (record->event.pressed) { if (record->event.pressed) {
@ -173,8 +173,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_two_keys(KC_LSFT, KC_AMPR); press_two_keys(KC_LSFT, KC_AMPR);
} }
return false; return STOP_PROCESSING;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -188,7 +188,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case WORKMAN: case WORKMAN:
if (record->event.pressed) { if (record->event.pressed) {
@ -197,7 +197,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_WORKMAN); persistent_default_layer_set(1UL<<_WORKMAN);
} }
return false; return STOP_PROCESSING;
break; break;
case DEAD: case DEAD:
if (record->event.pressed) { if (record->event.pressed) {
@ -205,7 +205,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
set_oneshot_layer(_DEAD, ONESHOT_START); set_oneshot_layer(_DEAD, ONESHOT_START);
clear_oneshot_layer_state(ONESHOT_PRESSED); clear_oneshot_layer_state(ONESHOT_PRESSED);
} }
return false; return STOP_PROCESSING;
break; break;
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -214,7 +214,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -224,7 +224,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -234,7 +234,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case PLOVER: case PLOVER:
if (record->event.pressed) { if (record->event.pressed) {
@ -253,7 +253,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
keymap_config.nkro = 1; keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw); eeconfig_update_keymap(keymap_config.raw);
} }
return false; return STOP_PROCESSING;
break; break;
case EXT_PLV: case EXT_PLV:
if (record->event.pressed) { if (record->event.pressed) {
@ -262,7 +262,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
layer_off(_PLOVER); layer_off(_PLOVER);
} }
return false; return STOP_PROCESSING;
break; break;
case TOG_PLV: case TOG_PLV:
if (record->event.pressed) { if (record->event.pressed) {
@ -274,10 +274,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
register_code(KC_O); register_code(KC_O);
clear_keyboard(); clear_keyboard();
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -244,7 +244,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
return MACRO_NONE; return MACRO_NONE;
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -253,7 +253,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -262,7 +262,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -271,7 +271,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -281,7 +281,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -291,7 +291,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -302,7 +302,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case PLOVER: case PLOVER:
if (record->event.pressed) { if (record->event.pressed) {
@ -321,7 +321,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
keymap_config.nkro = 1; keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw); eeconfig_update_keymap(keymap_config.raw);
} }
return false; return STOP_PROCESSING;
break; break;
case EXT_PLV: case EXT_PLV:
if (record->event.pressed) { if (record->event.pressed) {
@ -330,10 +330,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
layer_off(_PLOVER); layer_off(_PLOVER);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -186,7 +186,7 @@ float tone_goodbye[][2] = SONG(GOODBYE_SOUND);
#endif #endif
bool process_record_user(uint16_t keycode, keyrecord_t *record) level_t process_user(uint16_t keycode, keyrecord_t *record)
{ {
switch (keycode) { switch (keycode) {
case LOWER: case LOWER:
@ -196,7 +196,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record)
layer_off(_LOWER); layer_off(_LOWER);
} }
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
return false; return STOP_PROCESSING;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
layer_on(_RAISE); layer_on(_RAISE);
@ -204,27 +204,27 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record)
layer_off(_RAISE); layer_off(_RAISE);
} }
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
return false; return STOP_PROCESSING;
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
layer_off(_ARROW); layer_off(_ARROW);
layer_off(_NUMPAD); layer_off(_NUMPAD);
} }
return false; return STOP_PROCESSING;
case ARROW: case ARROW:
if (record->event.pressed) { if (record->event.pressed) {
layer_off(_NUMPAD); layer_off(_NUMPAD);
layer_on(_ARROW); layer_on(_ARROW);
} }
return false; return STOP_PROCESSING;
case NUMPAD: case NUMPAD:
if (record->event.pressed) { if (record->event.pressed) {
layer_off(_ARROW); layer_off(_ARROW);
layer_on(_NUMPAD); layer_on(_NUMPAD);
} }
return false; return STOP_PROCESSING;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) void matrix_init_user(void)

@ -126,7 +126,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case NERD: case NERD:
if (record->event.pressed) { if (record->event.pressed) {
@ -135,7 +135,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_NERD); persistent_default_layer_set(1UL<<_NERD);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -145,7 +145,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -155,10 +155,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -105,7 +105,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -114,7 +114,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -123,7 +123,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -132,7 +132,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -142,7 +142,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -152,7 +152,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -163,7 +163,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case PLOVER: case PLOVER:
if (record->event.pressed) { if (record->event.pressed) {
@ -182,7 +182,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
keymap_config.nkro = 1; keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw); eeconfig_update_keymap(keymap_config.raw);
} }
return false; return STOP_PROCESSING;
break; break;
case EXT_PLV: case EXT_PLV:
if (record->event.pressed) { if (record->event.pressed) {
@ -191,10 +191,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
layer_off(_PLOVER); layer_off(_PLOVER);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -144,7 +144,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -153,7 +153,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -162,7 +162,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -172,7 +172,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -182,7 +182,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -193,10 +193,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -167,7 +167,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -176,7 +176,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -185,7 +185,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -194,7 +194,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -204,7 +204,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -214,7 +214,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -225,10 +225,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -181,25 +181,25 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
float plover_gb_song[][2] = SONG(PLOVER_GOODBYE_SOUND); float plover_gb_song[][2] = SONG(PLOVER_GOODBYE_SOUND);
#endif #endif
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
set_single_persistent_default_layer(_QWERTY); set_single_persistent_default_layer(_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
set_single_persistent_default_layer(_COLEMAK); set_single_persistent_default_layer(_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
set_single_persistent_default_layer(_DVORAK); set_single_persistent_default_layer(_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -209,7 +209,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -219,7 +219,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -230,7 +230,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case PLOVER: case PLOVER:
if (!record->event.pressed) { if (!record->event.pressed) {
@ -240,7 +240,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
layer_on(_PLOVER); layer_on(_PLOVER);
} }
return false; return STOP_PROCESSING;
break; break;
case EXT_PLV: case EXT_PLV:
if (record->event.pressed) { if (record->event.pressed) {
@ -249,8 +249,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
layer_off(_PLOVER); layer_off(_PLOVER);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -188,7 +188,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -197,7 +197,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -206,7 +206,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -215,7 +215,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -225,7 +225,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -235,7 +235,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -246,7 +246,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case PLOVER: case PLOVER:
if (record->event.pressed) { if (record->event.pressed) {
@ -265,7 +265,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
keymap_config.nkro = 1; keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw); eeconfig_update_keymap(keymap_config.raw);
} }
return false; return STOP_PROCESSING;
break; break;
case EXT_PLV: case EXT_PLV:
if (record->event.pressed) { if (record->event.pressed) {
@ -274,10 +274,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
layer_off(_PLOVER); layer_off(_PLOVER);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -104,12 +104,12 @@ const uint16_t PROGMEM fn_actions[] = {
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
static uint16_t key_timer; static uint16_t key_timer;
uint16_t macro_kc = (keycode == MO(_DYN) ? DYN_REC_STOP : keycode); uint16_t macro_kc = (keycode == MO(_DYN) ? DYN_REC_STOP : keycode);
if (!process_record_dynamic_macro(macro_kc, record)) { if (!process_record_dynamic_macro(macro_kc, record)) {
return false; return STOP_PROCESSING;
} }
switch (keycode) { switch (keycode) {
@ -120,7 +120,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LW); layer_off(_LW);
} }
update_tri_layer(_LW, _RS, _DL); update_tri_layer(_LW, _RS, _DL);
return false; return STOP_PROCESSING;
break; break;
case KM_RS: case KM_RS:
if (record->event.pressed) { if (record->event.pressed) {
@ -129,7 +129,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RS); layer_off(_RS);
} }
update_tri_layer(_LW, _RS, _DL); update_tri_layer(_LW, _RS, _DL);
return false; return STOP_PROCESSING;
break; break;
case KM_SHLK: case KM_SHLK:
register_code(KC_LSFT); register_code(KC_LSFT);
@ -179,7 +179,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_NM); layer_off(_NM);
} }
return true; return CONTINUE_PROCESSING;
} }
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)

@ -164,7 +164,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -173,7 +173,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -182,7 +182,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -191,7 +191,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -201,7 +201,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -211,7 +211,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -222,10 +222,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
void matrix_init_user(void) { void matrix_init_user(void) {

@ -196,7 +196,7 @@ const uint32_t PROGMEM unicode_map[] = {
static uint16_t key_timer; static uint16_t key_timer;
static uint8_t caps_status = 0; static uint8_t caps_status = 0;
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case COLEMAK: case COLEMAK:
if(record->event.pressed){ if(record->event.pressed){
@ -205,7 +205,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
PLAY_NOTE_ARRAY(tone_colemak, false, 0); PLAY_NOTE_ARRAY(tone_colemak, false, 0);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
case SWCOLE: case SWCOLE:
if(record->event.pressed){ if(record->event.pressed){
@ -214,7 +214,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
PLAY_NOTE_ARRAY(tone_swcole, false, 0); PLAY_NOTE_ARRAY(tone_swcole, false, 0);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if(record->event.pressed){ if(record->event.pressed){
@ -224,7 +224,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if(record->event.pressed){ if(record->event.pressed){
@ -234,7 +234,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case SHFT_CAP: case SHFT_CAP:
if(record->event.pressed){ if(record->event.pressed){
@ -257,7 +257,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
unregister_code(KC_LSHIFT); unregister_code(KC_LSHIFT);
} }
return false; return STOP_PROCESSING;
break; break;
case CTRLB: // Control-B on tap (bold) case CTRLB: // Control-B on tap (bold)
if(record->event.pressed){ if(record->event.pressed){
@ -276,7 +276,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
unregister_code(KC_LCTL); unregister_code(KC_LCTL);
} }
return false; return STOP_PROCESSING;
break; break;
case CPYPST: // One key copy/paste case CPYPST: // One key copy/paste
if(record->event.pressed){ if(record->event.pressed){
@ -298,7 +298,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
} }
} }
return false; return STOP_PROCESSING;
break; break;
#ifdef UNICODE_ENABLE #ifdef UNICODE_ENABLE
case UNIWIN: case UNIWIN:
@ -308,7 +308,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
PLAY_NOTE_ARRAY(uniwin, false, 0); PLAY_NOTE_ARRAY(uniwin, false, 0);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
case UNILIN: case UNILIN:
if(record->event.pressed){ if(record->event.pressed){
@ -317,7 +317,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
PLAY_NOTE_ARRAY(unilin, false, 0); PLAY_NOTE_ARRAY(unilin, false, 0);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
case DISFACE: // ಠ_ಠ case DISFACE: // ಠ_ಠ
if(record->event.pressed){ if(record->event.pressed){
@ -327,7 +327,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
process_unicode((0x0CA0|QK_UNICODE), record); // Eye process_unicode((0x0CA0|QK_UNICODE), record); // Eye
} }
return false; return STOP_PROCESSING;
break; break;
case TFLIP: // (╯°□°)╯ ︵ ┻━┻ case TFLIP: // (╯°□°)╯ ︵ ┻━┻
if(record->event.pressed){ if(record->event.pressed){
@ -349,7 +349,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
process_unicode((0x2501|QK_UNICODE), record); // Table process_unicode((0x2501|QK_UNICODE), record); // Table
process_unicode((0x253B|QK_UNICODE), record); // Table process_unicode((0x253B|QK_UNICODE), record); // Table
} }
return false; return STOP_PROCESSING;
break; break;
case TPUT: // ┬──┬ ( ゜-゜ノ) case TPUT: // ┬──┬ ( ゜-゜ノ)
if(record->event.pressed){ if(record->event.pressed){
@ -371,7 +371,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
tap(KC_0); tap(KC_0);
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case SHRUG: // ¯\_(ツ)_/¯ case SHRUG: // ¯\_(ツ)_/¯
if(record->event.pressed){ if(record->event.pressed){
@ -389,7 +389,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
tap(KC_SLSH); // Arm tap(KC_SLSH); // Arm
process_unicode((0x00AF|QK_UNICODE), record); // Hand process_unicode((0x00AF|QK_UNICODE), record); // Hand
} }
return false; return STOP_PROCESSING;
break; break;
#endif #endif
case FACE: // (o_O) case FACE: // (o_O)
@ -404,16 +404,16 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
tap(KC_RPRN); tap(KC_RPRN);
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case RANDIG: case RANDIG:
if (record->event.pressed) { if (record->event.pressed) {
tap_random_base64(); tap_random_base64();
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };
void matrix_init_user(void){ // Run once at startup void matrix_init_user(void){ // Run once at startup

@ -139,7 +139,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -165,9 +165,9 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
break; break;
default: default:
return true; return CONTINUE_PROCESSING;
break; break;
} }
return false; return STOP_PROCESSING;
}; };

@ -166,25 +166,25 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
set_single_persistent_default_layer(_QWERTY); set_single_persistent_default_layer(_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
set_single_persistent_default_layer(_COLEMAK); set_single_persistent_default_layer(_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
set_single_persistent_default_layer(_DVORAK); set_single_persistent_default_layer(_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -194,7 +194,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -204,7 +204,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -215,8 +215,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };

@ -201,13 +201,13 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -217,7 +217,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -227,13 +227,13 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case MQWERTY: case MQWERTY:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_MQWERTY); persistent_default_layer_set(1UL<<_MQWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case MLOWER: case MLOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -243,7 +243,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_MLOWER); layer_off(_MLOWER);
update_tri_layer(_MLOWER, _MRAISE, _ADJUST); update_tri_layer(_MLOWER, _MRAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case MRAISE: case MRAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -253,10 +253,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_MRAISE); layer_off(_MRAISE);
update_tri_layer(_MLOWER, _MRAISE, _ADJUST); update_tri_layer(_MLOWER, _MRAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };
void matrix_init_user(void) { void matrix_init_user(void) {

@ -87,7 +87,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
/*bool process_record_user(uint16_t keycode, keyrecord_t *record) {*/ /*level_t process_user(uint16_t keycode, keyrecord_t *record) {*/
/*return true;*/ /*return true;*/
/*[>switch (keycode) {<]*/ /*[>switch (keycode) {<]*/
/*[>case QWERTY:<]*/ /*[>case QWERTY:<]*/

@ -141,7 +141,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -150,7 +150,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -160,7 +160,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -170,7 +170,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -181,10 +181,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };
void matrix_init_user(void) { void matrix_init_user(void) {

@ -188,7 +188,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -197,7 +197,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -206,7 +206,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -215,7 +215,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -225,7 +225,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -235,7 +235,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -246,10 +246,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };
void matrix_init_user(void) { void matrix_init_user(void) {

@ -182,7 +182,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -191,7 +191,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -200,7 +200,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -209,7 +209,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -219,7 +219,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -229,7 +229,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -240,10 +240,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };
void matrix_init_user(void) { void matrix_init_user(void) {

@ -196,7 +196,7 @@ const uint32_t PROGMEM unicode_map[] = {
static uint16_t key_timer; static uint16_t key_timer;
static uint8_t caps_status = 0; static uint8_t caps_status = 0;
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case COLEMAK: case COLEMAK:
if(record->event.pressed){ if(record->event.pressed){
@ -205,7 +205,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
PLAY_NOTE_ARRAY(tone_colemak, false, 0); PLAY_NOTE_ARRAY(tone_colemak, false, 0);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
case SWCOLE: case SWCOLE:
if(record->event.pressed){ if(record->event.pressed){
@ -214,7 +214,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
PLAY_NOTE_ARRAY(tone_swcole, false, 0); PLAY_NOTE_ARRAY(tone_swcole, false, 0);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if(record->event.pressed){ if(record->event.pressed){
@ -224,7 +224,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if(record->event.pressed){ if(record->event.pressed){
@ -234,7 +234,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case SHFT_CAP: case SHFT_CAP:
if(record->event.pressed){ if(record->event.pressed){
@ -257,7 +257,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
unregister_code(KC_LSHIFT); unregister_code(KC_LSHIFT);
} }
return false; return STOP_PROCESSING;
break; break;
case CTRLB: // Control-B on tap (bold) case CTRLB: // Control-B on tap (bold)
if(record->event.pressed){ if(record->event.pressed){
@ -276,7 +276,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
unregister_code(KC_LCTL); unregister_code(KC_LCTL);
} }
return false; return STOP_PROCESSING;
break; break;
case CPYPST: // One key copy/paste case CPYPST: // One key copy/paste
if(record->event.pressed){ if(record->event.pressed){
@ -298,7 +298,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
} }
} }
return false; return STOP_PROCESSING;
break; break;
#ifdef UNICODE_ENABLE #ifdef UNICODE_ENABLE
case UNIWIN: case UNIWIN:
@ -308,7 +308,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
PLAY_NOTE_ARRAY(uniwin, false, 0); PLAY_NOTE_ARRAY(uniwin, false, 0);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
case UNILIN: case UNILIN:
if(record->event.pressed){ if(record->event.pressed){
@ -317,7 +317,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
PLAY_NOTE_ARRAY(unilin, false, 0); PLAY_NOTE_ARRAY(unilin, false, 0);
#endif #endif
} }
return false; return STOP_PROCESSING;
break; break;
case DISFACE: // ಠ_ಠ case DISFACE: // ಠ_ಠ
if(record->event.pressed){ if(record->event.pressed){
@ -327,7 +327,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
process_unicode((0x0CA0|QK_UNICODE), record); // Eye process_unicode((0x0CA0|QK_UNICODE), record); // Eye
} }
return false; return STOP_PROCESSING;
break; break;
case TFLIP: // (╯°□°)╯ ︵ ┻━┻ case TFLIP: // (╯°□°)╯ ︵ ┻━┻
if(record->event.pressed){ if(record->event.pressed){
@ -349,7 +349,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
process_unicode((0x2501|QK_UNICODE), record); // Table process_unicode((0x2501|QK_UNICODE), record); // Table
process_unicode((0x253B|QK_UNICODE), record); // Table process_unicode((0x253B|QK_UNICODE), record); // Table
} }
return false; return STOP_PROCESSING;
break; break;
case TPUT: // ┬──┬ ( ゜-゜ノ) case TPUT: // ┬──┬ ( ゜-゜ノ)
if(record->event.pressed){ if(record->event.pressed){
@ -371,7 +371,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
tap(KC_0); tap(KC_0);
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case SHRUG: // ¯\_(ツ)_/¯ case SHRUG: // ¯\_(ツ)_/¯
if(record->event.pressed){ if(record->event.pressed){
@ -389,7 +389,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
tap(KC_SLSH); // Arm tap(KC_SLSH); // Arm
process_unicode((0x00AF|QK_UNICODE), record); // Hand process_unicode((0x00AF|QK_UNICODE), record); // Hand
} }
return false; return STOP_PROCESSING;
break; break;
#endif #endif
case FACE: // (o_O) case FACE: // (o_O)
@ -404,16 +404,16 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
tap(KC_RPRN); tap(KC_RPRN);
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case RANDIG: case RANDIG:
if (record->event.pressed) { if (record->event.pressed) {
tap_random_base64(); tap_random_base64();
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };
void matrix_init_user(void){ // Run once at startup void matrix_init_user(void){ // Run once at startup

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -207,7 +207,7 @@ bool process_german(uint16_t keycode, keyrecord_t *record) {
return true; return true;
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
//revive dead keys //revive dead keys
#ifndef DONT_REVIVE_DEADKEYS #ifndef DONT_REVIVE_DEADKEYS
bool shift_active = keyboard_report->mods & (MOD_BIT(KC_LSFT) | MOD_BIT(KC_LSFT)); bool shift_active = keyboard_report->mods & (MOD_BIT(KC_LSFT) | MOD_BIT(KC_LSFT));
@ -222,13 +222,13 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
register_code(KC_SPACE); register_code(KC_SPACE);
unregister_code(KC_SPACE); unregister_code(KC_SPACE);
} }
return false; return STOP_PROCESSING;
} }
#endif #endif
#if LANGUAGE == GERMAN #if LANGUAGE == GERMAN
return process_german(keycode, record); return process_german(keycode, record);
#else #else
return true; return CONTINUE_PROCESSING;
#endif #endif
} }

@ -632,7 +632,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
// Custom Keys // Custom Keys
bool process_record_user (uint16_t keycode, keyrecord_t *record) { level_t process_user (uint16_t keycode, keyrecord_t *record) {
uint16_t root_note = MIDI_INVALID_NOTE; // Starting value for the root note of each chord uint16_t root_note = MIDI_INVALID_NOTE; // Starting value for the root note of each chord
@ -691,5 +691,5 @@ bool process_record_user (uint16_t keycode, keyrecord_t *record) {
process_midi(root_note - 3, record); // Diminished 7th Note process_midi(root_note - 3, record); // Diminished 7th Note
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -166,8 +166,8 @@ void matrix_init_user(void) {
void matrix_scan_user(void) { void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -83,8 +83,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -116,26 +116,26 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -182,7 +182,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
@ -191,7 +191,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -200,7 +200,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
@ -209,7 +209,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -219,7 +219,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -229,7 +229,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -240,10 +240,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };
void matrix_init_user(void) { void matrix_init_user(void) {

@ -165,7 +165,7 @@ void tap(uint16_t keycode){
unregister_code(keycode); unregister_code(keycode);
}; };
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case LENNY: // ( ͡° ͜ʖ ͡°) case LENNY: // ( ͡° ͜ʖ ͡°)
if(record->event.pressed){ if(record->event.pressed){
@ -186,7 +186,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
tap(KC_0); // Head tap(KC_0); // Head
unregister_code(KC_LSFT); unregister_code(KC_LSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case DWNHRT: // (´・ω・`) case DWNHRT: // (´・ω・`)
if(record->event.pressed){ if(record->event.pressed){
@ -203,7 +203,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
tap(KC_0); // Head tap(KC_0); // Head
unregister_code(KC_LSFT); unregister_code(KC_LSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case SHRUG: // ¯\_(ツ)_/¯ case SHRUG: // ¯\_(ツ)_/¯
if(record->event.pressed){ if(record->event.pressed){
@ -222,10 +222,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
tap(KC_SLSH); // Arm tap(KC_SLSH); // Arm
process_unicode((0x00AF|QK_UNICODE), record); // Hand process_unicode((0x00AF|QK_UNICODE), record); // Hand
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
}; };
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {
@ -54,8 +54,8 @@ void matrix_scan_user(void) {
} }
__attribute__ ((weak)) __attribute__ ((weak))
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
__attribute__ ((weak)) __attribute__ ((weak))

@ -290,25 +290,25 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
default_layer_set(1UL<<_QWERTY); default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
default_layer_set(1UL<<_COLEMAK); default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
default_layer_set(1UL<<_DVORAK); default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -318,7 +318,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -328,7 +328,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -339,7 +339,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
case PLOVER: case PLOVER:
if (record->event.pressed) { if (record->event.pressed) {
@ -354,16 +354,16 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
keymap_config.nkro = 1; keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw); eeconfig_update_keymap(keymap_config.raw);
} }
return false; return STOP_PROCESSING;
break; break;
case EXT_PLV: case EXT_PLV:
if (record->event.pressed) { if (record->event.pressed) {
layer_off(_PLOVER); layer_off(_PLOVER);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }
/* /*

@ -176,25 +176,25 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -204,7 +204,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -214,7 +214,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case BACKLIT: case BACKLIT:
if (record->event.pressed) { if (record->event.pressed) {
@ -225,8 +225,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else { } else {
unregister_code(KC_RSFT); unregister_code(KC_RSFT);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -76,25 +76,25 @@ void persistent_default_layer_set(uint16_t default_layer) {
default_layer_set(default_layer); default_layer_set(default_layer);
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY); persistent_default_layer_set(1UL<<_QWERTY);
} }
return false; return STOP_PROCESSING;
break; break;
case COLEMAK: case COLEMAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_COLEMAK); persistent_default_layer_set(1UL<<_COLEMAK);
} }
return false; return STOP_PROCESSING;
break; break;
case DVORAK: case DVORAK:
if (record->event.pressed) { if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORAK); persistent_default_layer_set(1UL<<_DVORAK);
} }
return false; return STOP_PROCESSING;
break; break;
case LOWER: case LOWER:
if (record->event.pressed) { if (record->event.pressed) {
@ -104,7 +104,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER); layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
case RAISE: case RAISE:
if (record->event.pressed) { if (record->event.pressed) {
@ -114,8 +114,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE); layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer(_LOWER, _RAISE, _ADJUST);
} }
return false; return STOP_PROCESSING;
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -180,14 +180,14 @@ void dynamic_macro_record_end(
/* Handle the key events related to the dynamic macros. Should be /* Handle the key events related to the dynamic macros. Should be
* called from process_record_user() like this: * called from process_record_user() like this:
* *
* bool process_record_user(uint16_t keycode, keyrecord_t *record) { * level_t process_user(uint16_t keycode, keyrecord_t *record) {
* if (!process_record_dynamic_macro(keycode, record)) { * if (!process_record_dynamic_macro(keycode, record)) {
* return false; * return false;
* } * }
* <...THE REST OF THE FUNCTION...> * <...THE REST OF THE FUNCTION...>
* } * }
*/ */
bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record) level_t process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record)
{ {
/* Both macros use the same buffer but read/write on different /* Both macros use the same buffer but read/write on different
* ends of it. * ends of it.
@ -242,17 +242,17 @@ bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record)
case DYN_REC_START1: case DYN_REC_START1:
dynamic_macro_record_start(&macro_pointer, macro_buffer); dynamic_macro_record_start(&macro_pointer, macro_buffer);
macro_id = 1; macro_id = 1;
return false; return STOP_PROCESSING;
case DYN_REC_START2: case DYN_REC_START2:
dynamic_macro_record_start(&macro_pointer, r_macro_buffer); dynamic_macro_record_start(&macro_pointer, r_macro_buffer);
macro_id = 2; macro_id = 2;
return false; return STOP_PROCESSING;
case DYN_MACRO_PLAY1: case DYN_MACRO_PLAY1:
dynamic_macro_play(macro_buffer, macro_end, +1); dynamic_macro_play(macro_buffer, macro_end, +1);
return false; return STOP_PROCESSING;
case DYN_MACRO_PLAY2: case DYN_MACRO_PLAY2:
dynamic_macro_play(r_macro_buffer, r_macro_end, -1); dynamic_macro_play(r_macro_buffer, r_macro_end, -1);
return false; return STOP_PROCESSING;
} }
} }
} else { } else {
@ -273,11 +273,11 @@ bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record)
} }
macro_id = 0; macro_id = 0;
} }
return false; return STOP_PROCESSING;
case DYN_MACRO_PLAY1: case DYN_MACRO_PLAY1:
case DYN_MACRO_PLAY2: case DYN_MACRO_PLAY2:
dprintln("dynamic macro: ignoring macro play key while recording"); dprintln("dynamic macro: ignoring macro play key while recording");
return false; return STOP_PROCESSING;
default: default:
/* Store the key in the macro buffer and process it normally. */ /* Store the key in the macro buffer and process it normally. */
switch (macro_id) { switch (macro_id) {
@ -288,12 +288,12 @@ bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record)
dynamic_macro_record_key(r_macro_buffer, &macro_pointer, macro_end, -1, record); dynamic_macro_record_key(r_macro_buffer, &macro_pointer, macro_end, -1, record);
break; break;
} }
return true; return CONTINUE_PROCESSING;
break; break;
} }
} }
return true; return CONTINUE_PROCESSING;
} }
#undef DYNAMIC_MACRO_CURRENT_SLOT #undef DYNAMIC_MACRO_CURRENT_SLOT

@ -16,16 +16,16 @@ static float compute_freq_for_midi_note(uint8_t note)
return pow(2.0, (note - 69) / 12.0) * PITCH_STANDARD_A; return pow(2.0, (note - 69) / 12.0) * PITCH_STANDARD_A;
} }
bool process_audio(uint16_t keycode, keyrecord_t *record) { level_t process_audio(uint16_t keycode, keyrecord_t *record) {
if (keycode == AU_ON && record->event.pressed) { if (keycode == AU_ON && record->event.pressed) {
audio_on(); audio_on();
return false; return STOP_PROCESSING;
} }
if (keycode == AU_OFF && record->event.pressed) { if (keycode == AU_OFF && record->event.pressed) {
audio_off(); audio_off();
return false; return STOP_PROCESSING;
} }
if (keycode == AU_TOG && record->event.pressed) { if (keycode == AU_TOG && record->event.pressed) {
@ -34,22 +34,22 @@ bool process_audio(uint16_t keycode, keyrecord_t *record) {
} else { } else {
audio_on(); audio_on();
} }
return false; return STOP_PROCESSING;
} }
if (keycode == MUV_IN && record->event.pressed) { if (keycode == MUV_IN && record->event.pressed) {
voice_iterate(); voice_iterate();
PLAY_SONG(voice_change_song); PLAY_SONG(voice_change_song);
return false; return STOP_PROCESSING;
} }
if (keycode == MUV_DE && record->event.pressed) { if (keycode == MUV_DE && record->event.pressed) {
voice_deiterate(); voice_deiterate();
PLAY_SONG(voice_change_song); PLAY_SONG(voice_change_song);
return false; return STOP_PROCESSING;
} }
return true; return CONTINUE_PROCESSING;
} }
void process_audio_noteon(uint8_t note) { void process_audio_noteon(uint8_t note) {

@ -1,7 +1,9 @@
#ifndef PROCESS_AUDIO_H #ifndef PROCESS_AUDIO_H
#define PROCESS_AUDIO_H #define PROCESS_AUDIO_H
bool process_audio(uint16_t keycode, keyrecord_t *record); #include "quantum.h"
level_t process_audio(uint16_t keycode, keyrecord_t *record);
void process_audio_noteon(uint8_t note); void process_audio_noteon(uint8_t note);
void process_audio_noteoff(uint8_t note); void process_audio_noteoff(uint8_t note);
void process_audio_all_notes_off(void); void process_audio_all_notes_off(void);

@ -51,7 +51,7 @@ bool process_chording(uint16_t keycode, keyrecord_t *record) {
chord_keys[chord_key_count] = (keycode & 0xFF); chord_keys[chord_key_count] = (keycode & 0xFF);
chord_key_count++; chord_key_count++;
chord_key_down++; chord_key_down++;
return false; return STOP_PROCESSING;
} else { } else {
if (chording) { if (chording) {
chord_key_down--; chord_key_down--;
@ -61,16 +61,16 @@ bool process_chording(uint16_t keycode, keyrecord_t *record) {
if (keys_chord((uint8_t[]){KC_ENTER, KC_SPACE})) { if (keys_chord((uint8_t[]){KC_ENTER, KC_SPACE})) {
register_code(KC_A); register_code(KC_A);
unregister_code(KC_A); unregister_code(KC_A);
return false; return STOP_PROCESSING;
} }
for (uint8_t i = 0; i < chord_key_count; i++) { for (uint8_t i = 0; i < chord_key_count; i++) {
register_code(chord_keys[i]); register_code(chord_keys[i]);
unregister_code(chord_keys[i]); unregister_code(chord_keys[i]);
return false; return STOP_PROCESSING;
} }
} }
} }
} }
} }
return true; return CONTINUE_PROCESSING;
} }

@ -27,6 +27,6 @@ uint8_t chord_keys[CHORDING_MAX] = {0};
uint8_t chord_key_count = 0; uint8_t chord_key_count = 0;
uint8_t chord_key_down = 0; uint8_t chord_key_down = 0;
bool process_chording(uint16_t keycode, keyrecord_t *record); level_t process_chording(uint16_t keycode, keyrecord_t *record);
#endif #endif

@ -112,7 +112,7 @@ static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *
return is_combo_active; return is_combo_active;
} }
bool process_combo(uint16_t keycode, keyrecord_t *record) level_t process_combo(uint16_t keycode, keyrecord_t *record)
{ {
bool is_combo_key = false; bool is_combo_key = false;
@ -121,7 +121,7 @@ bool process_combo(uint16_t keycode, keyrecord_t *record)
is_combo_key |= process_single_combo(combo, keycode, record); is_combo_key |= process_single_combo(combo, keycode, record);
} }
return !is_combo_key; return is_combo_key ? STOP_PROCESSING : CONTINUE_PROCESSING;
} }
void matrix_scan_combo(void) void matrix_scan_combo(void)

@ -52,7 +52,7 @@ typedef struct
#define COMBO_TERM TAPPING_TERM #define COMBO_TERM TAPPING_TERM
#endif #endif
bool process_combo(uint16_t keycode, keyrecord_t *record); level_t process_combo(uint16_t keycode, keyrecord_t *record);
void matrix_scan_combo(void); void matrix_scan_combo(void);
void process_combo_event(uint8_t combo_index, bool pressed); void process_combo_event(uint8_t combo_index, bool pressed);

@ -29,7 +29,7 @@ uint16_t leader_time = 0;
uint16_t leader_sequence[5] = {0, 0, 0, 0, 0}; uint16_t leader_sequence[5] = {0, 0, 0, 0, 0};
uint8_t leader_sequence_size = 0; uint8_t leader_sequence_size = 0;
bool process_leader(uint16_t keycode, keyrecord_t *record) { level_t process_leader(uint16_t keycode, keyrecord_t *record) {
// Leader key set-up // Leader key set-up
if (record->event.pressed) { if (record->event.pressed) {
if (!leading && keycode == KC_LEAD) { if (!leading && keycode == KC_LEAD) {
@ -42,13 +42,13 @@ bool process_leader(uint16_t keycode, keyrecord_t *record) {
leader_sequence[2] = 0; leader_sequence[2] = 0;
leader_sequence[3] = 0; leader_sequence[3] = 0;
leader_sequence[4] = 0; leader_sequence[4] = 0;
return false; return STOP_PROCESSING;
} }
if (leading && timer_elapsed(leader_time) < LEADER_TIMEOUT) { if (leading && timer_elapsed(leader_time) < LEADER_TIMEOUT) {
leader_sequence[leader_sequence_size] = keycode; leader_sequence[leader_sequence_size] = keycode;
leader_sequence_size++; leader_sequence_size++;
return false; return STOP_PROCESSING;
} }
} }
return true; return CONTINUE_PROCESSING;
} }

@ -19,7 +19,7 @@
#include "quantum.h" #include "quantum.h"
bool process_leader(uint16_t keycode, keyrecord_t *record); level_t process_leader(uint16_t keycode, keyrecord_t *record);
void leader_start(void); void leader_start(void);
void leader_end(void); void leader_end(void);

@ -99,7 +99,7 @@ uint8_t midi_compute_note(uint16_t keycode)
return 12 * midi_config.octave + (keycode - MIDI_TONE_MIN) + midi_config.transpose; return 12 * midi_config.octave + (keycode - MIDI_TONE_MIN) + midi_config.transpose;
} }
bool process_midi(uint16_t keycode, keyrecord_t *record) level_t process_midi(uint16_t keycode, keyrecord_t *record)
{ {
switch (keycode) { switch (keycode) {
case MIDI_TONE_MIN ... MIDI_TONE_MAX: case MIDI_TONE_MIN ... MIDI_TONE_MAX:
@ -122,38 +122,38 @@ bool process_midi(uint16_t keycode, keyrecord_t *record)
} }
tone_status[tone] = MIDI_INVALID_NOTE; tone_status[tone] = MIDI_INVALID_NOTE;
} }
return false; return STOP_PROCESSING;
} }
case MIDI_OCTAVE_MIN ... MIDI_OCTAVE_MAX: case MIDI_OCTAVE_MIN ... MIDI_OCTAVE_MAX:
if (record->event.pressed) { if (record->event.pressed) {
midi_config.octave = keycode - MIDI_OCTAVE_MIN; midi_config.octave = keycode - MIDI_OCTAVE_MIN;
dprintf("midi octave %d\n", midi_config.octave); dprintf("midi octave %d\n", midi_config.octave);
} }
return false; return STOP_PROCESSING;
case MI_OCTD: case MI_OCTD:
if (record->event.pressed && midi_config.octave > 0) { if (record->event.pressed && midi_config.octave > 0) {
midi_config.octave--; midi_config.octave--;
dprintf("midi octave %d\n", midi_config.octave); dprintf("midi octave %d\n", midi_config.octave);
} }
return false; return STOP_PROCESSING;
case MI_OCTU: case MI_OCTU:
if (record->event.pressed && midi_config.octave < (MIDI_OCTAVE_MAX - MIDI_OCTAVE_MIN)) { if (record->event.pressed && midi_config.octave < (MIDI_OCTAVE_MAX - MIDI_OCTAVE_MIN)) {
midi_config.octave++; midi_config.octave++;
dprintf("midi octave %d\n", midi_config.octave); dprintf("midi octave %d\n", midi_config.octave);
} }
return false; return STOP_PROCESSING;
case MIDI_TRANSPOSE_MIN ... MIDI_TRANSPOSE_MAX: case MIDI_TRANSPOSE_MIN ... MIDI_TRANSPOSE_MAX:
if (record->event.pressed) { if (record->event.pressed) {
midi_config.transpose = keycode - MI_TRNS_0; midi_config.transpose = keycode - MI_TRNS_0;
dprintf("midi transpose %d\n", midi_config.transpose); dprintf("midi transpose %d\n", midi_config.transpose);
} }
return false; return STOP_PROCESSING;
case MI_TRNSD: case MI_TRNSD:
if (record->event.pressed && midi_config.transpose > (MIDI_TRANSPOSE_MIN - MI_TRNS_0)) { if (record->event.pressed && midi_config.transpose > (MIDI_TRANSPOSE_MIN - MI_TRNS_0)) {
midi_config.transpose--; midi_config.transpose--;
dprintf("midi transpose %d\n", midi_config.transpose); dprintf("midi transpose %d\n", midi_config.transpose);
} }
return false; return STOP_PROCESSING;
case MI_TRNSU: case MI_TRNSU:
if (record->event.pressed && midi_config.transpose < (MIDI_TRANSPOSE_MAX - MI_TRNS_0)) { if (record->event.pressed && midi_config.transpose < (MIDI_TRANSPOSE_MAX - MI_TRNS_0)) {
const bool positive = midi_config.transpose > 0; const bool positive = midi_config.transpose > 0;
@ -162,72 +162,72 @@ bool process_midi(uint16_t keycode, keyrecord_t *record)
midi_config.transpose--; midi_config.transpose--;
dprintf("midi transpose %d\n", midi_config.transpose); dprintf("midi transpose %d\n", midi_config.transpose);
} }
return false; return STOP_PROCESSING;
case MIDI_VELOCITY_MIN ... MIDI_VELOCITY_MAX: case MIDI_VELOCITY_MIN ... MIDI_VELOCITY_MAX:
if (record->event.pressed) { if (record->event.pressed) {
midi_config.velocity = keycode - MIDI_VELOCITY_MIN; midi_config.velocity = keycode - MIDI_VELOCITY_MIN;
dprintf("midi velocity %d\n", midi_config.velocity); dprintf("midi velocity %d\n", midi_config.velocity);
} }
return false; return STOP_PROCESSING;
case MI_VELD: case MI_VELD:
if (record->event.pressed && midi_config.velocity > 0) { if (record->event.pressed && midi_config.velocity > 0) {
midi_config.velocity--; midi_config.velocity--;
dprintf("midi velocity %d\n", midi_config.velocity); dprintf("midi velocity %d\n", midi_config.velocity);
} }
return false; return STOP_PROCESSING;
case MI_VELU: case MI_VELU:
if (record->event.pressed) { if (record->event.pressed) {
midi_config.velocity++; midi_config.velocity++;
dprintf("midi velocity %d\n", midi_config.velocity); dprintf("midi velocity %d\n", midi_config.velocity);
} }
return false; return STOP_PROCESSING;
case MIDI_CHANNEL_MIN ... MIDI_CHANNEL_MAX: case MIDI_CHANNEL_MIN ... MIDI_CHANNEL_MAX:
if (record->event.pressed) { if (record->event.pressed) {
midi_config.channel = keycode - MIDI_CHANNEL_MIN; midi_config.channel = keycode - MIDI_CHANNEL_MIN;
dprintf("midi channel %d\n", midi_config.channel); dprintf("midi channel %d\n", midi_config.channel);
} }
return false; return STOP_PROCESSING;
case MI_CHD: case MI_CHD:
if (record->event.pressed) { if (record->event.pressed) {
midi_config.channel--; midi_config.channel--;
dprintf("midi channel %d\n", midi_config.channel); dprintf("midi channel %d\n", midi_config.channel);
} }
return false; return STOP_PROCESSING;
case MI_CHU: case MI_CHU:
if (record->event.pressed) { if (record->event.pressed) {
midi_config.channel++; midi_config.channel++;
dprintf("midi channel %d\n", midi_config.channel); dprintf("midi channel %d\n", midi_config.channel);
} }
return false; return STOP_PROCESSING;
case MI_ALLOFF: case MI_ALLOFF:
if (record->event.pressed) { if (record->event.pressed) {
midi_send_cc(&midi_device, midi_config.channel, 0x7B, 0); midi_send_cc(&midi_device, midi_config.channel, 0x7B, 0);
dprintf("midi all notes off\n"); dprintf("midi all notes off\n");
} }
return false; return STOP_PROCESSING;
case MI_SUS: case MI_SUS:
midi_send_cc(&midi_device, midi_config.channel, 0x40, record->event.pressed ? 127 : 0); midi_send_cc(&midi_device, midi_config.channel, 0x40, record->event.pressed ? 127 : 0);
dprintf("midi sustain %d\n", record->event.pressed); dprintf("midi sustain %d\n", record->event.pressed);
return false; return STOP_PROCESSING;
case MI_PORT: case MI_PORT:
midi_send_cc(&midi_device, midi_config.channel, 0x41, record->event.pressed ? 127 : 0); midi_send_cc(&midi_device, midi_config.channel, 0x41, record->event.pressed ? 127 : 0);
dprintf("midi portamento %d\n", record->event.pressed); dprintf("midi portamento %d\n", record->event.pressed);
return false; return STOP_PROCESSING;
case MI_SOST: case MI_SOST:
midi_send_cc(&midi_device, midi_config.channel, 0x42, record->event.pressed ? 127 : 0); midi_send_cc(&midi_device, midi_config.channel, 0x42, record->event.pressed ? 127 : 0);
dprintf("midi sostenuto %d\n", record->event.pressed); dprintf("midi sostenuto %d\n", record->event.pressed);
return false; return STOP_PROCESSING;
case MI_SOFT: case MI_SOFT:
midi_send_cc(&midi_device, midi_config.channel, 0x43, record->event.pressed ? 127 : 0); midi_send_cc(&midi_device, midi_config.channel, 0x43, record->event.pressed ? 127 : 0);
dprintf("midi soft %d\n", record->event.pressed); dprintf("midi soft %d\n", record->event.pressed);
return false; return STOP_PROCESSING;
case MI_LEG: case MI_LEG:
midi_send_cc(&midi_device, midi_config.channel, 0x43, record->event.pressed ? 127 : 0); midi_send_cc(&midi_device, midi_config.channel, 0x43, record->event.pressed ? 127 : 0);
dprintf("midi legato %d\n", record->event.pressed); dprintf("midi legato %d\n", record->event.pressed);
return false; return STOP_PROCESSING;
case MI_MOD: case MI_MOD:
midi_modulation_step = record->event.pressed ? 1 : -1; midi_modulation_step = record->event.pressed ? 1 : -1;
return false; return STOP_PROCESSING;
case MI_MODSD: case MI_MODSD:
if (record->event.pressed) { if (record->event.pressed) {
midi_config.modulation_interval++; midi_config.modulation_interval++;
@ -236,16 +236,16 @@ bool process_midi(uint16_t keycode, keyrecord_t *record)
midi_config.modulation_interval--; midi_config.modulation_interval--;
dprintf("midi modulation interval %d\n", midi_config.modulation_interval); dprintf("midi modulation interval %d\n", midi_config.modulation_interval);
} }
return false; return STOP_PROCESSING;
case MI_MODSU: case MI_MODSU:
if (record->event.pressed && midi_config.modulation_interval > 0) { if (record->event.pressed && midi_config.modulation_interval > 0) {
midi_config.modulation_interval--; midi_config.modulation_interval--;
dprintf("midi modulation interval %d\n", midi_config.modulation_interval); dprintf("midi modulation interval %d\n", midi_config.modulation_interval);
} }
return false; return STOP_PROCESSING;
}; };
return true; return CONTINUE_PROCESSING;
} }
#endif // MIDI_ADVANCED #endif // MIDI_ADVANCED

@ -43,7 +43,7 @@ midi_config_t midi_config;
void midi_init(void); void midi_init(void);
void midi_task(void); void midi_task(void);
bool process_midi(uint16_t keycode, keyrecord_t *record); level_t process_midi(uint16_t keycode, keyrecord_t *record);
#define MIDI_INVALID_NOTE 0xFF #define MIDI_INVALID_NOTE 0xFF
#define MIDI_TONE_COUNT (MIDI_TONE_MAX - MIDI_TONE_MIN + 1) #define MIDI_TONE_COUNT (MIDI_TONE_MAX - MIDI_TONE_MIN + 1)

@ -100,16 +100,16 @@ void music_all_notes_off(void) {
#endif #endif
} }
bool process_music(uint16_t keycode, keyrecord_t *record) { level_t process_music(uint16_t keycode, keyrecord_t *record) {
if (keycode == MU_ON && record->event.pressed) { if (keycode == MU_ON && record->event.pressed) {
music_on(); music_on();
return false; return STOP_PROCESSING;
} }
if (keycode == MU_OFF && record->event.pressed) { if (keycode == MU_OFF && record->event.pressed) {
music_off(); music_off();
return false; return STOP_PROCESSING;
} }
if (keycode == MU_TOG && record->event.pressed) { if (keycode == MU_TOG && record->event.pressed) {
@ -118,12 +118,12 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
} else { } else {
music_on(); music_on();
} }
return false; return STOP_PROCESSING;
} }
if (keycode == MU_MOD && record->event.pressed) { if (keycode == MU_MOD && record->event.pressed) {
music_mode_cycle(); music_mode_cycle();
return false; return STOP_PROCESSING;
} }
if (music_activated) { if (music_activated) {
@ -134,7 +134,7 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
music_sequence_recorded = false; music_sequence_recorded = false;
music_sequence_playing = false; music_sequence_playing = false;
music_sequence_count = 0; music_sequence_count = 0;
return false; return STOP_PROCESSING;
} }
if (keycode == KC_LALT) { // Stop recording/playing if (keycode == KC_LALT) { // Stop recording/playing
@ -144,7 +144,7 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
} }
music_sequence_recording = false; music_sequence_recording = false;
music_sequence_playing = false; music_sequence_playing = false;
return false; return STOP_PROCESSING;
} }
if (keycode == KC_LGUI && music_sequence_recorded) { // Start playing if (keycode == KC_LGUI && music_sequence_recorded) { // Start playing
@ -153,17 +153,17 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
music_sequence_playing = true; music_sequence_playing = true;
music_sequence_position = 0; music_sequence_position = 0;
music_sequence_timer = 0; music_sequence_timer = 0;
return false; return STOP_PROCESSING;
} }
if (keycode == KC_UP) { if (keycode == KC_UP) {
music_sequence_interval-=10; music_sequence_interval-=10;
return false; return STOP_PROCESSING;
} }
if (keycode == KC_DOWN) { if (keycode == KC_DOWN) {
music_sequence_interval+=10; music_sequence_interval+=10;
return false; return STOP_PROCESSING;
} }
} }
@ -190,10 +190,10 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
} }
if (MUSIC_MASK) if (MUSIC_MASK)
return false; return STOP_PROCESSING;
} }
return true; return CONTINUE_PROCESSING;
} }
bool is_music_on(void) { bool is_music_on(void) {

@ -29,7 +29,7 @@ enum music_modes {
NUMBER_OF_MODES NUMBER_OF_MODES
}; };
bool process_music(uint16_t keycode, keyrecord_t *record); level_t process_music(uint16_t keycode, keyrecord_t *record);
bool is_music_on(void); bool is_music_on(void);
void music_toggle(void); void music_toggle(void);

@ -74,14 +74,14 @@ void print_box_string(const char text[]) {
print_string(out); print_string(out);
} }
bool process_printer(uint16_t keycode, keyrecord_t *record) { level_t process_printer(uint16_t keycode, keyrecord_t *record) {
if (keycode == PRINT_ON) { if (keycode == PRINT_ON) {
enable_printing(); enable_printing();
return false; return STOP_PROCESSING;
} }
if (keycode == PRINT_OFF) { if (keycode == PRINT_OFF) {
disable_printing(); disable_printing();
return false; return STOP_PROCESSING;
} }
if (printing_enabled) { if (printing_enabled) {
@ -101,7 +101,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
} else { } else {
character_shift--; character_shift--;
} }
return false; return STOP_PROCESSING;
break; break;
} }
@ -110,18 +110,18 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) { if (record->event.pressed) {
print_box_string("This is a line of text!"); print_box_string("This is a line of text!");
} }
return false; return STOP_PROCESSING;
case KC_ESC: case KC_ESC:
if (record->event.pressed) { if (record->event.pressed) {
print_char(0x1B); print_char(0x1B);
} }
return false; return STOP_PROCESSING;
break; break;
case KC_SPC: case KC_SPC:
if (record->event.pressed) { if (record->event.pressed) {
print_char(0x20); print_char(0x20);
} }
return false; return STOP_PROCESSING;
break; break;
case KC_A ... KC_Z: case KC_A ... KC_Z:
if (record->event.pressed) { if (record->event.pressed) {
@ -131,7 +131,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x61 + (keycode - KC_A)); print_char(0x61 + (keycode - KC_A));
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_1 ... KC_0: case KC_1 ... KC_0:
if (record->event.pressed) { if (record->event.pressed) {
@ -141,7 +141,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x30 + ((keycode - KC_1 + 1) % 10)); print_char(0x30 + ((keycode - KC_1 + 1) % 10));
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_ENT: case KC_ENT:
if (record->event.pressed) { if (record->event.pressed) {
@ -151,7 +151,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x0A); print_char(0x0A);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_BSPC: case KC_BSPC:
if (record->event.pressed) { if (record->event.pressed) {
@ -161,7 +161,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x1A); print_char(0x1A);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_DOT: case KC_DOT:
if (record->event.pressed) { if (record->event.pressed) {
@ -171,7 +171,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x2E); print_char(0x2E);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_COMM: case KC_COMM:
if (record->event.pressed) { if (record->event.pressed) {
@ -181,7 +181,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x2C); print_char(0x2C);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_SLSH: case KC_SLSH:
if (record->event.pressed) { if (record->event.pressed) {
@ -191,7 +191,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x2F); print_char(0x2F);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_QUOT: case KC_QUOT:
if (record->event.pressed) { if (record->event.pressed) {
@ -201,7 +201,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x27); print_char(0x27);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_GRV: case KC_GRV:
if (record->event.pressed) { if (record->event.pressed) {
@ -211,7 +211,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x60); print_char(0x60);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_MINS: case KC_MINS:
if (record->event.pressed) { if (record->event.pressed) {
@ -221,7 +221,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x2D); print_char(0x2D);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_EQL: case KC_EQL:
if (record->event.pressed) { if (record->event.pressed) {
@ -231,7 +231,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x3D); print_char(0x3D);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_LBRC: case KC_LBRC:
if (record->event.pressed) { if (record->event.pressed) {
@ -241,7 +241,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x5B); print_char(0x5B);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_RBRC: case KC_RBRC:
if (record->event.pressed) { if (record->event.pressed) {
@ -251,7 +251,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x5D); print_char(0x5D);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_BSLS: case KC_BSLS:
if (record->event.pressed) { if (record->event.pressed) {
@ -261,10 +261,10 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x5C); print_char(0x5C);
} }
} }
return false; return STOP_PROCESSING;
break; break;
} }
} }
return true; return CONTINUE_PROCESSING;
} }

@ -21,6 +21,6 @@
#include "protocol/serial.h" #include "protocol/serial.h"
bool process_printer(uint16_t keycode, keyrecord_t *record); level_t process_printer(uint16_t keycode, keyrecord_t *record);
#endif #endif

@ -80,14 +80,14 @@ void print_string(char c[]) {
print_char(c[i]); print_char(c[i]);
} }
bool process_printer(uint16_t keycode, keyrecord_t *record) { level_t process_printer(uint16_t keycode, keyrecord_t *record) {
if (keycode == PRINT_ON) { if (keycode == PRINT_ON) {
enable_printing(); enable_printing();
return false; return STOP_PROCESSING;
} }
if (keycode == PRINT_OFF) { if (keycode == PRINT_OFF) {
disable_printing(); disable_printing();
return false; return STOP_PROCESSING;
} }
if (printing_enabled) { if (printing_enabled) {
@ -107,7 +107,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
} else { } else {
character_shift--; character_shift--;
} }
return false; return STOP_PROCESSING;
break; break;
} }
@ -116,18 +116,18 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) { if (record->event.pressed) {
print_string("This is a line of text!\n\n\n"); print_string("This is a line of text!\n\n\n");
} }
return false; return STOP_PROCESSING;
case KC_ESC: case KC_ESC:
if (record->event.pressed) { if (record->event.pressed) {
print_char(0x1B); print_char(0x1B);
} }
return false; return STOP_PROCESSING;
break; break;
case KC_SPC: case KC_SPC:
if (record->event.pressed) { if (record->event.pressed) {
print_char(0x20); print_char(0x20);
} }
return false; return STOP_PROCESSING;
break; break;
case KC_A ... KC_Z: case KC_A ... KC_Z:
if (record->event.pressed) { if (record->event.pressed) {
@ -137,7 +137,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x61 + (keycode - KC_A)); print_char(0x61 + (keycode - KC_A));
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_1 ... KC_0: case KC_1 ... KC_0:
if (record->event.pressed) { if (record->event.pressed) {
@ -147,7 +147,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x30 + ((keycode - KC_1 + 1) % 10)); print_char(0x30 + ((keycode - KC_1 + 1) % 10));
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_ENT: case KC_ENT:
if (record->event.pressed) { if (record->event.pressed) {
@ -157,7 +157,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x0A); print_char(0x0A);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_BSPC: case KC_BSPC:
if (record->event.pressed) { if (record->event.pressed) {
@ -167,7 +167,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x1A); print_char(0x1A);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_DOT: case KC_DOT:
if (record->event.pressed) { if (record->event.pressed) {
@ -177,7 +177,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x2E); print_char(0x2E);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_COMM: case KC_COMM:
if (record->event.pressed) { if (record->event.pressed) {
@ -187,7 +187,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x2C); print_char(0x2C);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_SLSH: case KC_SLSH:
if (record->event.pressed) { if (record->event.pressed) {
@ -197,7 +197,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x2F); print_char(0x2F);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_QUOT: case KC_QUOT:
if (record->event.pressed) { if (record->event.pressed) {
@ -207,7 +207,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x27); print_char(0x27);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_GRV: case KC_GRV:
if (record->event.pressed) { if (record->event.pressed) {
@ -217,7 +217,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x60); print_char(0x60);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_MINS: case KC_MINS:
if (record->event.pressed) { if (record->event.pressed) {
@ -227,7 +227,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x2D); print_char(0x2D);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_EQL: case KC_EQL:
if (record->event.pressed) { if (record->event.pressed) {
@ -237,7 +237,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x3D); print_char(0x3D);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_LBRC: case KC_LBRC:
if (record->event.pressed) { if (record->event.pressed) {
@ -247,7 +247,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x5B); print_char(0x5B);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_RBRC: case KC_RBRC:
if (record->event.pressed) { if (record->event.pressed) {
@ -257,7 +257,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x5D); print_char(0x5D);
} }
} }
return false; return STOP_PROCESSING;
break; break;
case KC_BSLS: case KC_BSLS:
if (record->event.pressed) { if (record->event.pressed) {
@ -267,10 +267,10 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
print_char(0x5C); print_char(0x5C);
} }
} }
return false; return STOP_PROCESSING;
break; break;
} }
} }
return true; return CONTINUE_PROCESSING;
} }

@ -120,19 +120,19 @@ bool send_state_gemini(void) {
return false; return false;
} }
bool process_steno(uint16_t keycode, keyrecord_t *record) { level_t process_steno(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QK_STENO_BOLT: case QK_STENO_BOLT:
if (IS_PRESSED(record->event)) { if (IS_PRESSED(record->event)) {
steno_set_mode(STENO_MODE_BOLT); steno_set_mode(STENO_MODE_BOLT);
} }
return false; return STOP_PROCESSING;
case QK_STENO_GEMINI: case QK_STENO_GEMINI:
if (IS_PRESSED(record->event)) { if (IS_PRESSED(record->event)) {
steno_set_mode(STENO_MODE_GEMINI); steno_set_mode(STENO_MODE_GEMINI);
} }
return false; return STOP_PROCESSING;
case STN__MIN...STN__MAX: case STN__MIN...STN__MAX:
if (IS_PRESSED(record->event)) { if (IS_PRESSED(record->event)) {
@ -144,7 +144,7 @@ bool process_steno(uint16_t keycode, keyrecord_t *record) {
case STENO_MODE_GEMINI: case STENO_MODE_GEMINI:
return update_state_gemini(key); return update_state_gemini(key);
default: default:
return false; return STOP_PROCESSING;
} }
} else { } else {
--pressed; --pressed;
@ -156,11 +156,11 @@ bool process_steno(uint16_t keycode, keyrecord_t *record) {
case STENO_MODE_GEMINI: case STENO_MODE_GEMINI:
return send_state_gemini(); return send_state_gemini();
default: default:
return false; return STOP_PROCESSING;
} }
} }
} }
} }
return true; return CONTINUE_PROCESSING;
} }

@ -24,7 +24,7 @@
typedef enum { STENO_MODE_BOLT, STENO_MODE_GEMINI } steno_mode_t; typedef enum { STENO_MODE_BOLT, STENO_MODE_GEMINI } steno_mode_t;
bool process_steno(uint16_t keycode, keyrecord_t *record); level_t process_steno(uint16_t keycode, keyrecord_t *record);
void steno_init(void); void steno_init(void);
void steno_set_mode(steno_mode_t mode); void steno_set_mode(steno_mode_t mode);

@ -72,7 +72,7 @@ static inline void process_tap_dance_action_on_reset (qk_tap_dance_action_t *act
send_keyboard_report(); send_keyboard_report();
} }
bool process_tap_dance(uint16_t keycode, keyrecord_t *record) { level_t process_tap_dance(uint16_t keycode, keyrecord_t *record) {
uint16_t idx = keycode - QK_TAP_DANCE; uint16_t idx = keycode - QK_TAP_DANCE;
qk_tap_dance_action_t *action; qk_tap_dance_action_t *action;
@ -108,10 +108,10 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
default: default:
if (!record->event.pressed) if (!record->event.pressed)
return true; return CONTINUE_PROCESSING;
if (highest_td == -1) if (highest_td == -1)
return true; return CONTINUE_PROCESSING;
for (int i = 0; i <= highest_td; i++) { for (int i = 0; i <= highest_td; i++) {
action = &tap_dance_actions[i]; action = &tap_dance_actions[i];
@ -124,7 +124,7 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
break; break;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -20,6 +20,7 @@
#include <stdbool.h> #include <stdbool.h>
#include <inttypes.h> #include <inttypes.h>
#include "quantum.h"
typedef struct typedef struct
{ {
@ -79,7 +80,7 @@ extern qk_tap_dance_action_t tap_dance_actions[];
/* To be used internally */ /* To be used internally */
bool process_tap_dance(uint16_t keycode, keyrecord_t *record); level_t process_tap_dance(uint16_t keycode, keyrecord_t *record);
void matrix_scan_tap_dance (void); void matrix_scan_tap_dance (void);
void reset_tap_dance (qk_tap_dance_state_t *state); void reset_tap_dance (qk_tap_dance_state_t *state);

@ -88,19 +88,19 @@ void register_ucis(const char *hex) {
} }
} }
bool process_ucis (uint16_t keycode, keyrecord_t *record) { level_t process_ucis (uint16_t keycode, keyrecord_t *record) {
uint8_t i; uint8_t i;
if (!qk_ucis_state.in_progress) if (!qk_ucis_state.in_progress)
return true; return CONTINUE_PROCESSING;
if (qk_ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH && if (qk_ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH &&
!(keycode == KC_BSPC || keycode == KC_ESC || keycode == KC_SPC || keycode == KC_ENT)) { !(keycode == KC_BSPC || keycode == KC_ESC || keycode == KC_SPC || keycode == KC_ENT)) {
return false; return STOP_PROCESSING;
} }
if (!record->event.pressed) if (!record->event.pressed)
return true; return CONTINUE_PROCESSING;
qk_ucis_state.codes[qk_ucis_state.count] = keycode; qk_ucis_state.codes[qk_ucis_state.count] = keycode;
qk_ucis_state.count++; qk_ucis_state.count++;
@ -108,10 +108,10 @@ bool process_ucis (uint16_t keycode, keyrecord_t *record) {
if (keycode == KC_BSPC) { if (keycode == KC_BSPC) {
if (qk_ucis_state.count >= 2) { if (qk_ucis_state.count >= 2) {
qk_ucis_state.count -= 2; qk_ucis_state.count -= 2;
return true; return CONTINUE_PROCESSING;
} else { } else {
qk_ucis_state.count--; qk_ucis_state.count--;
return false; return STOP_PROCESSING;
} }
} }
@ -126,7 +126,7 @@ bool process_ucis (uint16_t keycode, keyrecord_t *record) {
if (keycode == KC_ESC) { if (keycode == KC_ESC) {
qk_ucis_state.in_progress = false; qk_ucis_state.in_progress = false;
return false; return STOP_PROCESSING;
} }
unicode_input_start(); unicode_input_start();
@ -143,7 +143,7 @@ bool process_ucis (uint16_t keycode, keyrecord_t *record) {
unicode_input_finish(); unicode_input_finish();
qk_ucis_state.in_progress = false; qk_ucis_state.in_progress = false;
return false; return STOP_PROCESSING;
} }
return true; return CONTINUE_PROCESSING;
} }

@ -46,6 +46,6 @@ void qk_ucis_start(void);
void qk_ucis_start_user(void); void qk_ucis_start_user(void);
void qk_ucis_symbol_fallback (void); void qk_ucis_symbol_fallback (void);
void register_ucis(const char *hex); void register_ucis(const char *hex);
bool process_ucis (uint16_t keycode, keyrecord_t *record); level_t process_ucis (uint16_t keycode, keyrecord_t *record);
#endif #endif

@ -19,7 +19,7 @@
static uint8_t first_flag = 0; static uint8_t first_flag = 0;
bool process_unicode(uint16_t keycode, keyrecord_t *record) { level_t process_unicode(uint16_t keycode, keyrecord_t *record) {
if (keycode > QK_UNICODE && record->event.pressed) { if (keycode > QK_UNICODE && record->event.pressed) {
if (first_flag == 0) { if (first_flag == 0) {
set_unicode_input_mode(eeprom_read_byte(EECONFIG_UNICODEMODE)); set_unicode_input_mode(eeprom_read_byte(EECONFIG_UNICODEMODE));
@ -30,6 +30,6 @@ bool process_unicode(uint16_t keycode, keyrecord_t *record) {
register_hex(unicode); register_hex(unicode);
unicode_input_finish(); unicode_input_finish();
} }
return true; return CONTINUE_PROCESSING;
} }

@ -19,6 +19,6 @@
#include "quantum.h" #include "quantum.h"
#include "process_unicode_common.h" #include "process_unicode_common.h"
bool process_unicode(uint16_t keycode, keyrecord_t *record); level_t process_unicode(uint16_t keycode, keyrecord_t *record);
#endif #endif

@ -44,7 +44,7 @@ void register_hex32(uint32_t hex) {
__attribute__((weak)) __attribute__((weak))
void unicode_map_input_error() {} void unicode_map_input_error() {}
bool process_unicode_map(uint16_t keycode, keyrecord_t *record) { level_t process_unicode_map(uint16_t keycode, keyrecord_t *record) {
uint8_t input_mode = get_unicode_input_mode(); uint8_t input_mode = get_unicode_input_mode();
if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) { if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) {
const uint32_t* map = unicode_map; const uint32_t* map = unicode_map;
@ -68,5 +68,5 @@ bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
unicode_input_finish(); unicode_input_finish();
} }
} }
return true; return CONTINUE_PROCESSING;
} }

@ -21,5 +21,5 @@
#include "process_unicode_common.h" #include "process_unicode_common.h"
void unicode_map_input_error(void); void unicode_map_input_error(void);
bool process_unicode_map(uint16_t keycode, keyrecord_t *record); level_t process_unicode_map(uint16_t keycode, keyrecord_t *record);
#endif #endif

@ -117,20 +117,25 @@ void unregister_code16 (uint16_t code) {
} }
__attribute__ ((weak)) __attribute__ ((weak))
bool process_action_kb(keyrecord_t *record) { bool process_record_kb_deprecated(uint16_t keycode, keyrecord_t *record) {
return true; return true;
} }
__attribute__ ((weak)) __attribute__ ((weak))
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
return process_record_user(keycode, record); return process_record_kb_deprecated(keycode, record) ? CONTINUE_PROCESSING : STOP_PROCESSING;
} }
__attribute__ ((weak)) __attribute__ ((weak))
bool process_record_user(uint16_t keycode, keyrecord_t *record) { bool process_record_user_deprecated(uint16_t keycode, keyrecord_t *record) {
return true; return true;
} }
__attribute__ ((weak))
level_t process_user(uint16_t keycode, keyrecord_t *record) {
return process_record_user_deprecated(keycode, record) ? CONTINUE_PROCESSING : STOP_PROCESSING;
}
void reset_keyboard(void) { void reset_keyboard(void) {
clear_keyboard(); clear_keyboard();
#if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_ENABLE_BASIC)) #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_ENABLE_BASIC))
@ -162,7 +167,8 @@ void reset_keyboard(void) {
static bool shift_interrupted[2] = {0, 0}; static bool shift_interrupted[2] = {0, 0};
static uint16_t scs_timer[2] = {0, 0}; static uint16_t scs_timer[2] = {0, 0};
bool process_record_quantum(keyrecord_t *record) { level_t process_quantum(keyrecord_t *record) {
level_t level = CONTINUE_PROCESSING;
/* This gets the keycode from the key pressed */ /* This gets the keycode from the key pressed */
keypos_t key = record->event.key; keypos_t key = record->event.key;
@ -182,57 +188,67 @@ bool process_record_quantum(keyrecord_t *record) {
keycode = keymap_key_to_keycode(layer, key); keycode = keymap_key_to_keycode(layer, key);
} else } else
#endif #endif
keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key); keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
// This is how you use actions here // This is how you use actions here
// if (keycode == KC_LEAD) { // if (keycode == KC_LEAD) {
// action_t action; // action_t action;
// action.code = ACTION_DEFAULT_LAYER_SET(0); // action.code = ACTION_DEFAULT_LAYER_SET(0);
// process_action(record, action); // process_action(record, action);
// return false; // level |= STOP_PROCESSING;
// } // }
if (!( level |= process_user(keycode, record);
process_record_kb(keycode, record) && if (!(level & STOP_PROCESSING))
level |= process_kb(keycode, record);
#if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED) #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
process_midi(keycode, record) && if (!(level & STOP_PROCESSING))
level |= process_midi(keycode, record);
#endif #endif
#ifdef AUDIO_ENABLE #ifdef AUDIO_ENABLE
process_audio(keycode, record) && if (!(level & STOP_PROCESSING))
level |= process_audio(keycode, record);
#endif #endif
#ifdef STENO_ENABLE #ifdef STENO_ENABLE
process_steno(keycode, record) && if (!(level & STOP_PROCESSING))
level |= process_steno(keycode, record);
#endif #endif
#if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC)) #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
process_music(keycode, record) && if (!(level & STOP_PROCESSING))
level |= process_music(keycode, record);
#endif #endif
#ifdef TAP_DANCE_ENABLE #ifdef TAP_DANCE_ENABLE
process_tap_dance(keycode, record) && if (!(level & STOP_PROCESSING))
level |= process_tap_dance(keycode, record);
#endif #endif
#ifndef DISABLE_LEADER #ifndef DISABLE_LEADER
process_leader(keycode, record) && if (!(level & STOP_PROCESSING))
level |= process_leader(keycode, record);
#endif #endif
#ifndef DISABLE_CHORDING #ifndef DISABLE_CHORDING
process_chording(keycode, record) && if (!(level & STOP_PROCESSING))
level |= process_chording(keycode, record)
#endif #endif
#ifdef COMBO_ENABLE #ifdef COMBO_ENABLE
process_combo(keycode, record) && if (!(level & STOP_PROCESSING))
level |= process_combo(keycode, record);
#endif #endif
#ifdef UNICODE_ENABLE #ifdef UNICODE_ENABLE
process_unicode(keycode, record) && if (!(level & STOP_PROCESSING))
level |= process_unicode(keycode, record);
#endif #endif
#ifdef UCIS_ENABLE #ifdef UCIS_ENABLE
process_ucis(keycode, record) && if (!(level & STOP_PROCESSING))
level |= process_ucis(keycode, record);
#endif #endif
#ifdef PRINTING_ENABLE #ifdef PRINTING_ENABLE
process_printer(keycode, record) && if (!(level & STOP_PROCESSING))
level |= process_printer(keycode, record);
#endif #endif
#ifdef UNICODEMAP_ENABLE #ifdef UNICODEMAP_ENABLE
process_unicode_map(keycode, record) && if (!(level & STOP_PROCESSING))
level |= process_unicode_map(keycode, record);
#endif #endif
true)) {
return false;
}
// Shift / paren setup // Shift / paren setup
@ -241,33 +257,33 @@ bool process_record_quantum(keyrecord_t *record) {
if (record->event.pressed) { if (record->event.pressed) {
reset_keyboard(); reset_keyboard();
} }
return false; return (level | STOP_PROCESSING);
break; break;
case DEBUG: case DEBUG:
if (record->event.pressed) { if (record->event.pressed) {
print("\nDEBUG: enabled.\n"); print("\nDEBUG: enabled.\n");
debug_enable = true; debug_enable = true;
} }
return false; return (level | STOP_PROCESSING);
break; break;
#ifdef FAUXCLICKY_ENABLE #ifdef FAUXCLICKY_ENABLE
case FC_TOG: case FC_TOG:
if (record->event.pressed) { if (record->event.pressed) {
FAUXCLICKY_TOGGLE; FAUXCLICKY_TOGGLE;
} }
return false; return (level | STOP_PROCESSING);
break; break;
case FC_ON: case FC_ON:
if (record->event.pressed) { if (record->event.pressed) {
FAUXCLICKY_ON; FAUXCLICKY_ON;
} }
return false; return (level | STOP_PROCESSING);
break; break;
case FC_OFF: case FC_OFF:
if (record->event.pressed) { if (record->event.pressed) {
FAUXCLICKY_OFF; FAUXCLICKY_OFF;
} }
return false; return (level | STOP_PROCESSING);
break; break;
#endif #endif
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
@ -275,49 +291,49 @@ bool process_record_quantum(keyrecord_t *record) {
if (record->event.pressed) { if (record->event.pressed) {
rgblight_toggle(); rgblight_toggle();
} }
return false; return (level | STOP_PROCESSING);
break; break;
case RGB_MOD: case RGB_MOD:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_step(); rgblight_step();
} }
return false; return (level | STOP_PROCESSING);
break; break;
case RGB_HUI: case RGB_HUI:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_increase_hue(); rgblight_increase_hue();
} }
return false; return (level | STOP_PROCESSING);
break; break;
case RGB_HUD: case RGB_HUD:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_decrease_hue(); rgblight_decrease_hue();
} }
return false; return (level | STOP_PROCESSING);
break; break;
case RGB_SAI: case RGB_SAI:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_increase_sat(); rgblight_increase_sat();
} }
return false; return (level | STOP_PROCESSING);
break; break;
case RGB_SAD: case RGB_SAD:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_decrease_sat(); rgblight_decrease_sat();
} }
return false; return (level | STOP_PROCESSING);
break; break;
case RGB_VAI: case RGB_VAI:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_increase_val(); rgblight_increase_val();
} }
return false; return (level | STOP_PROCESSING);
break; break;
case RGB_VAD: case RGB_VAD:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_decrease_val(); rgblight_decrease_val();
} }
return false; return (level | STOP_PROCESSING);
break; break;
#endif #endif
#ifdef PROTOCOL_LUFA #ifdef PROTOCOL_LUFA
@ -325,20 +341,20 @@ bool process_record_quantum(keyrecord_t *record) {
if (record->event.pressed) { if (record->event.pressed) {
set_output(OUTPUT_AUTO); set_output(OUTPUT_AUTO);
} }
return false; return (level | STOP_PROCESSING);
break; break;
case OUT_USB: case OUT_USB:
if (record->event.pressed) { if (record->event.pressed) {
set_output(OUTPUT_USB); set_output(OUTPUT_USB);
} }
return false; return (level | STOP_PROCESSING);
break; break;
#ifdef BLUETOOTH_ENABLE #ifdef BLUETOOTH_ENABLE
case OUT_BT: case OUT_BT:
if (record->event.pressed) { if (record->event.pressed) {
set_output(OUTPUT_BLUETOOTH); set_output(OUTPUT_BLUETOOTH);
} }
return false; return (level | STOP_PROCESSING);
break; break;
#endif #endif
#endif #endif
@ -423,7 +439,7 @@ bool process_record_quantum(keyrecord_t *record) {
eeconfig_update_keymap(keymap_config.raw); eeconfig_update_keymap(keymap_config.raw);
clear_keyboard(); // clear to prevent stuck keys clear_keyboard(); // clear to prevent stuck keys
return false; return (level | STOP_PROCESSING);
} }
break; break;
case KC_LSPO: { case KC_LSPO: {
@ -445,7 +461,7 @@ bool process_record_quantum(keyrecord_t *record) {
} }
unregister_mods(MOD_BIT(KC_LSFT)); unregister_mods(MOD_BIT(KC_LSFT));
} }
return false; return (level | STOP_PROCESSING);
// break; // break;
} }
@ -468,7 +484,7 @@ bool process_record_quantum(keyrecord_t *record) {
} }
unregister_mods(MOD_BIT(KC_RSFT)); unregister_mods(MOD_BIT(KC_RSFT));
} }
return false; return (level | STOP_PROCESSING);
// break; // break;
} }
case GRAVE_ESC: { case GRAVE_ESC: {
@ -486,7 +502,7 @@ bool process_record_quantum(keyrecord_t *record) {
} }
} }
return process_action_kb(record); return level;
} }
__attribute__ ((weak)) __attribute__ ((weak))

@ -48,6 +48,17 @@ extern uint32_t default_layer_state;
extern uint32_t layer_state; extern uint32_t layer_state;
#endif #endif
typedef enum {
PL_STOP_PROCESSING
} process_level_t;
#define CONTINUE_PROCESSING (0)
#define STOP_PROCESSING (1<<PL_STOP_PROCESSING)
// uint8_t supports up to 8 stops
#define level_t uint8_t
#ifdef MIDI_ENABLE #ifdef MIDI_ENABLE
#include <lufa.h> #include <lufa.h>
#ifdef MIDI_ADVANCED #ifdef MIDI_ADVANCED
@ -119,9 +130,23 @@ void matrix_init_kb(void);
void matrix_scan_kb(void); void matrix_scan_kb(void);
void matrix_init_user(void); void matrix_init_user(void);
void matrix_scan_user(void); void matrix_scan_user(void);
bool process_action_kb(keyrecord_t *record);
bool process_record_kb(uint16_t keycode, keyrecord_t *record); /* keyboard-specific key event (pre)processing */
bool process_record_user(uint16_t keycode, keyrecord_t *record); level_t process_quantum(keyrecord_t *record);
level_t process_kb(uint16_t keycode, keyrecord_t *record);
level_t process_user(uint16_t keycode, keyrecord_t *record);
bool process_record_kb_deprecated(uint16_t keycode, keyrecord_t *record);
#define process_record_kb dummy_var_kb; \
_Pragma ("GCC warning \"'bool process_record_kb' is deprecated - use 'level_t process_kb' instead\"") \
bool process_record_kb_deprecated
bool process_record_user_deprecated(uint16_t keycode, keyrecord_t *record);
#define process_record_user dummy_var_user; \
_Pragma ("GCC warning \"'bool process_record_user' is deprecated - use 'level_t process_user' instead\"") \
bool process_record_user_deprecated
void reset_keyboard(void); void reset_keyboard(void);

@ -50,8 +50,8 @@ void matrix_scan_user(void) {
} }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { level_t process_user(uint16_t keycode, keyrecord_t *record) {
return true; return CONTINUE_PROCESSING;
} }
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {

@ -29,11 +29,11 @@ void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { level_t process_kb(uint16_t keycode, keyrecord_t *record) {
// put your per-action keyboard code here // put your per-action keyboard code here
// runs for every action, just before processing by the firmware // runs for every action, just before processing by the firmware
return process_record_user(keycode, record); return CONTINUE_PROCESSING;
} }
void led_set_kb(uint8_t usb_led) { void led_set_kb(uint8_t usb_led) {

@ -40,6 +40,8 @@ int tp_buttons;
#include <fauxclicky.h> #include <fauxclicky.h>
#endif #endif
#include "quantum.h"
void action_exec(keyevent_t event) void action_exec(keyevent_t event)
{ {
if (!IS_NOEVENT(event)) { if (!IS_NOEVENT(event)) {
@ -120,24 +122,18 @@ void process_record_nocache(keyrecord_t *record)
} }
#endif #endif
__attribute__ ((weak))
bool process_record_quantum(keyrecord_t *record) {
return true;
}
void process_record(keyrecord_t *record) void process_record(keyrecord_t *record)
{ {
if (IS_NOEVENT(record->event)) { return; } if (IS_NOEVENT(record->event)) { return; }
if(!process_record_quantum(record)) process_quantum(record);
return;
action_t action = store_or_get_action(record->event.pressed, record->event.key); action_t action = store_or_get_action(record->event.pressed, record->event.key);
dprint("ACTION: "); debug_action(action); dprint("ACTION: "); debug_action(action);
#ifndef NO_ACTION_LAYER #ifndef NO_ACTION_LAYER
dprint(" layer_state: "); layer_debug(); dprint(" layer_state: "); layer_debug();
dprint(" default_layer_state: "); default_layer_debug(); dprint(" default_layer_state: "); default_layer_debug();
#endif #endif
dprintln(); dprintln();
process_action(record, action); process_action(record, action);

@ -58,9 +58,6 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt);
/* user defined special function */ /* user defined special function */
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt); void action_function(keyrecord_t *record, uint8_t id, uint8_t opt);
/* keyboard-specific key event (pre)processing */
bool process_record_quantum(keyrecord_t *record);
/* Utilities for actions. */ /* Utilities for actions. */
#if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
extern bool disable_action_cache; extern bool disable_action_cache;

Loading…
Cancel
Save