API tools faq
paste
Guest User

Untitled

a guest
Jul 3rd, 2026
22
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 13.09 KB | Source Code | 0 0
raw download clone embed print report
  1. #include "qmk_settings.h"
  2.  
  3. #include <stddef.h>
  4. #include <string.h>
  5.  
  6. #include "progmem.h"
  7. #include "dynamic_keymap.h"
  8. #include "process_auto_shift.h"
  9. #include "mousekey.h"
  10. #include "process_combo.h"
  11. #include "action_tapping.h"
  12. #include "keycode_config.h"
  13.  
  14. static int eeprom_settings_get(const qmk_settings_proto_t *proto, void *setting, size_t maxsz);
  15. static int eeprom_settings_getbit(const qmk_settings_proto_t *proto, void *setting, size_t maxsz);
  16. static int eeprom_settings_set(const qmk_settings_proto_t *proto, const void *setting, size_t maxsz);
  17. static int eeprom_settings_setbit(const qmk_settings_proto_t *proto, const void *setting, size_t maxsz);
  18. static int magic_settings_get(const qmk_settings_proto_t *proto, void *setting, size_t maxsz);
  19. static int magic_settings_set(const qmk_settings_proto_t *proto, const void *setting, size_t maxsz);
  20.  
  21. qmk_settings_t QS;
  22.  
  23. #define DECLARE_SETTING_NOTIFY(id, _get, _set, _notify)  { .qsid=id, .get=_get, .set=_set, .notify=_notify }
  24. #define DECLARE_SETTING(id, _get, _set) DECLARE_SETTING_NOTIFY(id, _get, _set, NULL)
  25. #define DECLARE_STATIC_SETTING_NOTIFY(id, field, notify_)  { .qsid=id, .ptr=&QS.field, .sz=sizeof(QS.field), .get=eeprom_settings_get, .set=eeprom_settings_set, .notify=notify_ }
  26. #define DECLARE_STATIC_SETTING(id, field) DECLARE_STATIC_SETTING_NOTIFY(id, field, NULL)
  27. #define DECLARE_STATIC_BITSETTING(id, field, bit_) { .qsid=id, .ptr=&QS.field, .sz=sizeof(QS.field), .bit=bit_, .get=eeprom_settings_getbit, .set=eeprom_settings_setbit }
  28.  
  29. static void auto_shift_timeout_apply(void) {
  30.     set_autoshift_timeout(QS.auto_shift_timeout);
  31. }
  32.  
  33. #if defined(MOUSEKEY_ENABLE) && !defined(MK_3_SPEED)
  34. static void mousekey_apply(void) {
  35.     mk_delay = QS.mousekey_delay / 10;
  36.     mk_interval = QS.mousekey_interval;
  37.     mk_max_speed = QS.mousekey_max_speed;
  38.     mk_time_to_max = QS.mousekey_time_to_max;
  39.     mk_wheel_delay = QS.mousekey_wheel_delay / 10;
  40.     mk_wheel_interval    = QS.mousekey_wheel_interval;
  41.     mk_wheel_max_speed   = QS.mousekey_wheel_max_speed;
  42.     mk_wheel_time_to_max = QS.mousekey_wheel_time_to_max;
  43. }
  44. #endif
  45.  
  46. static const qmk_settings_proto_t protos[] PROGMEM = {
  47.    DECLARE_STATIC_SETTING(1, grave_esc_override),
  48.    DECLARE_STATIC_SETTING(2, combo_term),
  49.    DECLARE_STATIC_SETTING(3, auto_shift),
  50.    DECLARE_STATIC_SETTING_NOTIFY(4, auto_shift_timeout, auto_shift_timeout_apply),
  51.    DECLARE_STATIC_SETTING(5, osk_tap_toggle),
  52.    DECLARE_STATIC_SETTING(6, osk_timeout),
  53.    DECLARE_STATIC_SETTING(7, tapping_term),
  54. #if defined(MOUSEKEY_ENABLE) && !defined(MK_3_SPEED)
  55.    DECLARE_STATIC_SETTING_NOTIFY(9, mousekey_delay, mousekey_apply),
  56.    DECLARE_STATIC_SETTING_NOTIFY(10, mousekey_interval, mousekey_apply),
  57.    DECLARE_STATIC_SETTING_NOTIFY(11, mousekey_move_delta, mousekey_apply),
  58.    DECLARE_STATIC_SETTING_NOTIFY(12, mousekey_max_speed, mousekey_apply),
  59.    DECLARE_STATIC_SETTING_NOTIFY(13, mousekey_time_to_max, mousekey_apply),
  60.    DECLARE_STATIC_SETTING_NOTIFY(14, mousekey_wheel_delay, mousekey_apply),
  61.    DECLARE_STATIC_SETTING_NOTIFY(15, mousekey_wheel_interval, mousekey_apply),
  62.    DECLARE_STATIC_SETTING_NOTIFY(16, mousekey_wheel_max_speed, mousekey_apply),
  63.    DECLARE_STATIC_SETTING_NOTIFY(17, mousekey_wheel_time_to_max, mousekey_apply),
  64. #endif
  65.    DECLARE_STATIC_SETTING(18, tap_code_delay),
  66.    DECLARE_STATIC_SETTING(19, tap_hold_caps_delay),
  67.    DECLARE_STATIC_SETTING(20, tapping_toggle),
  68.    DECLARE_SETTING(21, magic_settings_get, magic_settings_set),
  69.    DECLARE_STATIC_BITSETTING(22, tapping_v2, QS_tapping_permissive_hold_bit),
  70.    DECLARE_STATIC_BITSETTING(23, tapping_v2, QS_tapping_hold_on_other_key_press_bit),
  71.    DECLARE_STATIC_BITSETTING(24, tapping_v2, QS_tapping_retro_tapping_bit),
  72.    DECLARE_STATIC_SETTING(25, quick_tap_term),
  73.    DECLARE_STATIC_BITSETTING(26, tapping_v2, QS_tapping_chordal_hold_bit),
  74.    DECLARE_STATIC_SETTING(27, flow_tap_term),
  75. };
  76.  
  77. static void eeprom_settings_load(void) {
  78.     for (size_t i = 0; i < sizeof(qmk_settings_t); ++i) {
  79.         uint8_t byte;
  80.         byte = dynamic_keymap_get_qmk_settings(i);
  81.         memcpy((char*)&QS + i, &byte, 1);
  82.     }
  83. }
  84.  
  85. static void eeprom_settings_save(void) {
  86.     for (size_t i = 0; i < sizeof(qmk_settings_t); ++i) {
  87.         uint8_t old_byte, new_byte;
  88.         old_byte = dynamic_keymap_get_qmk_settings(i);
  89.         memcpy(&new_byte, (char*)&QS + i, 1);
  90.         if (old_byte != new_byte)
  91.             dynamic_keymap_set_qmk_settings(i, new_byte);
  92.     }
  93. }
  94.  
  95. static int eeprom_settings_get(const qmk_settings_proto_t *proto, void *setting, size_t maxsz) {
  96.     uint8_t sz = pgm_read_byte(&proto->sz);
  97.     if (sz > maxsz)
  98.         return -1;
  99.     memcpy(setting, pgm_read_ptr(&proto->ptr), sz);
  100.     return 0;
  101. }
  102.  
  103. static int eeprom_settings_getbit(const qmk_settings_proto_t *proto, void *setting, size_t maxsz) {
  104.     uint8_t bit = pgm_read_byte(&proto->bit);
  105.     uint32_t encoded = 0;
  106.     if (maxsz < 1 || eeprom_settings_get(proto, &encoded, sizeof(encoded)) < 0)
  107.         return -1;
  108.     *(uint8_t*)setting = !!(encoded & (1 << bit));
  109.     return 0;
  110. }
  111.  
  112. static int eeprom_settings_set(const qmk_settings_proto_t *proto, const void *setting, size_t maxsz) {
  113.     uint8_t sz = pgm_read_byte(&proto->sz);
  114.     if (sz > maxsz)
  115.         return -1;
  116.     memcpy(pgm_read_ptr(&proto->ptr), setting, sz);
  117.     eeprom_settings_save();
  118.     return 0;
  119. }
  120.  
  121. static int eeprom_settings_setbit(const qmk_settings_proto_t *proto, const void *setting, size_t maxsz) {
  122.     uint8_t bit = pgm_read_byte(&proto->bit);
  123.     uint32_t encoded = 0;
  124.     if (maxsz < 1 || eeprom_settings_get(proto, &encoded, sizeof(encoded)) < 0)
  125.         return -1;
  126.     encoded &= ~(1 << bit);
  127.     encoded |= (((*(uint8_t*)setting) & 1) << bit);
  128.     return eeprom_settings_set(proto, &encoded, sizeof(encoded));
  129. }
  130.  
  131. static int magic_settings_get(const qmk_settings_proto_t *proto, void *setting, size_t maxsz) {
  132.     uint32_t flags;
  133.  
  134.     if (maxsz < sizeof(flags))
  135.         return -1;
  136.  
  137.     flags = \
  138.         (keymap_config.swap_control_capslock << 0) |
  139.         (keymap_config.capslock_to_control << 1) |
  140.         (keymap_config.swap_lalt_lgui << 2) |
  141.         (keymap_config.swap_ralt_rgui << 3) |
  142.         (keymap_config.no_gui << 4) |
  143.         (keymap_config.swap_grave_esc << 5) |
  144.         (keymap_config.swap_backslash_backspace << 6) |
  145.         (keymap_config.nkro << 7) |
  146.         (keymap_config.swap_lctl_lgui << 8) |
  147.         (keymap_config.swap_rctl_rgui << 9) |
  148.         0;
  149.  
  150.     memcpy(setting, &flags, sizeof(flags));
  151.     return 0;
  152. }
  153.  
  154. static int magic_settings_set(const qmk_settings_proto_t *proto, const void *setting, size_t maxsz) {
  155.     uint32_t flags;
  156.  
  157.     if (maxsz < sizeof(flags))
  158.         return -1;
  159.  
  160.     memcpy(&flags, setting, sizeof(flags));
  161.  
  162.     /* must call clear_keyboard for the NKRO setting to not cause stuck keys */
  163.     clear_keyboard();
  164.     keymap_config.swap_control_capslock = !!(flags & (1 << 0));
  165.     keymap_config.capslock_to_control = !!(flags & (1 << 1));
  166.     keymap_config.swap_lalt_lgui = !!(flags & (1 << 2));
  167.     keymap_config.swap_ralt_rgui = !!(flags & (1 << 3));
  168.     keymap_config.no_gui = !!(flags & (1 << 4));
  169.     keymap_config.swap_grave_esc = !!(flags & (1 << 5));
  170.     keymap_config.swap_backslash_backspace = !!(flags & (1 << 6));
  171.     keymap_config.nkro = !!(flags & (1 << 7));
  172.     keymap_config.swap_lctl_lgui = !!(flags & (1 << 8));
  173.     keymap_config.swap_rctl_rgui = !!(flags & (1 << 9));
  174.     eeconfig_update_keymap(&keymap_config);
  175.  
  176.     return 0;
  177. }
  178.  
  179. void qmk_settings_init(void) {
  180.     eeprom_settings_load();
  181.     /* execute all callbacks to initialize the settings */
  182.     for (size_t i = 0; i < sizeof(protos)/sizeof(*protos); ++i) {
  183.         const qmk_settings_proto_t *proto = &protos[i];
  184.         qmk_settings_notify_t notify = pgm_read_ptr(&proto->notify);
  185.         if (notify)
  186.             notify();
  187.     }
  188. }
  189.  
  190. void qmk_settings_reset(void) {
  191.     QS.grave_esc_override = 0;
  192.     QS.auto_shift = 0;
  193.     QS.auto_shift_timeout = AUTO_SHIFT_TIMEOUT;
  194.     QS.osk_tap_toggle = ONESHOT_TAP_TOGGLE;
  195.     QS.osk_timeout = ONESHOT_TIMEOUT;
  196.  
  197. #if defined(MOUSEKEY_ENABLE) && !defined(MK_3_SPEED)
  198.     QS.mousekey_delay = MOUSEKEY_DELAY;
  199.     QS.mousekey_interval = MOUSEKEY_INTERVAL;
  200.     QS.mousekey_move_delta = MOUSEKEY_MOVE_DELTA;
  201.     QS.mousekey_max_speed = MOUSEKEY_MAX_SPEED;
  202.     QS.mousekey_time_to_max = MOUSEKEY_TIME_TO_MAX;
  203.     QS.mousekey_wheel_delay = MOUSEKEY_WHEEL_DELAY;
  204.     QS.mousekey_wheel_interval = MOUSEKEY_WHEEL_INTERVAL;
  205.     QS.mousekey_wheel_max_speed = MOUSEKEY_WHEEL_MAX_SPEED;
  206.     QS.mousekey_wheel_time_to_max = MOUSEKEY_WHEEL_TIME_TO_MAX;
  207. #endif
  208.  
  209.     QS.combo_term = COMBO_TERM;
  210.     QS.tapping_term = TAPPING_TERM;
  211.     QS.tapping_v2 = 0;
  212. #ifdef PERMISSIVE_HOLD
  213.     QS.tapping_v2 |= (1 << QS_tapping_permissive_hold_bit);
  214. #endif
  215. #ifdef HOLD_ON_OTHER_KEY_PRESS
  216.     QS.tapping_v2 |= (1 << QS_tapping_hold_on_other_key_press_bit);
  217. #endif
  218. #ifdef RETRO_TAPPING
  219.     QS.tapping_v2 |= (1 << QS_tapping_retro_tapping_bit);
  220. #endif
  221. #ifdef CHORDAL_HOLD
  222.     QS.tapping_v2 |= (1 << QS_tapping_chordal_hold_bit);
  223. #endif
  224.     QS.quick_tap_term = QUICK_TAP_TERM;
  225.     QS.tap_code_delay = TAP_CODE_DELAY;
  226.     QS.tap_hold_caps_delay = TAP_HOLD_CAPS_DELAY;
  227.     QS.tapping_toggle = TAPPING_TOGGLE;
  228.     QS.flow_tap_term = 0;
  229.  
  230.     eeprom_settings_save();
  231.  
  232.     /* must call clear_keyboard for the NKRO setting to not cause stuck keys */
  233.     clear_keyboard();
  234.     keymap_config.raw = 0;
  235.     keymap_config.oneshot_enable = 1;
  236.     keymap_config.nkro = NKRO_DEFAULT_ON;
  237. #ifdef AUTOCORRECT_ENABLE
  238.     keymap_config.autocorrect_enable = true;
  239. #endif
  240.     eeconfig_update_keymap(&keymap_config);
  241.  
  242.     /* to trigger all callbacks */
  243.     qmk_settings_init();
  244. }
  245.  
  246. void qmk_settings_query(uint16_t qsid_gt, void *buffer, size_t sz) {
  247.     /* set all FFs, so caller can identify when all settings are retrieved by looking for an 0xFFFF entry */
  248.     memset(buffer, 0xFF, sz);
  249.  
  250.     size_t buffer_offset = 0;
  251.     for (size_t i = 0; i < sizeof(protos)/sizeof(*protos); ++i) {
  252.         uint16_t qsid;
  253.  
  254.         /* if output buffer has no space left, bail out */
  255.         if (buffer_offset + sizeof(qsid) > sz)
  256.             break;
  257.  
  258.         qsid = pgm_read_word(&protos[i].qsid);
  259.         if (qsid > qsid_gt) {
  260.             memcpy((char*)buffer + buffer_offset, &qsid, sizeof(qsid));
  261.             buffer_offset += sizeof(qsid);
  262.         }
  263.     }
  264. }
  265.  
  266. static const qmk_settings_proto_t *find_setting(uint16_t qsid) {
  267.     for (size_t i = 0; i < sizeof(protos)/sizeof(*protos); ++i)
  268.         if (pgm_read_word(&protos[i].qsid) == qsid)
  269.             return &protos[i];
  270.     return NULL;
  271. }
  272.  
  273. int qmk_settings_get(uint16_t qsid, void *setting, size_t maxsz) {
  274.     const qmk_settings_proto_t *proto = find_setting(qsid);
  275.     if (!proto)
  276.         return -1;
  277.  
  278.     qmk_settings_get_t get = pgm_read_ptr(&proto->get);
  279.     if (!get)
  280.         return -1;
  281.  
  282.     return get(proto, setting, maxsz);
  283. }
  284.  
  285. int qmk_settings_set(uint16_t qsid, const void *setting, size_t maxsz) {
  286.     const qmk_settings_proto_t *proto = find_setting(qsid);
  287.     if (!proto)
  288.         return -1;
  289.  
  290.     qmk_settings_set_t set = pgm_read_ptr(&proto->set);
  291.     if (!set)
  292.         return -1;
  293.  
  294.     int ret = set(proto, setting, maxsz);
  295.     if (ret != 0)
  296.         return ret;
  297.  
  298.     qmk_settings_notify_t notify = pgm_read_ptr(&proto->notify);
  299.     if (notify)
  300.         notify();
  301.     return 0;
  302. }
  303.  
  304. uint16_t qs_get_tapping_term(uint16_t keycode, keyrecord_t *record) {
  305.     return QS.tapping_term;
  306. }
  307.  
  308. bool get_permissive_hold(uint16_t keycode, keyrecord_t *record) {
  309.     return QS_tapping_permissive_hold;
  310. }
  311.  
  312. bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) {
  313.     return QS_tapping_hold_on_other_key_press;
  314. }
  315.  
  316. uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record) {
  317.     return QS.quick_tap_term;
  318. }
  319.  
  320. bool get_retro_tapping(uint16_t keycode, keyrecord_t *record) {
  321.     return QS_tapping_retro_tapping;
  322. }
  323.  
  324. uint16_t get_combo_term(uint16_t index, combo_t *combo) {
  325.     return QS.combo_term;
  326. }
  327.  
  328. bool get_auto_shifted_key(uint16_t keycode, keyrecord_t *record) {
  329.     switch (keycode) {
  330.         case AUTO_SHIFT_ALPHA:
  331.             if (!QS_auto_shift_no_auto_shift_alpha) return true;
  332.             break;
  333.         case AUTO_SHIFT_NUMERIC:
  334.             if (!QS_auto_shift_no_auto_shift_numeric) return true;
  335.             break;
  336.         case AUTO_SHIFT_SPECIAL:
  337.             if (!QS_auto_shift_no_auto_shift_special) return true;
  338.             break;
  339.     }
  340.     return false;
  341. }
  342.  
  343. bool get_auto_shift_repeat(uint16_t keycode, keyrecord_t *record) {
  344.     return QS_auto_shift_repeat;
  345. }
  346.  
  347. bool get_auto_shift_no_auto_repeat(uint16_t keycode, keyrecord_t *record) {
  348.     return QS_auto_shift_no_auto_repeat;
  349. }
  350.  
  351. bool get_chordal_hold(uint16_t tap_hold_keycode, keyrecord_t* tap_hold_record,
  352.                       uint16_t other_keycode, keyrecord_t* other_record) {
  353.     if (QS_tapping_chordal_hold)
  354.         return get_chordal_hold_default(tap_hold_record, other_record);
  355.     return true;
  356. }
  357.  
  358. uint16_t get_flow_tap_term(uint16_t keycode, keyrecord_t *record, uint16_t prev_keycode) {
  359.     if (is_flow_tap_key(keycode) && is_flow_tap_key(prev_keycode)) {
  360.         return QS.flow_tap_term;
  361.     }
  362.     return 0;
  363. }
  364.  
Tags: QMK
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!