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