logo

qmk_firmware

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

action_layer.c (11215B)

    

  1. #include <limits.h>
  2. #include <stdint.h>
  4. #include "keyboard.h"
  5. #include "action.h"
  6. #include "encoder.h"
  7. #include "util.h"
  8. #include "action_layer.h"
  10. /** \brief Default Layer State
  11.  */
  12. layer_state_t default_layer_state = 0;
  14. /** \brief Default Layer State Set At user Level
  15.  *
  16.  * Run user code on default layer state change
  17.  */
  18. __attribute__((weak)) layer_state_t default_layer_state_set_user(layer_state_t state) {
  19.     return state;
  20. }
  22. /** \brief Default Layer State Set At Keyboard Level
  23.  *
  24.  *  Run keyboard code on default layer state change
  25.  */
  26. __attribute__((weak)) layer_state_t default_layer_state_set_kb(layer_state_t state) {
  27.     return default_layer_state_set_user(state);
  28. }
  30. /** \brief Default Layer State Set At Module Level
  31.  *
  32.  * Run module code on default layer state change
  33.  */
  34. __attribute__((weak)) layer_state_t default_layer_state_set_modules(layer_state_t state) {
  35.     return state;
  36. }
  38. /** \brief Default Layer State Set
  39.  *
  40.  * Static function to set the default layer state, prints debug info and clears keys
  41.  */
  42. static void default_layer_state_set(layer_state_t state) {
  43.     state = default_layer_state_set_modules(state);
  44.     state = default_layer_state_set_kb(state);
  45.     ac_dprintf("default_layer_state: ");
  46.     default_layer_debug();
  47.     ac_dprintf(" to ");
  48.     default_layer_state = state;
  49.     default_layer_debug();
  50.     ac_dprintf("\n");
  51. #if defined(STRICT_LAYER_RELEASE)
  52.     clear_keyboard_but_mods(); // To avoid stuck keys
  53. #elif defined(SEMI_STRICT_LAYER_RELEASE)
  54.     clear_keyboard_but_mods_and_keys(); // Don't reset held keys
  55. #endif
  56. }
  58. /** \brief Default Layer Print
  59.  *
  60.  * Print out the hex value of the 32-bit default layer state, as well as the value of the highest bit.
  61.  */
  62. void default_layer_debug(void) {
  63.     ac_dprintf("%08hX(%u)", default_layer_state, get_highest_layer(default_layer_state));
  64. }
  66. /** \brief Default Layer Set
  67.  *
  68.  * Sets the default layer state.
  69.  */
  70. void default_layer_set(layer_state_t state) {
  71.     default_layer_state_set(state);
  72. }
  74. #ifndef NO_ACTION_LAYER
  75. /** \brief Default Layer Or
  76.  *
  77.  * Turns on the default layer based on matching bits between specified layer and existing layer state
  78.  */
  79. void default_layer_or(layer_state_t state) {
  80.     default_layer_state_set(default_layer_state | state);
  81. }
  82. /** \brief Default Layer And
  83.  *
  84.  * Turns on default layer based on matching enabled bits between specified layer and existing layer state
  85.  */
  86. void default_layer_and(layer_state_t state) {
  87.     default_layer_state_set(default_layer_state & state);
  88. }
  89. /** \brief Default Layer Xor
  90.  *
  91.  * Turns on default layer based on non-matching bits between specified layer and existing layer state
  92.  */
  93. void default_layer_xor(layer_state_t state) {
  94.     default_layer_state_set(default_layer_state ^ state);
  95. }
  96. #endif
  98. #ifndef NO_ACTION_LAYER
  99. /** \brief Keymap Layer State
  100.  */
  101. layer_state_t layer_state = 0;
  103. /** \brief Layer state set user
  104.  *
  105.  * Runs user code on layer state change
  106.  */
  107. __attribute__((weak)) layer_state_t layer_state_set_user(layer_state_t state) {
  108.     return state;
  109. }
  111. /** \brief Layer state set keyboard
  112.  *
  113.  * Runs keyboard code on layer state change
  114.  */
  115. __attribute__((weak)) layer_state_t layer_state_set_kb(layer_state_t state) {
  116.     return layer_state_set_user(state);
  117. }
  119. /** \brief Layer state set modules
  120.  *
  121.  * Runs module code on layer state change
  122.  */
  124. __attribute__((weak)) layer_state_t layer_state_set_modules(layer_state_t state) {
  125.     return state;
  126. }
  128. /** \brief Layer state set
  129.  *
  130.  * Sets the layer to match the specified state (a bitmask)
  131.  */
  132. void layer_state_set(layer_state_t state) {
  133.     state = layer_state_set_modules(state);
  134.     state = layer_state_set_kb(state);
  135.     ac_dprintf("layer_state: ");
  136.     layer_debug();
  137.     ac_dprintf(" to ");
  138.     layer_state = state;
  139.     layer_debug();
  140.     ac_dprintf("\n");
  141. #    if defined(STRICT_LAYER_RELEASE)
  142.     clear_keyboard_but_mods(); // To avoid stuck keys
  143. #    elif defined(SEMI_STRICT_LAYER_RELEASE)
  144.     clear_keyboard_but_mods_and_keys(); // Don't reset held keys
  145. #    endif
  146. }
  148. /** \brief Layer clear
  149.  *
  150.  * Turn off all layers
  151.  */
  152. void layer_clear(void) {
  153.     layer_state_set(0);
  154. }
  156. /** \brief Layer state is
  157.  *
  158.  * Return whether the given state is on (it might still be shadowed by a higher state, though)
  159.  */
  160. bool layer_state_is(uint8_t layer) {
  161.     return layer_state_cmp(layer_state, layer);
  162. }
  164. /** \brief Layer state compare
  165.  *
  166.  * Used for comparing layers {mostly used for unit testing}
  167.  */
  168. bool layer_state_cmp(layer_state_t cmp_layer_state, uint8_t layer) {
  169.     if (!cmp_layer_state) {
  170.         return layer == 0;
  171.     }
  172.     return (cmp_layer_state & ((layer_state_t)1 << layer)) != 0;
  173. }
  175. /** \brief Layer move
  176.  *
  177.  * Turns on the given layer and turn off all other layers
  178.  */
  179. void layer_move(uint8_t layer) {
  180.     layer_state_set((layer_state_t)1 << layer);
  181. }
  183. /** \brief Layer on
  184.  *
  185.  * Turns on given layer
  186.  */
  187. void layer_on(uint8_t layer) {
  188.     layer_state_set(layer_state | ((layer_state_t)1 << layer));
  189. }
  191. /** \brief Layer off
  192.  *
  193.  * Turns off given layer
  194.  */
  195. void layer_off(uint8_t layer) {
  196.     layer_state_set(layer_state & ~((layer_state_t)1 << layer));
  197. }
  199. /** \brief Layer invert
  200.  *
  201.  * Toggle the given layer (set it if it's unset, or unset it if it's set)
  202.  */
  203. void layer_invert(uint8_t layer) {
  204.     layer_state_set(layer_state ^ ((layer_state_t)1 << layer));
  205. }
  207. /** \brief Layer or
  208.  *
  209.  * Turns on layers based on matching bits between specified layer and existing layer state
  210.  */
  211. void layer_or(layer_state_t state) {
  212.     layer_state_set(layer_state | state);
  213. }
  214. /** \brief Layer and
  215.  *
  216.  * Turns on layers based on matching enabled bits between specified layer and existing layer state
  217.  */
  218. void layer_and(layer_state_t state) {
  219.     layer_state_set(layer_state & state);
  220. }
  221. /** \brief Layer xor
  222.  *
  223.  * Turns on layers based on non-matching bits between specified layer and existing layer state
  224.  */
  225. void layer_xor(layer_state_t state) {
  226.     layer_state_set(layer_state ^ state);
  227. }
  229. /** \brief Layer debug printing
  230.  *
  231.  * Print out the hex value of the 32-bit layer state, as well as the value of the highest bit.
  232.  */
  233. void layer_debug(void) {
  234.     ac_dprintf("%08hX(%u)", layer_state, get_highest_layer(layer_state));
  235. }
  236. #endif
  238. #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
  239. /** \brief source layer cache
  240.  */
  242. uint8_t source_layers_cache[((MATRIX_ROWS * MATRIX_COLS) + (CHAR_BIT)-1) / (CHAR_BIT)][MAX_LAYER_BITS] = {{0}};
  243. #    ifdef ENCODER_MAP_ENABLE
  244. uint8_t encoder_source_layers_cache[(NUM_ENCODERS + (CHAR_BIT)-1) / (CHAR_BIT)][MAX_LAYER_BITS] = {{0}};
  245. #    endif // ENCODER_MAP_ENABLE
  247. /** \brief update source layers cache impl
  248.  *
  249.  * Updates the supplied cache when changing layers
  250.  */
  251. void update_source_layers_cache_impl(uint8_t layer, uint16_t entry_number, uint8_t cache[][MAX_LAYER_BITS]) {
  252.     const uint16_t storage_idx = entry_number / (CHAR_BIT);
  253.     const uint8_t  storage_bit = entry_number % (CHAR_BIT);
  254.     for (uint8_t bit_number = 0; bit_number < MAX_LAYER_BITS; bit_number++) {
  255.         cache[storage_idx][bit_number] ^= (-((layer & (1U << bit_number)) != 0) ^ cache[storage_idx][bit_number]) & (1U << storage_bit);
  256.     }
  257. }
  259. /** \brief read source layers cache
  260.  *
  261.  * reads the cached keys stored when the layer was changed
  262.  */
  263. uint8_t read_source_layers_cache_impl(uint16_t entry_number, uint8_t cache[][MAX_LAYER_BITS]) {
  264.     const uint16_t storage_idx = entry_number / (CHAR_BIT);
  265.     const uint8_t  storage_bit = entry_number % (CHAR_BIT);
  266.     uint8_t        layer       = 0;
  268.     for (uint8_t bit_number = 0; bit_number < MAX_LAYER_BITS; bit_number++) {
  269.         layer |= ((cache[storage_idx][bit_number] & (1U << storage_bit)) != 0) << bit_number;
  270.     }
  272.     return layer;
  273. }
  275. /** \brief update encoder source layers cache
  276.  *
  277.  * Updates the cached encoders when changing layers
  278.  */
  279. void update_source_layers_cache(keypos_t key, uint8_t layer) {
  280.     if (key.row < MATRIX_ROWS && key.col < MATRIX_COLS) {
  281.         const uint16_t entry_number = (uint16_t)(key.row * MATRIX_COLS) + key.col;
  282.         update_source_layers_cache_impl(layer, entry_number, source_layers_cache);
  283.     }
  284. #    ifdef ENCODER_MAP_ENABLE
  285.     else if (key.row == KEYLOC_ENCODER_CW || key.row == KEYLOC_ENCODER_CCW) {
  286.         const uint16_t entry_number = key.col;
  287.         update_source_layers_cache_impl(layer, entry_number, encoder_source_layers_cache);
  288.     }
  289. #    endif // ENCODER_MAP_ENABLE
  290. }
  292. /** \brief read source layers cache
  293.  *
  294.  * reads the cached keys stored when the layer was changed
  295.  */
  296. uint8_t read_source_layers_cache(keypos_t key) {
  297.     if (key.row < MATRIX_ROWS && key.col < MATRIX_COLS) {
  298.         const uint16_t entry_number = (uint16_t)(key.row * MATRIX_COLS) + key.col;
  299.         return read_source_layers_cache_impl(entry_number, source_layers_cache);
  300.     }
  301. #    ifdef ENCODER_MAP_ENABLE
  302.     else if (key.row == KEYLOC_ENCODER_CW || key.row == KEYLOC_ENCODER_CCW) {
  303.         const uint16_t entry_number = key.col;
  304.         return read_source_layers_cache_impl(entry_number, encoder_source_layers_cache);
  305.     }
  306. #    endif // ENCODER_MAP_ENABLE
  307.     return 0;
  308. }
  309. #endif
  311. /** \brief Store or get action (FIXME: Needs better summary)
  312.  *
  313.  * Make sure the action triggered when the key is released is the same
  314.  * one as the one triggered on press. It's important for the mod keys
  315.  * when the layer is switched after the down event but before the up
  316.  * event as they may get stuck otherwise.
  317.  */
  318. action_t store_or_get_action(bool pressed, keypos_t key) {
  319. #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
  320.     if (disable_action_cache) {
  321.         return layer_switch_get_action(key);
  322.     }
  324.     uint8_t layer;
  326.     if (pressed) {
  327.         layer = layer_switch_get_layer(key);
  328.         update_source_layers_cache(key, layer);
  329.     } else {
  330.         layer = read_source_layers_cache(key);
  331.     }
  332.     return action_for_key(layer, key);
  333. #else
  334.     return layer_switch_get_action(key);
  335. #endif
  336. }
  338. /** \brief Layer switch get layer
  339.  *
  340.  * Gets the layer based on key info
  341.  */
  342. uint8_t layer_switch_get_layer(keypos_t key) {
  343. #ifndef NO_ACTION_LAYER
  344.     action_t action;
  345.     action.code = ACTION_TRANSPARENT;
  347.     layer_state_t layers = layer_state | default_layer_state;
  348.     /* check top layer first */
  349.     for (int8_t i = MAX_LAYER - 1; i >= 0; i--) {
  350.         if (layers & ((layer_state_t)1 << i)) {
  351.             action = action_for_key(i, key);
  352.             if (action.code != ACTION_TRANSPARENT) {
  353.                 return i;
  354.             }
  355.         }
  356.     }
  357.     /* fall back to layer 0 */
  358.     return 0;
  359. #else
  360.     return get_highest_layer(default_layer_state);
  361. #endif
  362. }
  364. /** \brief Layer switch get layer
  365.  *
  366.  * Gets action code based on key position
  367.  */
  368. action_t layer_switch_get_action(keypos_t key) {
  369.     return action_for_key(layer_switch_get_layer(key), key);
  370. }
  372. #ifndef NO_ACTION_LAYER
  373. layer_state_t update_tri_layer_state(layer_state_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
  374.     layer_state_t mask12 = ((layer_state_t)1 << layer1) | ((layer_state_t)1 << layer2);
  375.     layer_state_t mask3  = (layer_state_t)1 << layer3;
  376.     return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
  377. }
  379. void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
  380.     layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
  381. }
  382. #endif