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