Compare commits

...

3 Commits

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

@ -36,16 +36,16 @@ enum my_keycodes {
## 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.
### 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.
```
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case FOO:
if (record->event.pressed) {
@ -53,21 +53,21 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else {
// 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:
// Play a tone when enter is pressed
if (record->event.pressed) {
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
* Keyboard/Revision: `bool process_record_kb(uint16_t keycode, keyrecord_t *record)`
* Keymap: `bool process_record_user(uint16_t keycode, keyrecord_t *record)`
* Keyboard/Revision: `level_t process_kb(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.

@ -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) {
case FOO:
// 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)
* [`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)
* [`bool process_record_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_kb(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/cluecard.c#L20)
* [`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_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)
@ -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)
* [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

@ -173,31 +173,31 @@ void persistent_default_layer_set(uint16_t 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) {
case QWERTY:
if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case COLEMAK:
if (record->event.pressed) {
persistent_default_layer_set(1UL<<_COLEMAK);
}
return false;
return STOP_PROCESSING;
break;
case DVORAK:
if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORAK);
}
return false;
return STOP_PROCESSING;
break;
case DVORMAC:
if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORMAC);
}
return false;
return STOP_PROCESSING;
break;
case LOWER:
if (record->event.pressed) {
@ -207,7 +207,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case RAISE:
if (record->event.pressed) {
@ -217,8 +217,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
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;
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 (record->event.pressed)
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) {
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
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
bool queue = true;
//Cancle one-shot mods.
@ -201,7 +201,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
}
break;
}
return queue;
return queue ? CONTINUE_PROCESSING : STOP_PROCESSING;
}
// TAP DANCE SETTINGS

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

@ -156,26 +156,26 @@ void persistent_default_layer_set(uint16_t 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) {
case QWERTY:
if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case COLEMAK:
if (record->event.pressed) {
persistent_default_layer_set(1UL<<_COLEMAK);
}
return false;
return STOP_PROCESSING;
break;
case DVORAK:
if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORAK);
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}

@ -17,11 +17,11 @@ void matrix_scan_kb(void) {
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
// 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) {

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

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

@ -148,7 +148,7 @@ void persistant_default_layer_set(uint16_t 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) {
case QWERTY:
if (record->event.pressed) {
@ -157,7 +157,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistant_default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case LOWER:
if (record->event.pressed) {
@ -167,7 +167,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case RAISE:
if (record->event.pressed) {
@ -177,10 +177,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
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) {
// case QWERTY:
// return false
// return STOP_PROCESSING
// break;
// case LOWER:
// if (record->event.pressed) {
@ -271,7 +271,7 @@ void matrix_scan_user(void) {
// layer_off(_LOWER);
// update_tri_layer(_LOWER, _RAISE, _ADJUST);
// }
// return false;
// return STOP_PROCESSING;
// break;
// case RAISE:
// if (record->event.pressed) {
@ -281,9 +281,9 @@ void matrix_scan_user(void) {
// layer_off(_RAISE);
// update_tri_layer(_LOWER, _RAISE, _ADJUST);
// }
// return false;
// return STOP_PROCESSING;
// break;
// }
// return true;
// return CONTINUE_PROCESSING;
//}

@ -267,7 +267,7 @@ void send_chord(void)
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
// changes mode whilst pressing other keys.
@ -275,7 +275,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record)
pressed_count++;
else
pressed_count--;
return true;
return CONTINUE_PROCESSING;
}
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;
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
// dynamically generate these.
case EPRM:
if (record->event.pressed) {
eeconfig_init();
}
return false;
return STOP_PROCESSING;
break;
case VRSN:
if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
// 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)
);
bool process_record_user (uint16_t keycode, keyrecord_t *record) {
level_t process_user (uint16_t keycode, keyrecord_t *record) {
#if KEYLOGGER_ENABLE
if (log_enable) {
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);
return false;
return STOP_PROCESSING;
}
}
return true;
return CONTINUE_PROCESSING;
}
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) {
case BEL_F0:
if(record->event.pressed){
@ -260,7 +260,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(SWPH);
}
return false;
return STOP_PROCESSING;
}
break;
case BEL_F1:
@ -268,7 +268,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(SYMB);
layer_off(NUMP);
return false;
return STOP_PROCESSING;
}
break;
case E_SHRUG: // ¯\_(ツ)_/¯
@ -287,7 +287,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
tap(KC_SLSH); // Arm
process_unicode((0x00AF|QK_UNICODE), record); // Hand
}
return false;
return STOP_PROCESSING;
break;
case E_TFLIP: // (╯°□°)╯ ︵ ┻━┻
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((0x253B|QK_UNICODE), record); // Table
}
return false;
return STOP_PROCESSING;
break;
case E_TSET: // ┬──┬ ( ゜-゜ノ)
if (record->event.pressed) {
@ -331,11 +331,11 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
tap(KC_0);
unregister_code(KC_RSFT);
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
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;
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
// dynamically generate these.
case EPRM:
if (record->event.pressed) {
eeconfig_init();
}
return false;
return STOP_PROCESSING;
break;
case VRSN:
if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
}
return false;
return STOP_PROCESSING;
break;
case RGB_SLD:
if (record->event.pressed) {
@ -189,10 +189,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_mode(1);
#endif
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
// 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;
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
// dynamically generate these.
case EPRM:
if (record->event.pressed) {
eeconfig_init();
}
return false;
return STOP_PROCESSING;
break;
case VRSN:
if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
}
return false;
return STOP_PROCESSING;
break;
case RGB_SLD:
if (record->event.pressed) {
@ -186,10 +186,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_mode(1);
#endif
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
// 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) {
// dynamically generate these.
case RGB_FF00BB:
@ -170,10 +170,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_setrgb(0xff,0x00,0xbb);
#endif
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
LEADER_EXTERNS();

@ -165,20 +165,20 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
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) {
// dynamically generate these.
case EPRM:
if (record->event.pressed) {
eeconfig_init();
}
return false;
return STOP_PROCESSING;
break;
case VRSN:
if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
}
return false;
return STOP_PROCESSING;
break;
case RGB_SLD:
if (record->event.pressed) {
@ -186,10 +186,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_mode(1);
#endif
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
// 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;
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
// dynamically generate these.
case EPRM:
if (record->event.pressed) {
eeconfig_init();
}
return false;
return STOP_PROCESSING;
break;
case VRSN:
if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
}
return false;
return STOP_PROCESSING;
break;
case RGB_SLD:
if (record->event.pressed) {
@ -103,10 +103,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_mode(1);
#endif
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
// 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 process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
// dynamically generate these.
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);
#endif
}
return false;
return STOP_PROCESSING;
break;
case RGB_00FF00:
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);
#endif
}
return false;
return STOP_PROCESSING;
break;
case RGB_0000FF:
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);
#endif
}
return false;
return STOP_PROCESSING;
break;
case RGB_FFFFFF:
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);
#endif
}
return false;
return STOP_PROCESSING;
break;
case RGB_TOGGLE:
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);
#endif
}
return false;
return STOP_PROCESSING;
break;
case LED1:
if (record->event.pressed) {
@ -120,7 +120,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
status_led1_on = true;
}
}
return false;
return STOP_PROCESSING;
break;
case LED2:
if (record->event.pressed) {
@ -132,7 +132,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
status_led2_on = true;
}
}
return false;
return STOP_PROCESSING;
break;
case LED3:
if (record->event.pressed) {
@ -144,8 +144,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
status_led3_on = true;
}
}
return false;
return STOP_PROCESSING;
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;
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
// dynamically generate these.
case EPRM:
if (record->event.pressed) {
eeconfig_init();
}
return false;
return STOP_PROCESSING;
break;
case VRSN:
if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
}
return false;
return STOP_PROCESSING;
break;
case RGB_SLD:
if (record->event.pressed) {
@ -210,10 +210,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_mode(1);
#endif
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
// Runs just one time when the keyboard initializes.

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
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
// 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) {
@ -54,8 +54,8 @@ void matrix_scan_user(void) {
}
__attribute__ ((weak))
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
return true;
level_t process_user(uint16_t keycode, keyrecord_t *record) {
return CONTINUE_PROCESSING;
}
__attribute__ ((weak))

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

@ -12,11 +12,11 @@ void matrix_scan_kb(void) {
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
// 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) {

@ -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) {
case QWERTY:
if (record->event.pressed) {
@ -259,7 +259,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistant_default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case COLEMAK:
if (record->event.pressed) {
@ -268,7 +268,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistant_default_layer_set(1UL<<_COLEMAK);
}
return false;
return STOP_PROCESSING;
break;
case LOWER:
if (record->event.pressed) {
@ -291,7 +291,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER);
update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case RAISE:
if (record->event.pressed) {
@ -314,7 +314,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
TOG_STATUS = false;
update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case BACKLIT:
if (record->event.pressed) {
@ -325,7 +325,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else {
unregister_code(KC_RSFT);
}
return false;
return STOP_PROCESSING;
break;
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
@ -334,10 +334,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_step();
RGB_current_mode = rgblight_config.mode;
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
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) {
case QWERTY:
if (record->event.pressed) {
@ -261,7 +261,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistant_default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case LOWER:
if (record->event.pressed) {
@ -284,7 +284,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER);
update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case RAISE:
if (record->event.pressed) {
@ -307,7 +307,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
TOG_STATUS = false;
update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case BACKLIT:
if (record->event.pressed) {
@ -318,7 +318,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else {
unregister_code(KC_RSFT);
}
return false;
return STOP_PROCESSING;
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
case TG_NUMLAY:
@ -335,7 +335,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_mode(RGB_current_mode);
layer_off(_NUMLAY); }
}
return false;
return STOP_PROCESSING;
break;
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
@ -344,10 +344,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_step();
RGB_current_mode = rgblight_config.mode;
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
void matrix_init_user(void) {

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

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

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

@ -393,8 +393,8 @@ void matrix_scan_user(void) {
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
return true;
level_t process_user(uint16_t keycode, keyrecord_t *record) {
return CONTINUE_PROCESSING;
}
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) {
case KC_FN0:
if (record->event.pressed) {
@ -64,5 +64,5 @@ bool process_record_user (uint16_t keycode, keyrecord_t *record) {
}
break;
}
return true;
return CONTINUE_PROCESSING;
}

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
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
// 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) {

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

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

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
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
// 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) {

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

@ -45,11 +45,11 @@ void matrix_scan_kb(void) {
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
// 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) {

@ -178,9 +178,9 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
};
// 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)) {
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);
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case COLEMAK:
if (record->event.pressed) {
persistent_default_layer_set(1UL<<_COLEMAK);
}
return false;
return STOP_PROCESSING;
break;
case DVORAK:
if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORAK);
}
return false;
return STOP_PROCESSING;
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) {
return true;
level_t process_user (uint16_t keycode, keyrecord_t *record) {
return CONTINUE_PROCESSING;
}
// 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);
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case LOWER:
if (record->event.pressed) {
@ -267,7 +267,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case RAISE:
if (record->event.pressed) {
@ -277,10 +277,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
/*

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

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

@ -78,11 +78,11 @@ void matrix_scan_kb(void) {
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
// 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) {

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

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
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
// 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) {

@ -42,8 +42,8 @@ void matrix_scan_user(void) {
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
return true;
level_t process_user(uint16_t keycode, keyrecord_t *record) {
return CONTINUE_PROCESSING;
}
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;
layer = biton32(layer_state);
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();
}
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
// 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) {

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

@ -29,11 +29,11 @@ void matrix_scan_kb(void) {
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
// runs for every action, just before processing by the firmware
return process_record_user(keycode, record);
return CONTINUE_PROCESSING;
}
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) {
case QWERTY:
if (record->event.pressed) {
@ -210,7 +210,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistent_default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case COLEMAK:
if (record->event.pressed) {
@ -219,7 +219,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistent_default_layer_set(1UL<<_COLEMAK);
}
return false;
return STOP_PROCESSING;
break;
case DVORAK:
if (record->event.pressed) {
@ -228,7 +228,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistent_default_layer_set(1UL<<_DVORAK);
}
return false;
return STOP_PROCESSING;
break;
case LOWER:
if (record->event.pressed) {
@ -247,7 +247,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER);
update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case RAISE:
if (record->event.pressed) {
@ -266,7 +266,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
TOG_STATUS = false;
update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case BACKLIT:
if (record->event.pressed) {
@ -277,7 +277,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else {
unregister_code(KC_RSFT);
}
return false;
return STOP_PROCESSING;
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
case RGB_MOD:
@ -286,10 +286,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
rgblight_step();
RGB_current_mode = rgblight_config.mode;
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
void matrix_init_user(void) {

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

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

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

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

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

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

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

@ -132,7 +132,7 @@ void persistant_default_layer_set(uint16_t 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) {
case QWERTY:
if (record->event.pressed) {
@ -141,7 +141,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistant_default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case LOWER:
if (record->event.pressed) {
@ -151,7 +151,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case RAISE:
if (record->event.pressed) {
@ -161,7 +161,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case ADJUST:
if (record->event.pressed) {
@ -169,8 +169,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else {
layer_off(_ADJUST);
}
return false;
return STOP_PROCESSING;
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;
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
uint8_t 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);
return false;
return STOP_PROCESSING;
break;
//SHIFT is handled as LSHIFT in the general case
case SHIFT:
@ -171,7 +171,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
}
}
update_tri_layer(_FUNCTION, _SHIFTED, _FUNCSHIFT);
return false;
return STOP_PROCESSING;
break;
//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) {

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

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

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

@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
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
// 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) {

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

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

@ -91,7 +91,7 @@ void persistent_default_layer_set(uint16_t 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) {
case QWERTY:
if (record->event.pressed) {
@ -100,7 +100,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistent_default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case COLEMAK:
if (record->event.pressed) {
@ -109,7 +109,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistent_default_layer_set(1UL<<_COLEMAK);
}
return false;
return STOP_PROCESSING;
break;
case DVORAK:
if (record->event.pressed) {
@ -118,7 +118,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistent_default_layer_set(1UL<<_DVORAK);
}
return false;
return STOP_PROCESSING;
break;
case LOWER:
if (record->event.pressed) {
@ -128,7 +128,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case RAISE:
if (record->event.pressed) {
@ -138,7 +138,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case ADJUST:
if (record->event.pressed) {
@ -146,8 +146,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else {
layer_off(_ADJUST);
}
return false;
return STOP_PROCESSING;
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. */
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();
if (modifiers & MOD_BIT(KC_RALT) && record->event.pressed) {
uint16_t kc = keymap_key_to_keycode(KM_HAXHAX, record->event.key);
if (kc != KC_TRNS) {
register_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) {
return true;
level_t process_user(uint16_t keycode, keyrecord_t *record) {
return CONTINUE_PROCESSING;
}
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) {
return true;
level_t process_user(uint16_t keycode, keyrecord_t *record) {
return CONTINUE_PROCESSING;
}
void led_set_user(uint8_t usb_led) {

@ -29,11 +29,11 @@ void matrix_scan_kb(void) {
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
// runs for every action, just before processing by the firmware
return process_record_user(keycode, record);
return CONTINUE_PROCESSING;
}
void led_init_ports(void) {

@ -339,18 +339,18 @@ void plover_lookup(void) {
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) {
case QWERTY:
if (record->event.pressed) {
persistant_default_layer_set(1UL<<BASE_QWERTY_LAYER);
}
return false;
return STOP_PROCESSING;
case COLEMAK:
if (record->event.pressed) {
persistant_default_layer_set(1UL<<BASE_COLEMAK_LAYER);
}
return false;
return STOP_PROCESSING;
case LOWER:
if (record->event.pressed) {
layer_on(LOWER_LAYER);
@ -359,7 +359,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(LOWER_LAYER);
update_tri_layer(LOWER_LAYER, RAISE_LAYER, KEYBOARD_LAYER);
}
return false;
return STOP_PROCESSING;
case RAISE:
if (record->event.pressed) {
layer_on(RAISE_LAYER);
@ -368,7 +368,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(RAISE_LAYER);
update_tri_layer(LOWER_LAYER, RAISE_LAYER, KEYBOARD_LAYER);
}
return false;
return STOP_PROCESSING;
case STENO:
if (record->event.pressed) {
layer_off(RAISE_LAYER);
@ -383,20 +383,20 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
eeconfig_update_keymap(keymap_config.raw);
plover_resume();
}
return false;
return STOP_PROCESSING;
case PV_EXIT:
if (record->event.pressed) {
plover_suspend();
layer_off(BASE_STENO_LAYER);
}
return false;
return STOP_PROCESSING;
case PV_LOOK:
if (record->event.pressed) {
plover_lookup();
}
return false;
return STOP_PROCESSING;
}
return true;
return CONTINUE_PROCESSING;
}
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) {
case MOVE:
if (record->event.pressed) {
@ -130,7 +130,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_MOVE);
update_tri_layer(_MOVE, _SYMB, _MOUSE);
}
return false;
return STOP_PROCESSING;
break;
case SYMB:
if (record->event.pressed) {
@ -140,7 +140,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_SYMB);
update_tri_layer(_MOVE, _SYMB, _MOUSE);
}
return false;
return STOP_PROCESSING;
break;
case FUNC:
if (record->event.pressed) {
@ -148,8 +148,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else {
layer_off(_FUNC);
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}

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

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

@ -154,7 +154,7 @@ void persistent_default_layer_set(uint16_t 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) {
case QWERTY:
if (record->event.pressed) {
@ -163,7 +163,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistent_default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case LOWER:
if (record->event.pressed) {
@ -173,7 +173,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case RAISE:
if (record->event.pressed) {
@ -183,7 +183,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case BACKLIT:
if (record->event.pressed) {
@ -194,10 +194,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else {
unregister_code(KC_RSFT);
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
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);
#endif
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
set_single_persistent_default_layer(_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case COLEMAK:
if (record->event.pressed) {
set_single_persistent_default_layer(_COLEMAK);
}
return false;
return STOP_PROCESSING;
break;
case DVORAK:
if (record->event.pressed) {
set_single_persistent_default_layer(_DVORAK);
}
return false;
return STOP_PROCESSING;
break;
case LOWER:
if (record->event.pressed) {
@ -205,7 +205,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case RAISE:
if (record->event.pressed) {
@ -215,7 +215,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case BACKLIT:
if (record->event.pressed) {
@ -226,7 +226,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else {
unregister_code(KC_RSFT);
}
return false;
return STOP_PROCESSING;
break;
case PLOVER:
if (record->event.pressed) {
@ -245,7 +245,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw);
}
return false;
return STOP_PROCESSING;
break;
case EXT_PLV:
if (record->event.pressed) {
@ -254,8 +254,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
layer_off(_PLOVER);
}
return false;
return STOP_PROCESSING;
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)
};
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)) {
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) {
case QWERTY:
if (record->event.pressed) {
@ -221,7 +221,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
persistent_default_layer_set(1UL<<_QWERTY);
}
break;
return false;
return STOP_PROCESSING;
case COLEMAK:
if (record->event.pressed) {
#ifdef AUDIO_ENABLE
@ -230,7 +230,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
persistent_default_layer_set(1UL<<_COLEMAK);
}
break;
return false;
return STOP_PROCESSING;
case DVORAK:
if (record->event.pressed) {
#ifdef AUDIO_ENABLE
@ -239,7 +239,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
persistent_default_layer_set(1UL<<_DVORAK);
}
break;
return false;
return STOP_PROCESSING;
case LOWER:
if (record->event.pressed) {
layer_on(_LOWER);
@ -253,7 +253,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
break;
return false;
return STOP_PROCESSING;
case RAISE:
if (record->event.pressed) {
layer_on(_RAISE);
@ -267,7 +267,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
break;
return false;
return STOP_PROCESSING;
case BACKLIT:
if (record->event.pressed) {
register_code(KC_RSFT);
@ -278,7 +278,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
unregister_code(KC_RSFT);
}
break;
return false;
return STOP_PROCESSING;
case PLOVER:
if (!record->event.pressed) {
#ifdef AUDIO_ENABLE
@ -288,7 +288,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_on(_PLOVER);
}
break;
return false;
return STOP_PROCESSING;
case EXT_PLV:
if (record->event.pressed) {
#ifdef AUDIO_ENABLE
@ -297,61 +297,61 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_PLOVER);
}
break;
return false;
return STOP_PROCESSING;
case RGBLED_TOGGLE:
//led operations
if (record->event.pressed) {
rgblight_toggle();
}
return false;
return STOP_PROCESSING;
break;
case RGBLED_INCREASE_HUE:
if (record->event.pressed) {
rgblight_increase_hue();
}
return false;
return STOP_PROCESSING;
break;
case RGBLED_DECREASE_HUE:
if (record->event.pressed) {
rgblight_decrease_hue();
}
return false;
return STOP_PROCESSING;
break;
case RGBLED_INCREASE_SAT:
if (record->event.pressed) {
rgblight_increase_sat();
}
return false;
return STOP_PROCESSING;
break;
case RGBLED_DECREASE_SAT:
if (record->event.pressed) {
rgblight_decrease_sat();
}
return false;
return STOP_PROCESSING;
break;
case RGBLED_INCREASE_VAL:
if (record->event.pressed) {
rgblight_increase_val();
}
return false;
return STOP_PROCESSING;
break;
case RGBLED_DECREASE_VAL:
if (record->event.pressed) {
rgblight_decrease_val();
}
return false;
return STOP_PROCESSING;
break;
case RGBLED_STEP_MODE:
if (record->event.pressed) {
rgblight_step();
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
};
void matrix_init_user(void) {

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

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

@ -275,7 +275,7 @@ void persistent_default_layer_set(uint16_t 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) {
case QWERTY:
if (record->event.pressed) {
@ -284,7 +284,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case COLEMAK:
if (record->event.pressed) {
@ -293,7 +293,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
default_layer_set(1UL<<_COLEMAK);
}
return false;
return STOP_PROCESSING;
break;
case DVORAK:
if (record->event.pressed) {
@ -302,7 +302,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
default_layer_set(1UL<<_DVORAK);
}
return false;
return STOP_PROCESSING;
break;
case LOWER:
if (record->event.pressed) {
@ -312,7 +312,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case RAISE:
if (record->event.pressed) {
@ -322,7 +322,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case BACKLIT:
if (record->event.pressed) {
@ -333,7 +333,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else {
unregister_code(KC_RSFT);
}
return false;
return STOP_PROCESSING;
break;
case PLOVER:
if (record->event.pressed) {
@ -352,7 +352,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw);
}
return false;
return STOP_PROCESSING;
break;
case EXT_PLV:
if (record->event.pressed) {
@ -361,10 +361,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
layer_off(_PLOVER);
}
return false;
return STOP_PROCESSING;
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);
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case MY_BELW:
if (record->event.pressed) {
@ -93,7 +93,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_ENT);
}
return false;
return STOP_PROCESSING;
case MY_ABVE:
if (record->event.pressed) {
@ -102,14 +102,14 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_UP);
}
return false;
return STOP_PROCESSING;
case MY_TERM:
if (record->event.pressed) {
press_three_keys(KC_LGUI, KC_LSFT, KC_ENT);
}
return false;
return STOP_PROCESSING;
case MY_DEQL: // /=
if (record->event.pressed) {
@ -117,7 +117,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_EQL);
}
return false;
return STOP_PROCESSING;
case MY_MEQL: // *=
if (record->event.pressed) {
@ -125,7 +125,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_EQL);
}
return false;
return STOP_PROCESSING;
case MY_SEQL: // -=
if (record->event.pressed) {
@ -133,7 +133,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_EQL);
}
return false;
return STOP_PROCESSING;
case MY_PEQL: // +=
if (record->event.pressed) {
@ -141,7 +141,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_EQL);
}
return false;
return STOP_PROCESSING;
case MY_NEQL: // !=
if (record->event.pressed) {
@ -149,7 +149,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
press_key(KC_EQL);
}
return false;
return STOP_PROCESSING;
case MY_LTGT: // <>
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);
}
return false;
return STOP_PROCESSING;
case MY_DPIP: // ||
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);
}
return false;
return STOP_PROCESSING;
case MY_DAMP: // &&
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);
}
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);
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case WORKMAN:
if (record->event.pressed) {
@ -197,7 +197,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistent_default_layer_set(1UL<<_WORKMAN);
}
return false;
return STOP_PROCESSING;
break;
case DEAD:
if (record->event.pressed) {
@ -205,7 +205,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
set_oneshot_layer(_DEAD, ONESHOT_START);
clear_oneshot_layer_state(ONESHOT_PRESSED);
}
return false;
return STOP_PROCESSING;
break;
case QWERTY:
if (record->event.pressed) {
@ -214,7 +214,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistent_default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case LOWER:
if (record->event.pressed) {
@ -224,7 +224,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case RAISE:
if (record->event.pressed) {
@ -234,7 +234,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case PLOVER:
if (record->event.pressed) {
@ -253,7 +253,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw);
}
return false;
return STOP_PROCESSING;
break;
case EXT_PLV:
if (record->event.pressed) {
@ -262,7 +262,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
layer_off(_PLOVER);
}
return false;
return STOP_PROCESSING;
break;
case TOG_PLV:
if (record->event.pressed) {
@ -274,10 +274,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
register_code(KC_O);
clear_keyboard();
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
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;
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
level_t process_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
@ -253,7 +253,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistent_default_layer_set(1UL<<_QWERTY);
}
return false;
return STOP_PROCESSING;
break;
case COLEMAK:
if (record->event.pressed) {
@ -262,7 +262,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistent_default_layer_set(1UL<<_COLEMAK);
}
return false;
return STOP_PROCESSING;
break;
case DVORAK:
if (record->event.pressed) {
@ -271,7 +271,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
persistent_default_layer_set(1UL<<_DVORAK);
}
return false;
return STOP_PROCESSING;
break;
case LOWER:
if (record->event.pressed) {
@ -281,7 +281,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case RAISE:
if (record->event.pressed) {
@ -291,7 +291,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
return STOP_PROCESSING;
break;
case BACKLIT:
if (record->event.pressed) {
@ -302,7 +302,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} else {
unregister_code(KC_RSFT);
}
return false;
return STOP_PROCESSING;
break;
case PLOVER:
if (record->event.pressed) {
@ -321,7 +321,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw);
}
return false;
return STOP_PROCESSING;
break;
case EXT_PLV:
if (record->event.pressed) {
@ -330,10 +330,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif
layer_off(_PLOVER);
}
return false;
return STOP_PROCESSING;
break;
}
return true;
return CONTINUE_PROCESSING;
}
void matrix_init_user(void) {

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

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

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

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

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save