di0ib/tmk_keyboard_custom
Archived
1
0
Fork 0
Code Releases Activity

Merge branch 'layer_switch'

Browse Source
This commit is contained in:
tmk 2013-02-16 04:20:01 +09:00
commit 98d96b3b9a
10 changed files with 264 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
common.mk
View File

@ -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 \

135
common/action.c
View File

@ -24,13 +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"
/* default layer indicates base layer */
uint8_t default_layer = 0;
/* current layer indicates active layer at this time */
uint8_t current_layer = 0;
#include "layer_switch.h"
static void process_action(keyrecord_t *record);
@ -213,23 +207,14 @@ 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;
}
/* current layer: 0 means default layer */
if (current_layer) {
action = action_for_key(current_layer, key);
if (action.code != ACTION_TRANSPARENT) {
debug("current layer: used. "); debug_dec(current_layer); debug("\n");
return action;
}
}
/* default layer */
debug("default layer: used. \n");
//debug("get_aciton: default layer: "); debug_dec(default_layer); debug("\n");
action = action_for_key(default_layer, key);
return action;
}
@ -242,7 +227,8 @@ static void process_action(keyrecord_t *record)
if (IS_NOEVENT(event)) { return; }
action_t action = get_action(event.key);
debug("ACTION: "); debug_action(action); debug("\n");
debug("ACTION: "); debug_action(action); debug(" ");
layer_switch_debug(); debug("["); debug_dec(default_layer); debug("]\n");
switch (action.kind.id) {
/* Key and Mods */
@ -383,57 +369,57 @@ static void process_action(keyrecord_t *record)
break;
/* Layer key */
case ACT_LAYER:
case ACT_LAYER_SET:
switch (action.layer.code) {
case LAYER_MOMENTARY: /* momentary */
if (event.pressed) {
layer_switch(action.layer.val);
layer_switch_move(action.layer.val);
}
else {
// NOTE: This is needed by legacy keymap support
layer_switch(0);
layer_switch_move(0);
}
break;
case LAYER_ON_PRESS:
if (event.pressed) {
layer_switch(action.layer.val);
layer_switch_move(action.layer.val);
}
break;
case LAYER_ON_RELEASE:
if (!event.pressed) {
layer_switch(action.layer.val);
layer_switch_move(action.layer.val);
}
break;
case LAYER_ON_BOTH:
layer_switch(action.layer.val);
layer_switch_move(action.layer.val);
break;
case LAYER_TAP_TOGGLE: /* switch on hold and toggle on several taps */
if (event.pressed) {
if (tap_count < TAPPING_TOGGLE) {
layer_switch(action.layer.val);
layer_switch_move(action.layer.val);
}
} else {
if (tap_count >= TAPPING_TOGGLE) {
debug("LAYER_PRESSED: tap toggle.\n");
layer_switch(action.layer.val);
layer_switch_move(action.layer.val);
}
}
break;
case LAYER_SET_DEFAULT_ON_PRESS:
if (event.pressed) {
default_layer = action.layer.val;
layer_switch(0);
layer_switch_move(0);
}
break;
case LAYER_SET_DEFAULT_ON_RELEASE:
if (!event.pressed) {
default_layer = action.layer.val;
layer_switch(0);
layer_switch_move(0);
}
break;
case LAYER_SET_DEFAULT_ON_BOTH:
default_layer = action.layer.val;
layer_switch(0);
layer_switch_move(0);
break;
default:
/* tap key */
@ -443,7 +429,7 @@ static void process_action(keyrecord_t *record)
register_code(action.layer.code);
} else {
debug("LAYER_SET: No tap: layer_set(on press)\n");
layer_switch(action.layer.val);
layer_switch_move(action.layer.val);
}
} else {
if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
@ -452,7 +438,7 @@ static void process_action(keyrecord_t *record)
} else {
// NOTE: This is needed by legacy keymap support
debug("LAYER_SET: No tap: return to default layer(on release)\n");
layer_switch(0);
layer_switch_move(0);
}
}
break;
@ -462,52 +448,52 @@ static void process_action(keyrecord_t *record)
switch (action.layer.code) {
case LAYER_MOMENTARY: /* momentary */
if (event.pressed) {
layer_switch(current_layer | action.layer.val);
layer_switch_move(layer_switch_get_layer() | action.layer.val);
} else {
layer_switch(current_layer & ~action.layer.val);
layer_switch_move(layer_switch_get_layer() & ~action.layer.val);
}
break;
case LAYER_ON_PRESS:
if (event.pressed) {
layer_switch(current_layer ^ action.layer.val);
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
}
break;
case LAYER_ON_RELEASE:
if (!event.pressed) {
layer_switch(current_layer ^ action.layer.val);
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
}
break;
case LAYER_ON_BOTH:
layer_switch(current_layer ^ action.layer.val);
layer_switch_move(layer_switch_get_layer() ^ 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_BIT: tap toggle(press).\n");
layer_switch(current_layer ^ action.layer.val);
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
}
} else {
if (tap_count <= TAPPING_TOGGLE) {
debug("LAYER_BIT: tap toggle(release).\n");
layer_switch(current_layer ^ action.layer.val);
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
}
}
break;
case LAYER_SET_DEFAULT_ON_PRESS:
if (event.pressed) {
default_layer = default_layer ^ action.layer.val;
layer_switch(0);
layer_switch_move(default_layer);
}
break;
case LAYER_SET_DEFAULT_ON_RELEASE:
if (!event.pressed) {
default_layer = default_layer ^ action.layer.val;
layer_switch(0);
layer_switch_move(default_layer);
}
break;
case LAYER_SET_DEFAULT_ON_BOTH:
default_layer = default_layer ^ action.layer.val;
layer_switch(0);
layer_switch_move(default_layer);
break;
default:
// tap key
@ -517,7 +503,7 @@ static void process_action(keyrecord_t *record)
register_code(action.layer.code);
} else {
debug("LAYER_BIT: No tap: layer_bit(on press)\n");
layer_switch(current_layer ^ action.layer.val);
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
}
} else {
if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
@ -525,51 +511,44 @@ static void process_action(keyrecord_t *record)
unregister_code(action.layer.code);
} else {
debug("LAYER_BIT: No tap: layer_bit(on release)\n");
layer_switch(current_layer ^ action.layer.val);
layer_switch_move(layer_switch_get_layer() ^ action.layer.val);
}
}
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_invert(action.layer.val);
}
break;
case LAYER_ON_RELEASE:
if (!event.pressed) {
layer_stack_remove_or_push(action.layer.val);
layer_stack_debug();
layer_switch_invert(action.layer.val);
}
break;
case LAYER_ON_BOTH:
layer_stack_remove_or_push(action.layer.val);
layer_stack_debug();
layer_switch_invert(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_invert(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_invert(action.layer.val);
}
}
break;
@ -577,21 +556,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_invert(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_invert(action.layer.val);
}
}
break;
@ -898,18 +875,6 @@ bool sending_anykey(void)
host_last_sysytem_report() || host_last_consumer_report());
}
void layer_switch(uint8_t new_layer)
{
if (current_layer != new_layer) {
debug("Layer Switch: "); debug_hex(current_layer);
debug(" -> "); debug_hex(new_layer); debug("\n");
current_layer = new_layer;
clear_keyboard_but_mods(); // To avoid stuck keys
// NOTE: update mods with full scan of matrix? if modifier changes between layers
}
}
bool is_tap_key(key_t key)
{
action_t action = get_action(key);
@ -918,7 +883,7 @@ bool is_tap_key(key_t key)
case ACT_LMODS_TAP:
case ACT_RMODS_TAP:
return true;
case ACT_LAYER:
case ACT_LAYER_SET:
case ACT_LAYER_BIT:
switch (action.layer.code) {
case LAYER_MOMENTARY:
@ -964,9 +929,9 @@ static void debug_action(action_t action)
case ACT_RMODS_TAP: debug("ACT_RMODS_TAP"); break;
case ACT_USAGE: debug("ACT_USAGE"); break;
case ACT_MOUSEKEY: debug("ACT_MOUSEKEY"); break;
case ACT_LAYER: debug("ACT_LAYER"); break;
case ACT_LAYER_SET: debug("ACT_LAYER_SET"); 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;

74
common/action.h
View File

@ -76,11 +76,6 @@ typedef union {
/* layer used currently */
extern uint8_t current_layer;
/* layer to return or start with */
extern uint8_t default_layer;
/* Execute action per keyevent */
void action_exec(keyevent_t event);
@ -155,17 +150,14 @@ bool waiting_buffer_has_anykey_pressed(void);
*
* Mouse Keys
* ----------
* TODO: can be combined with 'Other HID Usage'? to save action kind id.
* NOTE: can be combined with 'Other HID Usage'? to save action kind id.
* ACT_MOUSEKEY(0110):
* 0101|XXXX| keycode Mouse key
*
*
* Layer Actions
* -------------
* ACT_LAYER(1000): Set layer
* ACT_LAYER_BIT(1001): Bit-op layer
* ACT_LAYER_STACK: Layer stack
*
* ACT_LAYER_SET(1000): Set layer
* 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 +167,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 +176,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)
*
*
@ -217,9 +211,9 @@ enum action_kind_id {
ACT_USAGE = 0b0100,
ACT_MOUSEKEY = 0b0101,
ACT_LAYER = 0b1000,
ACT_LAYER_SET = 0b1000,
ACT_LAYER_BIT = 0b1001,
ACT_LAYER_STACK = 0b1011,
ACT_LAYER_SWITCH = 0b1011,
ACT_MACRO = 0b1100,
ACT_COMMAND = 0b1110,
@ -233,7 +227,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)
@ -278,14 +272,14 @@ enum layer_codes {
*/
/* set default layer */
#define ACTION_LAYER_SET_DEFAULT(layer) ACTION_LAYER_SET_DEFAULT_R(layer)
#define ACTION_LAYER_SET_DEFAULT_P(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_SET_DEFAULT_ON_PRESS)
#define ACTION_LAYER_SET_DEFAULT_R(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_SET_DEFAULT_ON_RELEASE)
#define ACTION_LAYER_SET_DEFAULT_B(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_SET_DEFAULT_ON_BOTH)
#define ACTION_LAYER_SET_DEFAULT_P(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_PRESS)
#define ACTION_LAYER_SET_DEFAULT_R(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_RELEASE)
#define ACTION_LAYER_SET_DEFAULT_B(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_SET_DEFAULT_ON_BOTH)
/* bit-xor default layer */
#define ACTION_LAYER_BIT_DEFAULT(bits) ACTION_LAYER_BIT_DEFAULT_R(bits)
#define ACTION_LAYER_BIT_DEFAULT_P(bits) ACTION(ACT_LAYER, (bits)<<8 | LAYER_SET_DEFAULT_ON_PRESS)
#define ACTION_LAYER_BIT_DEFAULT_R(bits) ACTION(ACT_LAYER, (bits)<<8 | LAYER_SET_DEFAULT_ON_RELEASE)
#define ACTION_LAYER_BIT_DEFAULT_B(bits) ACTION(ACT_LAYER, (bits)<<8 | LAYER_SET_DEFAULT_ON_BOTH)
#define ACTION_LAYER_BIT_DEFAULT_P(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_PRESS)
#define ACTION_LAYER_BIT_DEFAULT_R(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_RELEASE)
#define ACTION_LAYER_BIT_DEFAULT_B(bits) ACTION(ACT_LAYER_BIT, (bits)<<8 | LAYER_SET_DEFAULT_ON_BOTH)
/*
* Current layer: Return to default layer
*/
@ -297,13 +291,13 @@ enum layer_codes {
* Current layer: Set
*/
#define ACTION_LAYER_SET(layer) ACTION_LAYER_SET_P(layer)
#define ACTION_LAYER_SET_MOMENTARY(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_MOMENTARY)
#define ACTION_LAYER_SET_MOMENTARY(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_MOMENTARY)
#define ACTION_LAYER_SET_TOGGLE(layer) ACTION_LAYER_SET_R(layer)
#define ACTION_LAYER_SET_P(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_PRESS)
#define ACTION_LAYER_SET_R(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_RELEASE)
#define ACTION_LAYER_SET_B(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_ON_BOTH)
#define ACTION_LAYER_SET_TAP_TOGGLE(layer) ACTION(ACT_LAYER, (layer)<<8 | LAYER_TAP_TOGGLE)
#define ACTION_LAYER_SET_TAP_KEY(layer, key) ACTION(ACT_LAYER, (layer)<<8 | (key))
#define ACTION_LAYER_SET_P(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_PRESS)
#define ACTION_LAYER_SET_R(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_RELEASE)
#define ACTION_LAYER_SET_B(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_ON_BOTH)
#define ACTION_LAYER_SET_TAP_TOGGLE(layer) ACTION(ACT_LAYER_SET, (layer)<<8 | LAYER_TAP_TOGGLE)
#define ACTION_LAYER_SET_TAP_KEY(layer, key) ACTION(ACT_LAYER_SET, (layer)<<8 | (key))
/*
* Current layer: Bit-op
*/
@ -316,17 +310,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))
/*

11
common/command.c
View File

@ -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"
@ -543,12 +543,9 @@ static uint8_t numkey2num(uint8_t code)
static void switch_default_layer(uint8_t layer)
{
print_val_hex8(current_layer);
print_val_hex8(default_layer);
print("switch to "); print_val_hex8(layer);
// TODO check existence of layer or whether it can be used as default layer
print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer);
default_layer = layer;
current_layer = 0; /* 0 means default_layer */
layer_stack_clear();
layer_switch_clear();
clear_keyboard();
}

108
common/layer_stack.c
View File

@ -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;
}

