alpha
/
Kaleidoscope
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'cda154359d'
${ noResults }
Kaleidoscope/src/key_events.cpp

135 lines
4.0 KiB
Raw Normal View History Unescape

First pass at extracting key event functions to their own source files
9 years ago
#include "key_events.h"
Rearrange the SYNTHETIC bits, and their handling Introduces the RESERVED bit, a bit reserved for plugins. If it is set, the core handlers will not handle the event. Also rearranges the SYNTHETIC bits, to make slightly more sense. In practice, this means that LED_TOGGLE was promoted to a flag bit, under IS_INTERNAL. The handler that deals with synthetic events was updated to look at the flag bits in an order that does not cause confusion, and preparations were also made to turn it into an independent handler on its own (but that step has not been taken yet). This is just groundwork to clean things up, and make the event flow easier to follow. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
static void handle_keymap_key_event(Key keymapEntry, uint8_t keyState) {
if (keymapEntry.flags & SWITCH_TO_KEYMAP_MOMENTARY ) {
if (key_toggled_on(keyState)) {
if ( keymapEntry.rawKey == KEYMAP_NEXT) {
temporary_keymap++;
} else if ( keymapEntry.rawKey == KEYMAP_PREVIOUS) {
temporary_keymap--;
} else {
temporary_keymap = keymapEntry.rawKey;
}
}
if (key_toggled_off(keyState)) {
temporary_keymap = primary_keymap;
}
// switch keymap and stay there
} else if (key_toggled_on(keyState)) {
temporary_keymap = primary_keymap = keymapEntry.rawKey;
Storage.save_primary_keymap(primary_keymap);
}
}
static bool handle_synthetic_key_event(Key mappedKey, uint8_t keyState) {
if (mappedKey.flags & RESERVED)
return false;
if (!(mappedKey.flags & SYNTHETIC))
return false;
Use an overridable macroAction function for macro actions Instead of hardcoding the macro actions into the core firmware, use a `macroAction` function that is marked weak. This makes it possible to override the function from Sketches, and implement the handlers there. While there, also made sure that the `macroAction` is always called, with `keyState` argument appropriately set. With this, macro actions can trigger on keyup, or while held, or anytime the implementor wants, not just on keypress. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
if (!key_toggled_on(keyState))
Rearrange the SYNTHETIC bits, and their handling Introduces the RESERVED bit, a bit reserved for plugins. If it is set, the core handlers will not handle the event. Also rearranges the SYNTHETIC bits, to make slightly more sense. In practice, this means that LED_TOGGLE was promoted to a flag bit, under IS_INTERNAL. The handler that deals with synthetic events was updated to look at the flag bits in an order that does not cause confusion, and preparations were also made to turn it into an independent handler on its own (but that step has not been taken yet). This is just groundwork to clean things up, and make the event flow easier to follow. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
return true;
Refactor a bit of code for clarity..that also saves us a fair bit of flash
9 years ago
Rearrange the SYNTHETIC bits, and their handling Introduces the RESERVED bit, a bit reserved for plugins. If it is set, the core handlers will not handle the event. Also rearranges the SYNTHETIC bits, to make slightly more sense. In practice, this means that LED_TOGGLE was promoted to a flag bit, under IS_INTERNAL. The handler that deals with synthetic events was updated to look at the flag bits in an order that does not cause confusion, and preparations were also made to turn it into an independent handler on its own (but that step has not been taken yet). This is just groundwork to clean things up, and make the event flow easier to follow. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
if (mappedKey.flags & IS_INTERNAL) {
if (mappedKey.flags & LED_TOGGLE) {
Use an overridable macroAction function for macro actions Instead of hardcoding the macro actions into the core firmware, use a `macroAction` function that is marked weak. This makes it possible to override the function from Sketches, and implement the handlers there. While there, also made sure that the `macroAction` is always called, with `keyState` argument appropriately set. With this, macro actions can trigger on keyup, or while held, or anytime the implementor wants, not just on keypress. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
LEDControl.next_mode();
Rearrange the SYNTHETIC bits, and their handling Introduces the RESERVED bit, a bit reserved for plugins. If it is set, the core handlers will not handle the event. Also rearranges the SYNTHETIC bits, to make slightly more sense. In practice, this means that LED_TOGGLE was promoted to a flag bit, under IS_INTERNAL. The handler that deals with synthetic events was updated to look at the flag bits in an order that does not cause confusion, and preparations were also made to turn it into an independent handler on its own (but that step has not been taken yet). This is just groundwork to clean things up, and make the event flow easier to follow. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
} else {
return false;
Use an overridable macroAction function for macro actions Instead of hardcoding the macro actions into the core firmware, use a `macroAction` function that is marked weak. This makes it possible to override the function from Sketches, and implement the handlers there. While there, also made sure that the `macroAction` is always called, with `keyState` argument appropriately set. With this, macro actions can trigger on keyup, or while held, or anytime the implementor wants, not just on keypress. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
}
Rearrange the SYNTHETIC bits, and their handling Introduces the RESERVED bit, a bit reserved for plugins. If it is set, the core handlers will not handle the event. Also rearranges the SYNTHETIC bits, to make slightly more sense. In practice, this means that LED_TOGGLE was promoted to a flag bit, under IS_INTERNAL. The handler that deals with synthetic events was updated to look at the flag bits in an order that does not cause confusion, and preparations were also made to turn it into an independent handler on its own (but that step has not been taken yet). This is just groundwork to clean things up, and make the event flow easier to follow. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
} else if (mappedKey.flags & IS_CONSUMER) {
ConsumerControl.press(mappedKey.rawKey);
Use an overridable macroAction function for macro actions Instead of hardcoding the macro actions into the core firmware, use a `macroAction` function that is marked weak. This makes it possible to override the function from Sketches, and implement the handlers there. While there, also made sure that the `macroAction` is always called, with `keyState` argument appropriately set. With this, macro actions can trigger on keyup, or while held, or anytime the implementor wants, not just on keypress. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
} else if (mappedKey.flags & IS_SYSCTL) {
SystemControl.press(mappedKey.rawKey);
Rearrange the SYNTHETIC bits, and their handling Introduces the RESERVED bit, a bit reserved for plugins. If it is set, the core handlers will not handle the event. Also rearranges the SYNTHETIC bits, to make slightly more sense. In practice, this means that LED_TOGGLE was promoted to a flag bit, under IS_INTERNAL. The handler that deals with synthetic events was updated to look at the flag bits in an order that does not cause confusion, and preparations were also made to turn it into an independent handler on its own (but that step has not been taken yet). This is just groundwork to clean things up, and make the event flow easier to follow. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
} else if (mappedKey.flags & SWITCH_TO_KEYMAP ||
mappedKey.flags & SWITCH_TO_KEYMAP_MOMENTARY) {
// Should not happen, handled elsewhere.
Refactor a bit of code for clarity..that also saves us a fair bit of flash
9 years ago
}
Rearrange the SYNTHETIC bits, and their handling Introduces the RESERVED bit, a bit reserved for plugins. If it is set, the core handlers will not handle the event. Also rearranges the SYNTHETIC bits, to make slightly more sense. In practice, this means that LED_TOGGLE was promoted to a flag bit, under IS_INTERNAL. The handler that deals with synthetic events was updated to look at the flag bits in an order that does not cause confusion, and preparations were also made to turn it into an independent handler on its own (but that step has not been taken yet). This is just groundwork to clean things up, and make the event flow easier to follow. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
return true;
Refactor a bit of code for clarity..that also saves us a fair bit of flash
9 years ago
}
key_events: A way to hook into the event handling This adds a new `handle_user_key_event` function, that will get called before anything else, and can override what happens. If it returns true, the event will not be processed further by the firmware. By default, this function returns false, and is a no-op. It is defined with a `weak` attribute, to let the linker know that any other function with the same name should override his one. This makes it possible to have another version of this function in a firmware Sketch, and override the behaviour, to extend the event handling. This is the foundation that allows it to use external libraries, and tap into the firmware's event handler, to add new stuff. (We can already hook into the main loop by changing the top `loop` function in the Sketch) This addresses #21 for the most part. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
hooks: Add a way to replace hooks To make replacing work sanely, we first NULL out both the eventHandlers and loopHooks arrays in the Keyboardio_ constructor. This allows the replace functions to just run through the whole array, and either see hook pointers there, or NULL. So they don't need to be afraid of garbage being there. This makes the replacing very easy: run through the array, and replace the first occurrence of the old hook with the new. This further simplifies addition: the old hook we pass in, will be NULL. If we run out of space, it silently fails, like before. Replacing hooks is important for cases where one wants to build features that can be toggled off, or their behaviour otherwise changed at run-time. In this case, the most efficent way is to replace the hook, which is what these new helpers allow us to do. This closes #36. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
custom_handler_t eventHandlers[HOOK_MAX];
Improved custom key event handling Instead of always calling handle_user_key_event(), call a function pointed to by the customHandler variable. This makes it possible to override what function gets called, at run time, at very little cost. The reason for this change is to be able to change the user function into a testing one, if a magic combo is pressed, while still allowing the end-user to fully customize handle_user_key_event, and allow them to have access to the testing one too, without them doing anything special. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
Add a lookup_key() method This allows external libraries to look up the keycode for a given position, without having to reimplement the keymap themselves. This becomes important when you hook into the event processing. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
Key lookup_key(byte keymap, byte row, byte col) {
Key mappedKey;
mappedKey.raw = pgm_read_word(&(keymaps[keymap][row][col]));
return mappedKey;
}
Always call the default handler Instead of registering the default handler late, always call it at the end if no other handler took care of the event. This makes it less of an issue to order `Keyboardio.use()` and `Keyboardio.setup()`. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
static bool handle_key_event_default(Key mappedKey, byte row, byte col, uint8_t keyState) {
First pass at extracting key event functions to their own source files
9 years ago
//for every newly pressed button, figure out what logical key it is and send a key down event
// for every newly released button, figure out what logical key it is and send a key up event
key_events: look up mappedKey earlier Do the mappedKey lookup earlier, in handle_key_event, so that if any of our handlers need to look at the mapped key, they do not have to look it up themselves. This simplifies plugged hooks considerably, as they can always assume that the mapped key they receive is correct. They still receive enough information to do the lookup themselves, though, if they ever need that. Additionally, in handle_key_event_default, baseKey is only looked up if mappedKey was NoKey. This is so that hooks can defer to this function, via handle_key_event, setting their own mappedKey, without having to worry about setting a row/col that would map to a special key on the base layer. Fixes #39. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
Key baseKey = Key_NoKey;
keyswitch_state: Rename the state arguments to keyState Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
if (!(keyState & INJECTED)) {
key_events: look up mappedKey earlier Do the mappedKey lookup earlier, in handle_key_event, so that if any of our handlers need to look at the mapped key, they do not have to look it up themselves. This simplifies plugged hooks considerably, as they can always assume that the mapped key they receive is correct. They still receive enough information to do the lookup themselves, though, if they ever need that. Additionally, in handle_key_event_default, baseKey is only looked up if mappedKey was NoKey. This is so that hooks can defer to this function, via handle_key_event, setting their own mappedKey, without having to worry about setting a row/col that would map to a special key on the base layer. Fixes #39. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
baseKey = lookup_key(primary_keymap, row, col);
A way to restart the event handler with a different code There are scenarios where one would want to inject a keycode into the event handler chain, restart the processing from scratch, but with a keycode different than what the lookup would normally yield. For example, with one-shot modifiers, a feature one may wish is to be able to turn the one-shotness off, and have them act as normal modifiers. This is easily done, if we can remove the one-shot markup, and let the event handler process the resulting code as-is. This makes that possible: in a custom event handler, just call handle_key_event() with the first argument set to the desired code, and the rest left unchanged. This makes it possible to inject events: not just register keycodes with the HID, but inject synthetic events, something much more powerful. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
}
Add a lookup_key() method This allows external libraries to look up the keycode for a given position, without having to reimplement the keymap themselves. This becomes important when you hook into the event processing. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
simplify a bit of logic
8 years ago
if ((baseKey.flags & SWITCH_TO_KEYMAP
|| baseKey.flags & SWITCH_TO_KEYMAP_MOMENTARY)) {
keyswitch_state: Rename the state arguments to keyState Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
handle_keymap_key_event(baseKey, keyState);
rename SYNTHETIC_KEY to SYNTHETIC
8 years ago
} else if (mappedKey.flags & SYNTHETIC) {
keyswitch_state: Rename the state arguments to keyState Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
handle_synthetic_key_event( mappedKey, keyState);
} else if (key_is_pressed(keyState)) {
astyle
9 years ago
press_key(mappedKey);
Add an explicit release event Since macros and other injected keys do not clear the report, we need a way to release keys. The new `release_key` function does just that, similar to how `press_key` does it for key presses. It is called by the default event handler when the `keyState` toggles off, and has the `INJECTED` bit set. The reason behind this is that keys that will need this special treatment will always be injected keys. And those injected keys that do not need this treatment, can be handled by an event handler prior to the default. This should fix the macros not releasing keys issue. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
} else if (key_toggled_off(keyState) && (keyState & INJECTED)) {
release_key(mappedKey);
First pass at extracting key event functions to their own source files
9 years ago
}
Rework the custom event handler architecture Instead of a single custom function, have an array of functions that get called in order, until one of them returns true. Defaults to the normal event handler. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
return true;
First pass at extracting key event functions to their own source files
9 years ago
}
void press_key(Key mappedKey) {
if (mappedKey.flags & SHIFT_HELD) {
Keyboard.press(Key_LShift.rawKey);
}
if (mappedKey.flags & CTRL_HELD) {
Keyboard.press(Key_LCtrl.rawKey);
}
Split out the left and right alt keys, to make it easier to emulate altgr. This may or may not actually be useful.
8 years ago
if (mappedKey.flags & LALT_HELD) {
Keyboard.press(Key_LAlt.rawKey);
}
if (mappedKey.flags & RALT_HELD) {
First pass at extracting key event functions to their own source files
9 years ago
Keyboard.press(Key_RAlt.rawKey);
}
if (mappedKey.flags & GUI_HELD) {
Keyboard.press(Key_LGUI.rawKey);
}
Keyboard.press(mappedKey.rawKey);
}
Add an explicit release event Since macros and other injected keys do not clear the report, we need a way to release keys. The new `release_key` function does just that, similar to how `press_key` does it for key presses. It is called by the default event handler when the `keyState` toggles off, and has the `INJECTED` bit set. The reason behind this is that keys that will need this special treatment will always be injected keys. And those injected keys that do not need this treatment, can be handled by an event handler prior to the default. This should fix the macros not releasing keys issue. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
void release_key(Key mappedKey) {
if (mappedKey.flags & SHIFT_HELD) {
Keyboard.release(Key_LShift.rawKey);
}
if (mappedKey.flags & CTRL_HELD) {
Keyboard.release(Key_LCtrl.rawKey);
}
if (mappedKey.flags & LALT_HELD) {
Keyboard.release(Key_LAlt.rawKey);
}
if (mappedKey.flags & RALT_HELD) {
Keyboard.release(Key_RAlt.rawKey);
}
if (mappedKey.flags & GUI_HELD) {
Keyboard.release(Key_LGUI.rawKey);
}
Keyboard.release(mappedKey.rawKey);
}
Always call the default handler Instead of registering the default handler late, always call it at the end if no other handler took care of the event. This makes it less of an issue to order `Keyboardio.use()` and `Keyboardio.setup()`. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
void handle_key_event(Key mappedKey, byte row, byte col, uint8_t keyState) {
if (!(keyState & INJECTED)) {
mappedKey = lookup_key(temporary_keymap, row, col);
}
for (byte i = 0; eventHandlers[i] != NULL && i < HOOK_MAX; i++) {
custom_handler_t handler = eventHandlers[i];
if ((*handler)(mappedKey, row, col, keyState))
return;
}
handle_key_event_default(mappedKey, row, col, keyState);
}