logo

qmk_firmware

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

quantum.c (20548B)

    

  1. /* Copyright 2016-2017 Jack Humbert
  2.  *
  3.  * This program is free software: you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation, either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15.  */
  17. #include "quantum.h"
  19. #ifdef BACKLIGHT_ENABLE
  20. #    include "process_backlight.h"
  21. #endif
  23. #ifdef CONNECTION_ENABLE
  24. #    include "process_connection.h"
  25. #endif
  27. #ifdef GRAVE_ESC_ENABLE
  28. #    include "process_grave_esc.h"
  29. #endif
  31. #ifdef HAPTIC_ENABLE
  32. #    include "process_haptic.h"
  33. #endif
  35. #ifdef JOYSTICK_ENABLE
  36. #    include "process_joystick.h"
  37. #endif
  39. #ifdef LEADER_ENABLE
  40. #    include "process_leader.h"
  41. #endif
  43. #ifdef LED_MATRIX_ENABLE
  44. #    include "process_led_matrix.h"
  45. #endif
  47. #ifdef MAGIC_ENABLE
  48. #    include "process_magic.h"
  49. #endif
  51. #ifdef MIDI_ENABLE
  52. #    include "process_midi.h"
  53. #endif
  55. #if !defined(NO_ACTION_LAYER)
  56. #    include "process_default_layer.h"
  57. #endif
  59. #ifdef PROGRAMMABLE_BUTTON_ENABLE
  60. #    include "process_programmable_button.h"
  61. #endif
  63. #if defined(RGB_MATRIX_ENABLE)
  64. #    include "process_rgb_matrix.h"
  65. #endif
  67. #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
  68. #    include "process_underglow.h"
  69. #endif
  71. #ifdef SECURE_ENABLE
  72. #    include "process_secure.h"
  73. #endif
  75. #ifdef TRI_LAYER_ENABLE
  76. #    include "process_tri_layer.h"
  77. #endif
  79. #ifdef UNICODE_COMMON_ENABLE
  80. #    include "process_unicode_common.h"
  81. #endif
  83. #ifdef LAYER_LOCK_ENABLE
  84. #    include "process_layer_lock.h"
  85. #endif
  87. #ifdef AUDIO_ENABLE
  88. #    ifndef GOODBYE_SONG
  89. #        define GOODBYE_SONG SONG(GOODBYE_SOUND)
  90. #    endif
  91. float goodbye_song[][2] = GOODBYE_SONG;
  92. #    ifdef DEFAULT_LAYER_SONGS
  93. float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
  94. #    endif
  95. #endif
  97. uint8_t extract_mod_bits(uint16_t code) {
  98.     switch (code) {
  99.         case QK_MODS ... QK_MODS_MAX:
  100.             break;
  101.         default:
  102.             return 0;
  103.     }
  105.     uint8_t mods_to_send = 0;
  107.     if (code & QK_RMODS_MIN) { // Right mod flag is set
  108.         if (code & QK_LCTL) mods_to_send |= MOD_BIT(KC_RIGHT_CTRL);
  109.         if (code & QK_LSFT) mods_to_send |= MOD_BIT(KC_RIGHT_SHIFT);
  110.         if (code & QK_LALT) mods_to_send |= MOD_BIT(KC_RIGHT_ALT);
  111.         if (code & QK_LGUI) mods_to_send |= MOD_BIT(KC_RIGHT_GUI);
  112.     } else {
  113.         if (code & QK_LCTL) mods_to_send |= MOD_BIT(KC_LEFT_CTRL);
  114.         if (code & QK_LSFT) mods_to_send |= MOD_BIT(KC_LEFT_SHIFT);
  115.         if (code & QK_LALT) mods_to_send |= MOD_BIT(KC_LEFT_ALT);
  116.         if (code & QK_LGUI) mods_to_send |= MOD_BIT(KC_LEFT_GUI);
  117.     }
  119.     return mods_to_send;
  120. }
  122. void do_code16(uint16_t code, void (*f)(uint8_t)) {
  123.     f(extract_mod_bits(code));
  124. }
  126. __attribute__((weak)) void register_code16(uint16_t code) {
  127.     if (IS_MODIFIER_KEYCODE(code) || code == KC_NO) {
  128.         do_code16(code, register_mods);
  129.     } else {
  130.         do_code16(code, register_weak_mods);
  131.     }
  132.     register_code(code);
  133. }
  135. __attribute__((weak)) void unregister_code16(uint16_t code) {
  136.     unregister_code(code);
  137.     if (IS_MODIFIER_KEYCODE(code) || code == KC_NO) {
  138.         do_code16(code, unregister_mods);
  139.     } else {
  140.         do_code16(code, unregister_weak_mods);
  141.     }
  142. }
  144. /** \brief Tap a keycode with a delay.
  145.  *
  146.  * \param code The modded keycode to tap.
  147.  * \param delay The amount of time in milliseconds to leave the keycode registered, before unregistering it.
  148.  */
  149. __attribute__((weak)) void tap_code16_delay(uint16_t code, uint16_t delay) {
  150.     register_code16(code);
  151.     for (uint16_t i = delay; i > 0; i--) {
  152.         wait_ms(1);
  153.     }
  154.     unregister_code16(code);
  155. }
  157. /** \brief Tap a keycode with the default delay.
  158.  *
  159.  * \param code The modded keycode to tap. If `code` is `KC_CAPS_LOCK`, the delay will be `TAP_HOLD_CAPS_DELAY`, otherwise `TAP_CODE_DELAY`, if defined.
  160.  */
  161. __attribute__((weak)) void tap_code16(uint16_t code) {
  162.     tap_code16_delay(code, code == KC_CAPS_LOCK ? TAP_HOLD_CAPS_DELAY : TAP_CODE_DELAY);
  163. }
  165. __attribute__((weak)) bool pre_process_record_modules(uint16_t keycode, keyrecord_t *record) {
  166.     return true;
  167. }
  169. __attribute__((weak)) bool pre_process_record_kb(uint16_t keycode, keyrecord_t *record) {
  170.     return pre_process_record_user(keycode, record);
  171. }
  173. __attribute__((weak)) bool pre_process_record_user(uint16_t keycode, keyrecord_t *record) {
  174.     return true;
  175. }
  177. __attribute__((weak)) bool process_action_kb(keyrecord_t *record) {
  178.     return true;
  179. }
  181. __attribute__((weak)) bool process_record_modules(uint16_t keycode, keyrecord_t *record) {
  182.     return true;
  183. }
  185. __attribute__((weak)) bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
  186.     return process_record_user(keycode, record);
  187. }
  189. __attribute__((weak)) bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  190.     return true;
  191. }
  193. __attribute__((weak)) void post_process_record_modules(uint16_t keycode, keyrecord_t *record) {}
  195. __attribute__((weak)) void post_process_record_kb(uint16_t keycode, keyrecord_t *record) {
  196.     post_process_record_user(keycode, record);
  197. }
  199. __attribute__((weak)) void post_process_record_user(uint16_t keycode, keyrecord_t *record) {}
  201. __attribute__((weak)) bool shutdown_modules(bool jump_to_bootloader) {
  202.     return true;
  203. }
  205. __attribute__((weak)) void suspend_power_down_modules(void) {}
  207. __attribute__((weak)) void suspend_wakeup_init_modules(void) {}
  209. void shutdown_quantum(bool jump_to_bootloader) {
  210.     clear_keyboard();
  211. #if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
  212.     process_midi_all_notes_off();
  213. #endif
  214. #ifdef AUDIO_ENABLE
  215. #    ifndef NO_MUSIC_MODE
  216.     music_all_notes_off();
  217. #    endif
  218.     uint16_t timer_start = timer_read();
  219.     PLAY_SONG(goodbye_song);
  220.     shutdown_modules(jump_to_bootloader);
  221.     shutdown_kb(jump_to_bootloader);
  222.     while (timer_elapsed(timer_start) < 250)
  223.         wait_ms(1);
  224.     stop_all_notes();
  225. #else
  226.     shutdown_modules(jump_to_bootloader);
  227.     shutdown_kb(jump_to_bootloader);
  228.     wait_ms(250);
  229. #endif
  230. #ifdef HAPTIC_ENABLE
  231.     haptic_shutdown();
  232. #endif
  233. }
  235. void reset_keyboard(void) {
  236.     shutdown_quantum(true);
  237.     bootloader_jump();
  238. }
  240. void soft_reset_keyboard(void) {
  241.     shutdown_quantum(false);
  242.     mcu_reset();
  243. }
  245. /* Convert record into usable keycode via the contained event. */
  246. uint16_t get_record_keycode(keyrecord_t *record, bool update_layer_cache) {
  247. #if defined(COMBO_ENABLE) || defined(REPEAT_KEY_ENABLE)
  248.     if (record->keycode) {
  249.         return record->keycode;
  250.     }
  251. #endif
  252.     return get_event_keycode(record->event, update_layer_cache);
  253. }
  255. /* Convert event into usable keycode. Checks the layer cache to ensure that it
  256.  * retains the correct keycode after a layer change, if the key is still pressed.
  257.  * "update_layer_cache" is to ensure that it only updates the layer cache when
  258.  * appropriate, otherwise, it will update it and cause layer tap (and other keys)
  259.  * from triggering properly.
  260.  */
  261. uint16_t get_event_keycode(keyevent_t event, bool update_layer_cache) {
  262. #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
  263.     /* TODO: Use store_or_get_action() or a similar function. */
  264.     if (!disable_action_cache) {
  265.         uint8_t layer;
  267.         if (event.pressed && update_layer_cache) {
  268.             layer = layer_switch_get_layer(event.key);
  269.             update_source_layers_cache(event.key, layer);
  270.         } else {
  271.             layer = read_source_layers_cache(event.key);
  272.         }
  273.         return keymap_key_to_keycode(layer, event.key);
  274.     } else
  275. #endif
  276.         return keymap_key_to_keycode(layer_switch_get_layer(event.key), event.key);
  277. }
  279. /* Get keycode, and then process pre tapping functionality */
  280. bool pre_process_record_quantum(keyrecord_t *record) {
  281.     return pre_process_record_modules(get_record_keycode(record, true), record) && pre_process_record_kb(get_record_keycode(record, true), record) &&
  282. #ifdef COMBO_ENABLE
  283.            process_combo(get_record_keycode(record, true), record) &&
  284. #endif
  285.            true;
  286. }
  288. /* Get keycode, and then call keyboard function */
  289. void post_process_record_quantum(keyrecord_t *record) {
  290.     uint16_t keycode = get_record_keycode(record, false);
  291.     post_process_record_modules(keycode, record);
  292.     post_process_record_kb(keycode, record);
  293. }
  295. /* Core keycode function, hands off handling to other functions,
  296.     then processes internal quantum keycodes, and then processes
  297.     ACTIONs.                                                      */
  298. bool process_record_quantum(keyrecord_t *record) {
  299.     uint16_t keycode = get_record_keycode(record, true);
  301.     // This is how you use actions here
  302.     // if (keycode == QK_LEADER) {
  303.     //   action_t action;
  304.     //   action.code = ACTION_DEFAULT_LAYER_SET(0);
  305.     //   process_action(record, action);
  306.     //   return false;
  307.     // }
  309. #if defined(SECURE_ENABLE)
  310.     if (!preprocess_secure(keycode, record)) {
  311.         return false;
  312.     }
  313. #endif
  315. #ifdef TAP_DANCE_ENABLE
  316.     if (preprocess_tap_dance(keycode, record)) {
  317.         // The tap dance might have updated the layer state, therefore the
  318.         // result of the keycode lookup might change.
  319.         keycode = get_record_keycode(record, true);
  320.     }
  321. #endif
  323. #ifdef RGBLIGHT_ENABLE
  324.     if (record->event.pressed) {
  325.         preprocess_rgblight();
  326.     }
  327. #endif
  329. #ifdef WPM_ENABLE
  330.     if (record->event.pressed) {
  331.         update_wpm(keycode);
  332.     }
  333. #endif
  335.     if (!(
  336. #if defined(KEY_LOCK_ENABLE)
  337.             // Must run first to be able to mask key_up events.
  338.             process_key_lock(&keycode, record) &&
  339. #endif
  340. #if defined(DYNAMIC_MACRO_ENABLE) && !defined(DYNAMIC_MACRO_USER_CALL)
  341.             // Must run asap to ensure all keypresses are recorded.
  342.             process_dynamic_macro(keycode, record) &&
  343. #endif
  344. #ifdef REPEAT_KEY_ENABLE
  345.             process_last_key(keycode, record) && process_repeat_key(keycode, record) &&
  346. #endif
  347. #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
  348.             process_clicky(keycode, record) &&
  349. #endif
  350. #ifdef HAPTIC_ENABLE
  351.             process_haptic(keycode, record) &&
  352. #endif
  353. #if defined(POINTING_DEVICE_ENABLE) && defined(POINTING_DEVICE_AUTO_MOUSE_ENABLE)
  354.             process_auto_mouse(keycode, record) &&
  355. #endif
  356.             process_record_modules(keycode, record) && // modules must run before kb
  357.             process_record_kb(keycode, record) &&
  358. #if defined(VIA_ENABLE)
  359.             process_record_via(keycode, record) &&
  360. #endif
  361. #if defined(SECURE_ENABLE)
  362.             process_secure(keycode, record) &&
  363. #endif
  364. #if defined(SEQUENCER_ENABLE)
  365.             process_sequencer(keycode, record) &&
  366. #endif
  367. #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
  368.             process_midi(keycode, record) &&
  369. #endif
  370. #ifdef AUDIO_ENABLE
  371.             process_audio(keycode, record) &&
  372. #endif
  373. #if defined(BACKLIGHT_ENABLE)
  374.             process_backlight(keycode, record) &&
  375. #endif
  376. #if defined(LED_MATRIX_ENABLE)
  377.             process_led_matrix(keycode, record) &&
  378. #endif
  379. #ifdef STENO_ENABLE
  380.             process_steno(keycode, record) &&
  381. #endif
  382. #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
  383.             process_music(keycode, record) &&
  384. #endif
  385. #ifdef CAPS_WORD_ENABLE
  386.             process_caps_word(keycode, record) &&
  387. #endif
  388. #ifdef KEY_OVERRIDE_ENABLE
  389.             process_key_override(keycode, record) &&
  390. #endif
  391. #ifdef TAP_DANCE_ENABLE
  392.             process_tap_dance(keycode, record) &&
  393. #endif
  394. #if defined(UNICODE_COMMON_ENABLE)
  395.             process_unicode_common(keycode, record) &&
  396. #endif
  397. #ifdef LEADER_ENABLE
  398.             process_leader(keycode, record) &&
  399. #endif
  400. #ifdef AUTO_SHIFT_ENABLE
  401.             process_auto_shift(keycode, record) &&
  402. #endif
  403. #ifdef DYNAMIC_TAPPING_TERM_ENABLE
  404.             process_dynamic_tapping_term(keycode, record) &&
  405. #endif
  406. #ifdef SPACE_CADET_ENABLE
  407.             process_space_cadet(keycode, record) &&
  408. #endif
  409. #ifdef MAGIC_ENABLE
  410.             process_magic(keycode, record) &&
  411. #endif
  412. #ifdef GRAVE_ESC_ENABLE
  413.             process_grave_esc(keycode, record) &&
  414. #endif
  415. #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
  416.             process_underglow(keycode, record) &&
  417. #endif
  418. #if defined(RGB_MATRIX_ENABLE)
  419.             process_rgb_matrix(keycode, record) &&
  420. #endif
  421. #ifdef JOYSTICK_ENABLE
  422.             process_joystick(keycode, record) &&
  423. #endif
  424. #ifdef PROGRAMMABLE_BUTTON_ENABLE
  425.             process_programmable_button(keycode, record) &&
  426. #endif
  427. #ifdef AUTOCORRECT_ENABLE
  428.             process_autocorrect(keycode, record) &&
  429. #endif
  430. #ifdef TRI_LAYER_ENABLE
  431.             process_tri_layer(keycode, record) &&
  432. #endif
  433. #if !defined(NO_ACTION_LAYER)
  434.             process_default_layer(keycode, record) &&
  435. #endif
  436. #ifdef LAYER_LOCK_ENABLE
  437.             process_layer_lock(keycode, record) &&
  438. #endif
  439. #ifdef CONNECTION_ENABLE
  440.             process_connection(keycode, record) &&
  441. #endif
  442.             true)) {
  443.         return false;
  444.     }
  446.     if (record->event.pressed) {
  447.         switch (keycode) {
  448. #ifndef NO_RESET
  449.             case QK_BOOTLOADER:
  450.                 reset_keyboard();
  451.                 return false;
  452.             case QK_REBOOT:
  453.                 soft_reset_keyboard();
  454.                 return false;
  455. #endif
  456. #ifndef NO_DEBUG
  457.             case QK_DEBUG_TOGGLE:
  458.                 debug_enable ^= 1;
  459.                 if (debug_enable) {
  460.                     print("DEBUG: enabled.\n");
  461.                 } else {
  462.                     print("DEBUG: disabled.\n");
  463.                 }
  464. #endif
  465.                 return false;
  466.             case QK_CLEAR_EEPROM:
  467. #ifdef NO_RESET
  468.                 eeconfig_init();
  469. #else
  470.                 eeconfig_disable();
  471.                 soft_reset_keyboard();
  472. #endif
  473.                 return false;
  474. #ifdef VELOCIKEY_ENABLE
  475.             case QK_VELOCIKEY_TOGGLE:
  476.                 velocikey_toggle();
  477.                 return false;
  478. #endif
  479. #ifndef NO_ACTION_ONESHOT
  480.             case QK_ONE_SHOT_TOGGLE:
  481.                 oneshot_toggle();
  482.                 break;
  483.             case QK_ONE_SHOT_ON:
  484.                 oneshot_enable();
  485.                 break;
  486.             case QK_ONE_SHOT_OFF:
  487.                 oneshot_disable();
  488.                 break;
  489. #endif
  490. #ifdef ENABLE_COMPILE_KEYCODE
  491.             case QK_MAKE: // Compiles the firmware, and adds the flash command based on keyboard bootloader
  492.             {
  493. #    ifdef NO_ACTION_ONESHOT
  494.                 const uint8_t temp_mod = mod_config(get_mods());
  495. #    else
  496.                 const uint8_t temp_mod = mod_config(get_mods() | get_oneshot_mods());
  497.                 clear_oneshot_mods();
  498. #    endif
  499.                 clear_mods();
  501.                 SEND_STRING_DELAY("qmk", TAP_CODE_DELAY);
  502.                 if (temp_mod & MOD_MASK_SHIFT) { // if shift is held, flash rather than compile
  503.                     SEND_STRING_DELAY(" flash ", TAP_CODE_DELAY);
  504.                 } else {
  505.                     SEND_STRING_DELAY(" compile ", TAP_CODE_DELAY);
  506.                 }
  507. #    if defined(CONVERTER_ENABLED)
  508.                 SEND_STRING_DELAY("-kb " QMK_KEYBOARD " -km " QMK_KEYMAP " -e CONVERT_TO=" CONVERTER_TARGET SS_TAP(X_ENTER), TAP_CODE_DELAY);
  509. #    else
  510.                 SEND_STRING_DELAY("-kb " QMK_KEYBOARD " -km " QMK_KEYMAP SS_TAP(X_ENTER), TAP_CODE_DELAY);
  511. #    endif
  512.                 if (temp_mod & MOD_MASK_SHIFT && temp_mod & MOD_MASK_CTRL) {
  513.                     reset_keyboard();
  514.                 }
  515.             }
  516. #endif
  517.         }
  518.     }
  520.     return process_action_kb(record);
  521. }
  523. void set_single_default_layer(uint8_t default_layer) {
  524. #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
  525.     PLAY_SONG(default_layer_songs[default_layer]);
  526. #endif
  527.     default_layer_set((layer_state_t)1 << default_layer);
  528. }
  530. void set_single_persistent_default_layer(uint8_t default_layer) {
  531.     eeconfig_update_default_layer((layer_state_t)1 << default_layer);
  532.     set_single_default_layer(default_layer);
  533. }
  535. //------------------------------------------------------------------------------
  536. // Override these functions in your keymap file to play different tunes on
  537. // different events such as startup and bootloader jump
  539. __attribute__((weak)) bool shutdown_user(bool jump_to_bootloader) {
  540.     return true;
  541. }
  543. __attribute__((weak)) bool shutdown_kb(bool jump_to_bootloader) {
  544.     if (!shutdown_user(jump_to_bootloader)) {
  545.         return false;
  546.     }
  547.     return true;
  548. }
  550. void suspend_power_down_quantum(void) {
  551.     suspend_power_down_modules();
  552.     suspend_power_down_kb();
  553. #ifndef NO_SUSPEND_POWER_DOWN
  554. // Turn off backlight
  555. #    ifdef BACKLIGHT_ENABLE
  556.     backlight_level_noeeprom(0);
  557. #    endif
  559. #    ifdef LED_MATRIX_ENABLE
  560.     led_matrix_task();
  561. #    endif
  562. #    ifdef RGB_MATRIX_ENABLE
  563.     rgb_matrix_task();
  564. #    endif
  566.     // Turn off LED indicators
  567.     led_suspend();
  569. // Turn off audio
  570. #    ifdef AUDIO_ENABLE
  571.     stop_all_notes();
  572. #    endif
  574. // Turn off underglow
  575. #    if defined(RGBLIGHT_SLEEP) && defined(RGBLIGHT_ENABLE)
  576.     rgblight_suspend();
  577. #    endif
  579. #    if defined(LED_MATRIX_ENABLE)
  580.     led_matrix_set_suspend_state(true);
  581. #    endif
  582. #    if defined(RGB_MATRIX_ENABLE)
  583.     rgb_matrix_set_suspend_state(true);
  584. #    endif
  586. #    ifdef OLED_ENABLE
  587.     oled_off();
  588. #    endif
  589. #    ifdef ST7565_ENABLE
  590.     st7565_off();
  591. #    endif
  592. #    if defined(POINTING_DEVICE_ENABLE)
  593.     // run to ensure scanning occurs while suspended
  594.     pointing_device_task();
  595. #    endif
  596. #endif
  597. }
  599. __attribute__((weak)) void suspend_wakeup_init_quantum(void) {
  600. // Turn on backlight
  601. #ifdef BACKLIGHT_ENABLE
  602.     backlight_init();
  603. #endif
  605.     // Restore LED indicators
  606.     led_wakeup();
  608. // Wake up underglow
  609. #if defined(RGBLIGHT_SLEEP) && defined(RGBLIGHT_ENABLE)
  610.     rgblight_wakeup();
  611. #endif
  613. #if defined(LED_MATRIX_ENABLE)
  614.     led_matrix_set_suspend_state(false);
  615. #endif
  616. #if defined(RGB_MATRIX_ENABLE)
  617.     rgb_matrix_set_suspend_state(false);
  618. #endif
  619.     suspend_wakeup_init_modules();
  620.     suspend_wakeup_init_kb();
  621. }
  623. /** \brief converts unsigned integers into char arrays
  624.  *
  625.  * Takes an unsigned integer and converts that value into an equivalent char array
  626.  * A padding character may be specified, ' ' for leading spaces, '0' for leading zeros.
  627.  */
  629. const char *get_numeric_str(char *buf, size_t buf_len, uint32_t curr_num, char curr_pad) {
  630.     buf[buf_len - 1] = '\0';
  631.     for (size_t i = 0; i < buf_len - 1; ++i) {
  632.         char c               = '0' + curr_num % 10;
  633.         buf[buf_len - 2 - i] = (c == '0' && i == 0) ? '0' : (curr_num > 0 ? c : curr_pad);
  634.         curr_num /= 10;
  635.     }
  636.     return buf;
  637. }
  639. /** \brief converts uint8_t into char array
  640.  *
  641.  * Takes an uint8_t, and uses an internal static buffer to render that value into a char array
  642.  * A padding character may be specified, ' ' for leading spaces, '0' for leading zeros.
  643.  *
  644.  * NOTE: Subsequent invocations will reuse the same static buffer and overwrite the previous
  645.  *       contents. Use the result immediately, instead of caching it.
  646.  */
  647. const char *get_u8_str(uint8_t curr_num, char curr_pad) {
  648.     static char    buf[4]   = {0};
  649.     static uint8_t last_num = 0xFF;
  650.     static char    last_pad = '\0';
  651.     if (last_num == curr_num && last_pad == curr_pad) {
  652.         return buf;
  653.     }
  654.     last_num = curr_num;
  655.     last_pad = curr_pad;
  656.     return get_numeric_str(buf, sizeof(buf), curr_num, curr_pad);
  657. }
  659. /** \brief converts uint16_t into char array
  660.  *
  661.  * Takes an uint16_t, and uses an internal static buffer to render that value into a char array
  662.  * A padding character may be specified, ' ' for leading spaces, '0' for leading zeros.
  663.  *
  664.  * NOTE: Subsequent invocations will reuse the same static buffer and overwrite the previous
  665.  *       contents. Use the result immediately, instead of caching it.
  666.  */
  667. const char *get_u16_str(uint16_t curr_num, char curr_pad) {
  668.     static char     buf[6]   = {0};
  669.     static uint16_t last_num = 0xFF;
  670.     static char     last_pad = '\0';
  671.     if (last_num == curr_num && last_pad == curr_pad) {
  672.         return buf;
  673.     }
  674.     last_num = curr_num;
  675.     last_pad = curr_pad;
  676.     return get_numeric_str(buf, sizeof(buf), curr_num, curr_pad);
  677. }
  679. #if defined(SECURE_ENABLE)
  680. void secure_hook_quantum(secure_status_t secure_status) {
  681.     // If keys are being held when this is triggered, they may not be released properly
  682.     // this can result in stuck keys, mods and layers.  To prevent that, manually
  683.     // clear these, when it is triggered.
  685.     if (secure_status == SECURE_PENDING) {
  686.         clear_keyboard();
  687.         layer_clear();
  688.     }
  689. }
  690. #endif