logo

qmk_firmware

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

action_util.c (14553B)

    

  1. /*
  2. Copyright 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 "host.h"
  18. #include "report.h"
  19. #include "debug.h"
  20. #include "action_util.h"
  21. #include "action_layer.h"
  22. #include "timer.h"
  23. #include "keycode_config.h"
  24. #include <string.h>
  26. extern keymap_config_t keymap_config;
  28. static uint8_t real_mods = 0;
  29. static uint8_t weak_mods = 0;
  30. #ifdef KEY_OVERRIDE_ENABLE
  31. static uint8_t weak_override_mods = 0;
  32. static uint8_t suppressed_mods    = 0;
  33. #endif
  35. // TODO: pointer variable is not needed
  36. // report_keyboard_t keyboard_report = {};
  37. report_keyboard_t *keyboard_report = &(report_keyboard_t){};
  38. #ifdef NKRO_ENABLE
  39. report_nkro_t *nkro_report = &(report_nkro_t){};
  40. #endif
  42. extern inline void add_key(uint8_t key);
  43. extern inline void del_key(uint8_t key);
  44. extern inline void clear_keys(void);
  46. #ifndef NO_ACTION_ONESHOT
  47. static uint8_t oneshot_mods        = 0;
  48. static uint8_t oneshot_locked_mods = 0;
  49. uint8_t        get_oneshot_locked_mods(void) {
  50.     return oneshot_locked_mods;
  51. }
  52. void add_oneshot_locked_mods(uint8_t mods) {
  53.     if ((oneshot_locked_mods & mods) != mods) {
  54.         oneshot_locked_mods |= mods;
  55.         oneshot_locked_mods_changed_kb(oneshot_locked_mods);
  56.     }
  57. }
  58. void set_oneshot_locked_mods(uint8_t mods) {
  59.     if (mods != oneshot_locked_mods) {
  60.         oneshot_locked_mods = mods;
  61.         oneshot_locked_mods_changed_kb(oneshot_locked_mods);
  62.     }
  63. }
  64. void clear_oneshot_locked_mods(void) {
  65.     if (oneshot_locked_mods) {
  66.         oneshot_locked_mods = 0;
  67.         oneshot_locked_mods_changed_kb(oneshot_locked_mods);
  68.     }
  69. }
  70. void del_oneshot_locked_mods(uint8_t mods) {
  71.     if (oneshot_locked_mods & mods) {
  72.         oneshot_locked_mods &= ~mods;
  73.         oneshot_locked_mods_changed_kb(oneshot_locked_mods);
  74.     }
  75. }
  76. #    if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
  77. static uint16_t oneshot_time = 0;
  78. bool            has_oneshot_mods_timed_out(void) {
  79.     return TIMER_DIFF_16(timer_read(), oneshot_time) >= ONESHOT_TIMEOUT;
  80. }
  81. #    else
  82. bool has_oneshot_mods_timed_out(void) {
  83.     return false;
  84. }
  85. #    endif
  86. #endif
  88. /* oneshot layer */
  89. #ifndef NO_ACTION_ONESHOT
  90. /** \brief oneshot_layer_data bits
  91.  * LLLL LSSS
  92.  * where:
  93.  *   L => are layer bits
  94.  *   S => oneshot state bits
  95.  */
  96. static uint8_t oneshot_layer_data = 0;
  98. inline uint8_t get_oneshot_layer(void) {
  99.     return oneshot_layer_data >> 3;
  100. }
  101. inline uint8_t get_oneshot_layer_state(void) {
  102.     return oneshot_layer_data & 0b111;
  103. }
  105. #    ifdef SWAP_HANDS_ENABLE
  106. enum {
  107.     SHO_OFF,
  108.     SHO_ACTIVE,  // Swap hands button was pressed, and we didn't send any swapped keys yet
  109.     SHO_PRESSED, // Swap hands button is currently pressed
  110.     SHO_USED,    // Swap hands button is still pressed, and we already sent swapped keys
  111. } swap_hands_oneshot = SHO_OFF;
  112. #    endif
  114. #    if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
  115. static uint16_t oneshot_layer_time = 0;
  116. inline bool     has_oneshot_layer_timed_out(void) {
  117.     return TIMER_DIFF_16(timer_read(), oneshot_layer_time) >= ONESHOT_TIMEOUT && !(get_oneshot_layer_state() & ONESHOT_TOGGLED);
  118. }
  119. #        ifdef SWAP_HANDS_ENABLE
  120. static uint16_t oneshot_swaphands_time = 0;
  121. inline bool     has_oneshot_swaphands_timed_out(void) {
  122.     return TIMER_DIFF_16(timer_read(), oneshot_swaphands_time) >= ONESHOT_TIMEOUT && (swap_hands_oneshot == SHO_ACTIVE);
  123. }
  124. #        endif
  125. #    endif
  127. #    ifdef SWAP_HANDS_ENABLE
  129. void set_oneshot_swaphands(void) {
  130.     swap_hands_oneshot = SHO_PRESSED;
  131.     swap_hands         = true;
  132. #        if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
  133.     oneshot_swaphands_time = timer_read();
  134.     if (oneshot_layer_time != 0) {
  135.         oneshot_layer_time = oneshot_swaphands_time;
  136.     }
  137. #        endif
  138. }
  140. void release_oneshot_swaphands(void) {
  141.     if (swap_hands_oneshot == SHO_PRESSED) {
  142.         swap_hands_oneshot = SHO_ACTIVE;
  143.     }
  144.     if (swap_hands_oneshot == SHO_USED) {
  145.         clear_oneshot_swaphands();
  146.     }
  147. }
  149. void use_oneshot_swaphands(void) {
  150.     if (swap_hands_oneshot == SHO_PRESSED) {
  151.         swap_hands_oneshot = SHO_USED;
  152.     }
  153.     if (swap_hands_oneshot == SHO_ACTIVE) {
  154.         clear_oneshot_swaphands();
  155.     }
  156. }
  158. void clear_oneshot_swaphands(void) {
  159.     swap_hands_oneshot = SHO_OFF;
  160.     swap_hands         = false;
  161. #        if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
  162.     oneshot_swaphands_time = 0;
  163. #        endif
  164. }
  166. #    endif
  168. /** \brief Set oneshot layer
  169.  *
  170.  * FIXME: needs doc
  171.  */
  172. void set_oneshot_layer(uint8_t layer, uint8_t state) {
  173.     if (keymap_config.oneshot_enable) {
  174.         oneshot_layer_data = layer << 3 | state;
  175.         layer_on(layer);
  176. #    if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
  177.         oneshot_layer_time = timer_read();
  178. #    endif
  179.         oneshot_layer_changed_kb(get_oneshot_layer());
  180.     } else {
  181.         layer_on(layer);
  182.     }
  183. }
  184. /** \brief Reset oneshot layer
  185.  *
  186.  * FIXME: needs doc
  187.  */
  188. void reset_oneshot_layer(void) {
  189.     oneshot_layer_data = 0;
  190. #    if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
  191.     oneshot_layer_time = 0;
  192. #    endif
  193.     oneshot_layer_changed_kb(get_oneshot_layer());
  194. }
  195. /** \brief Clear oneshot layer
  196.  *
  197.  * FIXME: needs doc
  198.  */
  199. void clear_oneshot_layer_state(oneshot_fullfillment_t state) {
  200.     uint8_t start_state = oneshot_layer_data;
  201.     oneshot_layer_data &= ~state;
  202.     if ((!get_oneshot_layer_state() && start_state != oneshot_layer_data) && keymap_config.oneshot_enable) {
  203.         layer_off(get_oneshot_layer());
  204.         reset_oneshot_layer();
  205.     }
  206. }
  207. /** \brief Is oneshot layer active
  208.  *
  209.  * FIXME: needs doc
  210.  */
  211. bool is_oneshot_layer_active(void) {
  212.     return get_oneshot_layer_state();
  213. }
  215. /** \brief set oneshot
  216.  *
  217.  * FIXME: needs doc
  218.  */
  219. void oneshot_set(bool active) {
  220.     if (keymap_config.oneshot_enable != active) {
  221.         keymap_config.oneshot_enable = active;
  222.         eeconfig_update_keymap(&keymap_config);
  223.         clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
  224.         dprintf("Oneshot: active: %d\n", active);
  225.     }
  226. }
  228. /** \brief toggle oneshot
  229.  *
  230.  * FIXME: needs doc
  231.  */
  232. void oneshot_toggle(void) {
  233.     oneshot_set(!keymap_config.oneshot_enable);
  234. }
  236. /** \brief enable oneshot
  237.  *
  238.  * FIXME: needs doc
  239.  */
  240. void oneshot_enable(void) {
  241.     oneshot_set(true);
  242. }
  244. /** \brief disable oneshot
  245.  *
  246.  * FIXME: needs doc
  247.  */
  248. void oneshot_disable(void) {
  249.     oneshot_set(false);
  250. }
  252. bool is_oneshot_enabled(void) {
  253.     return keymap_config.oneshot_enable;
  254. }
  256. #endif
  258. static uint8_t get_mods_for_report(void) {
  259.     uint8_t mods = real_mods | weak_mods;
  261. #ifndef NO_ACTION_ONESHOT
  262.     if (oneshot_mods) {
  263. #    if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
  264.         if (has_oneshot_mods_timed_out()) {
  265.             dprintf("Oneshot: timeout\n");
  266.             clear_oneshot_mods();
  267.         }
  268. #    endif
  269.         mods |= oneshot_mods;
  270.         if (has_anykey()) {
  271.             clear_oneshot_mods();
  272.         }
  273.     }
  274. #endif
  276. #ifdef KEY_OVERRIDE_ENABLE
  277.     // These need to be last to be able to properly control key overrides
  278.     mods &= ~suppressed_mods;
  279.     mods |= weak_override_mods;
  280. #endif
  282.     return mods;
  283. }
  285. void send_6kro_report(void) {
  286.     keyboard_report->mods = get_mods_for_report();
  288. #ifdef PROTOCOL_VUSB
  289.     host_keyboard_send(keyboard_report);
  290. #else
  291.     static report_keyboard_t last_report;
  293.     /* Only send the report if there are changes to propagate to the host. */
  294.     if (memcmp(keyboard_report, &last_report, sizeof(report_keyboard_t)) != 0) {
  295.         memcpy(&last_report, keyboard_report, sizeof(report_keyboard_t));
  296.         host_keyboard_send(keyboard_report);
  297.     }
  298. #endif
  299. }
  301. #ifdef NKRO_ENABLE
  302. void send_nkro_report(void) {
  303.     nkro_report->mods = get_mods_for_report();
  305.     static report_nkro_t last_report;
  307.     /* Only send the report if there are changes to propagate to the host. */
  308.     if (memcmp(nkro_report, &last_report, sizeof(report_nkro_t)) != 0) {
  309.         memcpy(&last_report, nkro_report, sizeof(report_nkro_t));
  310.         host_nkro_send(nkro_report);
  311.     }
  312. }
  313. #endif
  315. /** \brief Send keyboard report
  316.  *
  317.  * FIXME: needs doc
  318.  */
  319. void send_keyboard_report(void) {
  320. #ifdef NKRO_ENABLE
  321.     if (host_can_send_nkro() && keymap_config.nkro) {
  322.         send_nkro_report();
  323.         return;
  324.     }
  325. #endif
  326.     send_6kro_report();
  327. }
  329. /** \brief Get mods
  330.  *
  331.  * FIXME: needs doc
  332.  */
  333. uint8_t get_mods(void) {
  334.     return real_mods;
  335. }
  336. /** \brief add mods
  337.  *
  338.  * FIXME: needs doc
  339.  */
  340. void add_mods(uint8_t mods) {
  341.     real_mods |= mods;
  342. }
  343. /** \brief del mods
  344.  *
  345.  * FIXME: needs doc
  346.  */
  347. void del_mods(uint8_t mods) {
  348.     real_mods &= ~mods;
  349. }
  350. /** \brief set mods
  351.  *
  352.  * FIXME: needs doc
  353.  */
  354. void set_mods(uint8_t mods) {
  355.     real_mods = mods;
  356. }
  357. /** \brief clear mods
  358.  *
  359.  * FIXME: needs doc
  360.  */
  361. void clear_mods(void) {
  362.     real_mods = 0;
  363. }
  365. /** \brief get weak mods
  366.  *
  367.  * FIXME: needs doc
  368.  */
  369. uint8_t get_weak_mods(void) {
  370.     return weak_mods;
  371. }
  372. /** \brief add weak mods
  373.  *
  374.  * FIXME: needs doc
  375.  */
  376. void add_weak_mods(uint8_t mods) {
  377.     weak_mods |= mods;
  378. }
  379. /** \brief del weak mods
  380.  *
  381.  * FIXME: needs doc
  382.  */
  383. void del_weak_mods(uint8_t mods) {
  384.     weak_mods &= ~mods;
  385. }
  386. /** \brief set weak mods
  387.  *
  388.  * FIXME: needs doc
  389.  */
  390. void set_weak_mods(uint8_t mods) {
  391.     weak_mods = mods;
  392. }
  393. /** \brief clear weak mods
  394.  *
  395.  * FIXME: needs doc
  396.  */
  397. void clear_weak_mods(void) {
  398.     weak_mods = 0;
  399. }
  401. #ifdef KEY_OVERRIDE_ENABLE
  402. /** \brief set weak mods used by key overrides. DO not call this manually
  403.  */
  404. void set_weak_override_mods(uint8_t mods) {
  405.     weak_override_mods = mods;
  406. }
  407. /** \brief clear weak mods used by key overrides. DO not call this manually
  408.  */
  409. void clear_weak_override_mods(void) {
  410.     weak_override_mods = 0;
  411. }
  413. /** \brief set suppressed mods used by key overrides. DO not call this manually
  414.  */
  415. void set_suppressed_override_mods(uint8_t mods) {
  416.     suppressed_mods = mods;
  417. }
  418. /** \brief clear suppressed mods used by key overrides. DO not call this manually
  419.  */
  420. void clear_suppressed_override_mods(void) {
  421.     suppressed_mods = 0;
  422. }
  423. #endif
  425. #ifndef NO_ACTION_ONESHOT
  426. /** \brief get oneshot mods
  427.  *
  428.  * FIXME: needs doc
  429.  */
  430. uint8_t get_oneshot_mods(void) {
  431.     return oneshot_mods;
  432. }
  434. void add_oneshot_mods(uint8_t mods) {
  435.     if ((oneshot_mods & mods) != mods) {
  436. #    if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
  437.         oneshot_time = timer_read();
  438. #    endif
  439.         oneshot_mods |= mods;
  440.         oneshot_mods_changed_kb(mods);
  441.     }
  442. }
  444. void del_oneshot_mods(uint8_t mods) {
  445.     if (oneshot_mods & mods) {
  446.         oneshot_mods &= ~mods;
  447. #    if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
  448.         oneshot_time = oneshot_mods ? timer_read() : 0;
  449. #    endif
  450.         oneshot_mods_changed_kb(oneshot_mods);
  451.     }
  452. }
  454. /** \brief set oneshot mods
  455.  *
  456.  * FIXME: needs doc
  457.  */
  458. void set_oneshot_mods(uint8_t mods) {
  459.     if (keymap_config.oneshot_enable) {
  460.         if (oneshot_mods != mods) {
  461. #    if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
  462.             oneshot_time = timer_read();
  463. #    endif
  464.             oneshot_mods = mods;
  465.             oneshot_mods_changed_kb(mods);
  466.         }
  467.     }
  468. }
  470. /** \brief clear oneshot mods
  471.  *
  472.  * FIXME: needs doc
  473.  */
  474. void clear_oneshot_mods(void) {
  475.     if (oneshot_mods) {
  476.         oneshot_mods = 0;
  477. #    if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
  478.         oneshot_time = 0;
  479. #    endif
  480.         oneshot_mods_changed_kb(oneshot_mods);
  481.     }
  482. }
  483. #endif
  485. /** \brief Called when the one shot modifiers have been changed.
  486.  *
  487.  * \param mods Contains the active modifiers active after the change.
  488.  */
  489. __attribute__((weak)) void oneshot_locked_mods_changed_user(uint8_t mods) {}
  491. /** \brief Called when the locked one shot modifiers have been changed.
  492.  *
  493.  * \param mods Contains the active modifiers active after the change.
  494.  */
  495. __attribute__((weak)) void oneshot_locked_mods_changed_kb(uint8_t mods) {
  496.     oneshot_locked_mods_changed_user(mods);
  497. }
  499. /** \brief Called when the one shot modifiers have been changed.
  500.  *
  501.  * \param mods Contains the active modifiers active after the change.
  502.  */
  503. __attribute__((weak)) void oneshot_mods_changed_user(uint8_t mods) {}
  505. /** \brief Called when the one shot modifiers have been changed.
  506.  *
  507.  * \param mods Contains the active modifiers active after the change.
  508.  */
  509. __attribute__((weak)) void oneshot_mods_changed_kb(uint8_t mods) {
  510.     oneshot_mods_changed_user(mods);
  511. }
  513. /** \brief Called when the one shot layers have been changed.
  514.  *
  515.  * \param layer Contains the layer that is toggled on, or zero when toggled off.
  516.  */
  517. __attribute__((weak)) void oneshot_layer_changed_user(uint8_t layer) {}
  519. /** \brief Called when the one shot layers have been changed.
  520.  *
  521.  * \param layer Contains the layer that is toggled on, or zero when toggled off.
  522.  */
  523. __attribute__((weak)) void oneshot_layer_changed_kb(uint8_t layer) {
  524.     oneshot_layer_changed_user(layer);
  525. }
  527. /** \brief inspect keyboard state
  528.  *
  529.  * FIXME: needs doc
  530.  */
  531. uint8_t has_anymod(void) {
  532.     return bitpop(real_mods);
  533. }
  535. #ifdef DUMMY_MOD_NEUTRALIZER_KEYCODE
  536. /** \brief Send a dummy keycode in between the register and unregister event of a modifier key, to neutralize the "flashing modifiers" phenomenon.
  537.  *
  538.  * \param active_mods 8-bit packed bit-array describing the currently active modifiers (in the format GASCGASC).
  539.  *
  540.  * Certain QMK features like  key overrides or retro tap must unregister a previously
  541.  * registered modifier before sending another keycode but this can trigger undesired
  542.  * keyboard shortcuts if the clean tap of a single modifier key is bound to an action
  543.  * on the host OS, as is for example the case for the left GUI key on Windows, which
  544.  * opens the Start Menu when tapped.
  545.  */
  546. void neutralize_flashing_modifiers(uint8_t active_mods) {
  547.     // In most scenarios, the flashing modifiers phenomenon is a problem
  548.     // only for a subset of modifier masks.
  549.     const static uint8_t mods_to_neutralize[] = MODS_TO_NEUTRALIZE;
  550.     const static uint8_t n_mods               = ARRAY_SIZE(mods_to_neutralize);
  551.     for (uint8_t i = 0; i < n_mods; ++i) {
  552.         if (active_mods == mods_to_neutralize[i]) {
  553.             tap_code(DUMMY_MOD_NEUTRALIZER_KEYCODE);
  554.             break;
  555.         }
  556.     }
  557. }
  558. #endif