diff --git a/src/main.c b/src/main.c index 5f396d7..de993ef 100644 --- a/src/main.c +++ b/src/main.c @@ -63,9 +63,6 @@ static uint8_t layers_top = 0; // ---------------------------------------------------------------------------- -/* - * main() - */ int main(void) { kb_init(); // does controller initialization too @@ -73,19 +70,18 @@ int main(void) { while (!usb_configured()); // initialize layers - main_init_layers(); + init_layers(); // never return main_key_loop(); return 0; } - // ---------------------------------------------------------------------------- // layer functions // ---------------------------------------------------------------------------- -void main_init_layers() { +void init_layers() { for (uint8_t layer=0; layer < KB_LAYERS; layer++) { layers_active[layer] = false; layers_sticky[layer] = StickyNone; @@ -107,17 +103,17 @@ uint8_t _highest_active_layer(uint8_t offset) { } // return the highest active layer -uint8_t main_layers_top_layer() { +uint8_t top_layer() { return layers_top; } // return if highest active layer is sticky -StickyState main_layers_top_sticky() { - return main_layers_sticky(layers_top); +StickyState layer_top_sticky() { + return layer_sticky(layers_top); } // return if layer is sticky -StickyState main_layers_sticky(uint8_t layer) { +StickyState layer_sticky(uint8_t layer) { if (layer < KB_LAYERS) { return layers_sticky[layer]; } @@ -125,7 +121,7 @@ StickyState main_layers_sticky(uint8_t 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; } layers_active[layer] = true; @@ -137,7 +133,7 @@ void main_layers_enable(uint8_t layer, StickyState sticky) { } // disable a layer -void main_layers_disable(uint8_t layer) { +void layer_disable(uint8_t layer) { // base layer stays always on if (layer >= KB_LAYERS || layer == 0) { return; } @@ -150,17 +146,17 @@ void main_layers_disable(uint8_t layer) { } // disable the highest active layer -void main_layers_disable_top() { - main_layers_disable(layers_top); +void layer_disable_top() { + layer_disable(layers_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); } // 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) = ( (current_is_pressed) ? 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 // for this layer (a non-transparent key) was pressed, pop the layer - if (main_layers_top_sticky() == StickyOnceUp && non_trans_key_pressed) { - main_layers_disable_top(); + if (layer_top_sticky() == StickyOnceUp && non_trans_key_pressed) { + layer_disable_top(); } } @@ -209,30 +205,53 @@ void _kbfun_press_release(bool press, uint8_t keycode) { return; } + if (press) { + _kbfun_press(keycode); + } else { + _kbfun_release(keycode); + } +} + +void _kbfun_press(uint8_t keycode) { // modifier keys switch (keycode) { - case KEY_LeftControl: (press) ? (keyboard_modifier_keys |= (1<<0)) : (keyboard_modifier_keys &= ~(1<<0)); return; - case KEY_LeftShift: (press) ? (keyboard_modifier_keys |= (1<<1)) : (keyboard_modifier_keys &= ~(1<<1)); return; - case KEY_LeftAlt: (press) ? (keyboard_modifier_keys |= (1<<2)) : (keyboard_modifier_keys &= ~(1<<2)); return; - case KEY_LeftGUI: (press) ? (keyboard_modifier_keys |= (1<<3)) : (keyboard_modifier_keys &= ~(1<<3)); return; - case KEY_RightControl: (press) ? (keyboard_modifier_keys |= (1<<4)) : (keyboard_modifier_keys &= ~(1<<4)); return; - case KEY_RightShift: (press) ? (keyboard_modifier_keys |= (1<<5)) : (keyboard_modifier_keys &= ~(1<<5)); return; - case KEY_RightAlt: (press) ? (keyboard_modifier_keys |= (1<<6)) : (keyboard_modifier_keys &= ~(1<<6)); return; - case KEY_RightGUI: (press) ? (keyboard_modifier_keys |= (1<<7)) : (keyboard_modifier_keys &= ~(1<<7)); return; + 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 (press) { - if (keyboard_keys[i] == 0) { - keyboard_keys[i] = keycode; - return; - } - } else { - if (keyboard_keys[i] == keycode) { - keyboard_keys[i] = 0; - return; - } + if (keyboard_keys[i] == 0) { + keyboard_keys[i] = keycode; + return; + } + } +} + +void _kbfun_release(uint8_t keycode) { +// 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? trans_key_pressed = true; layer_offset++; - current_layer = main_layers_peek(layer_offset); + current_layer = layer_peek(layer_offset); 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)) { uint8_t enable_layer = kb_layout_get(layer, current_row, current_col); 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? // Only the topmost layer on the stack should be in sticky once state, pop // 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) { */ - /* main_layers_disable_top(); */ + /* layer_disable_top(); */ /* } */ layer_enable_upto(layer); @@ -393,7 +412,7 @@ void kbfun_layer_disable() { if (is_layer_disable(key_function)) { 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() { uint8_t layer = _kbfun_get_keycode(); - uint8_t topLayer = main_layers_top_layer(); - StickyState topSticky = main_layers_top_sticky(); + uint8_t topLayer = top_layer(); + StickyState topSticky = layer_top_sticky(); if (current_is_pressed) { if (topLayer == layer) { // FIXME /* if (topSticky == StickyOnceUp) { */ - /* main_layers_enable(layer, StickyLock); */ + /* layer_enable(layer, StickyLock); */ /* } */ } else { // only the topmost layer on the stack should be in sticky once state 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 non_trans_key_pressed = false; } } else { - if (main_layers_sticky(layer) == StickyOnceDown) { + if (layer_sticky(layer) == StickyOnceDown) { // When releasing this sticky key, pop the layer always - main_layers_disable(layer); + layer_disable(layer); if (!non_trans_key_pressed) { // If no key defined for this layer (a non-transparent key) // was pressed, push the layer again, but in the // 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) { - current_layer = main_layers_top_layer(); + current_layer = top_layer(); layers_pressed[row][col] = current_layer; trans_key_pressed = false; } else { @@ -560,7 +579,7 @@ void main_key_loop() { current_row = row; current_col = col; layer_offset = 0; - main_exec_key(); + exec_key(); kb_was_transparent[row][col] = trans_key_pressed; } } diff --git a/src/main.h b/src/main.h index 4448aab..bb0046f 100644 --- a/src/main.h +++ b/src/main.h @@ -13,19 +13,21 @@ void kbfun_press_release(); uint8_t _kbfun_get_keycode(); void _kbfun_mediakey_press_release(bool press,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); 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_press_get(uint8_t layer,uint8_t row,uint8_t column); -void main_exec_key(void); -uint8_t main_layers_peek(uint8_t offset); -void main_layers_disable_top(); -void main_layers_disable(uint8_t layer); -void main_layers_enable(uint8_t layer,StickyState sticky); -StickyState main_layers_sticky(uint8_t layer); -StickyState main_layers_top_sticky(); -uint8_t main_layers_top_layer(); +void exec_key(void); +uint8_t layer_peek(uint8_t offset); +void layer_disable_top(); +void layer_disable(uint8_t layer); +void layer_enable(uint8_t layer,StickyState sticky); +StickyState layer_sticky(uint8_t layer); +StickyState layer_top_sticky(); +uint8_t top_layer(); uint8_t _highest_active_layer(uint8_t offset); void main_key_loop(); -void main_init_layers(); +void init_layers(); int main(void);