Fix functions when `NO_ACTION_TAPPING` is defined (#11528)

5 files changed, 78 insertions, 22 deletions

diff --git a/quantum/action.c b/quantum/action.c
index d2e54bf8ec..7d3f40a950 100644
--- a/quantum/action.c
+++ b/quantum/action.c
@@ -399,9 +399,9 @@ void process_action(keyrecord_t *record, action_t action) {
                 }
             }
         } break;
-#ifndef NO_ACTION_TAPPING
         case ACT_LMODS_TAP:
         case ACT_RMODS_TAP: {
+#ifndef NO_ACTION_TAPPING
             uint8_t mods = (action.kind.id == ACT_LMODS_TAP) ? action.key.mods : action.key.mods << 4;
             switch (action.layer_tap.code) {
 #    ifndef NO_ACTION_ONESHOT
@@ -523,8 +523,8 @@ void process_action(keyrecord_t *record, action_t action) {
                     }
                     break;
             }
+#endif // NO_ACTION_TAPPING
         } break;
-#endif
 #ifdef EXTRAKEY_ENABLE
         /* other HID usage */
         case ACT_USAGE:
@@ -537,7 +537,7 @@ void process_action(keyrecord_t *record, action_t action) {
                     break;
             }
             break;
-#endif
+#endif // EXTRAKEY_ENABLE
         /* Mouse key */
         case ACT_MOUSEKEY:
             register_mouse(action.key.code, event.pressed);
@@ -597,10 +597,10 @@ void process_action(keyrecord_t *record, action_t action) {
                 layer_off(action.layer_mods.layer);
             }
             break;
