logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

action.c (44197B)

    

  1. /*
  2. Copyright 2012,2013 Jun Wako <wakojun@gmail.com>
  4. This program is free software: you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation, either version 2 of the License, or
  7. (at your option) any later version.
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. GNU General Public License for more details.
  14. You should have received a copy of the GNU General Public License
  15. along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16. */
  17. #include <limits.h>
  19. #include "host.h"
  20. #include "keycode.h"
  21. #include "keyboard.h"
  22. #include "mousekey.h"
  23. #include "programmable_button.h"
  24. #include "command.h"
  25. #include "led.h"
  26. #include "action_layer.h"
  27. #include "action_tapping.h"
  28. #include "action_util.h"
  29. #include "action.h"
  30. #include "wait.h"
  31. #include "keycode_config.h"
  32. #include "debug.h"
  33. #include "quantum.h"
  35. #ifdef BACKLIGHT_ENABLE
  36. #    include "backlight.h"
  37. #endif
  39. #ifdef POINTING_DEVICE_ENABLE
  40. #    include "pointing_device.h"
  41. #endif
  43. #if defined(ENCODER_ENABLE) && defined(ENCODER_MAP_ENABLE) && defined(SWAP_HANDS_ENABLE)
  44. #    include "encoder.h"
  45. #endif
  47. int tp_buttons;
  49. #if defined(RETRO_TAPPING) || defined(RETRO_TAPPING_PER_KEY) || (defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT))
  50. bool     retro_tap_primed   = false;
  51. uint16_t retro_tap_curr_key = 0;
  52. #    if !(defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT))
  53. uint8_t retro_tap_curr_mods = 0;
  54. uint8_t retro_tap_next_mods = 0;
  55. #    endif
  56. #endif
  58. #if defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING)
  59. #    include "process_auto_shift.h"
  60. #endif
  62. #ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY
  63. __attribute__((weak)) bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) {
  64.     return false;
  65. }
  66. #endif
  68. #ifdef RETRO_TAPPING_PER_KEY
  69. __attribute__((weak)) bool get_retro_tapping(uint16_t keycode, keyrecord_t *record) {
  70.     return false;
  71. }
  72. #endif
  74. /** \brief Called to execute an action.
  75.  *
  76.  * FIXME: Needs documentation.
  77.  */
  78. void action_exec(keyevent_t event) {
  79.     if (IS_EVENT(event)) {
  80.         ac_dprintf("\n---- action_exec: start -----\n");
  81.         ac_dprintf("EVENT: ");
  82.         debug_event(event);
  83.         ac_dprintf("\n");
  84. #if defined(RETRO_TAPPING) || defined(RETRO_TAPPING_PER_KEY) || (defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT))
  85.         uint16_t event_keycode = get_event_keycode(event, false);
  86.         if (event.pressed) {
  87.             retro_tap_primed   = false;
  88.             retro_tap_curr_key = event_keycode;
  89.         } else if (retro_tap_curr_key == event_keycode) {
  90.             retro_tap_primed = true;
  91.         }
  92. #endif
  93.     }
  95.     if (event.pressed) {
  96.         // clear the potential weak mods left by previously pressed keys
  97.         clear_weak_mods();
  98.     }
  100. #ifdef SWAP_HANDS_ENABLE
  101.     // Swap hands handles both keys and encoders, if ENCODER_MAP_ENABLE is defined.
  102.     if (IS_EVENT(event)) {
  103.         process_hand_swap(&event);
  104.     }
  105. #endif
  107.     keyrecord_t record = {.event = event};
  109. #ifndef NO_ACTION_ONESHOT
  110.     if (keymap_config.oneshot_enable) {
  111. #    if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
  112.         if (has_oneshot_layer_timed_out()) {
  113.             clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
  114.         }
  115.         if (has_oneshot_mods_timed_out()) {
  116.             clear_oneshot_mods();
  117.         }
  118. #        ifdef SWAP_HANDS_ENABLE
  119.         if (has_oneshot_swaphands_timed_out()) {
  120.             clear_oneshot_swaphands();
  121.         }
  122. #        endif
  123. #    endif
  124.     }
  125. #endif
  127. #ifndef NO_ACTION_TAPPING
  128. #    if defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT)
  129.     if (event.pressed) {
  130.         retroshift_poll_time(&event);
  131.     }
  132. #    endif
  133.     if (IS_NOEVENT(record.event) || pre_process_record_quantum(&record)) {
  134.         action_tapping_process(record);
  135.     }
  136. #else
  137.     if (IS_NOEVENT(record.event) || pre_process_record_quantum(&record)) {
  138.         process_record(&record);
  139.     }
  140.     if (IS_EVENT(record.event)) {
  141.         ac_dprintf("processed: ");
  142.         debug_record(record);
  143.         dprintln();
  144.     }
  145. #endif
  146. }
  148. #ifdef SWAP_HANDS_ENABLE
  149. extern const keypos_t PROGMEM hand_swap_config[MATRIX_ROWS][MATRIX_COLS];
  150. #    ifdef ENCODER_MAP_ENABLE
  151. extern const uint8_t PROGMEM encoder_hand_swap_config[NUM_ENCODERS];
  152. #    endif // ENCODER_MAP_ENABLE
  154. bool swap_hands = false;
  155. bool swap_held  = false;
  157. bool should_swap_hands(size_t index, uint8_t *swap_state, bool pressed) {
  158.     size_t  array_index = index / (CHAR_BIT);
  159.     size_t  bit_index   = index % (CHAR_BIT);
  160.     uint8_t bit_val     = 1 << bit_index;
  161.     bool    do_swap     = pressed ? swap_hands : swap_state[array_index] & bit_val;
  162.     return do_swap;
  163. }
  165. void set_swap_hands_state(size_t index, uint8_t *swap_state, bool on) {
  166.     size_t  array_index = index / (CHAR_BIT);
  167.     size_t  bit_index   = index % (CHAR_BIT);
  168.     uint8_t bit_val     = 1 << bit_index;
  169.     if (on) {
  170.         swap_state[array_index] |= bit_val;
  171.     } else {
  172.         swap_state[array_index] &= ~bit_val;
  173.     }
  174. }
  176. void swap_hands_on(void) {
  177.     swap_hands = true;
  178. }
  180. void swap_hands_off(void) {
  181.     swap_hands = false;
  182. }
  184. void swap_hands_toggle(void) {
  185.     swap_hands = !swap_hands;
  186. }
  188. bool is_swap_hands_on(void) {
  189.     return swap_hands;
  190. }
  192. /** \brief Process Hand Swap
  193.  *
  194.  * FIXME: Needs documentation.
  195.  */
  196. void process_hand_swap(keyevent_t *event) {
  197.     keypos_t pos = event->key;
  198.     if (IS_KEYEVENT(*event) && pos.row < MATRIX_ROWS && pos.col < MATRIX_COLS) {
  199.         static uint8_t matrix_swap_state[((MATRIX_ROWS * MATRIX_COLS) + (CHAR_BIT)-1) / (CHAR_BIT)];
  200.         size_t         index   = (size_t)(pos.row * MATRIX_COLS) + pos.col;
  201.         bool           do_swap = should_swap_hands(index, matrix_swap_state, event->pressed);
  202.         if (do_swap) {
  203.             event->key.row = pgm_read_byte(&hand_swap_config[pos.row][pos.col].row);
  204.             event->key.col = pgm_read_byte(&hand_swap_config[pos.row][pos.col].col);
  205.             set_swap_hands_state(index, matrix_swap_state, true);
  206.         } else {
  207.             set_swap_hands_state(index, matrix_swap_state, false);
  208.         }
  209.     }
  210. #    ifdef ENCODER_MAP_ENABLE
  211.     else if (IS_ENCODEREVENT(*event) && (pos.row == KEYLOC_ENCODER_CW || pos.row == KEYLOC_ENCODER_CCW)) {
  212.         static uint8_t encoder_swap_state[((NUM_ENCODERS) + (CHAR_BIT)-1) / (CHAR_BIT)];
  213.         size_t         index   = pos.col;
  214.         bool           do_swap = should_swap_hands(index, encoder_swap_state, event->pressed);
  215.         if (do_swap) {
  216.             event->key.row = pos.row;
  217.             event->key.col = pgm_read_byte(&encoder_hand_swap_config[pos.col]);
  218.             set_swap_hands_state(index, encoder_swap_state, true);
  219.         } else {
  220.             set_swap_hands_state(index, encoder_swap_state, false);
  221.         }
  222.     }
  223. #    endif // ENCODER_MAP_ENABLE
  224. }
  225. #endif
  227. #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
  228. bool disable_action_cache = false;
  230. void process_record_nocache(keyrecord_t *record) {
  231.     disable_action_cache = true;
  232.     process_record(record);
  233.     disable_action_cache = false;
  234. }
  235. #else
  236. void process_record_nocache(keyrecord_t *record) {
  237.     process_record(record);
  238. }
  239. #endif
  241. __attribute__((weak)) bool process_record_quantum(keyrecord_t *record) {
  242.     return true;
  243. }
  245. __attribute__((weak)) void post_process_record_quantum(keyrecord_t *record) {}
  247. #ifndef NO_ACTION_TAPPING
  248. /** \brief Allows for handling tap-hold actions immediately instead of waiting for TAPPING_TERM or another keypress.
  249.  *
  250.  * FIXME: Needs documentation.
  251.  */
  252. void process_record_tap_hint(keyrecord_t *record) {
  253.     if (!IS_KEYEVENT(record->event)) {
  254.         return;
  255.     }
  257.     action_t action = layer_switch_get_action(record->event.key);
  259.     switch (action.kind.id) {
  260. #    ifdef SWAP_HANDS_ENABLE
  261.         case ACT_SWAP_HANDS:
  262.             switch (action.swap.code) {
  263.                 case OP_SH_ONESHOT:
  264.                     break;
  265.                 case OP_SH_TAP_TOGGLE:
  266.                 default:
  267.                     swap_hands = !swap_hands;
  268.                     swap_held  = true;
  269.             }
  270.             break;
  271. #    endif
  272.     }
  273. }
  274. #endif
  276. /** \brief Take a key event (key press or key release) and processes it.
  277.  *
  278.  * FIXME: Needs documentation.
  279.  */
  280. void process_record(keyrecord_t *record) {
  281.     if (IS_NOEVENT(record->event)) {
  282.         return;
  283.     }
  284. #ifdef FLOW_TAP_TERM
  285.     flow_tap_update_last_event(record);
  286. #endif // FLOW_TAP_TERM
  288.     if (!process_record_quantum(record)) {
  289. #ifndef NO_ACTION_ONESHOT
  290.         if (is_oneshot_layer_active() && record->event.pressed && keymap_config.oneshot_enable) {
  291.             clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
  292.         }
  293. #endif
  294.         return;
  295.     }
  297.     process_record_handler(record);
  298.     post_process_record_quantum(record);
  299. }
  301. void process_record_handler(keyrecord_t *record) {
  302. #if defined(COMBO_ENABLE) || defined(REPEAT_KEY_ENABLE)
  303.     action_t action;
  304.     if (record->keycode) {
  305.         action = action_for_keycode(record->keycode);
  306.     } else {
  307.         action = store_or_get_action(record->event.pressed, record->event.key);
  308.     }
  309. #else
  310.     action_t action = store_or_get_action(record->event.pressed, record->event.key);
  311. #endif
  312.     ac_dprintf("ACTION: ");
  313.     debug_action(action);
  314. #ifndef NO_ACTION_LAYER
  315.     ac_dprintf(" layer_state: ");
  316.     layer_debug();
  317.     ac_dprintf(" default_layer_state: ");
  318.     default_layer_debug();
  319. #endif
  320.     ac_dprintf("\n");
  322.     process_action(record, action);
  323. }
  325. /**
  326.  * @brief handles all the messy mouse stuff
  327.  *
  328.  * Handles all the edgecases and special stuff that is needed for coexistense
  329.  * of the multiple mouse subsystems.
  330.  *
  331.  * @param mouse_keycode[in] uint8_t mouse keycode
  332.  * @param pressed[in] bool
  333.  */
  335. void register_mouse(uint8_t mouse_keycode, bool pressed) {
  336. #ifdef MOUSEKEY_ENABLE
  337.     // if mousekeys is enabled, let it do the brunt of the work
  338.     if (pressed) {
  339.         mousekey_on(mouse_keycode);
  340.     } else {
  341.         mousekey_off(mouse_keycode);
  342.     }
  343.     // should mousekeys send report, or does something else handle this?
  344.     switch (mouse_keycode) {
  345. #    if defined(PS2_MOUSE_ENABLE) || defined(POINTING_DEVICE_ENABLE)
  346.         case QK_MOUSE_BUTTON_1 ... QK_MOUSE_BUTTON_8:
  347.             // let pointing device handle the buttons
  348.             // expand if/when it handles more of the code
  349. #        if defined(POINTING_DEVICE_ENABLE)
  350.             pointing_device_keycode_handler(mouse_keycode, pressed);
  351. #        endif
  352.             break;
  353. #    endif
  354.         default:
  355.             mousekey_send();
  356.             break;
  357.     }
  358. #elif defined(POINTING_DEVICE_ENABLE)
  359.     // if mousekeys isn't enabled, and pointing device is enabled, then
  360.     // let pointing device do all the heavy lifting, then
  361.     if (IS_MOUSE_KEYCODE(mouse_keycode)) {
  362.         pointing_device_keycode_handler(mouse_keycode, pressed);
  363.     }
  364. #endif
  366. #ifdef PS2_MOUSE_ENABLE
  367.     // make sure that ps2 mouse has button report synced
  368.     if (QK_MOUSE_BUTTON_1 <= mouse_keycode && mouse_keycode <= QK_MOUSE_BUTTON_3) {
  369.         uint8_t tmp_button_msk = MOUSE_BTN_MASK(mouse_keycode - QK_MOUSE_BUTTON_1);
  370.         tp_buttons             = pressed ? tp_buttons | tmp_button_msk : tp_buttons & ~tmp_button_msk;
  371.     }
  372. #endif
  373. }
  375. /** \brief Take an action and processes it.
  376.  *
  377.  * FIXME: Needs documentation.
  378.  */
  379. void process_action(keyrecord_t *record, action_t action) {
  380.     keyevent_t event = record->event;
  381. #ifndef NO_ACTION_TAPPING
  382.     uint8_t tap_count = record->tap.count;
  383. #endif
  385. #ifndef NO_ACTION_ONESHOT
  386.     bool do_release_oneshot = false;
  387.     // notice we only clear the one shot layer if the pressed key is not a modifier.
  388.     if (is_oneshot_layer_active() && event.pressed &&
  389.         (action.kind.id == ACT_USAGE || !(IS_MODIFIER_KEYCODE(action.key.code)
  390. #    ifndef NO_ACTION_TAPPING
  391.                                           || ((action.kind.id == ACT_LMODS_TAP || action.kind.id == ACT_RMODS_TAP) && (action.layer_tap.code <= MODS_TAP_TOGGLE || tap_count == 0))
  392. #    endif
  393.                                               ))
  394. #    ifdef SWAP_HANDS_ENABLE
  395.         && !(action.kind.id == ACT_SWAP_HANDS && action.swap.code == OP_SH_ONESHOT)
  396. #    endif
  397.         && keymap_config.oneshot_enable) {
  398.         clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
  399.         do_release_oneshot = !is_oneshot_layer_active();
  400.     }
  401. #endif
  403.     switch (action.kind.id) {
  404.         /* Key and Mods */
  405.         case ACT_LMODS:
  406.         case ACT_RMODS: {
  407.             uint8_t mods = (action.kind.id == ACT_LMODS) ? action.key.mods : action.key.mods << 4;
  408.             if (event.pressed) {
  409.                 if (mods) {
  410.                     if (IS_MODIFIER_KEYCODE(action.key.code) || action.key.code == KC_NO) {
  411.                         // e.g. LSFT(KC_LEFT_GUI): we don't want the LSFT to be weak as it would make it useless.
  412.                         // This also makes LSFT(KC_LEFT_GUI) behave exactly the same as LGUI(KC_LEFT_SHIFT).
  413.                         // Same applies for some keys like KC_MEH which are declared as MEH(KC_NO).
  414.                         add_mods(mods);
  415.                     } else {
  416.                         add_weak_mods(mods);
  417.                     }
  418.                     send_keyboard_report();
  419.                 }
  420.                 register_code(action.key.code);
  421.             } else {
  422.                 unregister_code(action.key.code);
  423.                 if (mods) {
  424.                     if (IS_MODIFIER_KEYCODE(action.key.code) || action.key.code == KC_NO) {
  425.                         del_mods(mods);
  426.                     } else {
  427.                         del_weak_mods(mods);
  428.                     }
  429.                     send_keyboard_report();
  430.                 }
  431.             }
  432.         } break;
  433.         case ACT_LMODS_TAP:
  434.         case ACT_RMODS_TAP: {
  435. #ifndef NO_ACTION_TAPPING
  436.             uint8_t mods = (action.kind.id == ACT_LMODS_TAP) ? action.key.mods : action.key.mods << 4;
  437.             switch (action.layer_tap.code) {
  438. #    ifndef NO_ACTION_ONESHOT
  439.                 case MODS_ONESHOT:
  440.                     // Oneshot modifier
  441.                     if (!keymap_config.oneshot_enable) {
  442.                         if (event.pressed) {
  443.                             if (mods) {
  444.                                 if (IS_MODIFIER_KEYCODE(action.key.code) || action.key.code == KC_NO) {
  445.                                     // e.g. LSFT(KC_LGUI): we don't want the LSFT to be weak as it would make it useless.
  446.                                     // This also makes LSFT(KC_LGUI) behave exactly the same as LGUI(KC_LSFT).
  447.                                     // Same applies for some keys like KC_MEH which are declared as MEH(KC_NO).
  448.                                     add_mods(mods);
  449.                                 } else {
  450.                                     add_weak_mods(mods);
  451.                                 }
  452.                                 send_keyboard_report();
  453.                             }
  454.                             register_code(action.key.code);
  455.                         } else {
  456.                             unregister_code(action.key.code);
  457.                             if (mods) {
  458.                                 if (IS_MODIFIER_KEYCODE(action.key.code) || action.key.code == KC_NO) {
  459.                                     del_mods(mods);
  460.                                 } else {
  461.                                     del_weak_mods(mods);
  462.                                 }
  463.                                 send_keyboard_report();
  464.                             }
  465.                         }
  466.                     } else {
  467.                         if (event.pressed) {
  468.                             if (tap_count == 0) {
  469.                                 // Not a tap, but a hold: register the held mod
  470.                                 ac_dprintf("MODS_TAP: Oneshot: 0\n");
  471.                                 register_mods(mods);
  472.                             } else if (tap_count == 1) {
  473.                                 ac_dprintf("MODS_TAP: Oneshot: start\n");
  474.                                 add_oneshot_mods(mods);
  475. #        if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1
  476.                             } else if (tap_count == ONESHOT_TAP_TOGGLE) {
  477.                                 ac_dprintf("MODS_TAP: Toggling oneshot");
  478.                                 register_mods(mods);
  479.                                 del_oneshot_mods(mods);
  480.                                 add_oneshot_locked_mods(mods);
  481. #        endif
  482.                             }
  483.                         } else {
  484.                             if (tap_count == 0) {
  485.                                 // Release hold: unregister the held mod and its variants
  486.                                 unregister_mods(mods);
  487.                                 del_oneshot_mods(mods);
  488.                                 del_oneshot_locked_mods(mods);
  489. #        if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1
  490.                             } else if (tap_count == 1 && (mods & get_mods())) {
  491.                                 unregister_mods(mods);
  492.                                 del_oneshot_mods(mods);
  493.                                 del_oneshot_locked_mods(mods);
  494. #        endif
  495.                             }
  496.                         }
  497.                     }
  498.                     break;
  499. #    endif
  500.                 case MODS_TAP_TOGGLE:
  501.                     if (event.pressed) {
  502.                         if (tap_count <= TAPPING_TOGGLE) {
  503.                             register_mods(mods);
  504.                         }
  505.                     } else {
  506.                         if (tap_count < TAPPING_TOGGLE) {
  507.                             unregister_mods(mods);
  508.                         }
  509.                     }
  510.                     break;
  511.                 default:
  512.                     if (event.pressed) {
  513.                         if (tap_count > 0) {
  514. #    ifdef HOLD_ON_OTHER_KEY_PRESS
  515.                             if (
  516. #        ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY
  517.                                 get_hold_on_other_key_press(get_event_keycode(record->event, false), record) &&
  518. #        endif
  519.                                 record->tap.interrupted) {
  520.                                 ac_dprintf("mods_tap: tap: cancel: add_mods\n");
  521.                                 // ad hoc: set 0 to cancel tap
  522.                                 record->tap.count = 0;
  523.                                 register_mods(mods);
  524.                             } else
  525. #    endif
  526.                             {
  527.                                 ac_dprintf("MODS_TAP: Tap: register_code\n");
  528.                                 register_code(action.key.code);
  529.                             }
  530.                         } else {
  531.                             ac_dprintf("MODS_TAP: No tap: add_mods\n");
  532.                             register_mods(mods);
  533.                         }
  534.                     } else {
  535.                         if (tap_count > 0) {
  536.                             ac_dprintf("MODS_TAP: Tap: unregister_code\n");
  537.                             if (action.layer_tap.code == KC_CAPS_LOCK) {
  538.                                 wait_ms(TAP_HOLD_CAPS_DELAY);
  539.                             } else {
  540.                                 wait_ms(TAP_CODE_DELAY);
  541.                             }
  542.                             unregister_code(action.key.code);
  543.                         } else {
  544.                             ac_dprintf("MODS_TAP: No tap: add_mods\n");
  545. #    if defined(RETRO_TAPPING) && defined(DUMMY_MOD_NEUTRALIZER_KEYCODE)
  546.                             // Send a dummy keycode to neutralize flashing modifiers
  547.                             // if the key was held and then released with no interruptions.
  548.                             uint16_t ev_kc = get_event_keycode(event, false);
  549.                             if (retro_tap_primed && retro_tap_curr_key == ev_kc) {
  550.                                 neutralize_flashing_modifiers(get_mods());
  551.                             }
  552. #    endif
  553.                             unregister_mods(mods);
  554.                         }
  555.                     }
  556.                     break;
  557.             }
  558. #endif // NO_ACTION_TAPPING
  559.         } break;
  560. #ifdef EXTRAKEY_ENABLE
  561.         /* other HID usage */
  562.         case ACT_USAGE:
  563.             switch (action.usage.page) {
  564.                 case PAGE_SYSTEM:
  565.                     host_system_send(event.pressed ? action.usage.code : 0);
  566.                     break;
  567.                 case PAGE_CONSUMER:
  568.                     host_consumer_send(event.pressed ? action.usage.code : 0);
  569.                     break;
  570.             }
  571.             break;
  572. #endif // EXTRAKEY_ENABLE
  573.         /* Mouse key */
  574.         case ACT_MOUSEKEY:
  575.             register_mouse(action.key.code, event.pressed);
  576.             break;
  577. #ifndef NO_ACTION_LAYER
  578.         case ACT_LAYER:
  579.             if (action.layer_bitop.on == 0) {
  580.                 /* Default Layer Bitwise Operation */
  581.                 if (!event.pressed) {
  582.                     uint8_t       shift = action.layer_bitop.part * 4;
  583.                     layer_state_t bits  = ((layer_state_t)action.layer_bitop.bits) << shift;
  584.                     layer_state_t mask  = (action.layer_bitop.xbit) ? ~(((layer_state_t)0xf) << shift) : 0;
  585.                     switch (action.layer_bitop.op) {
  586.                         case OP_BIT_AND:
  587.                             default_layer_and(bits | mask);
  588.                             break;
  589.                         case OP_BIT_OR:
  590.                             default_layer_or(bits | mask);
  591.                             break;
  592.                         case OP_BIT_XOR:
  593.                             default_layer_xor(bits | mask);
  594.                             break;
  595.                         case OP_BIT_SET:
  596.                             default_layer_set(bits | mask);
  597.                             break;
  598.                     }
  599.                 }
  600.             } else {
  601.                 /* Layer Bitwise Operation */
  602.                 if (event.pressed ? (action.layer_bitop.on & ON_PRESS) : (action.layer_bitop.on & ON_RELEASE)) {
  603.                     uint8_t       shift = action.layer_bitop.part * 4;
  604.                     layer_state_t bits  = ((layer_state_t)action.layer_bitop.bits) << shift;
  605.                     layer_state_t mask  = (action.layer_bitop.xbit) ? ~(((layer_state_t)0xf) << shift) : 0;
  606.                     switch (action.layer_bitop.op) {
  607.                         case OP_BIT_AND:
  608.                             layer_and(bits | mask);
  609.                             break;
  610.                         case OP_BIT_OR:
  611.                             layer_or(bits | mask);
  612.                             break;
  613.                         case OP_BIT_XOR:
  614.                             layer_xor(bits | mask);
  615.                             break;
  616.                         case OP_BIT_SET:
  617.                             layer_state_set(bits | mask);
  618.                             break;
  619.                     }
  620.                 }
  621.             }
  622.             break;
  623.         case ACT_LAYER_MODS:
  624.             if (event.pressed) {
  625.                 layer_on(action.layer_mods.layer);
  626.                 register_mods(action.layer_mods.mods);
  627.             } else {
  628.                 unregister_mods(action.layer_mods.mods);
  629.                 layer_off(action.layer_mods.layer);
  630.             }
  631.             break;
  632.         case ACT_LAYER_TAP:
  633.         case ACT_LAYER_TAP_EXT:
  634.             switch (action.layer_tap.code) {
  635. #    ifndef NO_ACTION_TAPPING
  636.                 case OP_TAP_TOGGLE:
  637.                     /* tap toggle */
  638.                     if (event.pressed) {
  639.                         if (tap_count < TAPPING_TOGGLE) {
  640.                             layer_invert(action.layer_tap.val);
  641.                         }
  642.                     } else {
  643.                         if (tap_count <= TAPPING_TOGGLE) {
  644.                             layer_invert(action.layer_tap.val);
  645.                         }
  646.                     }
  647.                     break;
  648. #    endif
  649.                 case OP_ON_OFF:
  650.                     event.pressed ? layer_on(action.layer_tap.val) : layer_off(action.layer_tap.val);
  651.                     break;
  652.                 case OP_OFF_ON:
  653.                     event.pressed ? layer_off(action.layer_tap.val) : layer_on(action.layer_tap.val);
  654.                     break;
  655.                 case OP_SET_CLEAR:
  656.                     event.pressed ? layer_move(action.layer_tap.val) : layer_clear();
  657.                     break;
  658. #    if !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING)
  659.                 case OP_ONESHOT:
  660.                     // Oneshot modifier
  661.                     if (!keymap_config.oneshot_enable) {
  662.                         if (event.pressed) {
  663.                             layer_on(action.layer_tap.val);
  664.                         } else {
  665.                             layer_off(action.layer_tap.val);
  666.                         }
  667.                     } else {
  668. #        if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1
  669.                         do_release_oneshot = false;
  670.                         if (event.pressed) {
  671.                             if (get_oneshot_layer_state() == ONESHOT_TOGGLED) {
  672.                                 reset_oneshot_layer();
  673.                                 layer_off(action.layer_tap.val);
  674.                                 break;
  675.                             } else if (tap_count < ONESHOT_TAP_TOGGLE) {
  676.                                 set_oneshot_layer(action.layer_tap.val, ONESHOT_START);
  677.                             }
  678.                         } else {
  679.                             if (tap_count >= ONESHOT_TAP_TOGGLE) {
  680.                                 reset_oneshot_layer();
  681.                                 set_oneshot_layer(action.layer_tap.val, ONESHOT_TOGGLED);
  682.                             } else {
  683.                                 clear_oneshot_layer_state(ONESHOT_PRESSED);
  684.                             }
  685.                         }
  686. #        else
  687.                         if (event.pressed) {
  688.                             set_oneshot_layer(action.layer_tap.val, ONESHOT_START);
  689.                         } else {
  690.                             clear_oneshot_layer_state(ONESHOT_PRESSED);
  691.                             if (tap_count > 1) {
  692.                                 clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
  693.                             }
  694.                         }
  695. #        endif
  696.                     }
  697. #    else  // NO_ACTION_ONESHOT && NO_ACTION_TAPPING
  698.                     if (event.pressed) {
  699.                         layer_on(action.layer_tap.val);
  700.                     } else {
  701.                         layer_off(action.layer_tap.val);
  702.                     }
  703. #    endif // !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING)
  704.                     break;
  705.                 default:
  706. #    ifndef NO_ACTION_TAPPING /* tap key */
  707.                     if (event.pressed) {
  708.                         if (tap_count > 0) {
  709.                             ac_dprintf("KEYMAP_TAP_KEY: Tap: register_code\n");
  710.                             register_code(action.layer_tap.code);
  711.                         } else {
  712.                             ac_dprintf("KEYMAP_TAP_KEY: No tap: On on press\n");
  713.                             layer_on(action.layer_tap.val);
  714.                         }
  715.                     } else {
  716.                         if (tap_count > 0) {
  717.                             ac_dprintf("KEYMAP_TAP_KEY: Tap: unregister_code\n");
  718.                             if (action.layer_tap.code == KC_CAPS_LOCK) {
  719.                                 wait_ms(TAP_HOLD_CAPS_DELAY);
  720.                             } else {
  721.                                 wait_ms(TAP_CODE_DELAY);
  722.                             }
  723.                             unregister_code(action.layer_tap.code);
  724.                         } else {
  725.                             ac_dprintf("KEYMAP_TAP_KEY: No tap: Off on release\n");
  726.                             layer_off(action.layer_tap.val);
  727.                         }
  728.                     }
  729. #    else
  730.                     if (event.pressed) {
  731.                         ac_dprintf("KEYMAP_TAP_KEY: Tap: register_code\n");
  732.                         register_code(action.layer_tap.code);
  733.                     } else {
  734.                         ac_dprintf("KEYMAP_TAP_KEY: Tap: unregister_code\n");
  735.                         if (action.layer_tap.code == KC_CAPS) {
  736.                             wait_ms(TAP_HOLD_CAPS_DELAY);
  737.                         } else {
  738.                             wait_ms(TAP_CODE_DELAY);
  739.                         }
  740.                         unregister_code(action.layer_tap.code);
  741.                     }
  742. #    endif
  743.                     break;
  744.             }
  745.             break;
  746. #endif // NO_ACTION_LAYER
  748. #ifdef SWAP_HANDS_ENABLE
  749.         case ACT_SWAP_HANDS:
  750.             switch (action.swap.code) {
  751.                 case OP_SH_TOGGLE:
  752.                     if (event.pressed) {
  753.                         swap_hands = !swap_hands;
  754.                     }
  755.                     break;
  756.                 case OP_SH_ON_OFF:
  757.                     swap_hands = event.pressed;
  758.                     break;
  759.                 case OP_SH_OFF_ON:
  760.                     swap_hands = !event.pressed;
  761.                     break;
  762.                 case OP_SH_ON:
  763.                     if (!event.pressed) {
  764.                         swap_hands = true;
  765.                     }
  766.                     break;
  767.                 case OP_SH_OFF:
  768.                     if (!event.pressed) {
  769.                         swap_hands = false;
  770.                     }
  771.                     break;
  772. #    ifndef NO_ACTION_ONESHOT
  773.                 case OP_SH_ONESHOT:
  774.                     if (event.pressed) {
  775.                         set_oneshot_swaphands();
  776.                     } else {
  777.                         release_oneshot_swaphands();
  778.                     }
  779.                     break;
  780. #    endif
  782. #    ifndef NO_ACTION_TAPPING
  783.                 case OP_SH_TAP_TOGGLE:
  784.                     /* tap toggle */
  786.                     if (event.pressed) {
  787.                         if (swap_held) {
  788.                             swap_held = false;
  789.                         } else {
  790.                             swap_hands = !swap_hands;
  791.                         }
  792.                     } else {
  793.                         if (tap_count < TAPPING_TOGGLE) {
  794.                             swap_hands = !swap_hands;
  795.                         }
  796.                     }
  797.                     break;
  798.                 default:
  799.                     /* tap key */
  800.                     if (tap_count > 0) {
  801.                         if (swap_held) {
  802.                             swap_hands = !swap_hands; // undo hold set up in _tap_hint
  803.                             swap_held  = false;
  804.                         }
  805.                         if (event.pressed) {
  806.                             register_code(action.swap.code);
  807.                         } else {
  808.                             wait_ms(TAP_CODE_DELAY);
  809.                             unregister_code(action.swap.code);
  810.                             *record = (keyrecord_t){}; // hack: reset tap mode
  811.                         }
  812.                     } else {
  813.                         if (swap_held && !event.pressed) {
  814.                             swap_hands = !swap_hands; // undo hold set up in _tap_hint
  815.                             swap_held  = false;
  816.                         }
  817.                     }
  818. #    endif
  819.             }
  820. #endif
  821.         default:
  822.             break;
  823.     }
  825. #ifndef NO_ACTION_LAYER
  826.     // if this event is a layer action, update the leds
  827.     switch (action.kind.id) {
  828.         case ACT_LAYER:
  829.         case ACT_LAYER_MODS:
  830. #    ifndef NO_ACTION_TAPPING
  831.         case ACT_LAYER_TAP:
  832.         case ACT_LAYER_TAP_EXT:
  833. #    endif
  834.             led_set(host_keyboard_leds());
  835. #    ifndef NO_ACTION_ONESHOT
  836.             // don't release the key
  837.             do_release_oneshot = false;
  838. #    endif
  839.             break;
  840.         default:
  841.             break;
  842.     }
  843. #endif
  845. #ifndef NO_ACTION_TAPPING
  846. #    if defined(RETRO_TAPPING) || defined(RETRO_TAPPING_PER_KEY) || (defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT))
  847.     if (is_tap_action(action)) {
  848.         if (event.pressed) {
  849.             if (tap_count > 0) {
  850.                 retro_tap_primed = false;
  851.             } else {
  852. #        if !(defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT))
  853.                 retro_tap_curr_mods = retro_tap_next_mods;
  854.                 retro_tap_next_mods = get_mods();
  855. #        endif
  856.             }
  857.         } else {
  858.             uint16_t event_keycode = get_event_keycode(event, false);
  859. #        if !(defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT))
  860.             uint8_t curr_mods = get_mods();
  861. #        endif
  862.             if (tap_count > 0) {
  863.                 retro_tap_primed = false;
  864.             } else if (retro_tap_curr_key == event_keycode) {
  865.                 if (
  866. #        ifdef RETRO_TAPPING_PER_KEY
  867.                     get_retro_tapping(event_keycode, record) &&
  868. #        endif
  869.                     retro_tap_primed) {
  870. #        if defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT)
  871.                     process_auto_shift(action.layer_tap.code, record);
  872. #        else
  873.                     register_mods(retro_tap_curr_mods);
  874.                     wait_ms(TAP_CODE_DELAY);
  875.                     tap_code(action.layer_tap.code);
  876.                     wait_ms(TAP_CODE_DELAY);
  877.                     unregister_mods(retro_tap_curr_mods);
  878. #        endif
  879.                 }
  880.                 retro_tap_primed = false;
  881.             }
  882. #        if !(defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT))
  883.             retro_tap_next_mods = curr_mods;
  884. #        endif
  885.         }
  886.     }
  887. #    endif
  888. #endif
  890. #ifdef SWAP_HANDS_ENABLE
  891. #    ifndef NO_ACTION_ONESHOT
  892.     if (event.pressed && !(action.kind.id == ACT_SWAP_HANDS && action.swap.code == OP_SH_ONESHOT)) {
  893.         use_oneshot_swaphands();
  894.     }
  895. #    endif
  896. #endif
  898. #ifndef NO_ACTION_ONESHOT
  899.     /* Because we switch layers after a oneshot event, we need to release the
  900.      * key before we leave the layer or no key up event will be generated.
  901.      */
  902.     if (do_release_oneshot && !(get_oneshot_layer_state() & ONESHOT_PRESSED)) {
  903.         record->event.pressed = false;
  904.         layer_on(get_oneshot_layer());
  905.         process_record(record);
  906.         layer_off(get_oneshot_layer());
  907.     }
  908. #endif
  909. }
  911. /** \brief Utilities for actions. (FIXME: Needs better description)
  912.  *
  913.  * FIXME: Needs documentation.
  914.  */
  915. __attribute__((weak)) void register_code(uint8_t code) {
  916.     if (code == KC_NO) {
  917.         return;
  919. #ifdef LOCKING_SUPPORT_ENABLE
  920.     } else if (KC_LOCKING_CAPS_LOCK == code) {
  921. #    ifdef LOCKING_RESYNC_ENABLE
  922.         // Resync: ignore if caps lock already is on
  923.         if (host_keyboard_led_state().caps_lock) return;
  924. #    endif
  925.         add_key(KC_CAPS_LOCK);
  926.         send_keyboard_report();
  927.         wait_ms(TAP_HOLD_CAPS_DELAY);
  928.         del_key(KC_CAPS_LOCK);
  929.         send_keyboard_report();
  931.     } else if (KC_LOCKING_NUM_LOCK == code) {
  932. #    ifdef LOCKING_RESYNC_ENABLE
  933.         if (host_keyboard_led_state().num_lock) return;
  934. #    endif
  935.         add_key(KC_NUM_LOCK);
  936.         send_keyboard_report();
  937.         wait_ms(100);
  938.         del_key(KC_NUM_LOCK);
  939.         send_keyboard_report();
  941.     } else if (KC_LOCKING_SCROLL_LOCK == code) {
  942. #    ifdef LOCKING_RESYNC_ENABLE
  943.         if (host_keyboard_led_state().scroll_lock) return;
  944. #    endif
  945.         add_key(KC_SCROLL_LOCK);
  946.         send_keyboard_report();
  947.         wait_ms(100);
  948.         del_key(KC_SCROLL_LOCK);
  949.         send_keyboard_report();
  950. #endif
  952.     } else if (IS_BASIC_KEYCODE(code)) {
  953.         // TODO: should push command_proc out of this block?
  954.         if (command_proc(code)) return;
  956.         // Force a new key press if the key is already pressed
  957.         // without this, keys with the same keycode, but different
  958.         // modifiers will be reported incorrectly, see issue #1708
  959.         if (is_key_pressed(code)) {
  960.             del_key(code);
  961.             send_keyboard_report();
  962.         }
  963.         add_key(code);
  964.         send_keyboard_report();
  965.     } else if (IS_MODIFIER_KEYCODE(code)) {
  966.         add_mods(MOD_BIT(code));
  967.         send_keyboard_report();
  969. #ifdef EXTRAKEY_ENABLE
  970.     } else if (IS_SYSTEM_KEYCODE(code)) {
  971.         host_system_send(KEYCODE2SYSTEM(code));
  972.     } else if (IS_CONSUMER_KEYCODE(code)) {
  973.         host_consumer_send(KEYCODE2CONSUMER(code));
  974. #endif
  976.     } else if (IS_MOUSE_KEYCODE(code)) {
  977.         register_mouse(code, true);
  978.     }
  979. }
  981. /** \brief Utilities for actions. (FIXME: Needs better description)
  982.  *
  983.  * FIXME: Needs documentation.
  984.  */
  985. __attribute__((weak)) void unregister_code(uint8_t code) {
  986.     if (code == KC_NO) {
  987.         return;
  989. #ifdef LOCKING_SUPPORT_ENABLE
  990.     } else if (KC_LOCKING_CAPS_LOCK == code) {
  991. #    ifdef LOCKING_RESYNC_ENABLE
  992.         // Resync: ignore if caps lock already is off
  993.         if (!host_keyboard_led_state().caps_lock) return;
  994. #    endif
  995.         add_key(KC_CAPS_LOCK);
  996.         send_keyboard_report();
  997.         del_key(KC_CAPS_LOCK);
  998.         send_keyboard_report();
  1000.     } else if (KC_LOCKING_NUM_LOCK == code) {
  1001. #    ifdef LOCKING_RESYNC_ENABLE
  1002.         if (!host_keyboard_led_state().num_lock) return;
  1003. #    endif
  1004.         add_key(KC_NUM_LOCK);
  1005.         send_keyboard_report();
  1006.         del_key(KC_NUM_LOCK);
  1007.         send_keyboard_report();
  1009.     } else if (KC_LOCKING_SCROLL_LOCK == code) {
  1010. #    ifdef LOCKING_RESYNC_ENABLE
  1011.         if (!host_keyboard_led_state().scroll_lock) return;
  1012. #    endif
  1013.         add_key(KC_SCROLL_LOCK);
  1014.         send_keyboard_report();
  1015.         del_key(KC_SCROLL_LOCK);
  1016.         send_keyboard_report();
  1017. #endif
  1019.     } else if (IS_BASIC_KEYCODE(code)) {
  1020.         del_key(code);
  1021.         send_keyboard_report();
  1022.     } else if (IS_MODIFIER_KEYCODE(code)) {
  1023.         del_mods(MOD_BIT(code));
  1024.         send_keyboard_report();
  1026. #ifdef EXTRAKEY_ENABLE
  1027.     } else if (IS_SYSTEM_KEYCODE(code)) {
  1028.         host_system_send(0);
  1029.     } else if (IS_CONSUMER_KEYCODE(code)) {
  1030.         host_consumer_send(0);
  1031. #endif
  1033.     } else if (IS_MOUSE_KEYCODE(code)) {
  1034.         register_mouse(code, false);
  1035.     }
  1036. }
  1038. /** \brief Tap a keycode with a delay.
  1039.  *
  1040.  * \param code The basic keycode to tap.
  1041.  * \param delay The amount of time in milliseconds to leave the keycode registered, before unregistering it.
  1042.  */
  1043. __attribute__((weak)) void tap_code_delay(uint8_t code, uint16_t delay) {
  1044.     register_code(code);
  1045.     wait_ms(delay);
  1046.     unregister_code(code);
  1047. }
  1049. /** \brief Tap a keycode with the default delay.
  1050.  *
  1051.  * \param code The basic keycode to tap. If `code` is `KC_CAPS_LOCK`, the delay will be `TAP_HOLD_CAPS_DELAY`, otherwise `TAP_CODE_DELAY`, if defined.
  1052.  */
  1053. __attribute__((weak)) void tap_code(uint8_t code) {
  1054.     tap_code_delay(code, code == KC_CAPS_LOCK ? TAP_HOLD_CAPS_DELAY : TAP_CODE_DELAY);
  1055. }
  1057. /** \brief Adds the given physically pressed modifiers and sends a keyboard report immediately.
  1058.  *
  1059.  * \param mods A bitfield of modifiers to register.
  1060.  */
  1061. __attribute__((weak)) void register_mods(uint8_t mods) {
  1062.     if (mods) {
  1063.         add_mods(mods);
  1064.         send_keyboard_report();
  1065.     }
  1066. }
  1068. /** \brief Removes the given physically pressed modifiers and sends a keyboard report immediately.
  1069.  *
  1070.  * \param mods A bitfield of modifiers to unregister.
  1071.  */
  1072. __attribute__((weak)) void unregister_mods(uint8_t mods) {
  1073.     if (mods) {
  1074.         del_mods(mods);
  1075.         send_keyboard_report();
  1076.     }
  1077. }
  1079. /** \brief Adds the given weak modifiers and sends a keyboard report immediately.
  1080.  *
  1081.  * \param mods A bitfield of modifiers to register.
  1082.  */
  1083. __attribute__((weak)) void register_weak_mods(uint8_t mods) {
  1084.     if (mods) {
  1085.         add_weak_mods(mods);
  1086.         send_keyboard_report();
  1087.     }
  1088. }
  1090. /** \brief Removes the given weak modifiers and sends a keyboard report immediately.
  1091.  *
  1092.  * \param mods A bitfield of modifiers to unregister.
  1093.  */
  1094. __attribute__((weak)) void unregister_weak_mods(uint8_t mods) {
  1095.     if (mods) {
  1096.         del_weak_mods(mods);
  1097.         send_keyboard_report();
  1098.     }
  1099. }
  1101. /** \brief Utilities for actions. (FIXME: Needs better description)
  1102.  *
  1103.  * FIXME: Needs documentation.
  1104.  */
  1105. void clear_keyboard(void) {
  1106.     clear_mods();
  1107.     clear_keyboard_but_mods();
  1108. }
  1110. /** \brief Utilities for actions. (FIXME: Needs better description)
  1111.  *
  1112.  * FIXME: Needs documentation.
  1113.  */
  1114. void clear_keyboard_but_mods(void) {
  1115.     clear_keys();
  1116.     clear_keyboard_but_mods_and_keys();
  1117. }
  1119. /** \brief Utilities for actions. (FIXME: Needs better description)
  1120.  *
  1121.  * FIXME: Needs documentation.
  1122.  */
  1123. void clear_keyboard_but_mods_and_keys(void) {
  1124. #ifdef EXTRAKEY_ENABLE
  1125.     host_system_send(0);
  1126.     host_consumer_send(0);
  1127. #endif
  1128.     clear_weak_mods();
  1129.     send_keyboard_report();
  1130. #ifdef MOUSEKEY_ENABLE
  1131.     mousekey_clear();
  1132.     mousekey_send();
  1133. #endif
  1134. #ifdef PROGRAMMABLE_BUTTON_ENABLE
  1135.     programmable_button_clear();
  1136. #endif
  1137. }
  1139. /** \brief Utilities for actions. (FIXME: Needs better description)
  1140.  *
  1141.  * FIXME: Needs documentation.
  1142.  */
  1143. bool is_tap_record(keyrecord_t *record) {
  1144.     if (IS_NOEVENT(record->event)) {
  1145.         return false;
  1146.     }
  1148. #if defined(COMBO_ENABLE) || defined(REPEAT_KEY_ENABLE)
  1149.     action_t action;
  1150.     if (record->keycode) {
  1151.         action = action_for_keycode(record->keycode);
  1152.     } else {
  1153.         action = layer_switch_get_action(record->event.key);
  1154.     }
  1155. #else
  1156.     action_t action = layer_switch_get_action(record->event.key);
  1157. #endif
  1158.     return is_tap_action(action);
  1159. }
  1161. /** \brief Utilities for actions. (FIXME: Needs better description)
  1162.  *
  1163.  * FIXME: Needs documentation.
  1164.  */
  1165. bool is_tap_action(action_t action) {
  1166.     switch (action.kind.id) {
  1167.         case ACT_LMODS_TAP:
  1168.         case ACT_RMODS_TAP:
  1169.         case ACT_LAYER_TAP:
  1170.         case ACT_LAYER_TAP_EXT:
  1171.             switch (action.layer_tap.code) {
  1172.                 case KC_NO ... KC_RIGHT_GUI:
  1173.                 case OP_TAP_TOGGLE:
  1174.                 case OP_ONESHOT:
  1175.                     return true;
  1176.             }
  1177.             return false;
  1178.         case ACT_SWAP_HANDS:
  1179.             switch (action.swap.code) {
  1180.                 case KC_NO ... KC_RIGHT_GUI:
  1181.                 case OP_SH_TAP_TOGGLE:
  1182.                     return true;
  1183.             }
  1184.             return false;
  1185.     }
  1186.     return false;
  1187. }
  1189. uint16_t get_tap_keycode(uint16_t keycode) {
  1190.     switch (keycode) {
  1191.         case QK_MOD_TAP ... QK_MOD_TAP_MAX:
  1192.             return QK_MOD_TAP_GET_TAP_KEYCODE(keycode);
  1193.         case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:
  1194.             return QK_LAYER_TAP_GET_TAP_KEYCODE(keycode);
  1195.         case QK_SWAP_HANDS ... QK_SWAP_HANDS_MAX:
  1196.             // IS_SWAP_HANDS_KEYCODE() tests for the special action keycodes
  1197.             // like SH_TOGG, SH_TT, ..., which overlap the SH_T(kc) range.
  1198.             if (!IS_SWAP_HANDS_KEYCODE(keycode)) {
  1199.                 return QK_SWAP_HANDS_GET_TAP_KEYCODE(keycode);
  1200.             }
  1201.             break;
  1202.     }
  1203.     return keycode;
  1204. }
  1206. /** \brief Debug print (FIXME: Needs better description)
  1207.  *
  1208.  * FIXME: Needs documentation.
  1209.  */
  1210. void debug_event(keyevent_t event) {
  1211.     ac_dprintf("%04X%c(%u)", (event.key.row << 8 | event.key.col), (event.pressed ? 'd' : 'u'), event.time);
  1212. }
  1213. /** \brief Debug print (FIXME: Needs better description)
  1214.  *
  1215.  * FIXME: Needs documentation.
  1216.  */
  1217. void debug_record(keyrecord_t record) {
  1218.     debug_event(record.event);
  1219. #ifndef NO_ACTION_TAPPING
  1220.     ac_dprintf(":%u%c", record.tap.count, (record.tap.interrupted ? '-' : ' '));
  1221. #endif
  1222. }
  1224. /** \brief Debug print (FIXME: Needs better description)
  1225.  *
  1226.  * FIXME: Needs documentation.
  1227.  */
  1228. void debug_action(action_t action) {
  1229.     switch (action.kind.id) {
  1230.         case ACT_LMODS:
  1231.             ac_dprintf("ACT_LMODS");
  1232.             break;
  1233.         case ACT_RMODS:
  1234.             ac_dprintf("ACT_RMODS");
  1235.             break;
  1236.         case ACT_LMODS_TAP:
  1237.             ac_dprintf("ACT_LMODS_TAP");
  1238.             break;
  1239.         case ACT_RMODS_TAP:
  1240.             ac_dprintf("ACT_RMODS_TAP");
  1241.             break;
  1242.         case ACT_USAGE:
  1243.             ac_dprintf("ACT_USAGE");
  1244.             break;
  1245.         case ACT_MOUSEKEY:
  1246.             ac_dprintf("ACT_MOUSEKEY");
  1247.             break;
  1248.         case ACT_LAYER:
  1249.             ac_dprintf("ACT_LAYER");
  1250.             break;
  1251.         case ACT_LAYER_MODS:
  1252.             ac_dprintf("ACT_LAYER_MODS");
  1253.             break;
  1254.         case ACT_LAYER_TAP:
  1255.             ac_dprintf("ACT_LAYER_TAP");
  1256.             break;
  1257.         case ACT_LAYER_TAP_EXT:
  1258.             ac_dprintf("ACT_LAYER_TAP_EXT");
  1259.             break;
  1260.         case ACT_SWAP_HANDS:
  1261.             ac_dprintf("ACT_SWAP_HANDS");
  1262.             break;
  1263.         default:
  1264.             ac_dprintf("UNKNOWN");
  1265.             break;
  1266.     }
  1267.     ac_dprintf("[%X:%02X]", action.kind.param >> 8, action.kind.param & 0xff);
  1268. }