From c2480884aa1321ec4a0364f773476f0e7f7d3069 Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Sat, 5 Mar 2016 14:42:17 +0100 Subject: Fix the layer-dependent modifiers handling Closes #181. --- tmk_core/common/action.c | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 77ea39e94..be06e12aa 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -53,6 +53,26 @@ void action_exec(keyevent_t event) #endif } +/* + * Make sure the action triggered when the key is released is the same + * one as the one triggered on press. It's important for the mod keys + * when the layer is switched after the down event but before the up + * event as they may get stuck otherwise. + */ +action_t store_or_get_action(bool pressed, keypos_t key) +{ +#ifndef NO_ACTION_LAYER + static action_t pressed_actions[MATRIX_ROWS][MATRIX_COLS]; + + if (pressed) { + pressed_actions[key.row][key.col] = layer_switch_get_action(key); + } + return pressed_actions[key.row][key.col]; +#else + return layer_switch_get_action(key); +#endif +} + void process_action(keyrecord_t *record) { keyevent_t event = record->event; @@ -62,7 +82,7 @@ void process_action(keyrecord_t *record) if (IS_NOEVENT(event)) { return; } - action_t action = layer_switch_get_action(event.key); + action_t action = store_or_get_action(event.pressed, event.key); dprint("ACTION: "); debug_action(action); #ifndef NO_ACTION_LAYER dprint(" layer_state: "); layer_debug(); -- cgit v1.2.3 From 8d55a12a9538742f510087f14fc59eb813b2ef42 Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Tue, 8 Mar 2016 08:48:43 +0100 Subject: Document the issue of stuck modifiers --- tmk_core/common/action.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index be06e12aa..26a5fad7a 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -61,7 +61,7 @@ void action_exec(keyevent_t event) */ action_t store_or_get_action(bool pressed, keypos_t key) { -#ifndef NO_ACTION_LAYER +#if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) static action_t pressed_actions[MATRIX_ROWS][MATRIX_COLS]; if (pressed) { -- cgit v1.2.3 From b7a81f041906c3c978a314987e486536be0a58cd Mon Sep 17 00:00:00 2001 From: Didier Loiseau Date: Tue, 8 Mar 2016 23:14:15 +0100 Subject: Fix #156: clear weak mods on every key press - new macro_mods bit field for mods applied by macros - weak_mods now only used for ACT_{L,R}MODS (i.e. LSFT, RSFT, LCTL etc.) - clear the _weak_ mods on every key *pressed* such that LSFT etc. can no more interfere with the next key --- tmk_core/common/action.c | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 77ea39e94..4197c53ed 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -70,6 +70,10 @@ void process_action(keyrecord_t *record) #endif dprintln(); + if (event.pressed) { + // clear the potential weak mods left by previously pressed keys + clear_weak_mods(); + } switch (action.kind.id) { /* Key and Mods */ case ACT_LMODS: @@ -500,6 +504,7 @@ void clear_keyboard(void) void clear_keyboard_but_mods(void) { clear_weak_mods(); + clear_macro_mods(); clear_keys(); send_keyboard_report(); #ifdef MOUSEKEY_ENABLE -- cgit v1.2.3 From 20dd9c032616722a54174d53b0f8824f639b5263 Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Sun, 13 Mar 2016 00:18:20 +0100 Subject: process_action may be called either with key cache or without it If one wants to temporarily disable the key cache (for example because it interferes with a macro), `disable_action_cache` must be set to `true`. `process_action_nocache` is a simple wrapper doing just that for a single call. --- tmk_core/common/action.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 26a5fad7a..1d3b73811 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -53,6 +53,17 @@ void action_exec(keyevent_t event) #endif } +#if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) +bool disable_action_cache = false; + +void process_action_nocache(keyrecord_t *record) +{ + disable_action_cache = true; + process_action(record); + disable_action_cache = false; +} +#endif + /* * Make sure the action triggered when the key is released is the same * one as the one triggered on press. It's important for the mod keys @@ -64,6 +75,10 @@ action_t store_or_get_action(bool pressed, keypos_t key) #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) static action_t pressed_actions[MATRIX_ROWS][MATRIX_COLS]; + if (disable_action_cache) { + return layer_switch_get_action(key); + } + if (pressed) { pressed_actions[key.row][key.col] = layer_switch_get_action(key); } -- cgit v1.2.3 From 73cb87740bd814c95007f9ef6ce3dcd542a62afd Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Tue, 15 Mar 2016 16:03:30 +0100 Subject: Always provide an implementation of process_action_nocache --- tmk_core/common/action.c | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 1d3b73811..0a3822a06 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -62,6 +62,11 @@ void process_action_nocache(keyrecord_t *record) process_action(record); disable_action_cache = false; } +#else +void process_action_nocache(keyrecord_t *record) +{ + process_action(record); +} #endif /* -- cgit v1.2.3 From a5cdc3aab1c430916eae66d4d9d751808613e700 Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Tue, 15 Mar 2016 16:51:50 +0100 Subject: Expose the pressed_actions_cache global variable --- tmk_core/common/action.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 0a3822a06..fc09383ee 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -55,6 +55,7 @@ void action_exec(keyevent_t event) #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) bool disable_action_cache = false; +action_t pressed_actions_cache[MATRIX_ROWS][MATRIX_COLS]; void process_action_nocache(keyrecord_t *record) { @@ -78,16 +79,14 @@ void process_action_nocache(keyrecord_t *record) action_t store_or_get_action(bool pressed, keypos_t key) { #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) - static action_t pressed_actions[MATRIX_ROWS][MATRIX_COLS]; - if (disable_action_cache) { return layer_switch_get_action(key); } if (pressed) { - pressed_actions[key.row][key.col] = layer_switch_get_action(key); + pressed_actions_cache[key.row][key.col] = layer_switch_get_action(key); } - return pressed_actions[key.row][key.col]; + return pressed_actions_cache[key.row][key.col]; #else return layer_switch_get_action(key); #endif -- cgit v1.2.3 From b4f442dfeaf4d434ae0d8459dc5199cd8fefc1c7 Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Sun, 27 Mar 2016 23:50:07 +0200 Subject: Cut the memory consumption of PREVENT_STUCK_MODIFIERS in half --- tmk_core/common/action.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index fc09383ee..acc6d11ea 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -55,7 +55,7 @@ void action_exec(keyevent_t event) #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) bool disable_action_cache = false; -action_t pressed_actions_cache[MATRIX_ROWS][MATRIX_COLS]; +int8_t pressed_actions_cache[MATRIX_ROWS][MATRIX_COLS]; void process_action_nocache(keyrecord_t *record) { @@ -84,9 +84,9 @@ action_t store_or_get_action(bool pressed, keypos_t key) } if (pressed) { - pressed_actions_cache[key.row][key.col] = layer_switch_get_action(key); + pressed_actions_cache[key.row][key.col] = layer_switch_get_layer(key); } - return pressed_actions_cache[key.row][key.col]; + return action_for_key(pressed_actions_cache[key.row][key.col], key); #else return layer_switch_get_action(key); #endif -- cgit v1.2.3 From ef21a855e6d60b78011ddb8940f58985b1c60acb Mon Sep 17 00:00:00 2001 From: Damien Pollet Date: Sun, 27 Mar 2016 17:58:26 +0200 Subject: Add per-event user hook function to QMK --- tmk_core/common/action.c | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 4197c53ed..c6595196f 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -53,6 +53,9 @@ void action_exec(keyevent_t event) #endif } +__attribute__ ((weak)) +void process_action_user(keyrecord_t *record) {} + void process_action(keyrecord_t *record) { keyevent_t event = record->event; @@ -62,6 +65,8 @@ void process_action(keyrecord_t *record) if (IS_NOEVENT(event)) { return; } + process_action_user(record); + action_t action = layer_switch_get_action(event.key); dprint("ACTION: "); debug_action(action); #ifndef NO_ACTION_LAYER -- cgit v1.2.3 From acd64aa841f92ee638ca630fc66c3ff91c09ae72 Mon Sep 17 00:00:00 2001 From: Damien Pollet Date: Mon, 28 Mar 2016 16:12:50 +0200 Subject: Rename function to be keyboard-specific --- tmk_core/common/action.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index c6595196f..2ccc0e0b9 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -54,7 +54,7 @@ void action_exec(keyevent_t event) } __attribute__ ((weak)) -void process_action_user(keyrecord_t *record) {} +void process_action_kb(keyrecord_t *record) {} void process_action(keyrecord_t *record) { @@ -65,7 +65,7 @@ void process_action(keyrecord_t *record) if (IS_NOEVENT(event)) { return; } - process_action_user(record); + process_action_kb(record); action_t action = layer_switch_get_action(event.key); dprint("ACTION: "); debug_action(action); -- cgit v1.2.3 From 317455178d177efc8eccdb8dc69ac18baf9e66e7 Mon Sep 17 00:00:00 2001 From: Eric-L-T Date: Fri, 1 Apr 2016 13:43:49 -0700 Subject: Update action.c --- tmk_core/common/action.c | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index acc6d11ea..4457d16d8 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -55,7 +55,7 @@ void action_exec(keyevent_t event) #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) bool disable_action_cache = false; -int8_t pressed_actions_cache[MATRIX_ROWS][MATRIX_COLS]; +uint8_t source_layers_cache[5][((MATRIX_ROWS * MATRIX_COLS) / 8) ? ((MATRIX_ROWS * MATRIX_COLS) / 8) : 1]; void process_action_nocache(keyrecord_t *record) { @@ -82,11 +82,22 @@ action_t store_or_get_action(bool pressed, keypos_t key) if (disable_action_cache) { return layer_switch_get_action(key); } - + uint8_t key_number = (key.col + (key.row * MATRIX_COLS)); + uint8_t storage_row = key_number / 8; + uint8_t storage_bit = key_number % 8; + uint8_t layer; if (pressed) { - pressed_actions_cache[key.row][key.col] = layer_switch_get_layer(key); + layer = layer_switch_get_layer(key); + for (uint8_t bit_number = 0; bit_number <= 4; bit_number++) { + source_layers_cache[bit_number][storage_row] ^= (-(!!(layer & (1 << bit_number)) ^ source_layers_cache[bit_number][storage_row])) & (1 << storage_bit); + } + } else { + layer = 0; + for (uint8_t bit_number = 0; bit_number <= 4; bit_number++) { + layer |= (!!(source_layers_cache[bit_number][storage_row] & (1 << storage_bit))) << bit_number; + } } - return action_for_key(pressed_actions_cache[key.row][key.col], key); + return action_for_key(layer, key); #else return layer_switch_get_action(key); #endif -- cgit v1.2.3 From 9a35f01c5516081a8c503d2344f0d082b1a29cd5 Mon Sep 17 00:00:00 2001 From: Eric-L-T Date: Fri, 1 Apr 2016 13:49:03 -0700 Subject: Update action.c --- tmk_core/common/action.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 4457d16d8..9ba03675a 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -82,7 +82,7 @@ action_t store_or_get_action(bool pressed, keypos_t key) if (disable_action_cache) { return layer_switch_get_action(key); } - uint8_t key_number = (key.col + (key.row * MATRIX_COLS)); + uint8_t key_number = key.col + (key.row * MATRIX_COLS); uint8_t storage_row = key_number / 8; uint8_t storage_bit = key_number % 8; uint8_t layer; -- cgit v1.2.3 From 420fc8620bfd47604848066b9d3798fb68a12e03 Mon Sep 17 00:00:00 2001 From: Eric-L-T Date: Fri, 1 Apr 2016 18:26:43 -0700 Subject: Update action.c --- tmk_core/common/action.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 9ba03675a..e4cbac9e8 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -82,18 +82,18 @@ action_t store_or_get_action(bool pressed, keypos_t key) if (disable_action_cache) { return layer_switch_get_action(key); } - uint8_t key_number = key.col + (key.row * MATRIX_COLS); - uint8_t storage_row = key_number / 8; - uint8_t storage_bit = key_number % 8; - uint8_t layer; + int8_t key_number = key.col + (key.row * MATRIX_COLS); + int8_t storage_row = key_number / 8; + int8_t storage_bit = key_number % 8; + int8_t layer; if (pressed) { layer = layer_switch_get_layer(key); - for (uint8_t bit_number = 0; bit_number <= 4; bit_number++) { + for (int8_t bit_number = 0; bit_number <= 4; bit_number++) { source_layers_cache[bit_number][storage_row] ^= (-(!!(layer & (1 << bit_number)) ^ source_layers_cache[bit_number][storage_row])) & (1 << storage_bit); } } else { layer = 0; - for (uint8_t bit_number = 0; bit_number <= 4; bit_number++) { + for (int8_t bit_number = 0; bit_number <= 4; bit_number++) { layer |= (!!(source_layers_cache[bit_number][storage_row] & (1 << storage_bit))) << bit_number; } } -- cgit v1.2.3 From 307f1dee21ba8ffc94d50b6b9338d54fa2e4d191 Mon Sep 17 00:00:00 2001 From: Eric-L-T Date: Fri, 1 Apr 2016 19:54:02 -0700 Subject: Update action.c --- tmk_core/common/action.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index e4cbac9e8..eecfdbb6d 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -82,19 +82,19 @@ action_t store_or_get_action(bool pressed, keypos_t key) if (disable_action_cache) { return layer_switch_get_action(key); } - int8_t key_number = key.col + (key.row * MATRIX_COLS); - int8_t storage_row = key_number / 8; - int8_t storage_bit = key_number % 8; - int8_t layer; + uint8_t key_number = key.col + (key.row * MATRIX_COLS); + uint8_t storage_row = key_number / 8; + uint8_t storage_bit = key_number % 8; + uint8_t layer; if (pressed) { layer = layer_switch_get_layer(key); - for (int8_t bit_number = 0; bit_number <= 4; bit_number++) { - source_layers_cache[bit_number][storage_row] ^= (-(!!(layer & (1 << bit_number)) ^ source_layers_cache[bit_number][storage_row])) & (1 << storage_bit); + for (uint8_t bit_number = 0; bit_number <= 4; bit_number++) { + source_layers_cache[bit_number][storage_row] ^= (-(!!(layer & (1U << bit_number)) ^ source_layers_cache[bit_number][storage_row])) & (1U << storage_bit); } } else { layer = 0; - for (int8_t bit_number = 0; bit_number <= 4; bit_number++) { - layer |= (!!(source_layers_cache[bit_number][storage_row] & (1 << storage_bit))) << bit_number; + for (uint8_t bit_number = 0; bit_number <= 4; bit_number++) { + layer |= (uint8_t)(!!(source_layers_cache[bit_number][storage_row] & (1U << storage_bit))) << bit_number; } } return action_for_key(layer, key); -- cgit v1.2.3 From f5365d1c1c619c5cb85b9b1ba97ebd04a7f56e05 Mon Sep 17 00:00:00 2001 From: Eric-L-T Date: Fri, 1 Apr 2016 20:04:13 -0700 Subject: Update action.c --- tmk_core/common/action.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index eecfdbb6d..f6fc8b005 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -89,7 +89,7 @@ action_t store_or_get_action(bool pressed, keypos_t key) if (pressed) { layer = layer_switch_get_layer(key); for (uint8_t bit_number = 0; bit_number <= 4; bit_number++) { - source_layers_cache[bit_number][storage_row] ^= (-(!!(layer & (1U << bit_number)) ^ source_layers_cache[bit_number][storage_row])) & (1U << storage_bit); + source_layers_cache[bit_number][storage_row] ^= (-(bool)((layer & (1U << bit_number)) != 0) ^ source_layers_cache[bit_number][storage_row])) & (1U << storage_bit); } } else { layer = 0; -- cgit v1.2.3 From 680301e3e3f837aa4f8bda403af3fc42156516fa Mon Sep 17 00:00:00 2001 From: eltang Date: Sat, 2 Apr 2016 06:48:44 -0700 Subject: Update action.c --- tmk_core/common/action.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index f6fc8b005..8735c7d64 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -91,7 +91,8 @@ action_t store_or_get_action(bool pressed, keypos_t key) for (uint8_t bit_number = 0; bit_number <= 4; bit_number++) { source_layers_cache[bit_number][storage_row] ^= (-(bool)((layer & (1U << bit_number)) != 0) ^ source_layers_cache[bit_number][storage_row])) & (1U << storage_bit); } - } else { + } + else { layer = 0; for (uint8_t bit_number = 0; bit_number <= 4; bit_number++) { layer |= (uint8_t)(!!(source_layers_cache[bit_number][storage_row] & (1U << storage_bit))) << bit_number; -- cgit v1.2.3 From fddccc95fe480a2ed039ffdac6aa9f3fac1f444f Mon Sep 17 00:00:00 2001 From: eltang Date: Sat, 2 Apr 2016 09:13:13 -0700 Subject: Update action.c --- tmk_core/common/action.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 8735c7d64..a3c5b4c5a 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -95,7 +95,7 @@ action_t store_or_get_action(bool pressed, keypos_t key) else { layer = 0; for (uint8_t bit_number = 0; bit_number <= 4; bit_number++) { - layer |= (uint8_t)(!!(source_layers_cache[bit_number][storage_row] & (1U << storage_bit))) << bit_number; + layer |= (uint8_t)((source_layers_cache[bit_number][storage_row] & (1U << storage_bit)) != 0) << bit_number; } } return action_for_key(layer, key); -- cgit v1.2.3 From da101b886689b3d2a8e4246ed20dee5f066bb1a1 Mon Sep 17 00:00:00 2001 From: eltang Date: Sat, 2 Apr 2016 09:29:32 -0700 Subject: Update action.c --- tmk_core/common/action.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index a3c5b4c5a..ae4e5545c 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -55,7 +55,7 @@ void action_exec(keyevent_t event) #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) bool disable_action_cache = false; -uint8_t source_layers_cache[5][((MATRIX_ROWS * MATRIX_COLS) / 8) ? ((MATRIX_ROWS * MATRIX_COLS) / 8) : 1]; +uint8_t source_layers_cache[5][((MATRIX_ROWS * MATRIX_COLS) / 8) ? ((MATRIX_ROWS * MATRIX_COLS) / 8) : 1] = {}; void process_action_nocache(keyrecord_t *record) { -- cgit v1.2.3 From f4f592910c51c048b1e1a08408ce16fd14eb3c32 Mon Sep 17 00:00:00 2001 From: eltang Date: Sat, 2 Apr 2016 09:34:01 -0700 Subject: Update action.c --- tmk_core/common/action.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index ae4e5545c..43d03f744 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -55,7 +55,7 @@ void action_exec(keyevent_t event) #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) bool disable_action_cache = false; -uint8_t source_layers_cache[5][((MATRIX_ROWS * MATRIX_COLS) / 8) ? ((MATRIX_ROWS * MATRIX_COLS) / 8) : 1] = {}; +uint8_t source_layers_cache[5][((MATRIX_ROWS * MATRIX_COLS) / 8) ? ((MATRIX_ROWS * MATRIX_COLS) / 8) : 1] = {0}; void process_action_nocache(keyrecord_t *record) { -- cgit v1.2.3 From 6c8e374d572f1cf0b62beb2a9718de84202c8a41 Mon Sep 17 00:00:00 2001 From: eltang Date: Sat, 2 Apr 2016 09:59:53 -0700 Subject: Update action.c --- tmk_core/common/action.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 43d03f744..f47256de7 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -55,7 +55,7 @@ void action_exec(keyevent_t event) #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) bool disable_action_cache = false; -uint8_t source_layers_cache[5][((MATRIX_ROWS * MATRIX_COLS) / 8) ? ((MATRIX_ROWS * MATRIX_COLS) / 8) : 1] = {0}; +uint8_t source_layers_cache[5][((MATRIX_ROWS * MATRIX_COLS + 7) / 8)] = {0}; void process_action_nocache(keyrecord_t *record) { -- cgit v1.2.3 From 5a9091689c3e1b4c444f56c9cb335817dc9fc2bb Mon Sep 17 00:00:00 2001 From: eltang Date: Sat, 2 Apr 2016 10:00:31 -0700 Subject: Update action.c --- tmk_core/common/action.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index f47256de7..bf609f5e7 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -55,7 +55,7 @@ void action_exec(keyevent_t event) #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) bool disable_action_cache = false; -uint8_t source_layers_cache[5][((MATRIX_ROWS * MATRIX_COLS + 7) / 8)] = {0}; +uint8_t source_layers_cache[5][(MATRIX_ROWS * MATRIX_COLS + 7) / 8] = {0}; void process_action_nocache(keyrecord_t *record) { -- cgit v1.2.3 From 4dce7258d1b31be0d91f6de0693a10917f514dd8 Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Sat, 2 Apr 2016 18:00:28 +0200 Subject: Cleanup after merge - remove a superfluous parenthesis - wrap lines longer than 80 characters - add const specifiers where appropriate - remove unnecessary casts --- tmk_core/common/action.c | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index bf609f5e7..78596a69c 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -82,20 +82,26 @@ action_t store_or_get_action(bool pressed, keypos_t key) if (disable_action_cache) { return layer_switch_get_action(key); } - uint8_t key_number = key.col + (key.row * MATRIX_COLS); - uint8_t storage_row = key_number / 8; - uint8_t storage_bit = key_number % 8; + const uint8_t key_number = key.col + (key.row * MATRIX_COLS); + const uint8_t storage_row = key_number / 8; + const uint8_t storage_bit = key_number % 8; uint8_t layer; if (pressed) { layer = layer_switch_get_layer(key); - for (uint8_t bit_number = 0; bit_number <= 4; bit_number++) { - source_layers_cache[bit_number][storage_row] ^= (-(bool)((layer & (1U << bit_number)) != 0) ^ source_layers_cache[bit_number][storage_row])) & (1U << storage_bit); + for (uint8_t bit_number = 0; bit_number < 5; bit_number++) { + source_layers_cache[bit_number][storage_row] ^= + (-((layer & (1U << bit_number)) != 0) + ^ source_layers_cache[bit_number][storage_row]) + & (1U << storage_bit); } } else { layer = 0; - for (uint8_t bit_number = 0; bit_number <= 4; bit_number++) { - layer |= (uint8_t)((source_layers_cache[bit_number][storage_row] & (1U << storage_bit)) != 0) << bit_number; + for (uint8_t bit_number = 0; bit_number < 5; bit_number++) { + layer |= + ((source_layers_cache[bit_number][storage_row] + & (1U << storage_bit)) != 0) + << bit_number; } } return action_for_key(layer, key); -- cgit v1.2.3 From 567f256c5d4598adb4dcd63fa4e4a7b4df553b12 Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Tue, 5 Apr 2016 10:54:47 +0200 Subject: Refactor the source layer cache encoding --- tmk_core/common/action.c | 41 ----------------------------------------- 1 file changed, 41 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 20e1fc614..6aa6dc260 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -55,7 +55,6 @@ void action_exec(keyevent_t event) #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) bool disable_action_cache = false; -uint8_t source_layers_cache[5][(MATRIX_ROWS * MATRIX_COLS + 7) / 8] = {0}; void process_action_nocache(keyrecord_t *record) { @@ -70,46 +69,6 @@ void process_action_nocache(keyrecord_t *record) } #endif -/* - * Make sure the action triggered when the key is released is the same - * one as the one triggered on press. It's important for the mod keys - * when the layer is switched after the down event but before the up - * event as they may get stuck otherwise. - */ -action_t store_or_get_action(bool pressed, keypos_t key) -{ -#if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) - if (disable_action_cache) { - return layer_switch_get_action(key); - } - const uint8_t key_number = key.col + (key.row * MATRIX_COLS); - const uint8_t storage_row = key_number / 8; - const uint8_t storage_bit = key_number % 8; - uint8_t layer; - if (pressed) { - layer = layer_switch_get_layer(key); - for (uint8_t bit_number = 0; bit_number < 5; bit_number++) { - source_layers_cache[bit_number][storage_row] ^= - (-((layer & (1U << bit_number)) != 0) - ^ source_layers_cache[bit_number][storage_row]) - & (1U << storage_bit); - } - } - else { - layer = 0; - for (uint8_t bit_number = 0; bit_number < 5; bit_number++) { - layer |= - ((source_layers_cache[bit_number][storage_row] - & (1U << storage_bit)) != 0) - << bit_number; - } - } - return action_for_key(layer, key); -#else - return layer_switch_get_action(key); -#endif -} - __attribute__ ((weak)) void process_action_kb(keyrecord_t *record) {} -- cgit v1.2.3 From 08871e56f78c08340bb229300c457c852105d155 Mon Sep 17 00:00:00 2001 From: Didier Loiseau Date: Wed, 6 Apr 2016 00:19:12 +0200 Subject: Fix issue #221: LGUI(KC_LSFT) does not work on mod keys, register LGUI, LSFT etc. as normal mods instead of weak mods: - they won't be cleared when pressing another key (#188) - they won't be cleared by layer switching - LSFT(KC_LGUI) will now have the same behavior as LGUI(KC_LSFT) --- tmk_core/common/action.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 2ccc0e0b9..901089634 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -88,14 +88,24 @@ void process_action(keyrecord_t *record) action.key.mods<<4; if (event.pressed) { if (mods) { - add_weak_mods(mods); + if (IS_MOD(action.key.code)) { + // e.g. LSFT(KC_LGUI): we don't want the LSFT to be weak as it would make it useless. + // this also makes LSFT(KC_LGUI) behave exactly the same as LGUI(KC_LSFT) + add_mods(mods); + } else { + add_weak_mods(mods); + } send_keyboard_report(); } register_code(action.key.code); } else { unregister_code(action.key.code); if (mods) { - del_weak_mods(mods); + if (IS_MOD(action.key.code)) { + del_mods(mods); + } else { + del_weak_mods(mods); + } send_keyboard_report(); } } -- cgit v1.2.3 From d5b72e7bde5ede25f7d5699b50b7d9eb6f31ba92 Mon Sep 17 00:00:00 2001 From: IBNobody Date: Sun, 17 Apr 2016 12:54:32 -0500 Subject: Fixed many compiler warnings related to print being disabled --- tmk_core/common/action.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index f9e6c17dc..0162fbd63 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -27,11 +27,11 @@ along with this program. If not, see . #include "action_util.h" #include "action.h" -#ifdef DEBUG_ACTION +//#ifdef DEBUG_ACTION #include "debug.h" -#else -#include "nodebug.h" -#endif +//#else +//#include "nodebug.h" +//#endif void action_exec(keyevent_t event) -- cgit v1.2.3 From 2bbf3d5820734eabbcf47c3072be6fdcaa9e36cc Mon Sep 17 00:00:00 2001 From: Jack Humbert Date: Thu, 28 Apr 2016 23:23:33 -0400 Subject: stops forcing debug_action --- tmk_core/common/action.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 0162fbd63..f9e6c17dc 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -27,11 +27,11 @@ along with this program. If not, see . #include "action_util.h" #include "action.h" -//#ifdef DEBUG_ACTION +#ifdef DEBUG_ACTION #include "debug.h" -//#else -//#include "nodebug.h" -//#endif +#else +#include "nodebug.h" +#endif void action_exec(keyevent_t event) -- cgit v1.2.3 From 74e97eefd7ae76f9ddcb76890a30aa9038804cdb Mon Sep 17 00:00:00 2001 From: Thiago Alves Date: Thu, 5 May 2016 18:41:37 -0700 Subject: Adds oneshot layer and oneshot tap toggling (#308) This commit is mostly a cherry-pick from `ahtn` at https://github.com/tmk/tmk_keyboard/pull/255. These are the changes: * Adds ACTION_LAYER_ONESHOT * Adds ONESHOT_TAP_TOGGLE * Mentions sticky keys in the docs on oneshot. --- tmk_core/common/action.c | 97 ++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 89 insertions(+), 8 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index f9e6c17dc..081e90b2d 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -74,6 +74,7 @@ void process_action_kb(keyrecord_t *record) {} void process_action(keyrecord_t *record) { + bool do_release_oneshot = false; keyevent_t event = record->event; #ifndef NO_ACTION_TAPPING uint8_t tap_count = record->tap.count; @@ -81,6 +82,13 @@ void process_action(keyrecord_t *record) if (IS_NOEVENT(event)) { return; } +#if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0)) + if (has_oneshot_layer_timed_out()) { + dprintf("Oneshot layer: timeout\n"); + clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED); + } +#endif + process_action_kb(record); action_t action = store_or_get_action(event.pressed, event.key); @@ -95,6 +103,15 @@ void process_action(keyrecord_t *record) // clear the potential weak mods left by previously pressed keys clear_weak_mods(); } + +#ifndef NO_ACTION_ONESHOT + // notice we only clear the one shot layer if the pressed key is not a modifier. + if (is_oneshot_layer_active() && event.pressed && !IS_MOD(action.key.code)) { + clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED); + do_release_oneshot = !is_oneshot_layer_active(); + } +#endif + switch (action.kind.id) { /* Key and Mods */ case ACT_LMODS: @@ -139,24 +156,37 @@ void process_action(keyrecord_t *record) // Oneshot modifier if (event.pressed) { if (tap_count == 0) { + dprint("MODS_TAP: Oneshot: 0\n"); register_mods(mods); - } - else if (tap_count == 1) { + } else if (tap_count == 1) { dprint("MODS_TAP: Oneshot: start\n"); set_oneshot_mods(mods); - } - else { + #if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1 + } else if (tap_count == ONESHOT_TAP_TOGGLE) { + dprint("MODS_TAP: Toggling oneshot"); + clear_oneshot_mods(); + set_oneshot_locked_mods(mods); + register_mods(mods); + #endif + } else { register_mods(mods); } } else { if (tap_count == 0) { clear_oneshot_mods(); unregister_mods(mods); - } - else if (tap_count == 1) { + } else if (tap_count == 1) { // Retain Oneshot mods - } - else { + #if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1 + if (mods & get_mods()) { + clear_oneshot_locked_mods(); + clear_oneshot_mods(); + unregister_mods(mods); + } + } else if (tap_count == ONESHOT_TAP_TOGGLE) { + // Toggle Oneshot Layer + #endif + } else { clear_oneshot_mods(); unregister_mods(mods); } @@ -309,6 +339,44 @@ void process_action(keyrecord_t *record) event.pressed ? layer_move(action.layer_tap.val) : layer_clear(); break; + #ifndef NO_ACTION_ONESHOT + case OP_ONESHOT: + // Oneshot modifier + #if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1 + do_release_oneshot = false; + if (event.pressed) { + del_mods(get_oneshot_locked_mods()); + if (get_oneshot_layer_state() == ONESHOT_TOGGLED) { + reset_oneshot_layer(); + layer_off(action.layer_tap.val); + break; + } else if (tap_count < ONESHOT_TAP_TOGGLE) { + layer_on(action.layer_tap.val); + set_oneshot_layer(action.layer_tap.val, ONESHOT_START); + } + } else { + add_mods(get_oneshot_locked_mods()); + if (tap_count >= ONESHOT_TAP_TOGGLE) { + reset_oneshot_layer(); + clear_oneshot_locked_mods(); + set_oneshot_layer(action.layer_tap.val, ONESHOT_TOGGLED); + } else { + clear_oneshot_layer_state(ONESHOT_PRESSED); + } + } + #else + if (event.pressed) { + layer_on(action.layer_tap.val); + set_oneshot_layer(action.layer_tap.val, ONESHOT_START); + } else { + clear_oneshot_layer_state(ONESHOT_PRESSED); + if (tap_count > 1) { + clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED); + } + } + #endif + break; + #endif default: /* tap key */ if (event.pressed) { @@ -372,6 +440,18 @@ void process_action(keyrecord_t *record) default: break; } + +#ifndef NO_ACTION_ONESHOT + /* Because we switch layers after a oneshot event, we need to release the + * key before we leave the layer or no key up event will be generated. + */ + if (do_release_oneshot && !(get_oneshot_layer_state() & ONESHOT_PRESSED ) ) { + record->event.pressed = false; + layer_on(get_oneshot_layer()); + process_action(record); + layer_off(get_oneshot_layer()); + } +#endif } @@ -560,6 +640,7 @@ bool is_tap_key(keypos_t key) switch (action.layer_tap.code) { case 0x00 ... 0xdf: case OP_TAP_TOGGLE: + case OP_ONESHOT: return true; } return false; -- cgit v1.2.3 From 1a8c0dd22d6a2255511d0db6a456315541b5815b Mon Sep 17 00:00:00 2001 From: Erez Zukerman Date: Sun, 15 May 2016 00:27:32 -0400 Subject: Leader key implementation (#326) * implements leader key for planck experimental * allows override of leader timeout * adds ability to use the leader key in seq * fixes leader keycode * adds chording prototype * fixes keycode detection * moves music mode to quantum.c * disables chording by default * updates process_action functions to return bool --- tmk_core/common/action.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 081e90b2d..c026b96d9 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -70,7 +70,9 @@ void process_action_nocache(keyrecord_t *record) #endif __attribute__ ((weak)) -void process_action_kb(keyrecord_t *record) {} +bool process_action_quantum(keyrecord_t *record) { + return true; +} void process_action(keyrecord_t *record) { @@ -89,7 +91,8 @@ void process_action(keyrecord_t *record) } #endif - process_action_kb(record); + if (!process_action_quantum(record)) + return; action_t action = store_or_get_action(event.pressed, event.key); dprint("ACTION: "); debug_action(action); -- cgit v1.2.3 From bf5c2ccee5497523c214dae7aacdc27fdbb0f235 Mon Sep 17 00:00:00 2001 From: Jack Humbert Date: Sun, 15 May 2016 00:47:25 -0400 Subject: splits process_action up to handle records separately (#329) * implements leader key for planck experimental * allows override of leader timeout * adds ability to use the leader key in seq * fixes leader keycode * adds chording prototype * fixes keycode detection * moves music mode to quantum.c * disables chording by default * adds music sequencer functionality * implements audio/music functions in quantum.c * splits up process_action to allow independent processing of actions * merging? --- tmk_core/common/action.c | 47 ++++++++++++++++++++++++++--------------------- 1 file changed, 26 insertions(+), 21 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index c026b96d9..be6dea2b7 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -46,7 +46,7 @@ void action_exec(keyevent_t event) #ifndef NO_ACTION_TAPPING action_tapping_process(record); #else - process_action(&record); + process_record(&record); if (!IS_NOEVENT(record.event)) { dprint("processed: "); debug_record(record); dprintln(); } @@ -56,25 +56,43 @@ void action_exec(keyevent_t event) #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) bool disable_action_cache = false; -void process_action_nocache(keyrecord_t *record) +void process_record_nocache(keyrecord_t *record) { disable_action_cache = true; - process_action(record); + process_record(record); disable_action_cache = false; } #else -void process_action_nocache(keyrecord_t *record) +void process_record_nocache(keyrecord_t *record) { - process_action(record); + process_record(record); } #endif __attribute__ ((weak)) -bool process_action_quantum(keyrecord_t *record) { +bool process_record_quantum(keyrecord_t *record) { return true; } -void process_action(keyrecord_t *record) +void process_record(keyrecord_t *record) +{ + if (IS_NOEVENT(record->event)) { return; } + + if(!process_record_quantum(record)) + return; + + action_t action = store_or_get_action(record->event.pressed, record->event.key); + dprint("ACTION: "); debug_action(action); +#ifndef NO_ACTION_LAYER + dprint(" layer_state: "); layer_debug(); + dprint(" default_layer_state: "); default_layer_debug(); +#endif + dprintln(); + + process_action(record, action); +} + +void process_action(keyrecord_t *record, action_t action) { bool do_release_oneshot = false; keyevent_t event = record->event; @@ -82,8 +100,6 @@ void process_action(keyrecord_t *record) uint8_t tap_count = record->tap.count; #endif - if (IS_NOEVENT(event)) { return; } - #if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0)) if (has_oneshot_layer_timed_out()) { dprintf("Oneshot layer: timeout\n"); @@ -91,17 +107,6 @@ void process_action(keyrecord_t *record) } #endif - if (!process_action_quantum(record)) - return; - - action_t action = store_or_get_action(event.pressed, event.key); - dprint("ACTION: "); debug_action(action); -#ifndef NO_ACTION_LAYER - dprint(" layer_state: "); layer_debug(); - dprint(" default_layer_state: "); default_layer_debug(); -#endif - dprintln(); - if (event.pressed) { // clear the potential weak mods left by previously pressed keys clear_weak_mods(); @@ -451,7 +456,7 @@ void process_action(keyrecord_t *record) if (do_release_oneshot && !(get_oneshot_layer_state() & ONESHOT_PRESSED ) ) { record->event.pressed = false; layer_on(get_oneshot_layer()); - process_action(record); + process_record(record); layer_off(get_oneshot_layer()); } #endif -- cgit v1.2.3 From dd378601608849679ead6e2cccb74f7f29c131dc Mon Sep 17 00:00:00 2001 From: Joe Wasson Date: Wed, 27 Jul 2016 08:43:02 -0700 Subject: Add one-hand support. This adds an action, `ACTION_SWAP_HANDS`, that swaps the the keys on the keyboard across a keymap-defined hemisphere in order to support one-hand typing without requiring a separate one-handed layer. See updated `doc/keymap.md` for more information. --- tmk_core/common/action.c | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index be6dea2b7..0413b1a99 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -41,6 +41,12 @@ void action_exec(keyevent_t event) dprint("EVENT: "); debug_event(event); dprintln(); } +#ifdef ONEHAND_ENABLE + if (!IS_NOEVENT(event)) { + process_hand_swap(&event); + } +#endif + keyrecord_t record = { .event = event }; #ifndef NO_ACTION_TAPPING @@ -53,6 +59,26 @@ void action_exec(keyevent_t event) #endif } +#ifdef ONEHAND_ENABLE +bool swap_hands = false; + +void process_hand_swap(keyevent_t *event) { + static swap_state_row_t swap_state[MATRIX_ROWS]; + + keypos_t pos = event->key; + swap_state_row_t col_bit = (swap_state_row_t)1<pressed ? swap_hands : + swap_state[pos.row] & (col_bit); + + if (do_swap) { + event->key = hand_swap_config[pos.row][pos.col]; + swap_state[pos.row] |= col_bit; + } else { + swap_state[pos.row] &= ~(col_bit); + } +} +#endif + #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS) bool disable_action_cache = false; @@ -439,6 +465,13 @@ void process_action(keyrecord_t *record, action_t action) break; #endif case ACT_COMMAND: + switch (action.command.id) { +#ifdef ONEHAND_ENABLE + case CMD_SWAP_HANDS: + swap_hands = event.pressed; + break; +#endif + } break; #ifndef NO_ACTION_FUNCTION case ACT_FUNCTION: -- cgit v1.2.3 From 8090f6b499fd87ddeb7a191f7bc3dace9d03be23 Mon Sep 17 00:00:00 2001 From: Joe Wasson Date: Thu, 28 Jul 2016 01:24:06 -0700 Subject: Improve one-hand support by adding more actions and tap keys. --- tmk_core/common/action.c | 57 ++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 53 insertions(+), 4 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 0413b1a99..08ef22eb9 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -465,14 +465,55 @@ void process_action(keyrecord_t *record, action_t action) break; #endif case ACT_COMMAND: - switch (action.command.id) { + break; #ifdef ONEHAND_ENABLE - case CMD_SWAP_HANDS: + case ACT_SWAP_HANDS: + switch (action.swap.code) { + case OP_SH_TOGGLE: + if (event.pressed) { + swap_hands = !swap_hands; + } + break; + case OP_SH_ON_OFF: swap_hands = event.pressed; break; -#endif + case OP_SH_OFF_ON: + swap_hands = !event.pressed; + break; + case OP_SH_ON: + if (!event.pressed) { + swap_hands = true; + } + break; + case OP_SH_OFF: + if (!event.pressed) { + swap_hands = false; + } + break; + #ifndef NO_ACTION_TAPPING + case OP_SH_TAP_TOGGLE: + /* tap toggle */ + if (tap_count > 0) { + if (!event.pressed) { + swap_hands = !swap_hands; + } + } else { + swap_hands = event.pressed; + } + break; + default: + if (tap_count > 0) { + if (event.pressed) { + register_code(action.swap.code); + } else { + unregister_code(action.swap.code); + } + } else { + swap_hands = event.pressed; + } + #endif } - break; +#endif #ifndef NO_ACTION_FUNCTION case ACT_FUNCTION: action_function(record, action.func.id, action.func.opt); @@ -685,6 +726,13 @@ bool is_tap_key(keypos_t key) return true; } return false; + case ACT_SWAP_HANDS: + switch (action.swap.code) { + case 0x00 ... 0xdf: + case OP_SH_TAP_TOGGLE: + return true; + } + return false; case ACT_MACRO: case ACT_FUNCTION: if (action.func.opt & FUNC_TAP) { return true; } @@ -725,6 +773,7 @@ void debug_action(action_t action) case ACT_MACRO: dprint("ACT_MACRO"); break; case ACT_COMMAND: dprint("ACT_COMMAND"); break; case ACT_FUNCTION: dprint("ACT_FUNCTION"); break; + case ACT_SWAP_HANDS: dprint("ACT_SWAP_HANDS"); break; default: dprint("UNKNOWN"); break; } dprintf("[%X:%02X]", action.kind.param>>8, action.kind.param&0xff); -- cgit v1.2.3 From d4309990472895bbbe82f7ba22ed33c16f928778 Mon Sep 17 00:00:00 2001 From: Didier Loiseau Date: Fri, 23 Sep 2016 00:55:15 +0200 Subject: Fix issue #772 Meh and Hyper not working --- tmk_core/common/action.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'tmk_core/common/action.c') diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c index 08ef22eb9..d485b46c7 100644 --- a/tmk_core/common/action.c +++ b/tmk_core/common/action.c @@ -155,9 +155,10 @@ void process_action(keyrecord_t *record, action_t action) action.key.mods<<4; if (event.pressed) { if (mods) { - if (IS_MOD(action.key.code)) { + if (IS_MOD(action.key.code) || action.key.code == KC_NO) { // e.g. LSFT(KC_LGUI): we don't want the LSFT to be weak as it would make it useless. - // this also makes LSFT(KC_LGUI) behave exactly the same as LGUI(KC_LSFT) + // This also makes LSFT(KC_LGUI) behave exactly the same as LGUI(KC_LSFT). + // Same applies for some keys like KC_MEH which are declared as MEH(KC_NO). add_mods(mods); } else { add_weak_mods(mods); @@ -168,7 +169,7 @@ void process_action(keyrecord_t *record, action_t action) } else { unregister_code(action.key.code); if (mods) { - if (IS_MOD(action.key.code)) { + if (IS_MOD(action.key.code) || action.key.code == KC_NO) { del_mods(mods); } else { del_weak_mods(mods); -- cgit v1.2.3