45
common/layer_stack.h
View File

@ -1,45 +0,0 @@
/*
Copyright 2013 Jun Wako <wakojun@gmail.com>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
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
#include <stdint.h>
#include "action.h"
/*
* 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);
#endif

104
common/layer_switch.c Normal file
View File

@ -0,0 +1,104 @@
#include <stdint.h>
#include "keyboard.h"
#include "action.h"
#include "debug.h"
#include "util.h"
#include "layer_switch.h"
uint8_t default_layer = 0;
uint16_t layer_switch_stat = 0;
uint16_t layer_switch_get_stat(void)
{
return layer_switch_stat;
}
/* return highest layer whose state is on */
uint8_t layer_switch_get_layer(void)
{
return biton16(layer_switch_stat);
}
static inline void stat_set(uint16_t stat)
{
debug("layer_switch: ");
layer_switch_debug(); debug(" to ");
layer_switch_stat = stat;
layer_switch_debug(); debug("\n");
clear_keyboard_but_mods(); // To avoid stuck keys
}
void layer_switch_clear(void)
{
stat_set(0);
}
void layer_switch_set(uint16_t stat)
{
stat_set(stat);
}
void layer_switch_move(uint8_t layer)
{
if (layer)
stat_set(1<<layer);
else
stat_set(0); // fall back to default layer
}
void layer_switch_on(uint8_t layer)
{
stat_set(layer_switch_stat | (1<<layer));
}
void layer_switch_off(uint8_t layer)
{
stat_set(layer_switch_stat & ~(1<<layer));
}
void layer_switch_invert(uint8_t layer)
{
stat_set(layer_switch_stat ^ (1<<layer));
}
void layer_switch_or(uint16_t stat)
{
stat_set(layer_switch_stat | stat);
}
void layer_switch_and(uint16_t stat)
{
stat_set(layer_switch_stat & stat);
}
void layer_switch_xor(uint16_t stat)
{
stat_set(layer_switch_stat ^ stat);
}
void layer_switch_debug(void)
{
debug_hex16(layer_switch_stat); debug("("); debug_dec(layer_switch_get_layer()); debug(")");
}
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) {
return action;
}
}
}
return action;
}

