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 '3154f7c997'
${ noResults }
Kaleidoscope/src/key_events.cpp

97 lines
2.9 KiB
Raw Normal View History Unescape

Merge the hooks into the Kaleidoscope object Having the hooks, and the hook methods in the Kaleidoscope object means we don't have to litter the definitions of the arrays around, and that the hooks are more tied to the object. We pollute the global namespace less, and having them in the object means that the hook helper functions will not be optimized out if not used within the Kaleidoscope repo. All in all, this saves us about 56 bytes of code, allows us to remove some hacks, and pulls things that are closely knit, closer together. While there, also changed the name of the `custom_handler_t` and `custom_loop_t` types to `eventHandlerHook` and `loopHook` (both under the `Kaleidoscope_` class), to better reflect what they are for. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
#include "Kaleidoscope.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
change "handle_key_event" to "handle_keyswitch_event" to make it clear that we're talking about something on the physical layer, rather than, say, a HID event
8 years ago
static bool handle_synthetic_keyswitch_event(Key mappedKey, uint8_t keyState) {
astyle pass
8 years ago
if (mappedKey.flags & RESERVED)
return false;
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
astyle pass
8 years ago
if (!(mappedKey.flags & SYNTHETIC))
return false;
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
astyle pass
8 years ago
if (mappedKey.flags & IS_INTERNAL) {
return false;
} else if (mappedKey.flags & IS_CONSUMER) {
if (key_is_pressed(keyState))
ConsumerControl.press(mappedKey.keyCode);
else if (key_was_pressed(keyState))
ConsumerControl.release(mappedKey.keyCode);
} else if (mappedKey.flags & IS_SYSCTL) {
if (key_is_pressed(keyState))
SystemControl.press(mappedKey.keyCode);
else if (key_was_pressed(keyState))
SystemControl.release();
} else if (mappedKey.flags & SWITCH_TO_KEYMAP) {
// Should not happen, handled elsewhere.
}
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
astyle pass
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
change "handle_key_event" to "handle_keyswitch_event" to make it clear that we're talking about something on the physical layer, rather than, say, a HID event
8 years ago
static bool handle_keyswitch_event_default(Key mappedKey, byte row, byte col, uint8_t keyState) {
astyle pass
8 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
First pass at extracting key event functions to their own source files
9 years ago
astyle pass
8 years ago
if (mappedKey.flags & SYNTHETIC) {
handle_synthetic_keyswitch_event(mappedKey, keyState);
} else if (key_is_pressed(keyState)) {
press_key(mappedKey);
} else if (key_toggled_off(keyState) && (keyState & INJECTED)) {
release_key(mappedKey);
}
return true;
First pass at extracting key event functions to their own source files
9 years ago
}
void press_key(Key mappedKey) {
astyle pass
8 years ago
if (mappedKey.flags & SHIFT_HELD) {
Keyboard.press(Key_LeftShift.keyCode);
}
if (mappedKey.flags & CTRL_HELD) {
Keyboard.press(Key_LeftControl.keyCode);
}
if (mappedKey.flags & LALT_HELD) {
Keyboard.press(Key_LeftAlt.keyCode);
}
if (mappedKey.flags & RALT_HELD) {
Keyboard.press(Key_RightAlt.keyCode);
}
if (mappedKey.flags & GUI_HELD) {
Keyboard.press(Key_LeftGui.keyCode);
}
Keyboard.press(mappedKey.keyCode);
First pass at extracting key event functions to their own source files
9 years ago
}
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) {
astyle pass
8 years ago
if (mappedKey.flags & SHIFT_HELD) {
Keyboard.release(Key_LeftShift.keyCode);
}
if (mappedKey.flags & CTRL_HELD) {
Keyboard.release(Key_LeftControl.keyCode);
}
if (mappedKey.flags & LALT_HELD) {
Keyboard.release(Key_LeftAlt.keyCode);
}
if (mappedKey.flags & RALT_HELD) {
Keyboard.release(Key_RightAlt.keyCode);
}
if (mappedKey.flags & GUI_HELD) {
Keyboard.release(Key_LeftGui.keyCode);
}
Keyboard.release(mappedKey.keyCode);
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
}
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
change "handle_key_event" to "handle_keyswitch_event" to make it clear that we're talking about something on the physical layer, rather than, say, a HID event
8 years ago
void handle_keyswitch_event(Key mappedKey, byte row, byte col, uint8_t keyState) {
astyle pass
8 years ago
if (!(keyState & INJECTED)) {
mappedKey = Layer.lookup(row, col);
}
for (byte i = 0; Kaleidoscope.eventHandlers[i] != NULL && i < HOOK_MAX; i++) {
Kaleidoscope_::eventHandlerHook handler = Kaleidoscope.eventHandlers[i];
mappedKey = (*handler)(mappedKey, row, col, keyState);
Layers: Don't use hooks for the layer event handler The layer handling is a core functionality, it should be active at all times, and should be at the very end, before the default event handler. Otherwise there may be ordering issues, when a plugin wants to return layer keys from its own event handler. This also saves us a couple of bytes of both code and data, as an additional bonus! Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
if (mappedKey.raw == Key_NoKey.raw)
astyle pass
8 years ago
return;
}
mappedKey = Layer.eventHandler(mappedKey, row, col, keyState);
if (mappedKey.raw == Key_NoKey.raw)
return;
handle_keyswitch_event_default(mappedKey, row, col, keyState);
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
}