diff options
Diffstat (limited to 'tmk_core/common/action_layer.c')
| -rw-r--r-- | tmk_core/common/action_layer.c | 101 |
1 files changed, 96 insertions, 5 deletions
diff --git a/tmk_core/common/action_layer.c b/tmk_core/common/action_layer.c index 22331376aa..f3cd381ab0 100644 --- a/tmk_core/common/action_layer.c +++ b/tmk_core/common/action_layer.c | |||
| @@ -11,16 +11,23 @@ | |||
| 11 | #endif | 11 | #endif |
| 12 | 12 | ||
| 13 | 13 | ||
| 14 | /* | 14 | /** \brief Default Layer State |
| 15 | * Default Layer State | ||
| 16 | */ | 15 | */ |
| 17 | uint32_t default_layer_state = 0; | 16 | uint32_t default_layer_state = 0; |
| 18 | 17 | ||
| 18 | /** \brief Default Layer State Set At Keyboard Level | ||
| 19 | * | ||
| 20 | * FIXME: Needs docs | ||
| 21 | */ | ||
| 19 | __attribute__((weak)) | 22 | __attribute__((weak)) |
| 20 | uint32_t default_layer_state_set_kb(uint32_t state) { | 23 | uint32_t default_layer_state_set_kb(uint32_t state) { |
| 21 | return state; | 24 | return state; |
| 22 | } | 25 | } |
| 23 | 26 | ||
| 27 | /** \brief Default Layer State Set | ||
| 28 | * | ||
| 29 | * FIXME: Needs docs | ||
| 30 | */ | ||
| 24 | static void default_layer_state_set(uint32_t state) | 31 | static void default_layer_state_set(uint32_t state) |
| 25 | { | 32 | { |
| 26 | state = default_layer_state_set_kb(state); | 33 | state = default_layer_state_set_kb(state); |
| @@ -31,25 +38,45 @@ static void default_layer_state_set(uint32_t state) | |||
| 31 | clear_keyboard_but_mods(); // To avoid stuck keys | 38 | clear_keyboard_but_mods(); // To avoid stuck keys |
| 32 | } | 39 | } |
| 33 | 40 | ||
| 41 | /** \brief Default Layer Print | ||
| 42 | * | ||
| 43 | * FIXME: Needs docs | ||
| 44 | */ | ||
| 34 | void default_layer_debug(void) | 45 | void default_layer_debug(void) |
| 35 | { | 46 | { |
| 36 | dprintf("%08lX(%u)", default_layer_state, biton32(default_layer_state)); | 47 | dprintf("%08lX(%u)", default_layer_state, biton32(default_layer_state)); |
| 37 | } | 48 | } |
| 38 | 49 | ||
| 50 | /** \brief Default Layer Set | ||
| 51 | * | ||
| 52 | * FIXME: Needs docs | ||
| 53 | */ | ||
| 39 | void default_layer_set(uint32_t state) | 54 | void default_layer_set(uint32_t state) |
| 40 | { | 55 | { |
| 41 | default_layer_state_set(state); | 56 | default_layer_state_set(state); |
| 42 | } | 57 | } |
| 43 | 58 | ||
| 44 | #ifndef NO_ACTION_LAYER | 59 | #ifndef NO_ACTION_LAYER |
| 60 | /** \brief Default Layer Or | ||
| 61 | * | ||
| 62 | * FIXME: Needs docs | ||
| 63 | */ | ||
| 45 | void default_layer_or(uint32_t state) | 64 | void default_layer_or(uint32_t state) |
| 46 | { | 65 | { |
| 47 | default_layer_state_set(default_layer_state | state); | 66 | default_layer_state_set(default_layer_state | state); |
| 48 | } | 67 | } |
| 68 | /** \brief Default Layer And | ||
| 69 | * | ||
| 70 | * FIXME: Needs docs | ||
| 71 | */ | ||
| 49 | void default_layer_and(uint32_t state) | 72 | void default_layer_and(uint32_t state) |
| 50 | { | 73 | { |
| 51 | default_layer_state_set(default_layer_state & state); | 74 | default_layer_state_set(default_layer_state & state); |
| 52 | } | 75 | } |
| 76 | /** \brief Default Layer Xor | ||
| 77 | * | ||
| 78 | * FIXME: Needs docs | ||
| 79 | */ | ||
| 53 | void default_layer_xor(uint32_t state) | 80 | void default_layer_xor(uint32_t state) |
| 54 | { | 81 | { |
| 55 | default_layer_state_set(default_layer_state ^ state); | 82 | default_layer_state_set(default_layer_state ^ state); |
| @@ -58,21 +85,32 @@ void default_layer_xor(uint32_t state) | |||
| 58 | 85 | ||
| 59 | 86 | ||
| 60 | #ifndef NO_ACTION_LAYER | 87 | #ifndef NO_ACTION_LAYER |
| 61 | /* | 88 | /** \brief Keymap Layer State |
| 62 | * Keymap Layer State | ||
| 63 | */ | 89 | */ |
| 64 | uint32_t layer_state = 0; | 90 | uint32_t layer_state = 0; |
| 65 | 91 | ||
| 92 | /** \brief Layer state set user | ||
| 93 | * | ||
| 94 | * FIXME: Needs docs | ||
| 95 | */ | ||
| 66 | __attribute__((weak)) | 96 | __attribute__((weak)) |
| 67 | uint32_t layer_state_set_user(uint32_t state) { | 97 | uint32_t layer_state_set_user(uint32_t state) { |
| 68 | return state; | 98 | return state; |
| 69 | } | 99 | } |
| 70 | 100 | ||
| 101 | /** \brief Layer state set keyboard | ||
| 102 | * | ||
| 103 | * FIXME: Needs docs | ||
| 104 | */ | ||
| 71 | __attribute__((weak)) | 105 | __attribute__((weak)) |
| 72 | uint32_t layer_state_set_kb(uint32_t state) { | 106 | uint32_t layer_state_set_kb(uint32_t state) { |
| 73 | return layer_state_set_user(state); | 107 | return layer_state_set_user(state); |
| 74 | } | 108 | } |
| 75 | 109 | ||
| 110 | /** \brief Layer state set | ||
| 111 | * | ||
| 112 | * FIXME: Needs docs | ||
| 113 | */ | ||
| 76 | void layer_state_set(uint32_t state) | 114 | void layer_state_set(uint32_t state) |
| 77 | { | 115 | { |
| 78 | state = layer_state_set_kb(state); | 116 | state = layer_state_set_kb(state); |
| @@ -83,54 +121,98 @@ void layer_state_set(uint32_t state) | |||
| 83 | clear_keyboard_but_mods(); // To avoid stuck keys | 121 | clear_keyboard_but_mods(); // To avoid stuck keys |
| 84 | } | 122 | } |
| 85 | 123 | ||
| 124 | /** \brief Layer clear | ||
| 125 | * | ||
| 126 | * FIXME: Needs docs | ||
| 127 | */ | ||
| 86 | void layer_clear(void) | 128 | void layer_clear(void) |
| 87 | { | 129 | { |
| 88 | layer_state_set(0); | 130 | layer_state_set(0); |
| 89 | } | 131 | } |
| 90 | 132 | ||
| 133 | /** \brief Layer state is | ||
| 134 | * | ||
| 135 | * FIXME: Needs docs | ||
| 136 | */ | ||
| 91 | bool layer_state_is(uint8_t layer) | 137 | bool layer_state_is(uint8_t layer) |
| 92 | { | 138 | { |
| 93 | return layer_state_cmp(layer_state, layer); | 139 | return layer_state_cmp(layer_state, layer); |
| 94 | } | 140 | } |
| 95 | 141 | ||
| 142 | /** \brief Layer state compare | ||
| 143 | * | ||
| 144 | * FIXME: Needs docs | ||
| 145 | */ | ||
| 96 | bool layer_state_cmp(uint32_t cmp_layer_state, uint8_t layer) { | 146 | bool layer_state_cmp(uint32_t cmp_layer_state, uint8_t layer) { |
| 97 | if (!cmp_layer_state) { return layer == 0; } | 147 | if (!cmp_layer_state) { return layer == 0; } |
| 98 | return (cmp_layer_state & (1UL<<layer)) != 0; | 148 | return (cmp_layer_state & (1UL<<layer)) != 0; |
| 99 | } | 149 | } |
| 100 | 150 | ||
| 151 | /** \brief Layer move | ||
| 152 | * | ||
| 153 | * FIXME: Needs docs | ||
| 154 | */ | ||
| 101 | void layer_move(uint8_t layer) | 155 | void layer_move(uint8_t layer) |
| 102 | { | 156 | { |
| 103 | layer_state_set(1UL<<layer); | 157 | layer_state_set(1UL<<layer); |
| 104 | } | 158 | } |
| 105 | 159 | ||
| 160 | /** \brief Layer on | ||
| 161 | * | ||
| 162 | * FIXME: Needs docs | ||
| 163 | */ | ||
| 106 | void layer_on(uint8_t layer) | 164 | void layer_on(uint8_t layer) |
| 107 | { | 165 | { |
| 108 | layer_state_set(layer_state | (1UL<<layer)); | 166 | layer_state_set(layer_state | (1UL<<layer)); |
| 109 | } | 167 | } |
| 110 | 168 | ||
| 169 | /** \brief Layer off | ||
| 170 | * | ||
| 171 | * FIXME: Needs docs | ||
| 172 | */ | ||
| 111 | void layer_off(uint8_t layer) | 173 | void layer_off(uint8_t layer) |
| 112 | { | 174 | { |
| 113 | layer_state_set(layer_state & ~(1UL<<layer)); | 175 | layer_state_set(layer_state & ~(1UL<<layer)); |
| 114 | } | 176 | } |
| 115 | 177 | ||
| 178 | /** \brief Layer invert | ||
| 179 | * | ||
| 180 | * FIXME: Needs docs | ||
| 181 | */ | ||
| 116 | void layer_invert(uint8_t layer) | 182 | void layer_invert(uint8_t layer) |
| 117 | { | 183 | { |
| 118 | layer_state_set(layer_state ^ (1UL<<layer)); | 184 | layer_state_set(layer_state ^ (1UL<<layer)); |
| 119 | } | 185 | } |
| 120 | 186 | ||
| 187 | /** \brief Layer or | ||
| 188 | * | ||
| 189 | * FIXME: Needs docs | ||
| 190 | */ | ||
| 121 | void layer_or(uint32_t state) | 191 | void layer_or(uint32_t state) |
| 122 | { | 192 | { |
| 123 | layer_state_set(layer_state | state); | 193 | layer_state_set(layer_state | state); |
| 124 | } | 194 | } |
| 195 | /** \brief Layer and | ||
| 196 | * | ||
| 197 | * FIXME: Needs docs | ||
| 198 | */ | ||
| 125 | void layer_and(uint32_t state) | 199 | void layer_and(uint32_t state) |
| 126 | { | 200 | { |
| 127 | layer_state_set(layer_state & state); | 201 | layer_state_set(layer_state & state); |
| 128 | } | 202 | } |
| 203 | /** \brief Layer xor | ||
| 204 | * | ||
| 205 | * FIXME: Needs docs | ||
| 206 | */ | ||
| 129 | void layer_xor(uint32_t state) | 207 | void layer_xor(uint32_t state) |
| 130 | { | 208 | { |
| 131 | layer_state_set(layer_state ^ state); | 209 | layer_state_set(layer_state ^ state); |
| 132 | } | 210 | } |
| 133 | 211 | ||
| 212 | /** \brief Layer debug printing | ||
| 213 | * | ||
| 214 | * FIXME: Needs docs | ||
| 215 | */ | ||
| 134 | void layer_debug(void) | 216 | void layer_debug(void) |
| 135 | { | 217 | { |
| 136 | dprintf("%08lX(%u)", layer_state, biton32(layer_state)); | 218 | dprintf("%08lX(%u)", layer_state, biton32(layer_state)); |
| @@ -172,7 +254,8 @@ uint8_t read_source_layers_cache(keypos_t key) | |||
| 172 | } | 254 | } |
| 173 | #endif | 255 | #endif |
| 174 | 256 | ||
| 175 | /* | 257 | /** \brief Store or get action (FIXME: Needs better summary) |
| 258 | * | ||
| 176 | * Make sure the action triggered when the key is released is the same | 259 | * Make sure the action triggered when the key is released is the same |
| 177 | * one as the one triggered on press. It's important for the mod keys | 260 | * one as the one triggered on press. It's important for the mod keys |
| 178 | * when the layer is switched after the down event but before the up | 261 | * when the layer is switched after the down event but before the up |
| @@ -201,6 +284,10 @@ action_t store_or_get_action(bool pressed, keypos_t key) | |||
| 201 | } | 284 | } |
| 202 | 285 | ||
| 203 | 286 | ||
| 287 | /** \brief Layer switch get layer | ||
| 288 | * | ||
| 289 | * FIXME: Needs docs | ||
| 290 | */ | ||
| 204 | int8_t layer_switch_get_layer(keypos_t key) | 291 | int8_t layer_switch_get_layer(keypos_t key) |
| 205 | { | 292 | { |
| 206 | #ifndef NO_ACTION_LAYER | 293 | #ifndef NO_ACTION_LAYER |
| @@ -224,6 +311,10 @@ int8_t layer_switch_get_layer(keypos_t key) | |||
| 224 | #endif | 311 | #endif |
| 225 | } | 312 | } |
| 226 | 313 | ||
| 314 | /** \brief Layer switch get layer | ||
| 315 | * | ||
| 316 | * FIXME: Needs docs | ||
| 317 | */ | ||
| 227 | action_t layer_switch_get_action(keypos_t key) | 318 | action_t layer_switch_get_action(keypos_t key) |
| 228 | { | 319 | { |
| 229 | return action_for_key(layer_switch_get_layer(key), key); | 320 | return action_for_key(layer_switch_get_layer(key), key); |
