remove STOP_FEATURE

docs/custom_quantum_functions.md

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

docs/quantum_keycodes.md

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

docs/understanding_qmk.md

@@ -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)
+    * [`level_t process_kb(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/cluecard.c#L20)
-      * [`bool process_record_user(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/keymaps/default/keymap.c#L58)
+      * [`level_t process_user(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/keymaps/default/keymap.c#L58)
     * [`bool process_midi(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_midi.c#L102)
     * [`bool process_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

keyboards/atreus/keymaps/xyverz/keymap.c

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

keyboards/atreus62/keymaps/atreus52/keymap.c

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

keyboards/atreus62/keymaps/mneme/keymap.c

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

keyboards/atreus62/keymaps/xyverz/keymap.c

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

keyboards/clueboard/keymaps/smt/keymap.c

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

keyboards/cluecard/cluecard.c

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

keyboards/cluecard/keymaps/default/keymap.c

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

keyboards/cluecard/keymaps/rgb_effects/keymap.c

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

keyboards/converter/ibm_terminal/keymaps/priyadi/keymap.c

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

keyboards/deltasplit75/v2/config.h

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

keyboards/dk60/keymaps/default/keymap.c

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

keyboards/eco/keymaps/that_canadian/keymap.c

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

keyboards/ergodox/ez/keymaps/blakedietz/keymap.c

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

keyboards/ergodox/ez/keymaps/steno/keymap.c

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

keyboards/ergodox/keymaps/333fred/keymap.c

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

keyboards/ergodox/keymaps/algernon/keymap.c

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

keyboards/ergodox/keymaps/belak/keymap.c

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

keyboards/ergodox/keymaps/bryan/keymap.c

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

keyboards/ergodox/keymaps/default/keymap.c

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

keyboards/ergodox/keymaps/erez_experimental/keymap.c

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

keyboards/ergodox/keymaps/italian/keymap.c

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

keyboards/ergodox/keymaps/reset_eeprom/keymap.c

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

keyboards/ergodox/keymaps/robot_test_layout/keymap.c

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

keyboards/ergodox/keymaps/swedish/keymap.c

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

keyboards/frosty_flake/frosty_flake.c

@@ -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) {
+level_t process_user(uint16_t keycode, keyrecord_t *record) {
-  return true;
+  return CONTINUE_PROCESSING;
 }
 
 __attribute__ ((weak))

keyboards/gherkin/keymaps/default/keymap.c

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

keyboards/hadron/hadron.c

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

keyboards/hadron/keymaps/default/keymap.c

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

keyboards/hadron/keymaps/side_numpad/keymap.c

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

keyboards/handwired/MS_sculpt_mobile/keymaps/default/keymap.c

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

keyboards/handwired/MS_sculpt_mobile/keymaps/milestogo/keymap.c

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

keyboards/handwired/atreus50/keymaps/default/keymap.c

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

keyboards/handwired/frenchdev/keymaps/default/keymap.c

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

keyboards/handwired/gamenum/keymaps/default/keymap.c

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

keyboards/handwired/kbod/kbod.c

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

keyboards/handwired/ortho5x13/keymaps/default/keymap.c

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

keyboards/handwired/pilcrow/keymaps/default/keymap.c

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

keyboards/handwired/pilcrow/pilcrow.c

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

keyboards/handwired/promethium/keymaps/priyadi/keymap.c

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

keyboards/handwired/traveller/keymaps/default/keymap.c

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

keyboards/handwired/traveller/traveller.c

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

keyboards/hhkb/keymaps/cinaeco/keymap.c

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

keyboards/hhkb/keymaps/smt/keymap.c

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

keyboards/infinity60/keymaps/jpetermans/keymap.c

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

keyboards/jd45/keymaps/blakedietz/keymap.c

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

keyboards/jd45/keymaps/jeebak/keymap.c

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

keyboards/kbd75/keymaps/default/keymap.c

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

keyboards/kinesis/alvicstep/alvicstep.c

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

keyboards/kinesis/keymaps/default/keymap.c

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

keyboards/kinesis/keymaps/dvorak/keymap.c

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

keyboards/kinesis/keymaps/milestogo/keymap.c

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

keyboards/kinesis/stapelberg/stapelberg.c

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

keyboards/kitten_paw/keymaps/default/keymap.c

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

keyboards/kitten_paw/keymaps/ickerwx/keymap.c

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

keyboards/kitten_paw/kitten_paw.c

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

keyboards/kmac/keymaps/default/keymap.c

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

keyboards/kmac/keymaps/winkeyless/keymap.c

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

keyboards/kmac/kmac.c

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

keyboards/lets_split/keymaps/OLED_sample/keymap.c

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

keyboards/lets_split/keymaps/default/keymap.c

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

keyboards/lets_split/keymaps/ergodoxish/keymap.c

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

keyboards/lets_split/keymaps/hexwire/keymap.c

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

keyboards/lets_split/keymaps/khord/keymap.c

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

keyboards/lets_split/keymaps/smt/keymap.c

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

keyboards/lets_split/keymaps/xyverz/keymap.c

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

keyboards/minidox/keymaps/default/keymap.c

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

keyboards/minidox/keymaps/that_canadian/keymap.c

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

keyboards/mitosis/keymaps/default/keymap.c

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

keyboards/miuni32/keymaps/adam-lee/keymap.c

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

keyboards/miuni32/keymaps/default/keymap.c

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

keyboards/miuni32/keymaps/ht_156/keymap.c

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

keyboards/miuni32/miuni32.c

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

keyboards/nyquist/keymaps/default/keymap.c

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

keyboards/nyquist/keymaps/hexwire/keymap.c

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

keyboards/orthodox/keymaps/default/keymap.c

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

keyboards/pegasushoof/keymaps/blowrak/keymap.c

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

keyboards/phantom/keymaps/default/keymap.c

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

keyboards/phantom/keymaps/rgbmod/keymap.c

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

keyboards/phantom/phantom.c

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

keyboards/planck/keymaps/brandon/keymap.c

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

keyboards/planck/keymaps/callum/keymap.c

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

keyboards/planck/keymaps/chance/keymap.c

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

keyboards/planck/keymaps/circuit/keymap.c

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

keyboards/planck/keymaps/dbroqua/keymap.c

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

keyboards/planck/keymaps/default/keymap.c

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

keyboards/planck/keymaps/dshields/keymap.c

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

keyboards/planck/keymaps/experimental/keymap.c

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

keyboards/planck/keymaps/handwired_binaryplease/keymap.c

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

keyboards/planck/keymaps/impossible/keymap.c

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

keyboards/planck/keymaps/jeebak/keymap.c

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

keyboards/planck/keymaps/jeremy-dev/keymap.c

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

keyboards/planck/keymaps/jhenahan/keymap.c

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

keyboards/planck/keymaps/khord/keymap.c

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

keyboards/planck/keymaps/lae3/keymap.c

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

keyboards/planck/keymaps/originerd/keymap.c

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

keyboards/planck/keymaps/premek/keymap.c

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

keyboards/planck/keymaps/sgoodwin/keymap.c

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

keyboards/planck/keymaps/smt/keymap.c

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

keyboards/planck/keymaps/steno/keymap.c

@@ -181,25 +181,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) {
@@ -209,7 +209,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) {
@@ -219,7 +219,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) {
@@ -230,7 +230,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) {
@@ -240,7 +240,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
         #endif
         layer_on(_PLOVER);
       }
-      return false;
+      return STOP_PROCESSING;
       break;
     case EXT_PLV:
       if (record->event.pressed) {
@@ -249,8 +249,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;
 }

keyboards/planck/keymaps/thermal_printer/keymap.c

@@ -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 QWERTY:
       if (record->event.pressed) {
@@ -197,7 +197,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) {
@@ -206,7 +206,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) {
@@ -215,7 +215,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) {
@@ -225,7 +225,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) {
@@ -235,7 +235,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) {
@@ -246,7 +246,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) {
@@ -265,7 +265,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) {
@@ -274,10 +274,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) {

keyboards/planck/keymaps/vifon/keymap.c

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

keyboards/planck/keymaps/xyverz/keymap.c

@@ -164,7 +164,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) {
@@ -173,7 +173,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) {
@@ -182,7 +182,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) {
@@ -191,7 +191,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) {
@@ -201,7 +201,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) {
@@ -211,7 +211,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) {
@@ -222,10 +222,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) {

keyboards/planck/keymaps/zach/zach_common_functions.c

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

keyboards/preonic/keymaps/0xdec/keymap.c

@@ -139,7 +139,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 COLEMAK:
       if (record->event.pressed) {
@@ -165,9 +165,9 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
       }
       break;
     default:
-      return true;
+      return CONTINUE_PROCESSING;
       break;
   }
 
-  return false;
+  return STOP_PROCESSING;
 };

keyboards/preonic/keymaps/default/keymap.c

@@ -166,25 +166,25 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 };
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+level_t process_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
         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) {
@@ -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 BACKLIT:
           if (record->event.pressed) {
@@ -215,8 +215,8 @@ 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;
 };

keyboards/preonic/keymaps/jacwib/keymap.c

@@ -201,13 +201,13 @@ 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 LOWER:
           if (record->event.pressed) {
@@ -217,7 +217,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) {
@@ -227,13 +227,13 @@ 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 MQWERTY:
           if (record->event.pressed) {
             persistent_default_layer_set(1UL<<_MQWERTY);
           }
-          return false;
+          return STOP_PROCESSING;
           break;
         case MLOWER:
           if (record->event.pressed) {
@@ -243,7 +243,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
             layer_off(_MLOWER);
             update_tri_layer(_MLOWER, _MRAISE, _ADJUST);
           }
-          return false;
+          return STOP_PROCESSING;
           break;
         case MRAISE:
           if (record->event.pressed) {
@@ -253,10 +253,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
             layer_off(_MRAISE);
             update_tri_layer(_MLOWER, _MRAISE, _ADJUST);
           }
-          return false;
+          return STOP_PROCESSING;
           break;
       }
-    return true;
+    return CONTINUE_PROCESSING;
 };
 
 void matrix_init_user(void) {

keyboards/preonic/keymaps/kinesis/keymap.c

@@ -87,7 +87,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) {*/
   /*return true;*/
   /*[>switch (keycode) {<]*/
     /*[>case QWERTY:<]*/

keyboards/preonic/keymaps/nikchi/keymap.c

@@ -141,7 +141,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) {
@@ -150,7 +150,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) {
@@ -160,7 +160,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) {
@@ -170,7 +170,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) {
@@ -181,10 +181,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) {

keyboards/preonic/keymaps/smt/keymap.c

@@ -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 QWERTY:
           if (record->event.pressed) {
@@ -197,7 +197,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) {
@@ -206,7 +206,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) {
@@ -215,7 +215,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) {
@@ -225,7 +225,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) {
@@ -235,7 +235,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) {
@@ -246,10 +246,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) {

keyboards/preonic/keymaps/xyverz/keymap.c

@@ -182,7 +182,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) {
@@ -191,7 +191,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) {
@@ -200,7 +200,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) {
@@ -209,7 +209,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) {
@@ -219,7 +219,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) {
@@ -229,7 +229,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) {
@@ -240,10 +240,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) {

keyboards/preonic/keymaps/zach/zach_common_functions.c

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

keyboards/roadkit/roadkit.c

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

keyboards/s60_x/default/default.c

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

keyboards/s60_x/keymaps/ansi_qwertz/keymap.c

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

keyboards/s60_x/keymaps/bluebear/keymap.c

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

keyboards/s60_x/keymaps/dbroqua/keymap.c

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

keyboards/s60_x/keymaps/jpec/keymap.c

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

keyboards/satan/keymaps/smt/keymap.c

@@ -116,26 +116,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;
 }

keyboards/subatomic/keymaps/default/keymap.c

@@ -182,7 +182,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) {
@@ -191,7 +191,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) {
@@ -200,7 +200,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) {
@@ -209,7 +209,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) {
@@ -219,7 +219,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) {
@@ -229,7 +229,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) {
@@ -240,10 +240,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) {

keyboards/tada68/keymaps/maartenwut/keymap.c

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

keyboards/tiger_lily/tiger_lily.c

@@ -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) {
+level_t process_user(uint16_t keycode, keyrecord_t *record) {
-  return true;
+  return CONTINUE_PROCESSING;
 }
 
 __attribute__ ((weak))

keyboards/tv44/keymaps/jeebak/keymap.c

@@ -290,25 +290,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) {
@@ -318,7 +318,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) {
@@ -328,7 +328,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) {
@@ -339,7 +339,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) {
@@ -354,16 +354,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;
 }
 
 /*

keyboards/tv44/keymaps/smt/keymap.c

@@ -176,25 +176,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) {
@@ -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,8 +225,8 @@ 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;
 }

keyboards/tv44/keymaps/xyverz/keymap.c

@@ -76,25 +76,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) {
@@ -104,7 +104,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) {
@@ -114,8 +114,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;
 }

keyboards/tv44/tv44.c

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

keyboards/vision_division/vision_division.c

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

quantum/dynamic_macro.h

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

quantum/process_keycode/process_audio.c

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

quantum/process_keycode/process_audio.h

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

quantum/process_keycode/process_chording.c

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

quantum/process_keycode/process_chording.h

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

quantum/process_keycode/process_combo.c

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

quantum/process_keycode/process_combo.h

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

quantum/process_keycode/process_leader.c

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

quantum/process_keycode/process_leader.h

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

quantum/process_keycode/process_midi.c

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

quantum/process_keycode/process_midi.h

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

quantum/process_keycode/process_music.c

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

quantum/process_keycode/process_music.h

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

quantum/process_keycode/process_printer.c

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

quantum/process_keycode/process_printer.h

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

quantum/process_keycode/process_printer_bb.c

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

quantum/process_keycode/process_steno.c

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

quantum/process_keycode/process_steno.h

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

quantum/process_keycode/process_tap_dance.c

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

quantum/process_keycode/process_tap_dance.h

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

quantum/process_keycode/process_ucis.c

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

quantum/process_keycode/process_ucis.h

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

quantum/process_keycode/process_unicode.c

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

quantum/process_keycode/process_unicode.h

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

quantum/process_keycode/process_unicodemap.c

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

quantum/process_keycode/process_unicodemap.h

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

quantum/quantum.c

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

quantum/quantum.h

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

quantum/template/keymaps/default/keymap.c

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

quantum/template/template.c

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

tmk_core/common/action.c

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

tmk_core/common/action.h

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