@@ -3,7 +3,7 @@ SRC += $(COMMON_DIR)/host.c \ | |||
$(COMMON_DIR)/keyboard.c \ | |||
$(COMMON_DIR)/action.c \ | |||
$(COMMON_DIR)/action_macro.c \ | |||
$(COMMON_DIR)/layer_stack.c \ | |||
$(COMMON_DIR)/layer_switch.c \ | |||
$(COMMON_DIR)/keymap.c \ | |||
$(COMMON_DIR)/command.c \ | |||
$(COMMON_DIR)/timer.c \ |
@@ -24,7 +24,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
#include "util.h" | |||
#include "debug.h" | |||
#include "action.h" | |||
#include "layer_stack.h" | |||
#include "layer_switch.h" | |||
/* default layer indicates base layer */ | |||
@@ -213,8 +213,8 @@ static action_t get_action(key_t key) | |||
action_t action; | |||
action.code = ACTION_NO; | |||
/* layer stack */ | |||
action = layer_stack_get_action(key); | |||
/* layer_switch */ | |||
action = layer_switch_get_action(key); | |||
if (action.code != ACTION_TRANSPARENT) { | |||
return action; | |||
} | |||
@@ -531,45 +531,38 @@ static void process_action(keyrecord_t *record) | |||
break; | |||
} | |||
break; | |||
case ACT_LAYER_STACK: | |||
case ACT_LAYER_SWITCH: | |||
switch (action.layer.code) { | |||
case LAYER_MOMENTARY: /* momentary */ | |||
if (event.pressed) { | |||
layer_stack_remove_then_push(action.layer.val); | |||
layer_stack_debug(); | |||
layer_switch_on(action.layer.val); | |||
} else { | |||
layer_stack_remove(action.layer.val); | |||
layer_stack_debug(); | |||
layer_switch_off(action.layer.val); | |||
} | |||
break; | |||
case LAYER_ON_PRESS: | |||
if (event.pressed) { | |||
layer_stack_remove_or_push(action.layer.val); | |||
layer_stack_debug(); | |||
layer_switch_inv(action.layer.val); | |||
} | |||
break; | |||
case LAYER_ON_RELEASE: | |||
if (!event.pressed) { | |||
layer_stack_remove_or_push(action.layer.val); | |||
layer_stack_debug(); | |||
layer_switch_inv(action.layer.val); | |||
} | |||
break; | |||
case LAYER_ON_BOTH: | |||
layer_stack_remove_or_push(action.layer.val); | |||
layer_stack_debug(); | |||
layer_switch_inv(action.layer.val); | |||
break; | |||
case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */ | |||
if (event.pressed) { | |||
if (tap_count < TAPPING_TOGGLE) { | |||
debug("LAYER_STACK: tap toggle(press).\n"); | |||
layer_stack_remove_or_push(action.layer.val); | |||
layer_stack_debug(); | |||
debug("LAYER_SWITCH: tap toggle(press).\n"); | |||
layer_switch_inv(action.layer.val); | |||
} | |||
} else { | |||
if (tap_count <= TAPPING_TOGGLE) { | |||
debug("LAYER_STACK: tap toggle(release).\n"); | |||
layer_stack_remove_or_push(action.layer.val); | |||
layer_stack_debug(); | |||
debug("LAYER_SWITCH: tap toggle(release).\n"); | |||
layer_switch_inv(action.layer.val); | |||
} | |||
} | |||
break; | |||
@@ -577,21 +570,19 @@ static void process_action(keyrecord_t *record) | |||
// tap key | |||
if (event.pressed) { | |||
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | |||
debug("LAYER_STACK: Tap: register_code\n"); | |||
debug("LAYER_SWITCH: Tap: register_code\n"); | |||
register_code(action.layer.code); | |||
} else { | |||
debug("LAYER_STACK: No tap: layer_stack(on press)\n"); | |||
layer_stack_remove_or_push(action.layer.val); | |||
layer_stack_debug(); | |||
debug("LAYER_SWITCH: No tap: layer_switch(on press)\n"); | |||
layer_switch_inv(action.layer.val); | |||
} | |||
} else { | |||
if (IS_TAPPING_KEY(event.key) && tap_count > 0) { | |||
debug("LAYER_STACK: Tap: unregister_code\n"); | |||
debug("LAYER_SWITCH: Tap: unregister_code\n"); | |||
unregister_code(action.layer.code); | |||
} else { | |||
debug("LAYER_STACK: No tap: layer_stack(on release)\n"); | |||
layer_stack_remove_or_push(action.layer.val); | |||
layer_stack_debug(); | |||
debug("LAYER_SWITCH: No tap: layer_switch(on release)\n"); | |||
layer_switch_inv(action.layer.val); | |||
} | |||
} | |||
break; | |||
@@ -898,6 +889,7 @@ bool sending_anykey(void) | |||
host_last_sysytem_report() || host_last_consumer_report()); | |||
} | |||
// TODO: rename or reinpl with new layer_switch.c | |||
void layer_switch(uint8_t new_layer) | |||
{ | |||
if (current_layer != new_layer) { | |||
@@ -966,7 +958,7 @@ static void debug_action(action_t action) | |||
case ACT_MOUSEKEY: debug("ACT_MOUSEKEY"); break; | |||
case ACT_LAYER: debug("ACT_LAYER"); break; | |||
case ACT_LAYER_BIT: debug("ACT_LAYER_BIT"); break; | |||
case ACT_LAYER_STACK: debug("ACT_LAYER_STACK"); break; | |||
case ACT_LAYER_SWITCH: debug("ACT_LAYER_SWITCH"); break; | |||
case ACT_MACRO: debug("ACT_MACRO"); break; | |||
case ACT_COMMAND: debug("ACT_COMMAND"); break; | |||
case ACT_FUNCTION: debug("ACT_FUNCTION"); break; |
@@ -163,9 +163,6 @@ bool waiting_buffer_has_anykey_pressed(void); | |||
* Layer Actions | |||
* ------------- | |||
* ACT_LAYER(1000): Set layer | |||
* ACT_LAYER_BIT(1001): Bit-op layer | |||
* ACT_LAYER_STACK: Layer stack | |||
* | |||
* 1000|LLLL|0000 0000 set current layer on press and return to default on release(momentary) | |||
* 1000|LLLL|0000 0001 set current layer on press | |||
* 1000|LLLL|0000 0010 set current layer on release | |||
@@ -175,6 +172,7 @@ bool waiting_buffer_has_anykey_pressed(void); | |||
* 1000|DDDD|1111 1111 set default layer on press | |||
* L: 0 means default layer | |||
* | |||
* ACT_LAYER_BIT(1001): Bit-op layer | |||
* 1001|BBBB|0000 0000 bit-on current layer on press and bit-off on release(momentary) | |||
* 1001|BBBB|0000 0001 bit-xor current layer on press | |||
* 1001|BBBB|0000 0010 bit-xor current layer on release | |||
@@ -183,12 +181,13 @@ bool waiting_buffer_has_anykey_pressed(void); | |||
* 1001|BBBB|1111 0000 bit-xor current layer on hold and toggle on several taps | |||
* 1001|BBBB|1111 1111 bit-xor default layer on both | |||
* | |||
* 1011|LLLL|0000 0000 push on press and remove on release(momentary) | |||
* 1011|LLLL|0000 0001 push or remove on press | |||
* 1011|LLLL|0000 0010 push or remove on release | |||
* 1011|LLLL|0000 0011 push or remove on both | |||
* 1011|LLLL| keycode push or remove on hold and send key on tap | |||
* 1011|LLLL|1111 0000 push or remove on hold and toggle on several taps | |||
* ACT_LAYER_SWITCH: Switch | |||
* 1011|LLLL|0000 0000 On on press and Off on release(momentary) | |||
* 1011|LLLL|0000 0001 Invert on press | |||
* 1011|LLLL|0000 0010 Invert on release | |||
* 1011|LLLL|0000 0011 Invert on both | |||
* 1011|LLLL| keycode Invert on hold and send key on tap | |||
* 1011|LLLL|1111 0000 Invert on hold and toggle on several taps | |||
* 1011|LLLL|1111 1111 (not used) | |||
* | |||
* | |||
@@ -219,7 +218,7 @@ enum action_kind_id { | |||
ACT_LAYER = 0b1000, | |||
ACT_LAYER_BIT = 0b1001, | |||
ACT_LAYER_STACK = 0b1011, | |||
ACT_LAYER_SWITCH = 0b1011, | |||
ACT_MACRO = 0b1100, | |||
ACT_COMMAND = 0b1110, | |||
@@ -233,7 +232,7 @@ enum action_kind_id { | |||
#define ACTION(kind, param) ((kind)<<12 | (param)) | |||
#define MODS4(mods) (((mods)>>4 | (mods)) & 0x0F) | |||
/* | |||
/* | |||
* Key | |||
*/ | |||
#define ACTION_KEY(key) ACTION(ACT_LMODS, key) | |||
@@ -316,17 +315,17 @@ enum layer_codes { | |||
#define ACTION_LAYER_BIT_TAP_TOGGLE(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_TAP_TOGGLE) | |||
#define ACTION_LAYER_BIT_TAP_KEY(bits, key) ACTION(ACT_LAYER_BIT, (bits)<<8 | (key)) | |||
/* | |||
* Layer Stack | |||
* Layer SWITCH | |||
*/ | |||
/* momentary */ | |||
#define ACTION_LAYER_STACK(layer) ACTION_LAYER_STACK_MOMENTARY(layer) | |||
#define ACTION_LAYER_STACK_MOMENTARY(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_MOMENTARY) | |||
#define ACTION_LAYER_STACK_TOGGLE(layer) ACTION_LAYER_STACK_R(layer) | |||
#define ACTION_LAYER_STACK_P(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_ON_PRESS) | |||
#define ACTION_LAYER_STACK_R(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_ON_RELEASE) | |||
#define ACTION_LAYER_STACK_B(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_ON_BOTH) | |||
#define ACTION_LAYER_STACK_TAP_TOGGLE(layer) ACTION(ACT_LAYER_STACK, (layer)<<8 | LAYER_TAP_TOGGLE) | |||
#define ACTION_LAYER_STACK_TAP_KEY(layer, key) ACTION(ACT_LAYER_STACK, (layer)<<8 | (key)) | |||
#define ACTION_LAYER_SWITCH(layer) ACTION_LAYER_SWITCH_MOMENTARY(layer) | |||
#define ACTION_LAYER_SWITCH_MOMENTARY(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_MOMENTARY) | |||
#define ACTION_LAYER_SWITCH_TOGGLE(layer) ACTION_LAYER_SWITCH_R(layer) | |||
#define ACTION_LAYER_SWITCH_P(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_PRESS) | |||
#define ACTION_LAYER_SWITCH_R(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_RELEASE) | |||
#define ACTION_LAYER_SWITCH_B(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_ON_BOTH) | |||
#define ACTION_LAYER_SWITCH_TAP_TOGGLE(layer) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | LAYER_TAP_TOGGLE) | |||
#define ACTION_LAYER_SWITCH_TAP_KEY(layer, key) ACTION(ACT_LAYER_SWITCH, (layer)<<8 | (key)) | |||
/* |
@@ -26,8 +26,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
#include "timer.h" | |||
#include "keyboard.h" | |||
#include "bootloader.h" | |||
#include "layer_switch.h" | |||
#include "command.h" | |||
#include "layer_stack.h" | |||
#ifdef MOUSEKEY_ENABLE | |||
#include "mousekey.h" | |||
@@ -549,6 +549,6 @@ static void switch_default_layer(uint8_t layer) | |||
default_layer = layer; | |||
current_layer = 0; /* 0 means default_layer */ | |||
layer_stack_clear(); | |||
layer_switch_clear(); | |||
clear_keyboard(); | |||
} |
@@ -1,108 +0,0 @@ | |||
#include <stdint.h> | |||
#include "keyboard.h" | |||
#include "layer_stack.h" | |||
#include "debug.h" | |||
static uint8_t top_layer = 0; | |||
/* [0] always works as sentinel and not used for store.*/ | |||
static layer_item_t layer_stack[LAYER_STACK_SIZE] = {}; | |||
void layer_stack_clear(void) | |||
{ | |||
for (uint8_t i = 0; i < LAYER_STACK_SIZE; i++) { | |||
layer_stack[i] = (layer_item_t){ .layer = 0, | |||
.next = 0, | |||
.used = false }; | |||
} | |||
} | |||
bool layer_stack_push(uint8_t layer) | |||
{ | |||
for (uint8_t i = 1; i < LAYER_STACK_SIZE; i++) { | |||
if (!layer_stack[i].used) { | |||
layer_stack[i] = (layer_item_t){ .layer = layer, | |||
.next = top_layer, | |||
.used = true }; | |||
top_layer = i; | |||
return true; | |||
} | |||
} | |||
return false; | |||
} | |||
bool layer_stack_pop(void) | |||
{ | |||
if (layer_stack[top_layer].used) { | |||
uint8_t popped = top_layer; | |||
top_layer = layer_stack[popped].next; | |||
layer_stack[popped] = (layer_item_t){}; | |||
return true; | |||
} | |||
return false; | |||
} | |||
bool layer_stack_remove(uint8_t layer) | |||
{ | |||
if (layer_stack[top_layer].used && layer_stack[top_layer].layer == layer) { | |||
layer_stack_pop(); | |||
debug("layer_stack_remove: top_layer\n"); | |||
return true; | |||
} | |||
for (uint8_t i = top_layer; layer_stack[i].used; i = layer_stack[i].next) { | |||
debug("layer_stack_remove: ["); debug_dec(i); debug("]"); | |||
debug_dec(layer_stack[i].layer); debug("\n"); | |||
uint8_t removed = layer_stack[i].next; | |||
if (layer_stack[removed].used && layer_stack[removed].layer == layer) { | |||
layer_stack[i].next = layer_stack[removed].next; | |||
layer_stack[removed] = (layer_item_t){}; | |||
debug("layer_stack_remove: removed.\n"); | |||
return true; | |||
} | |||
} | |||
return false; | |||
} | |||
bool layer_stack_remove_then_push(uint8_t layer) | |||
{ | |||
layer_stack_remove(layer); | |||
return layer_stack_push(layer); | |||
} | |||
bool layer_stack_remove_or_push(uint8_t layer) | |||
{ | |||
return (layer_stack_remove(layer)) || layer_stack_push(layer); | |||
} | |||
void layer_stack_debug(void) | |||
{ | |||
debug("layer_stack: "); | |||
layer_item_t item = layer_stack[top_layer]; | |||
while (item.used) { | |||
debug_dec(item.layer); | |||
debug("["); debug_dec(item.next); debug("] "); | |||
item = layer_stack[item.next]; | |||
} | |||
debug("\n"); | |||
} | |||
action_t layer_stack_get_action(key_t key) | |||
{ | |||
action_t action; | |||
action.code = ACTION_TRANSPARENT; | |||
/* layer stack */ | |||
for (layer_item_t i = layer_stack[top_layer]; i.used; i = layer_stack[i.next]) { | |||
action = action_for_key(i.layer, key); | |||
if (action.code != ACTION_TRANSPARENT) { | |||
layer_stack_debug(); | |||
debug("layer_stack: used. "); debug_dec(i.layer); debug("\n"); | |||
return action; | |||
} | |||
debug("layer_stack: through. "); debug_dec(i.layer); debug("\n"); | |||
} | |||
return action; | |||
} |
@@ -0,0 +1,68 @@ | |||
#include <stdint.h> | |||
#include "keyboard.h" | |||
#include "action.h" | |||
#include "debug.h" | |||
#include "layer_switch.h" | |||
uint16_t layer_switch_stat = 0; | |||
uint16_t layer_switch_stat_get(void) | |||
{ | |||
return layer_switch_stat; | |||
} | |||
void layer_switch_stat_set(uint16_t stat) | |||
{ | |||
layer_switch_stat = stat; | |||
layer_switch_debug(); | |||
} | |||
void layer_switch_clear(void) | |||
{ | |||
layer_switch_stat = 0; | |||
layer_switch_debug(); | |||
} | |||
void layer_switch_on(uint8_t layer) | |||
{ | |||
layer_switch_stat |= (1<<layer); | |||
layer_switch_debug(); | |||
} | |||
void layer_switch_off(uint8_t layer) | |||
{ | |||
layer_switch_stat &= ~(1<<layer); | |||
layer_switch_debug(); | |||
} | |||
void layer_switch_inv(uint8_t layer) | |||
{ | |||
layer_switch_stat ^= (1<<layer); | |||
layer_switch_debug(); | |||
} | |||
void layer_switch_debug(void) | |||
{ | |||
debug("layer_switch_stat: "); debug_bin16(layer_switch_stat); debug("\n"); | |||
} | |||
action_t layer_switch_get_action(key_t key) | |||
{ | |||
action_t action; | |||
action.code = ACTION_TRANSPARENT; | |||
/* higher layer first */ | |||
for (int8_t i = 15; i >= 0; i--) { | |||
if (layer_switch_stat & (1<<i)) { | |||
action = action_for_key(i, key); | |||
if (action.code != ACTION_TRANSPARENT) { | |||
layer_switch_debug(); | |||
debug("layer_switch: used. "); debug_dec(i); debug("\n"); | |||
return action; | |||
} | |||
} | |||
} | |||
return action; | |||
} |
@@ -14,32 +14,23 @@ GNU General Public License for more details. | |||
You should have received a copy of the GNU General Public License | |||
along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
*/ | |||
#ifndef LAYER_STACK_H | |||
#define LAYER_STACK_H | |||
#ifndef LAYER_SWITCH_H | |||
#define LAYER_SWITCH_H | |||
#include <stdint.h> | |||
#include "keyboard.h" | |||
#include "action.h" | |||
uint16_t layer_switch_stat; | |||
/* | |||
* Layer stack | |||
*/ | |||
#define LAYER_STACK_SIZE 8 | |||
typedef struct { | |||
uint8_t layer:4; | |||
uint8_t next:3; | |||
bool used; | |||
} layer_item_t; | |||
void layer_stack_clear(void); | |||
bool layer_stack_push(uint8_t layer); | |||
bool layer_stack_pop(void); | |||
bool layer_stack_remove(uint8_t layer); | |||
bool layer_stack_remove_then_push(uint8_t layer); | |||
bool layer_stack_remove_or_push(uint8_t layer); | |||
void layer_stack_debug(void); | |||
action_t layer_stack_get_action(key_t key); | |||
uint16_t layer_switch_stat_get(void); | |||
void layer_switch_stat_set(uint16_t stat); | |||
void layer_switch_clear(void); | |||
void layer_switch_on(uint8_t layer); | |||
void layer_switch_off(uint8_t layer); | |||
/* invert state */ | |||
void layer_switch_inv(uint8_t layer); | |||
void layer_switch_debug(void); | |||
action_t layer_switch_get_action(key_t key); | |||
#endif | |||