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

97 lines
2.8 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"
Layer handling reworked Instead of having a primary and a temporary layer, store the state of at most 32 layers in a bitfield. These can be individually turned on and off, and key lookup starts from the top, and goes downwards until the default layer to find a non-transparent key. This allows one to reuse a partially transparent layer: set the default, and the transparent parts will be reused. The numpad layer was updated accordingly. Having an interface to the layer switching things also makes it easier to build other behaviour on top of these. As part of the rework, layer handling was moved to a separate file, and into its own, full-blown handler. Furthermore, we now use a single bit for all keymap events. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
#include "layers.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 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);
Layer handling reworked Instead of having a primary and a temporary layer, store the state of at most 32 layers in a bitfield. These can be individually turned on and off, and key lookup starts from the top, and goes downwards until the default layer to find a non-transparent key. This allows one to reuse a partially transparent layer: set the default, and the transparent parts will be reused. The numpad layer was updated accordingly. Having an interface to the layer switching things also makes it easier to build other behaviour on top of these. As part of the rework, layer handling was moved to a separate file, and into its own, full-blown handler. Furthermore, we now use a single bit for all keymap events. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
} else if (mappedKey.flags & SWITCH_TO_KEYMAP) {
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
// 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
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
Layer handling reworked Instead of having a primary and a temporary layer, store the state of at most 32 layers in a bitfield. These can be individually turned on and off, and key lookup starts from the top, and goes downwards until the default layer to find a non-transparent key. This allows one to reuse a partially transparent layer: set the default, and the transparent parts will be reused. The numpad layer was updated accordingly. Having an interface to the layer switching things also makes it easier to build other behaviour on top of these. As part of the rework, layer handling was moved to a separate file, and into its own, full-blown handler. Furthermore, we now use a single bit for all keymap events. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
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)) {
Layer handling reworked Instead of having a primary and a temporary layer, store the state of at most 32 layers in a bitfield. These can be individually turned on and off, and key lookup starts from the top, and goes downwards until the default layer to find a non-transparent key. This allows one to reuse a partially transparent layer: set the default, and the transparent parts will be reused. The numpad layer was updated accordingly. Having an interface to the layer switching things also makes it easier to build other behaviour on top of these. As part of the rework, layer handling was moved to a separate file, and into its own, full-blown handler. Furthermore, we now use a single bit for all keymap events. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
mappedKey = Layer.lookup(row, col);
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
}
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);
}