diff options
Diffstat (limited to 'quantum/process_keycode')
46 files changed, 415 insertions, 219 deletions
| diff --git a/quantum/process_keycode/process_audio.c b/quantum/process_keycode/process_audio.c index c189dd02b7..ef2f52c9f1 100644 --- a/quantum/process_keycode/process_audio.c +++ b/quantum/process_keycode/process_audio.c @@ -1,5 +1,6 @@  #include "audio.h"  #include "process_audio.h" +#include <math.h>  #ifndef VOICE_CHANGE_SONG  #    define VOICE_CHANGE_SONG SONG(VOICE_CHANGE_SOUND) @@ -61,6 +62,3 @@ void process_audio_noteoff(uint8_t note) {  void process_audio_all_notes_off(void) {      stop_all_notes();  } - -__attribute__((weak)) void audio_on_user(void) {} -__attribute__((weak)) void audio_off_user(void) {} diff --git a/quantum/process_keycode/process_audio.h b/quantum/process_keycode/process_audio.h index 42cfab4af2..69e201e447 100644 --- a/quantum/process_keycode/process_audio.h +++ b/quantum/process_keycode/process_audio.h @@ -1,11 +1,12 @@  #pragma once +#include <stdint.h> +#include <stdbool.h> +#include "action.h" +  float compute_freq_for_midi_note(uint8_t note);  bool 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); - -void audio_on_user(void); -void audio_off_user(void); diff --git a/quantum/process_keycode/process_auto_shift.c b/quantum/process_keycode/process_auto_shift.c index 62c347ae0c..9b78214e43 100644 --- a/quantum/process_keycode/process_auto_shift.c +++ b/quantum/process_keycode/process_auto_shift.c @@ -14,27 +14,28 @@   * along with this program.  If not, see <http://www.gnu.org/licenses/>.   */ -#ifdef AUTO_SHIFT_ENABLE - -#    include <stdbool.h> -#    include "process_auto_shift.h" - -#    ifndef AUTO_SHIFT_DISABLED_AT_STARTUP -#        define AUTO_SHIFT_STARTUP_STATE true /* enabled */ -#    else -#        define AUTO_SHIFT_STARTUP_STATE false /* disabled */ -#    endif +#include "process_auto_shift.h" +#include "quantum.h" +#include "action_util.h" +#include "timer.h" +#include "keycodes.h" + +#ifndef AUTO_SHIFT_DISABLED_AT_STARTUP +#    define AUTO_SHIFT_STARTUP_STATE true /* enabled */ +#else +#    define AUTO_SHIFT_STARTUP_STATE false /* disabled */ +#endif  // Stores the last Auto Shift key's up or down time, for evaluation or keyrepeat.  static uint16_t autoshift_time = 0; -#    if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING) +#if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING)  // Stores the last key's up or down time, to replace autoshift_time so that Tap Hold times are accurate.  static uint16_t retroshift_time = 0;  // Stores a possibly Retro Shift key's up or down time, as retroshift_time needs  // to be set before the Retro Shift key is evaluated if it is interrupted by an  // Auto Shifted key.  static uint16_t last_retroshift_time; -#    endif +#endif  static uint16_t    autoshift_timeout = AUTO_SHIFT_TIMEOUT;  static uint16_t    autoshift_lastkey = KC_NO;  static keyrecord_t autoshift_lastrecord; @@ -68,15 +69,23 @@ __attribute__((weak)) bool get_custom_auto_shifted_key(uint16_t keycode, keyreco  /** \brief Called on physical press, returns whether is Auto Shift key */  __attribute__((weak)) bool get_auto_shifted_key(uint16_t keycode, keyrecord_t *record) {      switch (keycode) { -#    ifndef NO_AUTO_SHIFT_ALPHA +#ifndef NO_AUTO_SHIFT_ALPHA          case AUTO_SHIFT_ALPHA: -#    endif -#    ifndef NO_AUTO_SHIFT_NUMERIC +#endif +#ifndef NO_AUTO_SHIFT_NUMERIC          case AUTO_SHIFT_NUMERIC: +#endif +#ifndef NO_AUTO_SHIFT_SPECIAL +#    ifndef NO_AUTO_SHIFT_TAB +        case KC_TAB:  #    endif -#    ifndef NO_AUTO_SHIFT_SPECIAL -        case AUTO_SHIFT_SPECIAL: +#    ifndef NO_AUTO_SHIFT_SYMBOLS +        case AUTO_SHIFT_SYMBOLS:  #    endif +#endif +#ifdef AUTO_SHIFT_ENTER +        case KC_ENT: +#endif              return true;      }      return get_custom_auto_shifted_key(keycode, record); @@ -122,9 +131,9 @@ bool get_autoshift_shift_state(uint16_t keycode) {  /** \brief Restores the shift key if it was cancelled by Auto Shift */  static void autoshift_flush_shift(void) {      autoshift_flags.holding_shift = false; -#    ifdef CAPS_WORD_ENABLE +#ifdef CAPS_WORD_ENABLE      if (!is_caps_word_on()) -#    endif // CAPS_WORD_ENABLE +#endif // CAPS_WORD_ENABLE      {          del_weak_mods(MOD_BIT(KC_LSFT));      } @@ -146,26 +155,26 @@ static void autoshift_flush_shift(void) {  static bool autoshift_press(uint16_t keycode, uint16_t now, keyrecord_t *record) {      // clang-format off      if ((get_mods() -#    if !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING) +#if !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING)              | get_oneshot_mods() -#    endif +#endif          ) & (~MOD_BIT(KC_LSFT))      ) {          // clang-format on          // Prevents keyrepeating unshifted value of key after using it in a key combo.          autoshift_lastkey = KC_NO; -#    ifndef AUTO_SHIFT_MODIFIERS +#ifndef AUTO_SHIFT_MODIFIERS          // We can't return true here anymore because custom unshifted values are          // possible and there's no good way to tell whether the press returned          // true upon release.          set_autoshift_shift_state(keycode, false);          autoshift_press_user(keycode, false, record); -#        if !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING) +#    if !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING)          set_oneshot_mods(get_oneshot_mods() & (~MOD_BIT(KC_LSFT)));          clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED); -#        endif -        return false;  #    endif +        return false; +#endif      }      // Store record to be sent to user functions if there's no release record then. @@ -173,19 +182,19 @@ static bool autoshift_press(uint16_t keycode, uint16_t now, keyrecord_t *record)      autoshift_lastrecord.event.pressed = false;      autoshift_lastrecord.event.time    = 0;      // clang-format off -#    if defined(AUTO_SHIFT_REPEAT) || defined(AUTO_SHIFT_REPEAT_PER_KEY) +#if defined(AUTO_SHIFT_REPEAT) || defined(AUTO_SHIFT_REPEAT_PER_KEY)      if (keycode == autoshift_lastkey && -#        ifdef AUTO_SHIFT_REPEAT_PER_KEY +#    ifdef AUTO_SHIFT_REPEAT_PER_KEY          get_auto_shift_repeat(autoshift_lastkey, record) && -#        endif -#        if !defined(AUTO_SHIFT_NO_AUTO_REPEAT) || defined(AUTO_SHIFT_NO_AUTO_REPEAT_PER_KEY) +#    endif +#    if !defined(AUTO_SHIFT_NO_AUTO_REPEAT) || defined(AUTO_SHIFT_NO_AUTO_REPEAT_PER_KEY)          (              !autoshift_flags.lastshifted -#            ifdef AUTO_SHIFT_NO_AUTO_REPEAT_PER_KEY +#        ifdef AUTO_SHIFT_NO_AUTO_REPEAT_PER_KEY              || get_auto_shift_no_auto_repeat(autoshift_lastkey, record) -#            endif -        ) &&  #        endif +        ) && +#    endif          TIMER_DIFF_16(now, autoshift_time) < GET_TAPPING_TERM(autoshift_lastkey, record)      ) {          // clang-format on @@ -202,23 +211,23 @@ static bool autoshift_press(uint16_t keycode, uint16_t now, keyrecord_t *record)          autoshift_press_user(autoshift_lastkey, autoshift_flags.lastshifted, record);          return false;      } -#    endif +#endif      // Use physical shift state of press event to be more like normal typing. -#    if !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING) +#if !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING)      autoshift_flags.lastshifted = (get_mods() | get_oneshot_mods()) & MOD_BIT(KC_LSFT);      set_oneshot_mods(get_oneshot_mods() & (~MOD_BIT(KC_LSFT))); -#    else +#else      autoshift_flags.lastshifted = get_mods() & MOD_BIT(KC_LSFT); -#    endif +#endif      // Record the keycode so we can simulate it later.      autoshift_lastkey           = keycode;      autoshift_time              = now;      autoshift_flags.in_progress = true; -#    if !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING) +#if !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING)      clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED); -#    endif +#endif      return false;  } @@ -239,11 +248,11 @@ static void autoshift_end(uint16_t keycode, uint16_t now, bool matrix_trigger, k          autoshift_flags.lastshifted =              autoshift_flags.lastshifted              || TIMER_DIFF_16(now, autoshift_time) >= -#    ifdef AUTO_SHIFT_TIMEOUT_PER_KEY +#ifdef AUTO_SHIFT_TIMEOUT_PER_KEY                  get_autoshift_timeout(autoshift_lastkey, record) -#    else +#else                  autoshift_timeout -#    endif +#endif          ;          // clang-format on          set_autoshift_shift_state(autoshift_lastkey, autoshift_flags.lastshifted); @@ -258,23 +267,23 @@ static void autoshift_end(uint16_t keycode, uint16_t now, bool matrix_trigger, k          autoshift_press_user(autoshift_lastkey, autoshift_flags.lastshifted, record);          // clang-format off -#    if (defined(AUTO_SHIFT_REPEAT) || defined(AUTO_SHIFT_REPEAT_PER_KEY)) && (!defined(AUTO_SHIFT_NO_AUTO_REPEAT) || defined(AUTO_SHIFT_NO_AUTO_REPEAT_PER_KEY)) +#if (defined(AUTO_SHIFT_REPEAT) || defined(AUTO_SHIFT_REPEAT_PER_KEY)) && (!defined(AUTO_SHIFT_NO_AUTO_REPEAT) || defined(AUTO_SHIFT_NO_AUTO_REPEAT_PER_KEY))          if (matrix_trigger -#        ifdef AUTO_SHIFT_REPEAT_PER_KEY +#    ifdef AUTO_SHIFT_REPEAT_PER_KEY              && get_auto_shift_repeat(autoshift_lastkey, record) -#        endif -#        ifdef AUTO_SHIFT_NO_AUTO_REPEAT_PER_KEY +#    endif +#    ifdef AUTO_SHIFT_NO_AUTO_REPEAT_PER_KEY              && !get_auto_shift_no_auto_repeat(autoshift_lastkey, record) -#        endif +#    endif          ) {              // Prevents release.              return;          } -#    endif +#endif          // clang-format on -#    if TAP_CODE_DELAY > 0 +#if TAP_CODE_DELAY > 0          wait_ms(TAP_CODE_DELAY); -#    endif +#endif          autoshift_release_user(autoshift_lastkey, autoshift_flags.lastshifted, record);          autoshift_flush_shift(); @@ -302,11 +311,11 @@ void autoshift_matrix_scan(void) {      if (autoshift_flags.in_progress) {          const uint16_t now = timer_read();          if (TIMER_DIFF_16(now, autoshift_time) >= -#    ifdef AUTO_SHIFT_TIMEOUT_PER_KEY +#ifdef AUTO_SHIFT_TIMEOUT_PER_KEY              get_autoshift_timeout(autoshift_lastkey, &autoshift_lastrecord) -#    else +#else              autoshift_timeout -#    endif +#endif          ) {              autoshift_end(autoshift_lastkey, now, true, &autoshift_lastrecord);          } @@ -327,18 +336,18 @@ void autoshift_disable(void) {      autoshift_flush_shift();  } -#    ifndef AUTO_SHIFT_NO_SETUP +#ifndef AUTO_SHIFT_NO_SETUP  void autoshift_timer_report(void) { -#        ifdef SEND_STRING_ENABLE +#    ifdef SEND_STRING_ENABLE      const char *autoshift_timeout_str = get_u16_str(autoshift_timeout, ' ');      // Skip padding spaces      while (*autoshift_timeout_str == ' ') {          autoshift_timeout_str++;      }      send_string(autoshift_timeout_str); -#        endif -}  #    endif +} +#endif  bool get_autoshift_state(void) {      return autoshift_flags.enabled; @@ -360,11 +369,11 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {      // https://github.com/qmk/qmk_firmware/pull/9826#issuecomment-733559550      // clang-format off      const uint16_t now = -#    if !defined(RETRO_SHIFT) || defined(NO_ACTION_TAPPING) +#if !defined(RETRO_SHIFT) || defined(NO_ACTION_TAPPING)          timer_read() -#    else +#else          (record->event.pressed) ? retroshift_time : timer_read() -#    endif +#endif      ;      // clang-format on @@ -385,7 +394,7 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {                  autoshift_disable();                  break; -#    ifndef AUTO_SHIFT_NO_SETUP +#ifndef AUTO_SHIFT_NO_SETUP              case AS_UP:                  autoshift_timeout += 5;                  break; @@ -395,27 +404,27 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {              case AS_RPT:                  autoshift_timer_report();                  break; -#    endif +#endif          }              // If Retro Shift is disabled, possible custom actions shouldn't happen.              // clang-format off -#   if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING) -#       ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY +#if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING) +#    ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY              const bool is_hold_on_interrupt = get_hold_on_other_key_press(keycode, record); -#       else +#    else              const bool is_hold_on_interrupt = false; -#       endif -#   endif +#    endif +#endif          if (IS_RETRO(keycode) -#    if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING) +#if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING)              // Not tapped or #defines mean that rolls should use hold action.              && (                  record->tap.count == 0 -#        ifdef RETRO_TAPPING_PER_KEY +#    ifdef RETRO_TAPPING_PER_KEY                  || !get_retro_tapping(keycode, record) -#        endif -                || (record->tap.interrupted && is_hold_on_interrupt))  #    endif +                || (record->tap.interrupted && is_hold_on_interrupt)) +#endif          ) {              // clang-format on              autoshift_lastkey = KC_NO; @@ -431,21 +440,21 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {          // tap.count gets set to 0 in process_action          // clang-format off          else if (IS_RETRO(keycode) -#    if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING) +#if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING)              && (                  record->tap.count == 0 -#        ifdef RETRO_TAPPING_PER_KEY +#    ifdef RETRO_TAPPING_PER_KEY                  || !get_retro_tapping(keycode, record) -#        endif -            )  #    endif +            ) +#endif          ) {              // Fixes modifiers not being applied to rolls with AUTO_SHIFT_MODIFIERS set. -#    ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY +#ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY              if (autoshift_flags.in_progress && get_hold_on_other_key_press(keycode, record)) {                  autoshift_end(KC_NO, now, false, &autoshift_lastrecord);              } -#    endif +#endif              // clang-format on              return true;          } @@ -471,7 +480,7 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {      return true;  } -#    if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING) +#if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING)  // Called to record time before possible delays by action_tapping_process.  void retroshift_poll_time(keyevent_t *event) {      last_retroshift_time = retroshift_time; @@ -485,6 +494,4 @@ void retroshift_swap_times(void) {          last_retroshift_time = temp;      }  } -#    endif -  #endif diff --git a/quantum/process_keycode/process_auto_shift.h b/quantum/process_keycode/process_auto_shift.h index 66a4b3138a..885a47b533 100644 --- a/quantum/process_keycode/process_auto_shift.h +++ b/quantum/process_keycode/process_auto_shift.h @@ -16,7 +16,11 @@  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h" +#include "keyboard.h" +#include "keycodes.h"  #ifndef AUTO_SHIFT_TIMEOUT  #    define AUTO_SHIFT_TIMEOUT 175 @@ -28,10 +32,14 @@  // clang-format off  #define AUTO_SHIFT_ALPHA KC_A ... KC_Z  #define AUTO_SHIFT_NUMERIC KC_1 ... KC_0 +#define AUTO_SHIFT_SYMBOLS          \ +             KC_MINUS ... KC_SLASH: \ +        case KC_NONUS_BACKSLASH + +// Kept to avoid breaking existing keymaps.  #define AUTO_SHIFT_SPECIAL          \               KC_TAB:                \ -        case KC_MINUS ... KC_SLASH: \ -        case KC_NONUS_BACKSLASH +        case AUTO_SHIFT_SYMBOLS  // clang-format on  bool process_auto_shift(uint16_t keycode, keyrecord_t *record); diff --git a/quantum/process_keycode/process_autocorrect.c b/quantum/process_keycode/process_autocorrect.c index 1376788266..edc47718f3 100644 --- a/quantum/process_keycode/process_autocorrect.c +++ b/quantum/process_keycode/process_autocorrect.c @@ -1,11 +1,16 @@  // Copyright 2021 Google LLC  // Copyright 2021 @filterpaper +// Copyright 2023 Pablo Martinez (@elpekenin) <[email protected]>  // SPDX-License-Identifier: Apache-2.0  // Original source: https://getreuer.info/posts/keyboards/autocorrection  #include "process_autocorrect.h"  #include <string.h> +#include "keycodes.h" +#include "quantum_keycodes.h"  #include "keycode_config.h" +#include "send_string.h" +#include "action_util.h"  #if __has_include("autocorrect_data.h")  #    include "autocorrect_data.h" @@ -57,7 +62,7 @@ void autocorrect_toggle(void) {  }  /** - * @brief handler for determining if autocorrect should process keypress + * @brief handler for user to override whether autocorrect should process this keypress   *   * @param keycode Keycode registered by matrix press, per keymap   * @param record keyrecord_t structure @@ -67,6 +72,23 @@ void autocorrect_toggle(void) {   * @return false Stop processing and escape from autocorrect.   */  __attribute__((weak)) bool process_autocorrect_user(uint16_t *keycode, keyrecord_t *record, uint8_t *typo_buffer_size, uint8_t *mods) { +    return process_autocorrect_default_handler(keycode, record, typo_buffer_size, mods); +} + +/** + * @brief fallback handler for determining if autocorrect should process this keypress + *        can be used by user callback to get the basic keycode being "wrapped" + * + * NOTE: These values may have been edited by user callback before getting here + * + * @param keycode Keycode registered by matrix press, per keymap + * @param record keyrecord_t structure + * @param typo_buffer_size passed along to allow resetting of autocorrect buffer + * @param mods allow processing of mod status + * @return true Allow autocorection + * @return false Stop processing and escape from autocorrect. + */ +bool process_autocorrect_default_handler(uint16_t *keycode, keyrecord_t *record, uint8_t *typo_buffer_size, uint8_t *mods) {      // See quantum_keycodes.h for reference on these matched ranges.      switch (*keycode) {          // Exclude these keycodes from processing. @@ -157,10 +179,12 @@ __attribute__((weak)) bool process_autocorrect_user(uint16_t *keycode, keyrecord   *   * @param backspaces number of characters to remove   * @param str pointer to PROGMEM string to replace mistyped seletion with + * @param typo the wrong string that triggered a correction + * @param correct what it would become after the changes   * @return true apply correction   * @return false user handled replacement   */ -__attribute__((weak)) bool apply_autocorrect(uint8_t backspaces, const char *str) { +__attribute__((weak)) bool apply_autocorrect(uint8_t backspaces, const char *str, char *typo, char *correct) {      return true;  } @@ -284,11 +308,57 @@ bool process_autocorrect(uint16_t keycode, keyrecord_t *record) {          if (code & 128) { // A typo was found! Apply autocorrect.              const uint8_t backspaces = (code & 63) + !record->event.pressed; -            if (apply_autocorrect(backspaces, (char const *)(autocorrect_data + state + 1))) { +            const char *  changes    = (const char *)(autocorrect_data + state + 1); + +            /* Gather info about the typo'd word +             * +             * Since buffer may contain several words, delimited by spaces, we +             * iterate from the end to find the start and length of the typo +             */ +            char typo[AUTOCORRECT_MAX_LENGTH + 1] = {0}; // extra char for null terminator + +            uint8_t typo_len   = 0; +            uint8_t typo_start = 0; +            bool    space_last = typo_buffer[typo_buffer_size - 1] == KC_SPC; +            for (uint8_t i = typo_buffer_size; i > 0; --i) { +                // stop counting after finding space (unless it is the last thing) +                if (typo_buffer[i - 1] == KC_SPC && i != typo_buffer_size) { +                    typo_start = i; +                    break; +                } + +                ++typo_len; +            } + +            // when detecting 'typo:', reduce the length of the string by one +            if (space_last) { +                --typo_len; +            } + +            // convert buffer of keycodes into a string +            for (uint8_t i = 0; i < typo_len; ++i) { +                typo[i] = typo_buffer[typo_start + i] - KC_A + 'a'; +            } + +            /* Gather the corrected word +             * +             * A) Correction of 'typo:' -- Code takes into account +             * an extra backspace to delete the space (which we dont copy) +             * for this reason the offset is correct to "skip" the null terminator +             * +             * B) When correcting 'typo' -- Need extra offset for terminator +             */ +            char correct[AUTOCORRECT_MAX_LENGTH + 10] = {0}; // let's hope this is big enough + +            uint8_t offset = space_last ? backspaces : backspaces + 1; +            strcpy(correct, typo); +            strcpy_P(correct + typo_len - offset, changes); + +            if (apply_autocorrect(backspaces, changes, typo, correct)) {                  for (uint8_t i = 0; i < backspaces; ++i) {                      tap_code(KC_BSPC);                  } -                send_string_P((char const *)(autocorrect_data + state + 1)); +                send_string_P(changes);              }              if (keycode == KC_SPC) { diff --git a/quantum/process_keycode/process_autocorrect.h b/quantum/process_keycode/process_autocorrect.h index c7596107e5..ea77d6f56f 100644 --- a/quantum/process_keycode/process_autocorrect.h +++ b/quantum/process_keycode/process_autocorrect.h @@ -1,15 +1,19 @@  // Copyright 2021 Google LLC  // Copyright 2021 @filterpaper +// Copyright 2023 Pablo Martinez (@elpekenin) <[email protected]>  // SPDX-License-Identifier: Apache-2.0  // Original source: https://getreuer.info/posts/keyboards/autocorrection  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  bool process_autocorrect(uint16_t keycode, keyrecord_t *record);  bool process_autocorrect_user(uint16_t *keycode, keyrecord_t *record, uint8_t *typo_buffer_size, uint8_t *mods); -bool apply_autocorrect(uint8_t backspaces, const char *str); +bool process_autocorrect_default_handler(uint16_t *keycode, keyrecord_t *record, uint8_t *typo_buffer_size, uint8_t *mods); +bool apply_autocorrect(uint8_t backspaces, const char *str, char *typo, char *correct);  bool autocorrect_is_enabled(void);  void autocorrect_enable(void); diff --git a/quantum/process_keycode/process_backlight.h b/quantum/process_keycode/process_backlight.h index 7fe887ae67..e926833e79 100644 --- a/quantum/process_keycode/process_backlight.h +++ b/quantum/process_keycode/process_backlight.h @@ -16,6 +16,8 @@  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  bool process_backlight(uint16_t keycode, keyrecord_t *record); diff --git a/quantum/process_keycode/process_caps_word.c b/quantum/process_keycode/process_caps_word.c index d4382680bf..1088c8f76c 100644 --- a/quantum/process_keycode/process_caps_word.c +++ b/quantum/process_keycode/process_caps_word.c @@ -13,6 +13,14 @@  // limitations under the License.  #include "process_caps_word.h" +#include "process_auto_shift.h" +#include "caps_word.h" +#include "keycodes.h" +#include "quantum_keycodes.h" +#include "modifiers.h" +#include "timer.h" +#include "action_tapping.h" +#include "action_util.h"  #ifdef CAPS_WORD_INVERT_ON_SHIFT  static uint8_t held_mods = 0; diff --git a/quantum/process_keycode/process_caps_word.h b/quantum/process_keycode/process_caps_word.h index f215bbc3a3..f5eb140d32 100644 --- a/quantum/process_keycode/process_caps_word.h +++ b/quantum/process_keycode/process_caps_word.h @@ -14,8 +14,9 @@  #pragma once -#include "quantum.h" -#include "caps_word.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  /**   * @brief Process handler for Caps Word feature. diff --git a/quantum/process_keycode/process_clicky.c b/quantum/process_keycode/process_clicky.c index b662a3f2f4..0ee58282e6 100644 --- a/quantum/process_keycode/process_clicky.c +++ b/quantum/process_keycode/process_clicky.c @@ -1,5 +1,7 @@ -#include "audio.h"  #include "process_clicky.h" +#include "audio.h" +#include "eeconfig.h" +#include <stdlib.h>  #ifdef AUDIO_CLICKY diff --git a/quantum/process_keycode/process_clicky.h b/quantum/process_keycode/process_clicky.h index 67b6463c5d..dfdba14131 100644 --- a/quantum/process_keycode/process_clicky.h +++ b/quantum/process_keycode/process_clicky.h @@ -1,5 +1,9 @@  #pragma once +#include <stdint.h> +#include <stdbool.h> +#include "action.h" +  void clicky_play(void);  bool process_clicky(uint16_t keycode, keyrecord_t *record); diff --git a/quantum/process_keycode/process_combo.c b/quantum/process_keycode/process_combo.c index bbee560be9..64d30fc140 100644 --- a/quantum/process_keycode/process_combo.c +++ b/quantum/process_keycode/process_combo.c @@ -14,11 +14,17 @@   * along with this program.  If not, see <http://www.gnu.org/licenses/>.   */ -#include "keymap_common.h" -#include "print.h"  #include "process_combo.h" +#include <stddef.h> +#include "process_auto_shift.h" +#include "caps_word.h" +#include "timer.h" +#include "wait.h" +#include "keyboard.h" +#include "keymap_common.h" +#include "action_layer.h"  #include "action_tapping.h" -#include "action.h" +#include "action_util.h"  #include "keymap_introspection.h"  __attribute__((weak)) void process_combo_event(uint16_t combo_index, bool pressed) {} diff --git a/quantum/process_keycode/process_combo.h b/quantum/process_keycode/process_combo.h index bba5d5ee63..f1d534236e 100644 --- a/quantum/process_keycode/process_combo.h +++ b/quantum/process_keycode/process_combo.h @@ -16,9 +16,11 @@  #pragma once -#include "progmem.h" -#include "quantum.h"  #include <stdint.h> +#include <stdbool.h> +#include "action.h" +#include "keycodes.h" +#include "quantum_keycodes.h"  #ifdef EXTRA_SHORT_COMBOS  #    define MAX_COMBO_LENGTH 6 diff --git a/quantum/process_keycode/process_dynamic_macro.c b/quantum/process_keycode/process_dynamic_macro.c index bf6af566e2..5e4a6fa308 100644 --- a/quantum/process_keycode/process_dynamic_macro.c +++ b/quantum/process_keycode/process_dynamic_macro.c @@ -17,6 +17,15 @@  /* Author: Wojciech Siewierski < wojciech dot siewierski at onet dot pl > */  #include "process_dynamic_macro.h" +#include <stddef.h> +#include "action_layer.h" +#include "keycodes.h" +#include "debug.h" +#include "wait.h" + +#ifdef BACKLIGHT_ENABLE +#    include "backlight.h" +#endif  // default feedback method  void dynamic_macro_led_blink(void) { @@ -151,6 +160,67 @@ void dynamic_macro_record_end(keyrecord_t *macro_buffer, keyrecord_t *macro_poin      *macro_end = macro_pointer;  } +/* Both macros use the same buffer but read/write on different + * ends of it. + * + * Macro1 is written left-to-right starting from the beginning of + * the buffer. + * + * Macro2 is written right-to-left starting from the end of the + * buffer. + * + * ¯o_buffer   macro_end + *  v                   v + * +------------------------------------------------------------+ + * |>>>>>> MACRO1 >>>>>>      <<<<<<<<<<<<< MACRO2 <<<<<<<<<<<<<| + * +------------------------------------------------------------+ + *                           ^                                 ^ + *                         r_macro_end                  r_macro_buffer + * + * During the recording when one macro encounters the end of the + * other macro, the recording is stopped. Apart from this, there + * are no arbitrary limits for the macros' length in relation to + * each other: for example one can either have two medium sized + * macros or one long macro and one short macro. Or even one empty + * and one using the whole buffer. + */ +static keyrecord_t macro_buffer[DYNAMIC_MACRO_SIZE]; + +/* Pointer to the first buffer element after the first macro. + * Initially points to the very beginning of the buffer since the + * macro is empty. */ +static keyrecord_t *macro_end = macro_buffer; + +/* The other end of the macro buffer. Serves as the beginning of + * the second macro. */ +static keyrecord_t *const r_macro_buffer = macro_buffer + DYNAMIC_MACRO_SIZE - 1; + +/* Like macro_end but for the second macro. */ +static keyrecord_t *r_macro_end = r_macro_buffer; + +/* A persistent pointer to the current macro position (iterator) + * used during the recording. */ +static keyrecord_t *macro_pointer = NULL; + +/* 0   - no macro is being recorded right now + * 1,2 - either macro 1 or 2 is being recorded */ +static uint8_t macro_id = 0; + +/** + * If a dynamic macro is currently being recorded, stop recording. + */ +void dynamic_macro_stop_recording(void) { +    switch (macro_id) { +        case 1: +            dynamic_macro_record_end(macro_buffer, macro_pointer, +1, ¯o_end); +            break; +        case 2: +            dynamic_macro_record_end(r_macro_buffer, macro_pointer, -1, &r_macro_end); +            break; +    } +    macro_id = 0; +} +  /* Handle the key events related to the dynamic macros. Should be   * called from process_record_user() like this:   * @@ -162,52 +232,6 @@ void dynamic_macro_record_end(keyrecord_t *macro_buffer, keyrecord_t *macro_poin   *   }   */  bool process_dynamic_macro(uint16_t keycode, keyrecord_t *record) { -    /* Both macros use the same buffer but read/write on different -     * ends of it. -     * -     * Macro1 is written left-to-right starting from the beginning of -     * the buffer. -     * -     * Macro2 is written right-to-left starting from the end of the -     * buffer. -     * -     * ¯o_buffer   macro_end -     *  v                   v -     * +------------------------------------------------------------+ -     * |>>>>>> MACRO1 >>>>>>      <<<<<<<<<<<<< MACRO2 <<<<<<<<<<<<<| -     * +------------------------------------------------------------+ -     *                           ^                                 ^ -     *                         r_macro_end                  r_macro_buffer -     * -     * During the recording when one macro encounters the end of the -     * other macro, the recording is stopped. Apart from this, there -     * are no arbitrary limits for the macros' length in relation to -     * each other: for example one can either have two medium sized -     * macros or one long macro and one short macro. Or even one empty -     * and one using the whole buffer. -     */ -    static keyrecord_t macro_buffer[DYNAMIC_MACRO_SIZE]; - -    /* Pointer to the first buffer element after the first macro. -     * Initially points to the very beginning of the buffer since the -     * macro is empty. */ -    static keyrecord_t *macro_end = macro_buffer; - -    /* The other end of the macro buffer. Serves as the beginning of -     * the second macro. */ -    static keyrecord_t *const r_macro_buffer = macro_buffer + DYNAMIC_MACRO_SIZE - 1; - -    /* Like macro_end but for the second macro. */ -    static keyrecord_t *r_macro_end = r_macro_buffer; - -    /* A persistent pointer to the current macro position (iterator) -     * used during the recording. */ -    static keyrecord_t *macro_pointer = NULL; - -    /* 0   - no macro is being recorded right now -     * 1,2 - either macro 1 or 2 is being recorded */ -    static uint8_t macro_id = 0; -      if (macro_id == 0) {          /* No macro recording in progress. */          if (!record->event.pressed) { @@ -238,15 +262,7 @@ bool process_dynamic_macro(uint16_t keycode, keyrecord_t *record) {                  if (record->event.pressed ^ (keycode != QK_DYNAMIC_MACRO_RECORD_STOP)) { /* Ignore the initial release                                                                                            * just after the recording                                                                                            * starts for DM_RSTP. */ -                    switch (macro_id) { -                        case 1: -                            dynamic_macro_record_end(macro_buffer, macro_pointer, +1, ¯o_end); -                            break; -                        case 2: -                            dynamic_macro_record_end(r_macro_buffer, macro_pointer, -1, &r_macro_end); -                            break; -                    } -                    macro_id = 0; +                    dynamic_macro_stop_recording();                  }                  return false;  #ifdef DYNAMIC_MACRO_NO_NESTING diff --git a/quantum/process_keycode/process_dynamic_macro.h b/quantum/process_keycode/process_dynamic_macro.h index ab70726897..2f10733cae 100644 --- a/quantum/process_keycode/process_dynamic_macro.h +++ b/quantum/process_keycode/process_dynamic_macro.h @@ -18,7 +18,9 @@  /* Author: Wojciech Siewierski < wojciech dot siewierski at onet dot pl > */  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  /* May be overridden with a custom value. Be aware that the effective   * macro length is half of this value: each keypress is recorded twice @@ -39,3 +41,4 @@ void dynamic_macro_record_start_user(int8_t direction);  void dynamic_macro_play_user(int8_t direction);  void dynamic_macro_record_key_user(int8_t direction, keyrecord_t *record);  void dynamic_macro_record_end_user(int8_t direction); +void dynamic_macro_stop_recording(void); diff --git a/quantum/process_keycode/process_dynamic_tapping_term.c b/quantum/process_keycode/process_dynamic_tapping_term.c index 146b9fccd7..cf52626e42 100644 --- a/quantum/process_keycode/process_dynamic_tapping_term.c +++ b/quantum/process_keycode/process_dynamic_tapping_term.c @@ -14,8 +14,10 @@   * along with this program.  If not, see <http://www.gnu.org/licenses/>.   */ -#include "quantum.h"  #include "process_dynamic_tapping_term.h" +#include "quantum.h" +#include "keycodes.h" +#include "send_string.h"  #ifndef DYNAMIC_TAPPING_TERM_INCREMENT  #    define DYNAMIC_TAPPING_TERM_INCREMENT 5 diff --git a/quantum/process_keycode/process_dynamic_tapping_term.h b/quantum/process_keycode/process_dynamic_tapping_term.h index 85e83ee73b..fee29e18df 100644 --- a/quantum/process_keycode/process_dynamic_tapping_term.h +++ b/quantum/process_keycode/process_dynamic_tapping_term.h @@ -16,6 +16,7 @@  #pragma once +#include <stdint.h>  #include <stdbool.h>  #include "action.h" diff --git a/quantum/process_keycode/process_grave_esc.c b/quantum/process_keycode/process_grave_esc.c index ddf027391d..d786f57a80 100644 --- a/quantum/process_keycode/process_grave_esc.c +++ b/quantum/process_keycode/process_grave_esc.c @@ -14,6 +14,9 @@   * along with this program.  If not, see <http://www.gnu.org/licenses/>.   */  #include "process_grave_esc.h" +#include "keycodes.h" +#include "modifiers.h" +#include "action_util.h"  /* true if the last press of QK_GRAVE_ESCAPE was shifted (i.e. GUI or SHIFT were pressed), false otherwise.   * Used to ensure that the correct keycode is released if the key is released. diff --git a/quantum/process_keycode/process_grave_esc.h b/quantum/process_keycode/process_grave_esc.h index bbf4483763..358ff3c4e7 100644 --- a/quantum/process_keycode/process_grave_esc.h +++ b/quantum/process_keycode/process_grave_esc.h @@ -15,6 +15,8 @@   */  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  bool process_grave_esc(uint16_t keycode, keyrecord_t *record); diff --git a/quantum/process_keycode/process_haptic.h b/quantum/process_keycode/process_haptic.h index 6dbb0f014d..7e61f6c0d6 100644 --- a/quantum/process_keycode/process_haptic.h +++ b/quantum/process_keycode/process_haptic.h @@ -15,6 +15,7 @@   */  #pragma once +#include <stdint.h>  #include <stdbool.h>  #include "action.h" diff --git a/quantum/process_keycode/process_joystick.h b/quantum/process_keycode/process_joystick.h index 1fb8757708..aa1a443271 100644 --- a/quantum/process_keycode/process_joystick.h +++ b/quantum/process_keycode/process_joystick.h @@ -17,6 +17,7 @@  #pragma once  #include <stdint.h> -#include "quantum.h" +#include <stdbool.h> +#include "action.h"  bool process_joystick(uint16_t keycode, keyrecord_t *record); diff --git a/quantum/process_keycode/process_key_lock.h b/quantum/process_keycode/process_key_lock.h index 5159b0ba02..858945a8e4 100644 --- a/quantum/process_keycode/process_key_lock.h +++ b/quantum/process_keycode/process_key_lock.h @@ -16,7 +16,9 @@  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  void cancel_key_lock(void);  bool process_key_lock(uint16_t *keycode, keyrecord_t *record); diff --git a/quantum/process_keycode/process_key_override.c b/quantum/process_keycode/process_key_override.c index 17e490e67a..264e2562b8 100644 --- a/quantum/process_keycode/process_key_override.c +++ b/quantum/process_keycode/process_key_override.c @@ -15,12 +15,14 @@   * along with this program.  If not, see <http://www.gnu.org/licenses/>.   */ -#include "quantum.h" +#include "process_key_override.h"  #include "report.h"  #include "timer.h" -#include "process_key_override.h" - -#include <debug.h> +#include "debug.h" +#include "wait.h" +#include "action_util.h" +#include "quantum.h" +#include "quantum_keycodes.h"  #ifndef KEY_OVERRIDE_REPEAT_DELAY  #    define KEY_OVERRIDE_REPEAT_DELAY 500 @@ -322,6 +324,15 @@ static bool try_activating_override(const uint16_t keycode, const uint8_t layer,          clear_active_override(false); +#ifdef DUMMY_MOD_NEUTRALIZER_KEYCODE +        // Send a dummy keycode before unregistering the modifier(s) +        // so that suppressing the modifier(s) doesn't falsely get interpreted +        // by the host OS as a tap of a modifier key. +        // For example, unintended activations of the start menu on Windows when +        // using a GUI+<kc> key override with suppressed mods. +        neutralize_flashing_modifiers(active_mods); +#endif +          active_override                 = override;          active_override_trigger_is_down = true; diff --git a/quantum/process_keycode/process_key_override.h b/quantum/process_keycode/process_key_override.h index fd76f297a8..3e37c7e63a 100644 --- a/quantum/process_keycode/process_key_override.h +++ b/quantum/process_keycode/process_key_override.h @@ -18,9 +18,8 @@  #pragma once  #include <stdbool.h> -#include <stddef.h>  #include <stdint.h> - +#include "action.h"  #include "action_layer.h"  /** diff --git a/quantum/process_keycode/process_leader.c b/quantum/process_keycode/process_leader.c index a9823b6285..ca017a577d 100644 --- a/quantum/process_keycode/process_leader.c +++ b/quantum/process_keycode/process_leader.c @@ -16,6 +16,7 @@  #include "process_leader.h"  #include "leader.h" +#include "quantum_keycodes.h"  bool process_leader(uint16_t keycode, keyrecord_t *record) {      if (record->event.pressed) { diff --git a/quantum/process_keycode/process_leader.h b/quantum/process_keycode/process_leader.h index eb0f721f60..b78fbb94df 100644 --- a/quantum/process_keycode/process_leader.h +++ b/quantum/process_keycode/process_leader.h @@ -16,6 +16,8 @@  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  bool process_leader(uint16_t keycode, keyrecord_t *record); diff --git a/quantum/process_keycode/process_magic.c b/quantum/process_keycode/process_magic.c index 5fafe8550f..3b35884d68 100644 --- a/quantum/process_keycode/process_magic.c +++ b/quantum/process_keycode/process_magic.c @@ -14,8 +14,13 @@   * along with this program.  If not, see <http://www.gnu.org/licenses/>.   */  #include "process_magic.h" +#include "keycode_config.h" +#include "keycodes.h" +#include "eeconfig.h"  #ifdef AUDIO_ENABLE +#    include "audio.h" +  #    ifndef AG_NORM_SONG  #        define AG_NORM_SONG SONG(AG_NORM_SOUND)  #    endif diff --git a/quantum/process_keycode/process_magic.h b/quantum/process_keycode/process_magic.h index 1eb39f1455..aa65a43bae 100644 --- a/quantum/process_keycode/process_magic.h +++ b/quantum/process_keycode/process_magic.h @@ -15,6 +15,8 @@   */  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  bool process_magic(uint16_t keycode, keyrecord_t *record); diff --git a/quantum/process_keycode/process_midi.c b/quantum/process_keycode/process_midi.c index ce62559849..377fcb69e2 100644 --- a/quantum/process_keycode/process_midi.c +++ b/quantum/process_keycode/process_midi.c @@ -15,12 +15,13 @@   */  #include "process_midi.h" -#ifdef MIDI_ENABLE -#    include <LUFA/Drivers/USB/USB.h> -#    include "midi.h" -#    include "qmk_midi.h" +#include <LUFA/Drivers/USB/USB.h> +#include "midi.h" +#include "qmk_midi.h" +#include "timer.h" +#include "debug.h" -#    ifdef MIDI_BASIC +#ifdef MIDI_BASIC  void process_midi_basic_noteon(uint8_t note) {      midi_send_noteon(&midi_device, 0, note, 127); @@ -34,12 +35,9 @@ void process_midi_all_notes_off(void) {      midi_send_cc(&midi_device, 0, 0x7B, 0);  } -#    endif // MIDI_BASIC - -#    ifdef MIDI_ADVANCED - -#        include "timer.h" +#endif // MIDI_BASIC +#ifdef MIDI_ADVANCED  static uint8_t tone_status[2][MIDI_TONE_COUNT];  static uint8_t  midi_modulation; @@ -248,11 +246,11 @@ bool process_midi(uint16_t keycode, keyrecord_t *record) {      return true;  } -#    endif // MIDI_ADVANCED +#endif // MIDI_ADVANCED  void midi_task(void) {      midi_device_process(&midi_device); -#    ifdef MIDI_ADVANCED +#ifdef MIDI_ADVANCED      if (timer_elapsed(midi_modulation_timer) < midi_config.modulation_interval) return;      midi_modulation_timer = timer_read(); @@ -270,7 +268,5 @@ void midi_task(void) {          if (midi_modulation > 127) midi_modulation = 127;      } -#    endif +#endif  } - -#endif // MIDI_ENABLE diff --git a/quantum/process_keycode/process_midi.h b/quantum/process_keycode/process_midi.h index e528c6ec0c..64ccc610f9 100644 --- a/quantum/process_keycode/process_midi.h +++ b/quantum/process_keycode/process_midi.h @@ -16,7 +16,10 @@  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h" +#include "quantum_keycodes.h"  #ifdef MIDI_ENABLE diff --git a/quantum/process_keycode/process_music.c b/quantum/process_keycode/process_music.c index 7c572079a7..f047668504 100644 --- a/quantum/process_keycode/process_music.c +++ b/quantum/process_keycode/process_music.c @@ -14,8 +14,10 @@   * along with this program.  If not, see <http://www.gnu.org/licenses/>.   */  #include "process_music.h" +#include "timer.h"  #ifdef AUDIO_ENABLE +#    include "audio.h"  #    include "process_audio.h"  #endif  #if defined(MIDI_ENABLE) && defined(MIDI_BASIC) diff --git a/quantum/process_keycode/process_music.h b/quantum/process_keycode/process_music.h index 83726a05ba..ed39d3cda5 100644 --- a/quantum/process_keycode/process_music.h +++ b/quantum/process_keycode/process_music.h @@ -16,7 +16,9 @@  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC)) diff --git a/quantum/process_keycode/process_programmable_button.h b/quantum/process_keycode/process_programmable_button.h index 47c6ce5614..ef818af4ca 100644 --- a/quantum/process_keycode/process_programmable_button.h +++ b/quantum/process_keycode/process_programmable_button.h @@ -18,6 +18,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.  #pragma once  #include <stdint.h> -#include "quantum.h" +#include <stdbool.h> +#include "action.h"  bool process_programmable_button(uint16_t keycode, keyrecord_t *record); diff --git a/quantum/process_keycode/process_repeat_key.c b/quantum/process_keycode/process_repeat_key.c index f819aa226e..73f4ddedcf 100644 --- a/quantum/process_keycode/process_repeat_key.c +++ b/quantum/process_keycode/process_repeat_key.c @@ -13,6 +13,10 @@  // limitations under the License.  #include "process_repeat_key.h" +#include "repeat_key.h" +#include "keycodes.h" +#include "quantum_keycodes.h" +#include "action_util.h"  // Default implementation of remember_last_key_user().  __attribute__((weak)) bool remember_last_key_user(uint16_t keycode, keyrecord_t* record, uint8_t* remembered_mods) { diff --git a/quantum/process_keycode/process_repeat_key.h b/quantum/process_keycode/process_repeat_key.h index eddc50f254..c3b200c632 100644 --- a/quantum/process_keycode/process_repeat_key.h +++ b/quantum/process_keycode/process_repeat_key.h @@ -14,7 +14,9 @@  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  /**   * @brief Process handler for remembering the last key. diff --git a/quantum/process_keycode/process_rgb.c b/quantum/process_keycode/process_rgb.c index dae129786e..4e63bf3ca8 100644 --- a/quantum/process_keycode/process_rgb.c +++ b/quantum/process_keycode/process_rgb.c @@ -14,6 +14,14 @@   * along with this program.  If not, see <http://www.gnu.org/licenses/>.   */  #include "process_rgb.h" +#include "action_util.h" + +#ifdef RGB_MATRIX_ENABLE +#    include "rgb_matrix.h" +#endif +#ifdef RGBLIGHT_ENABLE +#    include "rgblight.h" +#endif  typedef void (*rgb_func_pointer)(void); diff --git a/quantum/process_keycode/process_rgb.h b/quantum/process_keycode/process_rgb.h index 26aca46896..b1069d4bb6 100644 --- a/quantum/process_keycode/process_rgb.h +++ b/quantum/process_keycode/process_rgb.h @@ -15,6 +15,8 @@   */  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  bool process_rgb(const uint16_t keycode, const keyrecord_t *record); diff --git a/quantum/process_keycode/process_secure.h b/quantum/process_keycode/process_secure.h index 2814264b92..78d793f0f6 100644 --- a/quantum/process_keycode/process_secure.h +++ b/quantum/process_keycode/process_secure.h @@ -3,6 +3,7 @@  #pragma once +#include <stdint.h>  #include <stdbool.h>  #include "action.h" diff --git a/quantum/process_keycode/process_sequencer.h b/quantum/process_keycode/process_sequencer.h index 2b85f24299..3a9bdc2b24 100644 --- a/quantum/process_keycode/process_sequencer.h +++ b/quantum/process_keycode/process_sequencer.h @@ -16,6 +16,8 @@  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  bool process_sequencer(uint16_t keycode, keyrecord_t *record); diff --git a/quantum/process_keycode/process_space_cadet.c b/quantum/process_keycode/process_space_cadet.c index 3109ea1711..4d9f01077e 100644 --- a/quantum/process_keycode/process_space_cadet.c +++ b/quantum/process_keycode/process_space_cadet.c @@ -14,6 +14,8 @@   * along with this program.  If not, see <http://www.gnu.org/licenses/>.   */  #include "process_space_cadet.h" +#include "keycodes.h" +#include "timer.h"  #include "action_tapping.h"  // ********** OBSOLETE DEFINES, STOP USING! (pls?) ********** diff --git a/quantum/process_keycode/process_space_cadet.h b/quantum/process_keycode/process_space_cadet.h index fcb70f3b43..6d10051532 100644 --- a/quantum/process_keycode/process_space_cadet.h +++ b/quantum/process_keycode/process_space_cadet.h @@ -15,7 +15,9 @@   */  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  void perform_space_cadet(keyrecord_t *record, uint16_t sc_keycode, uint8_t holdMod, uint8_t tapMod, uint8_t keycode);  bool process_space_cadet(uint16_t keycode, keyrecord_t *record); diff --git a/quantum/process_keycode/process_steno.c b/quantum/process_keycode/process_steno.c index d5ad61ba85..af26d4ca86 100644 --- a/quantum/process_keycode/process_steno.c +++ b/quantum/process_keycode/process_steno.c @@ -15,6 +15,7 @@   */  #include "process_steno.h"  #include "quantum_keycodes.h" +#include "eeconfig.h"  #include "keymap_steno.h"  #include <string.h>  #ifdef VIRTSER_ENABLE diff --git a/quantum/process_keycode/process_steno.h b/quantum/process_keycode/process_steno.h index 68d6097b9b..0dd2103218 100644 --- a/quantum/process_keycode/process_steno.h +++ b/quantum/process_keycode/process_steno.h @@ -16,7 +16,9 @@  #pragma once -#include "quantum.h" +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  #define BOLT_STROKE_SIZE 4  #define GEMINI_STROKE_SIZE 6 diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c index 706f5cddbb..1b2c6c8a44 100644 --- a/quantum/process_keycode/process_tap_dance.c +++ b/quantum/process_keycode/process_tap_dance.c @@ -13,7 +13,14 @@   * You should have received a copy of the GNU General Public License   * along with this program.  If not, see <http://www.gnu.org/licenses/>.   */ + +#include "process_tap_dance.h"  #include "quantum.h" +#include "action_layer.h" +#include "action_tapping.h" +#include "action_util.h" +#include "timer.h" +#include "wait.h"  static uint16_t active_td;  static uint16_t last_tap_time; diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h index 5cb6d9202c..386f504619 100644 --- a/quantum/process_keycode/process_tap_dance.h +++ b/quantum/process_keycode/process_tap_dance.h @@ -16,18 +16,17 @@  #pragma once -#ifdef TAP_DANCE_ENABLE - -#    include <stdbool.h> -#    include <inttypes.h> +#include <stdint.h> +#include <stdbool.h> +#include "action.h"  typedef struct {      uint16_t interrupting_keycode;      uint8_t  count;      uint8_t  weak_mods; -#    ifndef NO_ACTION_ONESHOT +#ifndef NO_ACTION_ONESHOT      uint8_t oneshot_mods; -#    endif +#endif      bool pressed : 1;      bool finished : 1;      bool interrupted : 1; @@ -56,24 +55,24 @@ typedef struct {      void (*layer_function)(uint8_t);  } tap_dance_dual_role_t; -#    define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) \ -        { .fn = {tap_dance_pair_on_each_tap, tap_dance_pair_finished, tap_dance_pair_reset}, .user_data = (void *)&((tap_dance_pair_t){kc1, kc2}), } +#define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) \ +    { .fn = {tap_dance_pair_on_each_tap, tap_dance_pair_finished, tap_dance_pair_reset}, .user_data = (void *)&((tap_dance_pair_t){kc1, kc2}), } -#    define ACTION_TAP_DANCE_LAYER_MOVE(kc, layer) \ -        { .fn = {tap_dance_dual_role_on_each_tap, tap_dance_dual_role_finished, tap_dance_dual_role_reset}, .user_data = (void *)&((tap_dance_dual_role_t){kc, layer, layer_move}), } +#define ACTION_TAP_DANCE_LAYER_MOVE(kc, layer) \ +    { .fn = {tap_dance_dual_role_on_each_tap, tap_dance_dual_role_finished, tap_dance_dual_role_reset}, .user_data = (void *)&((tap_dance_dual_role_t){kc, layer, layer_move}), } -#    define ACTION_TAP_DANCE_LAYER_TOGGLE(kc, layer) \ -        { .fn = {NULL, tap_dance_dual_role_finished, tap_dance_dual_role_reset}, .user_data = (void *)&((tap_dance_dual_role_t){kc, layer, layer_invert}), } +#define ACTION_TAP_DANCE_LAYER_TOGGLE(kc, layer) \ +    { .fn = {NULL, tap_dance_dual_role_finished, tap_dance_dual_role_reset}, .user_data = (void *)&((tap_dance_dual_role_t){kc, layer, layer_invert}), } -#    define ACTION_TAP_DANCE_FN(user_fn) \ -        { .fn = {NULL, user_fn, NULL}, .user_data = NULL, } +#define ACTION_TAP_DANCE_FN(user_fn) \ +    { .fn = {NULL, user_fn, NULL}, .user_data = NULL, } -#    define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset) \ -        { .fn = {user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset}, .user_data = NULL, } +#define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset) \ +    { .fn = {user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset}, .user_data = NULL, } -#    define TD(n) (QK_TAP_DANCE | TD_INDEX(n)) -#    define TD_INDEX(code) ((code)&0xFF) -#    define TAP_DANCE_KEYCODE(state) TD(((tap_dance_action_t *)state) - tap_dance_actions) +#define TD(n) (QK_TAP_DANCE | TD_INDEX(n)) +#define TD_INDEX(code) ((code)&0xFF) +#define TAP_DANCE_KEYCODE(state) TD(((tap_dance_action_t *)state) - tap_dance_actions)  extern tap_dance_action_t tap_dance_actions[]; @@ -92,9 +91,3 @@ void tap_dance_pair_reset(tap_dance_state_t *state, void *user_data);  void tap_dance_dual_role_on_each_tap(tap_dance_state_t *state, void *user_data);  void tap_dance_dual_role_finished(tap_dance_state_t *state, void *user_data);  void tap_dance_dual_role_reset(tap_dance_state_t *state, void *user_data); - -#else - -#    define TD(n) KC_NO - -#endif diff --git a/quantum/process_keycode/process_tri_layer.h b/quantum/process_keycode/process_tri_layer.h index 9c4e3df1c2..5e6e4ff94d 100644 --- a/quantum/process_keycode/process_tri_layer.h +++ b/quantum/process_keycode/process_tri_layer.h @@ -3,6 +3,8 @@  #pragma once +#include <stdint.h> +#include <stdbool.h>  #include "action.h"  /** | 
