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

minor refactor

master
Stefan Dorn 2016-02-04 11:16:53 +00:00
parent fef0497fcf
commit fc3259de73
2 changed files with 49 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/lib/key-functions/public/basic.c
View File

@ -15,7 +15,7 @@
/* /*
* Generate a normal keypress or keyrelease * Generate a normal keypress or keyrelease
*/ */
void kbfun_press_release(void) { void kbfun_press_release() {
if (!main_arg_trans_key_pressed) { if (!main_arg_trans_key_pressed) {
main_arg_any_non_trans_key_pressed = true; main_arg_any_non_trans_key_pressed = true;
} }
@ -33,7 +33,7 @@ void kbfun_press_release(void) {
* modifier key (shift, control, alt, gui) on the sticky layer instead of * modifier key (shift, control, alt, gui) on the sticky layer instead of
* defining the key to be transparent for the layer. * defining the key to be transparent for the layer.
*/ */
void kbfun_press_release_preserve_sticky(void) { void kbfun_press_release_preserve_sticky() {
uint8_t keycode = _kbfun_get_keycode(); uint8_t keycode = _kbfun_get_keycode();
_kbfun_press_release(main_arg_is_pressed, keycode); _kbfun_press_release(main_arg_is_pressed, keycode);
} }
@ -66,21 +66,18 @@ void kbfun_transparent(void) {
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
// all lower layers on a key should be secretly set/unset to enable proper layer stacking // all lower layers on a key should be secretly set/unset to enable proper layer stacking
static void layer_enable_downwards(uint8_t layer) { static void layers_enable_downwards(uint8_t layer) {
// TODO // TODO
main_layers_enable(layer, eStickyNone); main_layers_enable(layer, eStickyNone);
} }
static void layer_disable_downwards(uint8_t layer) { static void layers_disable_downwards(uint8_t layer) {
// TODO // TODO
main_layers_disable(layer); main_layers_disable(layer);
} }
// enable given layer // enable given layer
static void layer_enable(uint8_t layer) { static void layer_enable(uint8_t layer) {
// FIXME necessary?
main_layers_disable(layer);
// 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 = main_layers_top_sticky();
@ -88,12 +85,12 @@ static void layer_enable(uint8_t layer) {
main_layers_disable_top(); main_layers_disable_top();
} }
layer_enable_downwards(layer); layers_enable_downwards(layer);
} }
// disable given layer // disable given layer
static void layer_disable(uint8_t layer) { static void layer_disable(uint8_t layer) {
layer_disable_downwards(layer); layers_disable_downwards(layer);
} }
/* /*
@ -128,11 +125,10 @@ static void layer_disable(uint8_t layer) {
* popped if the function is invoked on a subsequent keypress. * popped if the function is invoked on a subsequent keypress.
*/ */
static void layer_sticky(uint8_t layer) { static void layer_sticky(uint8_t layer) {
uint8_t topLayer = main_layers_top_layer(); uint8_t topLayer = main_layers_top_layer();
uint8_t topSticky = main_layers_top_sticky(); uint8_t topSticky = main_layers_top_sticky();
if (main_arg_is_pressed) { if (main_arg_is_pressed) {
main_layers_disable(layer);
if (topLayer == layer) { if (topLayer == layer) {
if (topSticky == eStickyOnceUp) { if (topSticky == eStickyOnceUp) {
main_layers_enable(layer, eStickyLock); main_layers_enable(layer, eStickyLock);
@ -142,7 +138,8 @@ static void layer_sticky(uint8_t layer) {
if (topSticky == eStickyOnceDown || topSticky == eStickyOnceUp) { if (topSticky == eStickyOnceDown || topSticky == eStickyOnceUp) {
main_layers_disable_top(); main_layers_disable_top();
} }
main_layers_enable(layer, eStickyOnceDown); layers_enable_downwards(layer);
// 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
main_arg_any_non_trans_key_pressed = false; main_arg_any_non_trans_key_pressed = false;
} }

115
src/lib/key-functions/public/special.c
View File

@ -18,108 +18,71 @@
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// convenience macros
#define LAYER main_arg_layer
#define LAYER_OFFSET main_arg_layer_offset
#define ROW main_arg_row
#define COL main_arg_col
#define IS_PRESSED main_arg_is_pressed
#define WAS_PRESSED main_arg_was_pressed
// ----------------------------------------------------------------------------
/* /*
* [name] * Generate a 'shift' press or release before the normal keypress or release
* Shift + press|release
*
* [description]
* Generate a 'shift' press or release before the normal keypress or
* keyrelease
*/ */
void kbfun_shift_press_release(void) { void kbfun_shift_press_release(void) {
_kbfun_press_release(IS_PRESSED, KEY_LeftShift); _kbfun_press_release(main_arg_is_pressed, KEY_LeftShift);
kbfun_press_release(); kbfun_press_release();
} }
/* /*
* [name] * Generate a 'control' press or release before the normal keypress or release
* Control + press|release
*
* [description]
* Generate a 'control' press or release before the normal keypress or
* keyrelease
*/ */
void kbfun_control_press_release(void) { void kbfun_control_press_release(void) {
_kbfun_press_release(IS_PRESSED, KEY_LeftControl); _kbfun_press_release(main_arg_is_pressed, KEY_LeftControl);
kbfun_press_release(); kbfun_press_release();
} }
/* /*
* [name] * When assigned to two keys (e.g. the physical left and right shift keys)
* Two keys => capslock * (in both the press and release matrices), pressing and holding down one of
* the keys will make the second key toggle capslock
* *
* [description] * If either of the shifts are pressed when the second key is pressed, they
* When assigned to two keys (e.g. the physical left and right shift keys) * wil be released so that capslock will register properly when pressed.
* (in both the press and release matrices), pressing and holding down one of * Capslock will then be pressed and released, and the original state of the
* the keys will make the second key toggle capslock * shifts will be restored
*
* [note]
* If either of the shifts are pressed when the second key is pressed, they
* wil be released so that capslock will register properly when pressed.
* Capslock will then be pressed and released, and the original state of the
* shifts will be restored
*/ */
void kbfun_2_keys_capslock_press_release(void) { void kbfun_2_keys_capslock_press_release(void) {
static uint8_t keys_pressed; static uint8_t keys_pressed;
static bool lshift_pressed; static bool lshift_pressed;
static bool rshift_pressed; static bool rshift_pressed;
uint8_t keycode = kb_layout_get(LAYER, ROW, COL); uint8_t keycode = _kbfun_get_keycode();
if (!IS_PRESSED) keys_pressed--; if (!main_arg_is_pressed) { keys_pressed--; }
// take care of the key that was actually pressed // take care of the key that was actually pressed
_kbfun_press_release(IS_PRESSED, keycode); _kbfun_press_release(main_arg_is_pressed, keycode);
// take care of capslock (only on the press of the 2nd key) // take care of capslock (only on the press of the 2nd key)
if (keys_pressed == 1 && IS_PRESSED) { if (keys_pressed == 1 && main_arg_is_pressed) {
// save the state of left and right shift // save the state of left and right shift
lshift_pressed = _kbfun_is_pressed(KEY_LeftShift); lshift_pressed = _kbfun_is_pressed(KEY_LeftShift);
rshift_pressed = _kbfun_is_pressed(KEY_RightShift); rshift_pressed = _kbfun_is_pressed(KEY_RightShift);
// disable both // disable both
_kbfun_press_release(false, KEY_LeftShift); _kbfun_press_release(false, KEY_LeftShift);
_kbfun_press_release(false, KEY_RightShift); _kbfun_press_release(false, KEY_RightShift);
// press capslock, then release it // press capslock, then release it
_kbfun_press_release(true, KEY_CapsLock); _kbfun_press_release(true, KEY_CapsLock); usb_keyboard_send();
usb_keyboard_send(); _kbfun_press_release(false, KEY_CapsLock); usb_keyboard_send();
_kbfun_press_release(false, KEY_CapsLock);
usb_keyboard_send();
// restore the state of left and right shift // restore the state of left and right shift
if (lshift_pressed) if (lshift_pressed) { _kbfun_press_release(true, KEY_LeftShift); }
_kbfun_press_release(true, KEY_LeftShift); if (rshift_pressed) { _kbfun_press_release(true, KEY_RightShift); }
if (rshift_pressed) }
_kbfun_press_release(true, KEY_RightShift);
}
if (IS_PRESSED) keys_pressed++; if (main_arg_is_pressed) { keys_pressed++; }
} }
/* /*
* [name] * Generate a keypress for a media key
* Media Key Press Release
*
* [description]
* Generate a keypress for a media key, such as play/pause, next track, or
* previous track
*
*/ */
void kbfun_mediakey_press_release(void) { void kbfun_mediakey_press_release(void) {
uint8_t keycode = kb_layout_get(LAYER, ROW, COL); uint8_t keycode = _kbfun_get_keycode();
_kbfun_mediakey_press_release(IS_PRESSED, keycode); _kbfun_mediakey_press_release(main_arg_is_pressed, keycode);
} }
/* ---------------------------------------------------------------------------- /* ----------------------------------------------------------------------------