From 48a79b08ccbcd0af5269e2e9334042c8347d18f8 Mon Sep 17 00:00:00 2001 From: Drashna Jaelre Date: Sat, 18 Feb 2023 17:08:03 -0800 Subject: Fix functions when `NO_ACTION_TAPPING` is defined (#11528) --- quantum/action.c | 44 +++++++++++++++++++-------- quantum/action_tapping.h | 4 +-- quantum/keymap_common.c | 40 ++++++++++++++++++++---- quantum/process_keycode/process_autocorrect.c | 6 +++- quantum/process_keycode/process_caps_word.c | 6 +++- 5 files changed, 78 insertions(+), 22 deletions(-) (limited to 'quantum') 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); -- cgit v1.2.3