muflax
/
ergodox-firmware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

refactor

master
Stefan Dorn 2016-06-12 05:20:40 +01:00
parent 445e25b01b
commit 2f2c3d6994
2 changed files with 82 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
src/main.c
View File

@ -63,9 +63,6 @@ static uint8_t layers_top = 0;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
/*
* main()
*/
int main(void) { int main(void) {
kb_init(); // does controller initialization too kb_init(); // does controller initialization too
@ -73,19 +70,18 @@ int main(void) {
while (!usb_configured()); while (!usb_configured());
// initialize layers // initialize layers
main_init_layers(); init_layers();
// never return // never return
main_key_loop(); main_key_loop();
return 0; return 0;
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// layer functions // layer functions
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
void main_init_layers() { void init_layers() {
for (uint8_t layer=0; layer < KB_LAYERS; layer++) { for (uint8_t layer=0; layer < KB_LAYERS; layer++) {
layers_active[layer] = false; layers_active[layer] = false;
layers_sticky[layer] = StickyNone; layers_sticky[layer] = StickyNone;
@ -107,17 +103,17 @@ uint8_t _highest_active_layer(uint8_t offset) {
} }
// return the highest active layer // return the highest active layer
uint8_t main_layers_top_layer() { uint8_t top_layer() {
return layers_top; return layers_top;
} }
// return if highest active layer is sticky // return if highest active layer is sticky
StickyState main_layers_top_sticky() { StickyState layer_top_sticky() {
return main_layers_sticky(layers_top); return layer_sticky(layers_top);
} }
// return if layer is sticky // return if layer is sticky
StickyState main_layers_sticky(uint8_t layer) { StickyState layer_sticky(uint8_t layer) {
if (layer < KB_LAYERS) { if (layer < KB_LAYERS) {
return layers_sticky[layer]; return layers_sticky[layer];
} }
@ -125,7 +121,7 @@ StickyState main_layers_sticky(uint8_t layer) {
} }
// enable a layer // enable a layer
void main_layers_enable(uint8_t layer, StickyState sticky) { void layer_enable(uint8_t layer, StickyState sticky) {
if (layer >= KB_LAYERS) { return; } if (layer >= KB_LAYERS) { return; }
layers_active[layer] = true; layers_active[layer] = true;
@ -137,7 +133,7 @@ void main_layers_enable(uint8_t layer, StickyState sticky) {
} }
// disable a layer // disable a layer
void main_layers_disable(uint8_t layer) { void layer_disable(uint8_t layer) {
// base layer stays always on // base layer stays always on
if (layer >= KB_LAYERS || layer == 0) { return; } if (layer >= KB_LAYERS || layer == 0) { return; }
@ -150,17 +146,17 @@ void main_layers_disable(uint8_t layer) {
} }
// disable the highest active layer // disable the highest active layer
void main_layers_disable_top() { void layer_disable_top() {
main_layers_disable(layers_top); layer_disable(layers_top);
} }
// return layer offset elements below the top // return layer offset elements below the top
uint8_t main_layers_peek(uint8_t offset) { uint8_t layer_peek(uint8_t offset) {
return _highest_active_layer(offset); return _highest_active_layer(offset);
} }
// execute the keypress or keyrelease function (if it exists) of the key at the current possition // execute the keypress or keyrelease function (if it exists) of the key at the current possition
void main_exec_key(void) { void exec_key(void) {
void (*key_function)(void) = void (*key_function)(void) =
( (current_is_pressed) ( (current_is_pressed)
? kb_layout_press_get(current_layer, current_row, current_col) ? kb_layout_press_get(current_layer, current_row, current_col)
@ -172,8 +168,8 @@ void main_exec_key(void) {
// If the current layer is in the sticky once up state and a key defined // If the current layer is in the sticky once up state and a key defined
// for this layer (a non-transparent key) was pressed, pop the layer // for this layer (a non-transparent key) was pressed, pop the layer
if (main_layers_top_sticky() == StickyOnceUp && non_trans_key_pressed) { if (layer_top_sticky() == StickyOnceUp && non_trans_key_pressed) {
main_layers_disable_top(); layer_disable_top();
} }
} }
@ -209,30 +205,53 @@ void _kbfun_press_release(bool press, uint8_t keycode) {
return; return;
} }
if (press) {
_kbfun_press(keycode);
} else {
_kbfun_release(keycode);
}
}
void _kbfun_press(uint8_t keycode) {
// modifier keys // modifier keys
switch (keycode) { switch (keycode) {
case KEY_LeftControl: (press) ? (keyboard_modifier_keys |= (1<<0)) : (keyboard_modifier_keys &= ~(1<<0)); return; case KEY_LeftControl: keyboard_modifier_keys |= (1<<0); return;
case KEY_LeftShift: (press) ? (keyboard_modifier_keys |= (1<<1)) : (keyboard_modifier_keys &= ~(1<<1)); return; case KEY_LeftShift: keyboard_modifier_keys |= (1<<1); return;
case KEY_LeftAlt: (press) ? (keyboard_modifier_keys |= (1<<2)) : (keyboard_modifier_keys &= ~(1<<2)); return; case KEY_LeftAlt: keyboard_modifier_keys |= (1<<2); return;
case KEY_LeftGUI: (press) ? (keyboard_modifier_keys |= (1<<3)) : (keyboard_modifier_keys &= ~(1<<3)); return; case KEY_LeftGUI: keyboard_modifier_keys |= (1<<3); return;
case KEY_RightControl: (press) ? (keyboard_modifier_keys |= (1<<4)) : (keyboard_modifier_keys &= ~(1<<4)); return; case KEY_RightControl: keyboard_modifier_keys |= (1<<4); return;
case KEY_RightShift: (press) ? (keyboard_modifier_keys |= (1<<5)) : (keyboard_modifier_keys &= ~(1<<5)); return; case KEY_RightShift: keyboard_modifier_keys |= (1<<5); return;
case KEY_RightAlt: (press) ? (keyboard_modifier_keys |= (1<<6)) : (keyboard_modifier_keys &= ~(1<<6)); return; case KEY_RightAlt: keyboard_modifier_keys |= (1<<6); return;
case KEY_RightGUI: (press) ? (keyboard_modifier_keys |= (1<<7)) : (keyboard_modifier_keys &= ~(1<<7)); return; case KEY_RightGUI: keyboard_modifier_keys |= (1<<7); return;
} }
// all others // all others
for (uint8_t i=0; i<6; i++) { for (uint8_t i=0; i<6; i++) {
if (press) { if (keyboard_keys[i] == 0) {
if (keyboard_keys[i] == 0) { keyboard_keys[i] = keycode;
keyboard_keys[i] = keycode; return;
return; }
} }
} else { }
if (keyboard_keys[i] == keycode) {
keyboard_keys[i] = 0; void _kbfun_release(uint8_t keycode) {
return; // modifier keys
} switch (keycode) {
case KEY_LeftControl: keyboard_modifier_keys &= ~(1<<0); return;
case KEY_LeftShift: keyboard_modifier_keys &= ~(1<<1); return;
case KEY_LeftAlt: keyboard_modifier_keys &= ~(1<<2); return;
case KEY_LeftGUI: keyboard_modifier_keys &= ~(1<<3); return;
case KEY_RightControl: keyboard_modifier_keys &= ~(1<<4); return;
case KEY_RightShift: keyboard_modifier_keys &= ~(1<<5); return;
case KEY_RightAlt: keyboard_modifier_keys &= ~(1<<6); return;
case KEY_RightGUI: keyboard_modifier_keys &= ~(1<<7); return;
}
// all others
for (uint8_t i=0; i<6; i++) {
if (keyboard_keys[i] == keycode) {
keyboard_keys[i] = 0;
return;
} }
} }
} }
@ -323,9 +342,9 @@ void kbfun_transparent(void) {
// TODO maybe re-implement this cleaner? // TODO maybe re-implement this cleaner?
trans_key_pressed = true; trans_key_pressed = true;
layer_offset++; layer_offset++;
current_layer = main_layers_peek(layer_offset); current_layer = layer_peek(layer_offset);
layers_pressed[current_row][current_col] = current_layer; layers_pressed[current_row][current_col] = current_layer;
main_exec_key(); exec_key();
} }
@ -357,7 +376,7 @@ static void layer_enable_upto(uint8_t max_layer) {
if (is_layer_enable(key_function)) { if (is_layer_enable(key_function)) {
uint8_t enable_layer = kb_layout_get(layer, current_row, current_col); uint8_t enable_layer = kb_layout_get(layer, current_row, current_col);
if (enable_layer <= max_layer) { if (enable_layer <= max_layer) {
main_layers_enable(enable_layer, StickyNone); layer_enable(enable_layer, StickyNone);
} }
} }
} }
@ -374,9 +393,9 @@ void kbfun_layer_enable() {
// FIXME useful for anything? // FIXME useful for anything?
// Only the topmost layer on the stack should be in sticky once state, pop // Only the topmost layer on the stack should be in sticky once state, pop
// the top layer if it is in sticky once state // the top layer if it is in sticky once state
/* uint8_t topSticky = main_layers_top_sticky(); */ /* uint8_t topSticky = layer_top_sticky(); */
/* if (topSticky == StickyOnceDown || topSticky == StickyOnceUp) { */ /* if (topSticky == StickyOnceDown || topSticky == StickyOnceUp) { */
/* main_layers_disable_top(); */ /* layer_disable_top(); */
/* } */ /* } */
layer_enable_upto(layer); layer_enable_upto(layer);
@ -393,7 +412,7 @@ void kbfun_layer_disable() {
if (is_layer_disable(key_function)) { if (is_layer_disable(key_function)) {
uint8_t disable_layer = kb_layout_get(layer, current_row, current_col); uint8_t disable_layer = kb_layout_get(layer, current_row, current_col);
main_layers_disable(disable_layer); layer_disable(disable_layer);
} }
} }
} }
@ -415,35 +434,35 @@ void kbfun_layer_disable() {
*/ */
void kbfun_layer_sticky() { void kbfun_layer_sticky() {
uint8_t layer = _kbfun_get_keycode(); uint8_t layer = _kbfun_get_keycode();
uint8_t topLayer = main_layers_top_layer(); uint8_t topLayer = top_layer();
StickyState topSticky = main_layers_top_sticky(); StickyState topSticky = layer_top_sticky();
if (current_is_pressed) { if (current_is_pressed) {
if (topLayer == layer) { if (topLayer == layer) {
// FIXME // FIXME
/* if (topSticky == StickyOnceUp) { */ /* if (topSticky == StickyOnceUp) { */
/* main_layers_enable(layer, StickyLock); */ /* layer_enable(layer, StickyLock); */
/* } */ /* } */
} else { } else {
// only the topmost layer on the stack should be in sticky once state // only the topmost layer on the stack should be in sticky once state
if (topSticky == StickyOnceDown || topSticky == StickyOnceUp) { if (topSticky == StickyOnceDown || topSticky == StickyOnceUp) {
main_layers_disable_top(); layer_disable_top();
} }
main_layers_enable(layer, StickyOnceDown); layer_enable(layer, StickyOnceDown);
// this should be the only place we care about this flag being cleared // this should be the only place we care about this flag being cleared
non_trans_key_pressed = false; non_trans_key_pressed = false;
} }
} else { } else {
if (main_layers_sticky(layer) == StickyOnceDown) { if (layer_sticky(layer) == StickyOnceDown) {
// When releasing this sticky key, pop the layer always // When releasing this sticky key, pop the layer always
main_layers_disable(layer); layer_disable(layer);
if (!non_trans_key_pressed) { if (!non_trans_key_pressed) {
// If no key defined for this layer (a non-transparent key) // If no key defined for this layer (a non-transparent key)
// was pressed, push the layer again, but in the // was pressed, push the layer again, but in the
// StickyOnceUp state // StickyOnceUp state
main_layers_enable(layer, StickyOnceUp); layer_enable(layer, StickyOnceUp);
} }
} }
} }
@ -548,7 +567,7 @@ void main_key_loop() {
if (current_is_pressed != was_pressed) { if (current_is_pressed != was_pressed) {
if (current_is_pressed) { if (current_is_pressed) {
current_layer = main_layers_top_layer(); current_layer = top_layer();
layers_pressed[row][col] = current_layer; layers_pressed[row][col] = current_layer;
trans_key_pressed = false; trans_key_pressed = false;
} else { } else {
@ -560,7 +579,7 @@ void main_key_loop() {
current_row = row; current_row = row;
current_col = col; current_col = col;
layer_offset = 0; layer_offset = 0;
main_exec_key(); exec_key();
kb_was_transparent[row][col] = trans_key_pressed; kb_was_transparent[row][col] = trans_key_pressed;
} }
} }

20
src/main.h
View File

@ -13,19 +13,21 @@ void kbfun_press_release();
uint8_t _kbfun_get_keycode(); uint8_t _kbfun_get_keycode();
void _kbfun_mediakey_press_release(bool press,uint8_t keycode); void _kbfun_mediakey_press_release(bool press,uint8_t keycode);
bool _kbfun_is_pressed(uint8_t keycode); bool _kbfun_is_pressed(uint8_t keycode);
void _kbfun_release(uint8_t keycode);
void _kbfun_press(uint8_t keycode);
void _kbfun_press_release(bool press,uint8_t keycode); void _kbfun_press_release(bool press,uint8_t keycode);
uint8_t kb_layout_get(uint8_t layer,uint8_t row,uint8_t column); uint8_t kb_layout_get(uint8_t layer,uint8_t row,uint8_t column);
void_funptr_t kb_layout_release_get(uint8_t layer,uint8_t row,uint8_t column); void_funptr_t kb_layout_release_get(uint8_t layer,uint8_t row,uint8_t column);
void_funptr_t kb_layout_press_get(uint8_t layer,uint8_t row,uint8_t column); void_funptr_t kb_layout_press_get(uint8_t layer,uint8_t row,uint8_t column);
void main_exec_key(void); void exec_key(void);
uint8_t main_layers_peek(uint8_t offset); uint8_t layer_peek(uint8_t offset);
void main_layers_disable_top(); void layer_disable_top();
void main_layers_disable(uint8_t layer); void layer_disable(uint8_t layer);
void main_layers_enable(uint8_t layer,StickyState sticky); void layer_enable(uint8_t layer,StickyState sticky);
StickyState main_layers_sticky(uint8_t layer); StickyState layer_sticky(uint8_t layer);
StickyState main_layers_top_sticky(); StickyState layer_top_sticky();
uint8_t main_layers_top_layer(); uint8_t top_layer();
uint8_t _highest_active_layer(uint8_t offset); uint8_t _highest_active_layer(uint8_t offset);
void main_key_loop(); void main_key_loop();
void main_init_layers(); void init_layers();
int main(void); int main(void);