tmk_core/common/action_layer.c

   1 #include <stdint.h>
   2 #include "keyboard.h"
   3 #include "action.h"
   4 #include "util.h"
   5 #include "action_layer.h"
   6
   7 #ifdef DEBUG_ACTION
   8 #include "debug.h"
   9 #else
  10 #include "nodebug.h"
  11 #endif
  12
  13
  14 /** \brief Default Layer State
  15  */
  16 uint32_t default_layer_state = 0;
  17
  18 /** \brief Default Layer State Set At user Level
  19  *
  20  * FIXME: Needs docs
  21  */
  22 __attribute__((weak))
  23 uint32_t default_layer_state_set_user(uint32_t state) {
  24     return state;
  25 }
  26
  27 /** \brief Default Layer State Set At Keyboard Level
  28  *
  29  * FIXME: Needs docs
  30  */
  31 __attribute__((weak))
  32 uint32_t default_layer_state_set_kb(uint32_t state) {
  33     return default_layer_state_set_user(state);
  34 }
  35
  36 /** \brief Default Layer State Set
  37  *
  38  * FIXME: Needs docs
  39  */
  40 static void default_layer_state_set(uint32_t state)
  41 {
  42     state = default_layer_state_set_kb(state);
  43     debug("default_layer_state: ");
  44     default_layer_debug(); debug(" to ");
  45     default_layer_state = state;
  46     default_layer_debug(); debug("\n");
  47 #ifdef STRICT_LAYER_RELEASE
  48     clear_keyboard_but_mods(); // To avoid stuck keys
  49 #else
  50     clear_keyboard_but_mods_and_keys(); // Don't reset held keys
  51 #endif
  52 }
  53
  54 /** \brief Default Layer Print
  55  *
  56  * FIXME: Needs docs
  57  */
  58 void default_layer_debug(void)
  59 {
  60     dprintf("%08lX(%u)", default_layer_state, biton32(default_layer_state));
  61 }
  62
  63 /** \brief Default Layer Set
  64  *
  65  * FIXME: Needs docs
  66  */
  67 void default_layer_set(uint32_t state)
  68 {
  69     default_layer_state_set(state);
  70 }
  71
  72 #ifndef NO_ACTION_LAYER
  73 /** \brief Default Layer Or
  74  *
  75  * FIXME: Needs docs
  76  */
  77 void default_layer_or(uint32_t state)
  78 {
  79     default_layer_state_set(default_layer_state | state);
  80 }
  81 /** \brief Default Layer And
  82  *
  83  * FIXME: Needs docs
  84  */
  85 void default_layer_and(uint32_t state)
  86 {
  87     default_layer_state_set(default_layer_state & state);
  88 }
  89 /** \brief Default Layer Xor
  90  *
  91  * FIXME: Needs docs
  92  */
  93 void default_layer_xor(uint32_t state)
  94 {
  95     default_layer_state_set(default_layer_state ^ state);
  96 }
  97 #endif
  98
  99
 100 #ifndef NO_ACTION_LAYER
 101 /** \brief Keymap Layer State
 102  */
 103 uint32_t layer_state = 0;
 104
 105 /** \brief Layer state set user
 106  *
 107  * FIXME: Needs docs
 108  */
 109 __attribute__((weak))
 110 uint32_t layer_state_set_user(uint32_t state) {
 111     return state;
 112 }
 113
 114 /** \brief Layer state set keyboard
 115  *
 116  * FIXME: Needs docs
 117  */
 118 __attribute__((weak))
 119 uint32_t layer_state_set_kb(uint32_t state) {
 120     return layer_state_set_user(state);
 121 }
 122
 123 /** \brief Layer state set
 124  *
 125  * FIXME: Needs docs
 126  */
 127 void layer_state_set(uint32_t state)
 128 {
 129     state = layer_state_set_kb(state);
 130     dprint("layer_state: ");
 131     layer_debug(); dprint(" to ");
 132     layer_state = state;
 133     layer_debug(); dprintln();
 134 #ifdef STRICT_LAYER_RELEASE
 135     clear_keyboard_but_mods(); // To avoid stuck keys
 136 #else
 137     clear_keyboard_but_mods_and_keys(); // Don't reset held keys
 138 #endif
 139 }
 140
 141 /** \brief Layer clear
 142  *
 143  * FIXME: Needs docs
 144  */
 145 void layer_clear(void)
 146 {
 147     layer_state_set(0);
 148 }
 149
 150 /** \brief Layer state is
 151  *
 152  * FIXME: Needs docs
 153  */
 154 bool layer_state_is(uint8_t layer)
 155 {
 156     return layer_state_cmp(layer_state, layer);
 157 }
 158
 159 /** \brief Layer state compare
 160  *
 161  * FIXME: Needs docs
 162  */
 163 bool layer_state_cmp(uint32_t cmp_layer_state, uint8_t layer) {
 164     if (!cmp_layer_state) { return layer == 0; }
 165     return (cmp_layer_state & (1UL<<layer)) != 0;
 166 }
 167
 168 /** \brief Layer move
 169  *
 170  * FIXME: Needs docs
 171  */
 172 void layer_move(uint8_t layer)
 173 {
 174     layer_state_set(1UL<<layer);
 175 }
 176
 177 /** \brief Layer on
 178  *
 179  * FIXME: Needs docs
 180  */
 181 void layer_on(uint8_t layer)
 182 {
 183     layer_state_set(layer_state | (1UL<<layer));
 184 }
 185
 186 /** \brief Layer off
 187  *
 188  * FIXME: Needs docs
 189  */
 190 void layer_off(uint8_t layer)
 191 {
 192     layer_state_set(layer_state & ~(1UL<<layer));
 193 }
 194
 195 /** \brief Layer invert
 196  *
 197  * FIXME: Needs docs
 198  */
 199 void layer_invert(uint8_t layer)
 200 {
 201     layer_state_set(layer_state ^ (1UL<<layer));
 202 }
 203
 204 /** \brief Layer or
 205  *
 206  * FIXME: Needs docs
 207  */
 208 void layer_or(uint32_t state)
 209 {
 210     layer_state_set(layer_state | state);
 211 }
 212 /** \brief Layer and
 213  *
 214  * FIXME: Needs docs
 215  */
 216 void layer_and(uint32_t state)
 217 {
 218     layer_state_set(layer_state & state);
 219 }
 220 /** \brief Layer xor
 221  *
 222  * FIXME: Needs docs
 223  */
 224 void layer_xor(uint32_t state)
 225 {
 226     layer_state_set(layer_state ^ state);
 227 }
 228
 229 /** \brief Layer debug printing
 230  *
 231  * FIXME: Needs docs
 232  */
 233 void layer_debug(void)
 234 {
 235     dprintf("%08lX(%u)", layer_state, biton32(layer_state));
 236 }
 237 #endif
 238
 239 #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
 240 uint8_t source_layers_cache[(MATRIX_ROWS * MATRIX_COLS + 7) / 8][MAX_LAYER_BITS] = {{0}};
 241
 242 void update_source_layers_cache(keypos_t key, uint8_t layer)
 243 {
 244     const uint8_t key_number = key.col + (key.row * MATRIX_COLS);
 245     const uint8_t storage_row = key_number / 8;
 246     const uint8_t storage_bit = key_number % 8;
 247
 248     for (uint8_t bit_number = 0; bit_number < MAX_LAYER_BITS; bit_number++) {
 249         source_layers_cache[storage_row][bit_number] ^=
 250             (-((layer & (1U << bit_number)) != 0)
 251              ^ source_layers_cache[storage_row][bit_number])
 252             & (1U << storage_bit);
 253     }
 254 }
 255
 256 uint8_t read_source_layers_cache(keypos_t key)
 257 {
 258     const uint8_t key_number = key.col + (key.row * MATRIX_COLS);
 259     const uint8_t storage_row = key_number / 8;
 260     const uint8_t storage_bit = key_number % 8;
 261     uint8_t layer = 0;
 262
 263     for (uint8_t bit_number = 0; bit_number < MAX_LAYER_BITS; bit_number++) {
 264         layer |=
 265             ((source_layers_cache[storage_row][bit_number]
 266               & (1U << storage_bit)) != 0)
 267             << bit_number;
 268     }
 269
 270     return layer;
 271 }
 272 #endif
 273
 274 /** \brief Store or get action (FIXME: Needs better summary)
 275  *
 276  * Make sure the action triggered when the key is released is the same
 277  * one as the one triggered on press. It's important for the mod keys
 278  * when the layer is switched after the down event but before the up
 279  * event as they may get stuck otherwise.
 280  */
 281 action_t store_or_get_action(bool pressed, keypos_t key)
 282 {
 283 #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
 284     if (disable_action_cache) {
 285         return layer_switch_get_action(key);
 286     }
 287
 288     uint8_t layer;
 289
 290     if (pressed) {
 291         layer = layer_switch_get_layer(key);
 292         update_source_layers_cache(key, layer);
 293     }
 294     else {
 295         layer = read_source_layers_cache(key);
 296     }
 297     return action_for_key(layer, key);
 298 #else
 299     return layer_switch_get_action(key);
 300 #endif
 301 }
 302
 303
 304 /** \brief Layer switch get layer
 305  *
 306  * FIXME: Needs docs
 307  */
 308 int8_t layer_switch_get_layer(keypos_t key)
 309 {
 310 #ifndef NO_ACTION_LAYER
 311     action_t action;
 312     action.code = ACTION_TRANSPARENT;
 313
 314     uint32_t layers = layer_state | default_layer_state;
 315     /* check top layer first */
 316     for (int8_t i = 31; i >= 0; i--) {
 317         if (layers & (1UL<<i)) {
 318             action = action_for_key(i, key);
 319             if (action.code != ACTION_TRANSPARENT) {
 320                 return i;
 321             }
 322         }
 323     }
 324     /* fall back to layer 0 */
 325     return 0;
 326 #else
 327     return biton32(default_layer_state);
 328 #endif
 329 }
 330
 331 /** \brief Layer switch get layer
 332  *
 333  * FIXME: Needs docs
 334  */
 335 action_t layer_switch_get_action(keypos_t key)
 336 {
 337     return action_for_key(layer_switch_get_layer(key), key);
 338 }