action_layer.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209
  1. #include <stdint.h>
  2. #include "keyboard.h"
  3. #include "action.h"
  4. #include "util.h"
  5. #include "action_layer.h"
  6. #ifdef DEBUG_ACTION
  7. #include "debug.h"
  8. #else
  9. #include "nodebug.h"
  10. #endif
  11. /*
  12. * Default Layer State
  13. */
  14. uint32_t default_layer_state = 0;
  15. static void default_layer_state_set(uint32_t state)
  16. {
  17. debug("default_layer_state: ");
  18. default_layer_debug(); debug(" to ");
  19. default_layer_state = state;
  20. default_layer_debug(); debug("\n");
  21. clear_keyboard_but_mods(); // To avoid stuck keys
  22. }
  23. void default_layer_debug(void)
  24. {
  25. dprintf("%08lX(%u)", default_layer_state, biton32(default_layer_state));
  26. }
  27. void default_layer_set(uint32_t state)
  28. {
  29. default_layer_state_set(state);
  30. }
  31. #ifndef NO_ACTION_LAYER
  32. void default_layer_or(uint32_t state)
  33. {
  34. default_layer_state_set(default_layer_state | state);
  35. }
  36. void default_layer_and(uint32_t state)
  37. {
  38. default_layer_state_set(default_layer_state & state);
  39. }
  40. void default_layer_xor(uint32_t state)
  41. {
  42. default_layer_state_set(default_layer_state ^ state);
  43. }
  44. #endif
  45. #ifndef NO_ACTION_LAYER
  46. /*
  47. * Keymap Layer State
  48. */
  49. uint32_t layer_state = 0;
  50. __attribute__((weak))
  51. uint32_t layer_state_set_kb(uint32_t state) {
  52. return state;
  53. }
  54. static void layer_state_set(uint32_t state)
  55. {
  56. state = layer_state_set_kb(state);
  57. dprint("layer_state: ");
  58. layer_debug(); dprint(" to ");
  59. layer_state = state;
  60. layer_debug(); dprintln();
  61. clear_keyboard_but_mods(); // To avoid stuck keys
  62. }
  63. void layer_clear(void)
  64. {
  65. layer_state_set(0);
  66. }
  67. void layer_move(uint8_t layer)
  68. {
  69. layer_state_set(1UL<<layer);
  70. }
  71. void layer_on(uint8_t layer)
  72. {
  73. layer_state_set(layer_state | (1UL<<layer));
  74. }
  75. void layer_off(uint8_t layer)
  76. {
  77. layer_state_set(layer_state & ~(1UL<<layer));
  78. }
  79. void layer_invert(uint8_t layer)
  80. {
  81. layer_state_set(layer_state ^ (1UL<<layer));
  82. }
  83. void layer_or(uint32_t state)
  84. {
  85. layer_state_set(layer_state | state);
  86. }
  87. void layer_and(uint32_t state)
  88. {
  89. layer_state_set(layer_state & state);
  90. }
  91. void layer_xor(uint32_t state)
  92. {
  93. layer_state_set(layer_state ^ state);
  94. }
  95. void layer_debug(void)
  96. {
  97. dprintf("%08lX(%u)", layer_state, biton32(layer_state));
  98. }
  99. #endif
  100. #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
  101. uint8_t source_layers_cache[(MATRIX_ROWS * MATRIX_COLS + 7) / 8][MAX_LAYER_BITS] = {{0}};
  102. void update_source_layers_cache(keypos_t key, uint8_t layer)
  103. {
  104. const uint8_t key_number = key.col + (key.row * MATRIX_COLS);
  105. const uint8_t storage_row = key_number / 8;
  106. const uint8_t storage_bit = key_number % 8;
  107. for (uint8_t bit_number = 0; bit_number < MAX_LAYER_BITS; bit_number++) {
  108. source_layers_cache[storage_row][bit_number] ^=
  109. (-((layer & (1U << bit_number)) != 0)
  110. ^ source_layers_cache[storage_row][bit_number])
  111. & (1U << storage_bit);
  112. }
  113. }
  114. uint8_t read_source_layers_cache(keypos_t key)
  115. {
  116. const uint8_t key_number = key.col + (key.row * MATRIX_COLS);
  117. const uint8_t storage_row = key_number / 8;
  118. const uint8_t storage_bit = key_number % 8;
  119. uint8_t layer = 0;
  120. for (uint8_t bit_number = 0; bit_number < MAX_LAYER_BITS; bit_number++) {
  121. layer |=
  122. ((source_layers_cache[storage_row][bit_number]
  123. & (1U << storage_bit)) != 0)
  124. << bit_number;
  125. }
  126. return layer;
  127. }
  128. #endif
  129. /*
  130. * Make sure the action triggered when the key is released is the same
  131. * one as the one triggered on press. It's important for the mod keys
  132. * when the layer is switched after the down event but before the up
  133. * event as they may get stuck otherwise.
  134. */
  135. action_t store_or_get_action(bool pressed, keypos_t key)
  136. {
  137. #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
  138. if (disable_action_cache) {
  139. return layer_switch_get_action(key);
  140. }
  141. uint8_t layer;
  142. if (pressed) {
  143. layer = layer_switch_get_layer(key);
  144. update_source_layers_cache(key, layer);
  145. }
  146. else {
  147. layer = read_source_layers_cache(key);
  148. }
  149. return action_for_key(layer, key);
  150. #else
  151. return layer_switch_get_action(key);
  152. #endif
  153. }
  154. int8_t layer_switch_get_layer(keypos_t key)
  155. {
  156. action_t action;
  157. action.code = ACTION_TRANSPARENT;
  158. #ifndef NO_ACTION_LAYER
  159. uint32_t layers = layer_state | default_layer_state;
  160. /* check top layer first */
  161. for (int8_t i = 31; i >= 0; i--) {
  162. if (layers & (1UL<<i)) {
  163. action = action_for_key(i, key);
  164. if (action.code != ACTION_TRANSPARENT) {
  165. return i;
  166. }
  167. }
  168. }
  169. /* fall back to layer 0 */
  170. return 0;
  171. #else
  172. return biton32(default_layer_state);
  173. #endif
  174. }
  175. action_t layer_switch_get_action(keypos_t key)
  176. {
  177. return action_for_key(layer_switch_get_layer(key), key);
  178. }