alvierahman90/qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

updates all keymaps, restricts to two options

Browse Source
This commit is contained in:
Jack Humbert 2017-07-29 15:49:23 -04:00
parent 98ac10fd74
commit 151b7a4ae5
159 changed files with 916 additions and 901 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
docs/custom_quantum_functions.md
View File

@ -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_FEATURE; // 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.

4
docs/quantum_keycodes.md
View File

@ -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

6
docs/understanding_qmk.md
View File

@ -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

16
keyboards/atreus/keymaps/xyverz/keymap.c
View File

@ -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;
};

4
keyboards/atreus62/keymaps/atreus52/keymap.c
View File

@ -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;
}

4
keyboards/atreus62/keymaps/mneme/keymap.c
View File

@ -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

16
keyboards/atreus62/keymaps/xyverz/keymap.c
View File

@ -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;
};

10
keyboards/clueboard/keymaps/smt/keymap.c
View File

@ -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_FEATURE;
break;
case COLEMAK:
if (record->event.pressed) {
persistent_default_layer_set(1UL<<_COLEMAK);
}
return false;
return STOP_FEATURE;
break;
case DVORAK:
if (record->event.pressed) {
persistent_default_layer_set(1UL<<_DVORAK);
}
return false;
return STOP_FEATURE;
break;
}
return true;
return CONTINUE_PROCESSING;
}

4
keyboards/cluecard/cluecard.c
View File

@ -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) {

4
keyboards/cluecard/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/cluecard/keymaps/rgb_effects/keymap.c
View File

@ -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) {

18
keyboards/converter/ibm_terminal/keymaps/priyadi/keymap.c
View File

@ -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() {

6
keyboards/dk60/keymaps/default/keymap.c
View File

@ -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;
}

10
keyboards/eco/keymaps/that_canadian/keymap.c
View File

@ -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) {

10
keyboards/ergodox/ez/keymaps/blakedietz/keymap.c
View File

@ -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;
//}

4
keyboards/ergodox/ez/keymaps/steno/keymap.c
View File

@ -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)

8
keyboards/ergodox/keymaps/333fred/keymap.c
View File

@ -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.

6
keyboards/ergodox/keymaps/algernon/keymap.c
View File

@ -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) {

14
keyboards/ergodox/keymaps/belak/keymap.c
View File

@ -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) {

10
keyboards/ergodox/keymaps/bryan/keymap.c
View File

@ -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.

10
keyboards/ergodox/keymaps/default/keymap.c
View File

@ -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.

6
keyboards/ergodox/keymaps/erez_experimental/keymap.c
View File

@ -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();

10
keyboards/ergodox/keymaps/italian/keymap.c
View File

@ -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.

10
keyboards/ergodox/keymaps/reset_eeprom/keymap.c
View File

@ -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.

20
keyboards/ergodox/keymaps/robot_test_layout/keymap.c
View File

@ -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;
}

10
keyboards/ergodox/keymaps/swedish/keymap.c
View File

@ -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.

8
keyboards/frosty_flake/frosty_flake.c
View File

@ -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))

4
keyboards/gherkin/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/hadron/hadron.c
View File

@ -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) {

16
keyboards/hadron/keymaps/default/keymap.c
View File

@ -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) {

16
keyboards/hadron/keymaps/side_numpad/keymap.c
View File

@ -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) {

4
keyboards/handwired/MS_sculpt_mobile/keymaps/default/keymap.c
View File

@ -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) {

10
keyboards/handwired/MS_sculpt_mobile/keymaps/milestogo/keymap.c
View File

@ -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;
}

16
keyboards/handwired/atreus50/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/handwired/frenchdev/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/handwired/gamenum/keymaps/default/keymap.c
View File

@ -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;
}

4
keyboards/handwired/kbod/kbod.c
View File

@ -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) {

16
keyboards/handwired/ortho5x13/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/handwired/pilcrow/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/handwired/pilcrow/pilcrow.c
View File

@ -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) {

36
keyboards/handwired/promethium/keymaps/priyadi/keymap.c
View File

@ -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) {

4
keyboards/handwired/traveller/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/handwired/traveller/traveller.c
View File

@ -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) {

6
keyboards/hhkb/keymaps/cinaeco/keymap.c
View File

@ -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;
}

10
keyboards/hhkb/keymaps/smt/keymap.c
View File

@ -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;
}

4
keyboards/infinity60/keymaps/jpetermans/keymap.c
View File

@ -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.

10
keyboards/jd45/keymaps/blakedietz/keymap.c
View File