59
common/layer_switch.h Normal file
View File

@ -0,0 +1,59 @@
/*
Copyright 2013 Jun Wako <wakojun@gmail.com>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
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_SWITCH_H
#define LAYER_SWITCH_H
#include <stdint.h>
#include "keyboard.h"
#include "action.h"
/* base layer to fall back */
extern uint8_t default_layer;
/* layer status */
extern uint16_t layer_switch_stat;
/* return layer status */
uint16_t layer_switch_get_stat(void);
/* return current active layer */
uint8_t layer_switch_get_layer(void);
/* switch off all layers */
void layer_switch_clear(void);
/* set layer status */
void layer_switch_set(uint16_t stat);
/* move to layer */
void layer_switch_move(uint8_t layer);
/* switch on layer */
void layer_switch_on(uint8_t layer);
/* switch off layer */
void layer_switch_off(uint8_t layer);
/* switch state of layer */
void layer_switch_invert(uint8_t layer);
/* bitwise operation against layer status */
void layer_switch_or(uint16_t stat);
void layer_switch_and(uint16_t stat);
void layer_switch_xor(uint16_t stat);
void layer_switch_debug(void);
/* return action depending on current layer status */
action_t layer_switch_get_action(key_t key);
#endif

11
common/util.c
View File

@ -39,6 +39,7 @@ uint8_t bitpop16(uint16_t bits)
}
// most significant on-bit - return highest location of on-bit
// NOTE: return 0 when bit0 is on or all bits are off
uint8_t biton(uint8_t bits)
{
uint8_t n = 0;
@ -47,3 +48,13 @@ uint8_t biton(uint8_t bits)
if (bits >> 1) { bits >>= 1; n += 1;}
return n;
}
uint8_t biton16(uint16_t bits)
{
uint8_t n = 0;
if (bits >> 8) { bits >>= 8; n += 8;}
if (bits >> 4) { bits >>= 4; n += 4;}
if (bits >> 2) { bits >>= 2; n += 2;}
if (bits >> 1) { bits >>= 1; n += 1;}
return n;
}

1
common/util.h
View File

@ -31,5 +31,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
uint8_t bitpop(uint8_t bits);
uint8_t bitpop16(uint16_t bits);
uint8_t biton(uint8_t bits);
uint8_t biton16(uint16_t bits);
#endif