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