@ -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;
}
/*

20
keyboards/jd45/keymaps/jeebak/keymap.c
View File

@ -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;
}
/*

4
keyboards/kbd75/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/kinesis/alvicstep/alvicstep.c
View File

@ -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) {

4
keyboards/kinesis/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/kinesis/keymaps/dvorak/keymap.c
View File

@ -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) {

4
keyboards/kinesis/keymaps/milestogo/keymap.c
View File

@ -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) {

4
keyboards/kinesis/stapelberg/stapelberg.c
View File

@ -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) {

4
keyboards/kitten_paw/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/kitten_paw/keymaps/ickerwx/keymap.c
View File

@ -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;
}

4
keyboards/kitten_paw/kitten_paw.c
View File

@ -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) {

4
keyboards/kmac/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/kmac/keymaps/winkeyless/keymap.c
View File

@ -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) {

4
keyboards/kmac/kmac.c
View File

@ -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) {

18
keyboards/lets_split/keymaps/OLED_sample/keymap.c
View File

@ -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) {

16
keyboards/lets_split/keymaps/default/keymap.c
View File

@ -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;
}

16
keyboards/lets_split/keymaps/ergodoxish/keymap.c
View File

@ -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;
}

16
keyboards/lets_split/keymaps/hexwire/keymap.c
View File

@ -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;
}

16
keyboards/lets_split/keymaps/khord/keymap.c
View File

@ -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;
}

16
keyboards/lets_split/keymaps/smt/keymap.c
View File

@ -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;
}

14
keyboards/lets_split/keymaps/xyverz/keymap.c
View File

@ -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;
}

12
keyboards/minidox/keymaps/default/keymap.c
View File

@ -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;
}

12
keyboards/minidox/keymaps/that_canadian/keymap.c
View File

@ -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;
}

8
keyboards/mitosis/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/miuni32/keymaps/adam-lee/keymap.c
View File

@ -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) {

4
keyboards/miuni32/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/miuni32/keymaps/ht_156/keymap.c
View File

@ -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) {

4
keyboards/miuni32/miuni32.c
View File

@ -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) {

16
keyboards/nyquist/keymaps/default/keymap.c
View File

@ -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;
}

16
keyboards/nyquist/keymaps/hexwire/keymap.c
View File

@ -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;
}

16
keyboards/orthodox/keymaps/default/keymap.c
View File

@ -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;
}

6
keyboards/pegasushoof/keymaps/blowrak/keymap.c
View File

@ -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;
}

4
keyboards/phantom/keymaps/default/keymap.c
View File

@ -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) {

4
keyboards/phantom/keymaps/rgbmod/keymap.c
View File

@ -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) {

4
keyboards/phantom/phantom.c
View File

@ -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) {

18
keyboards/planck/keymaps/brandon/keymap.c
View File

@ -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) {

10
keyboards/planck/keymaps/callum/keymap.c
View File

@ -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;
}

24
keyboards/planck/keymaps/chance/keymap.c
View File

@ -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) {

12
keyboards/planck/keymaps/circuit/keymap.c
View File

@ -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) {

12
keyboards/planck/keymaps/dbroqua/keymap.c
View File

@ -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) {

20
keyboards/planck/keymaps/default/keymap.c
View File

@ -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;
}

6
keyboards/planck/keymaps/dshields/keymap.c
View File

@ -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;
}

36
keyboards/planck/keymaps/experimental/keymap.c
View File

@ -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) {

20
keyboards/planck/keymaps/handwired_binaryplease/keymap.c
View File

@ -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) {

10
keyboards/planck/keymaps/impossible/keymap.c
View File

@ -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) {

20
keyboards/planck/keymaps/jeebak/keymap.c
View File

@ -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;
}
/*

26
keyboards/planck/keymaps/jeremy-dev/keymap.c
View File

@ -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;
}

20
keyboards/planck/keymaps/jhenahan/keymap.c
View File

@ -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) {

20
keyboards/planck/keymaps/khord/keymap.c
View File

@ -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) {

14
keyboards/planck/keymaps/lae3/keymap.c
View File

@ -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)

10
keyboards/planck/keymaps/originerd/keymap.c
View File

@ -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) {

20
keyboards/planck/keymaps/premek/keymap.c
View File

@ -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) {

14
keyboards/planck/keymaps/sgoodwin/keymap.c
View File

@ -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) {

16
keyboards/planck/keymaps/smt/keymap.c
View File

@ -167,7 +167,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) {
@ -176,7 +176,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) {
@ -185,7 +185,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) {
@ -194,7 +194,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) {
@ -204,7 +204,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) {
@ -214,7 +214,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) {
@ -225,10 +225,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