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