-#    ifndef NO_ACTION_TAPPING
         case ACT_LAYER_TAP:
         case ACT_LAYER_TAP_EXT:
             switch (action.layer_tap.code) {
+#    ifndef NO_ACTION_TAPPING
                 case OP_TAP_TOGGLE:
                     /* tap toggle */
                     if (event.pressed) {
@@ -613,6 +613,7 @@ void process_action(keyrecord_t *record, action_t action) {
                         }
                     }
                     break;
+#    endif
                 case OP_ON_OFF:
                     event.pressed ? layer_on(action.layer_tap.val) : layer_off(action.layer_tap.val);
                     break;
@@ -622,7 +623,7 @@ void process_action(keyrecord_t *record, action_t action) {
                 case OP_SET_CLEAR:
                     event.pressed ? layer_move(action.layer_tap.val) : layer_clear();
                     break;
-#        ifndef NO_ACTION_ONESHOT
+#    if !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING)
                 case OP_ONESHOT:
                     // Oneshot modifier
                     if (!keymap_config.oneshot_enable) {
@@ -632,7 +633,7 @@ void process_action(keyrecord_t *record, action_t action) {
                             layer_off(action.layer_tap.val);
                         }
                     } else {
-#            if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1
+#        if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1
                         do_release_oneshot = false;
                         if (event.pressed) {
                             if (get_oneshot_layer_state() == ONESHOT_TOGGLED) {
@@ -651,7 +652,7 @@ void process_action(keyrecord_t *record, action_t action) {
                                 clear_oneshot_layer_state(ONESHOT_PRESSED);
                             }
                         }
-#            else
+#        else
                         if (event.pressed) {
                             layer_on(action.layer_tap.val);
                             set_oneshot_layer(action.layer_tap.val, ONESHOT_START);
@@ -661,12 +662,18 @@ void process_action(keyrecord_t *record, action_t action) {
                                 clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
                             }
                         }
-#            endif
+#        endif
+                    }
+#    else  // NO_ACTION_ONESHOT && NO_ACTION_TAPPING
+                    if (event.pressed) {
+                        layer_on(action.layer_tap.val);
+                    } else {
+                        layer_off(action.layer_tap.val);
                     }
+#    endif // !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING)
                     break;
-#        endif
                 default:
-                    /* tap key */
+#    ifndef NO_ACTION_TAPPING /* tap key */
                     if (event.pressed) {
                         if (tap_count > 0) {
                             ac_dprintf("KEYMAP_TAP_KEY: Tap: register_code\n");
@@ -689,11 +696,24 @@ void process_action(keyrecord_t *record, action_t action) {
                             layer_off(action.layer_tap.val);
                         }
                     }
+#    else
+                    if (event.pressed) {
+                        ac_dprintf("KEYMAP_TAP_KEY: Tap: register_code\n");
+                        register_code(action.layer_tap.code);
+                    } else {
+                        ac_dprintf("KEYMAP_TAP_KEY: Tap: unregister_code\n");
+                        if (action.layer_tap.code == KC_CAPS) {
+                            wait_ms(TAP_HOLD_CAPS_DELAY);
+                        } else {
+                            wait_ms(TAP_CODE_DELAY);
+                        }
+                        unregister_code(action.layer_tap.code);
+                    }
+#    endif
                     break;
             }
             break;
-#    endif
-#endif
+#endif // NO_ACTION_LAYER
 
 #ifdef SWAP_HANDS_ENABLE
         case ACT_SWAP_HANDS:
diff --git a/quantum/action_tapping.h b/quantum/action_tapping.h
index c078488c04..6099d80d6d 100644
--- a/quantum/action_tapping.h
+++ b/quantum/action_tapping.h
@@ -51,9 +51,9 @@ bool     get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record);
 extern uint16_t g_tapping_term;
 #endif
 
-#ifdef TAPPING_TERM_PER_KEY
+#if defined(TAPPING_TERM_PER_KEY) && !defined(NO_ACTION_TAPPING)
 #    define GET_TAPPING_TERM(keycode, record) get_tapping_term(keycode, record)
-#elif defined(DYNAMIC_TAPPING_TERM_ENABLE)
+#elif defined(DYNAMIC_TAPPING_TERM_ENABLE) && !defined(NO_ACTION_TAPPING)
 #    define GET_TAPPING_TERM(keycode, record) g_tapping_term
 #else
 #    define GET_TAPPING_TERM(keycode, record) (TAPPING_TERM)
diff --git a/quantum/keymap_common.c b/quantum/keymap_common.c
index b4feb39739..7b863af3b5 100644
--- a/quantum/keymap_common.c
+++ b/quantum/keymap_common.c
@@ -80,14 +80,20 @@ action_t action_for_keycode(uint16_t keycode) {
             action.code = ACTION_MODS_KEY(mod_config(QK_MODS_GET_MODS(keycode)), keycode_config(QK_MODS_GET_BASIC_KEYCODE(keycode))); // adds modifier to key
 #endif                                                                                                    // LEGACY_MAGIC_HANDLING
             break;
-#ifndef NO_ACTION_LAYER
         case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:
+#if !defined(NO_ACTION_LAYER) && !defined(NO_ACTION_TAPPING)
 #    ifdef LEGACY_MAGIC_HANDLING
             action.code = ACTION_LAYER_TAP_KEY(QK_LAYER_TAP_GET_LAYER(keycode), QK_LAYER_TAP_GET_TAP_KEYCODE(keycode));
 #    else  // LEGACY_MAGIC_HANDLING
             action.code = ACTION_LAYER_TAP_KEY(QK_LAYER_TAP_GET_LAYER(keycode), keycode_config(QK_LAYER_TAP_GET_TAP_KEYCODE(keycode)));
 #    endif // LEGACY_MAGIC_HANDLING
+#else
+            // pass through keycode_config again, since it previously missed it
+            // and then only send as ACTION_KEY to bypass most of action.c handling
+            action.code = ACTION_KEY(keycode_config(QK_LAYER_TAP_GET_TAP_KEYCODE(keycode)));
+#endif
             break;
+#ifndef NO_ACTION_LAYER
         case QK_TO ... QK_TO_MAX:;
             // Layer set "GOTO"
             action_layer = QK_TO_GET_LAYER(keycode);
@@ -115,32 +121,54 @@ action_t action_for_keycode(uint16_t keycode) {
             action_layer = QK_ONE_SHOT_LAYER_GET_LAYER(keycode);
             action.code  = ACTION_LAYER_ONESHOT(action_layer);
             break;
+#endif // NO_ACTION_ONESHOT
         case QK_ONE_SHOT_MOD ... QK_ONE_SHOT_MOD_MAX:;
             // OSM(mod) - One-shot mod
-            mod         = mod_config(QK_ONE_SHOT_MOD_GET_MODS(keycode));
+            mod = mod_config(QK_ONE_SHOT_MOD_GET_MODS(keycode));
+#if defined(NO_ACTION_TAPPING) || defined(NO_ACTION_ONESHOT)
+            action.code = ACTION_MODS(mod);
+#else  // defined(NO_ACTION_TAPPING) || defined(NO_ACTION_ONESHOT)
             action.code = ACTION_MODS_ONESHOT(mod);
+#endif // defined(NO_ACTION_TAPPING) || defined(NO_ACTION_ONESHOT)
             break;
-#endif
 #ifndef NO_ACTION_LAYER
         case QK_LAYER_TAP_TOGGLE ... QK_LAYER_TAP_TOGGLE_MAX:
+#    ifndef NO_ACTION_TAPPING
             action.code = ACTION_LAYER_TAP_TOGGLE(QK_LAYER_TAP_TOGGLE_GET_LAYER(keycode));
+#    else // NO_ACTION_TAPPING
+#        ifdef NO_ACTION_TAPPING_TAP_TOGGLE_MO
+            action.code = ACTION_LAYER_MOMENTARY(QK_LAYER_TAP_TOGGLE_GET_LAYER(keycode));
+#        else  // NO_ACTION_TAPPING_TAP_TOGGLE_MO
+            action.code = ACTION_LAYER_TOGGLE(QK_LAYER_TAP_TOGGLE_GET_LAYER(keycode));
+#        endif // NO_ACTION_TAPPING_TAP_TOGGLE_MO
+#    endif     // NO_ACTION_TAPPING
             break;
         case QK_LAYER_MOD ... QK_LAYER_MOD_MAX:
             mod          = mod_config(QK_LAYER_MOD_GET_MODS(keycode));
             action_layer = QK_LAYER_MOD_GET_LAYER(keycode);
             action.code  = ACTION_LAYER_MODS(action_layer, (mod & 0x10) ? mod << 4 : mod);
             break;
-#endif
-#ifndef NO_ACTION_TAPPING
+#endif // NO_ACTION_LAYER
         case QK_MOD_TAP ... QK_MOD_TAP_MAX:
+#ifndef NO_ACTION_TAPPING
             mod = mod_config(QK_MOD_TAP_GET_MODS(keycode));
 #    ifdef LEGACY_MAGIC_HANDLING
             action.code = ACTION_MODS_TAP_KEY(mod, QK_MOD_TAP_GET_TAP_KEYCODE(keycode));
 #    else  // LEGACY_MAGIC_HANDLING
             action.code = ACTION_MODS_TAP_KEY(mod, keycode_config(QK_MOD_TAP_GET_TAP_KEYCODE(keycode)));
 #    endif // LEGACY_MAGIC_HANDLING
+#else      // NO_ACTION_TAPPING
+#    ifdef NO_ACTION_TAPPING_MODTAP_MODS
+            // pass through mod_config again, since it previously missed it
+            // and then only send as ACTION_KEY to bypass most of action.c handling
+            action.code = ACTION_MODS(mod_config(QK_MOD_TAP_GET_MODS(keycode)));
+#    else  // NO_ACTION_TAPPING_MODTAP_MODS
+           // pass through keycode_config again, since it previously missed it
+           // and then only send as ACTION_KEY to bypass most of action.c handling
+            action.code = ACTION_KEY(keycode_config(QK_MOD_TAP_GET_TAP_KEYCODE(keycode)));
+#    endif // NO_ACTION_TAPPING_MODTAP_MODS
+#endif     // NO_ACTION_TAPPING
             break;
-#endif
 #ifdef SWAP_HANDS_ENABLE
         case QK_SWAP_HANDS ... QK_SWAP_HANDS_MAX:
 #    ifdef LEGACY_MAGIC_HANDLING
diff --git a/quantum/process_keycode/process_autocorrect.c b/quantum/process_keycode/process_autocorrect.c
index c89dffeaad..1376788266 100644
--- a/quantum/process_keycode/process_autocorrect.c
+++ b/quantum/process_keycode/process_autocorrect.c
@@ -128,7 +128,11 @@ __attribute__((weak)) bool process_autocorrect_user(uint16_t *keycode, keyrecord
 #ifdef SWAP_HANDS_ENABLE
             // Note: IS_SWAP_HANDS_KEYCODE() actually tests for the special action keycodes like SH_TOGG, SH_TT, ...,
             // which currently overlap the SH_T(kc) range.
-            if (IS_SWAP_HANDS_KEYCODE(*keycode) || !record->tap.count) {
+            if (IS_SWAP_HANDS_KEYCODE(*keycode)
+#    ifndef NO_ACTION_TAPPING
+                || !record->tap.count
+#    endif // NO_ACTION_TAPPING
+            ) {
                 return false;
             }
             *keycode = QK_SWAP_HANDS_GET_TAP_KEYCODE(*keycode);
diff --git a/quantum/process_keycode/process_caps_word.c b/quantum/process_keycode/process_caps_word.c
index 933abe629e..94302b29ae 100644
--- a/quantum/process_keycode/process_caps_word.c
+++ b/quantum/process_keycode/process_caps_word.c
@@ -145,7 +145,11 @@ bool process_caps_word(uint16_t keycode, keyrecord_t* record) {
             case QK_SWAP_HANDS ... QK_SWAP_HANDS_MAX:
                 // Note: IS_SWAP_HANDS_KEYCODE() actually tests for the special action keycodes like SH_TOGG, SH_TT, ...,
                 // which currently overlap the SH_T(kc) range.
-                if (IS_SWAP_HANDS_KEYCODE(keycode) || record->tap.count == 0) {
+                if (IS_SWAP_HANDS_KEYCODE(keycode)
+#    ifndef NO_ACTION_TAPPING
+                    || record->tap.count == 0
+#    endif // NO_ACTION_TAPPING
+                ) {
                     return true;
                 }
                 keycode = QK_SWAP_HANDS_GET_TAP_KEYCODE(keycode);