|
|
|
|
#include "key_events.h"
|
|
|
|
|
#include "layers.h"
|
|
|
|
|
|
|
|
|
|
static bool handle_synthetic_key_event(Key mappedKey, uint8_t keyState) {
|
|
|
|
|
if (mappedKey.flags & RESERVED)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
if (!(mappedKey.flags & SYNTHETIC))
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
if (!key_toggled_on(keyState))
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
if (mappedKey.flags & IS_INTERNAL) {
|
|
|
|
|
return false;
|
|
|
|
|
} else if (mappedKey.flags & IS_CONSUMER) {
|
|
|
|
|
ConsumerControl.press(mappedKey.keyCode);
|
|
|
|
|
} else if (mappedKey.flags & IS_SYSCTL) {
|
|
|
|
|
SystemControl.press(mappedKey.keyCode);
|
|
|
|
|
} else if (mappedKey.flags & SWITCH_TO_KEYMAP) {
|
|
|
|
|
// Should not happen, handled elsewhere.
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
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];
|
|
|
|
|
|
|
|
|
|
static bool handle_key_event_default(Key mappedKey, byte row, byte col, uint8_t keyState) {
|
|
|
|
|
//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
|
|
|
|
|
|
|
|
|
|
if (mappedKey.flags & SYNTHETIC) {
|
|
|
|
|
handle_synthetic_key_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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void press_key(Key mappedKey) {
|
|
|
|
|
if (mappedKey.flags & SHIFT_HELD) {
|
|
|
|
|
Keyboard.press(Key_LShift.keyCode);
|
|
|
|
|
}
|
|
|
|
|
if (mappedKey.flags & CTRL_HELD) {
|
|
|
|
|
Keyboard.press(Key_LCtrl.keyCode);
|
|
|
|
|
}
|
|
|
|
|
if (mappedKey.flags & LALT_HELD) {
|
|
|
|
|
Keyboard.press(Key_LAlt.keyCode);
|
|
|
|
|
}
|
|
|
|
|
if (mappedKey.flags & RALT_HELD) {
|
|
|
|
|
Keyboard.press(Key_RAlt.keyCode);
|
|
|
|
|
}
|
|
|
|
|
if (mappedKey.flags & GUI_HELD) {
|
|
|
|
|
Keyboard.press(Key_LGUI.keyCode);
|
|
|
|
|
}
|
|
|
|
|
Keyboard.press(mappedKey.keyCode);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void release_key(Key mappedKey) {
|
|
|
|
|
if (mappedKey.flags & SHIFT_HELD) {
|
|
|
|
|
Keyboard.release(Key_LShift.keyCode);
|
|
|
|
|
}
|
|
|
|
|
if (mappedKey.flags & CTRL_HELD) {
|
|
|
|
|
Keyboard.release(Key_LCtrl.keyCode);
|
|
|
|
|
}
|
|
|
|
|
if (mappedKey.flags & LALT_HELD) {
|
|
|
|
|
Keyboard.release(Key_LAlt.keyCode);
|
|
|
|
|
}
|
|
|
|
|
if (mappedKey.flags & RALT_HELD) {
|
|
|
|
|
Keyboard.release(Key_RAlt.keyCode);
|
|
|
|
|
}
|
|
|
|
|
if (mappedKey.flags & GUI_HELD) {
|
|
|
|
|
Keyboard.release(Key_LGUI.keyCode);
|
|
|
|
|
}
|
|
|
|
|
Keyboard.release(mappedKey.keyCode);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void handle_key_event(Key mappedKey, byte row, byte col, uint8_t keyState) {
|
|
|
|
|
if (!(keyState & INJECTED)) {
|
|
|
|
|
mappedKey = Layer.lookup(row, col);
|
|
|
|
|
}
|
|
|
|
|
for (byte i = 0; eventHandlers[i] != NULL && i < HOOK_MAX; i++) {
|
|
|
|
|
custom_handler_t handler = eventHandlers[i];
|
Event hooks reworked, again
Instead of returning a bool, to signal whether further processing should be
done, return a Key. Reason being, if we want to replace a key with another, for
subsequent handlers, it is a lot easier if we can modify what gets passed along,
than it is to inject a key, and try to avoid loops and infinite recursion.
Nevertheless, injecting keys is still possible.
This is not immediately useful for the core firmware, but makes it trivially
easy to upgrade keys from their normal behaviour to something special: for
example, a one-shot handler can auto-promote modifiers to one-shot, simply by
scheduling a promoter handler before the real one.
Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
|
|
|
mappedKey = (*handler)(mappedKey, row, col, keyState);
|
|
|
|
|
if (mappedKey.raw == Key_NoKey.raw)
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
mappedKey = Layer.eventHandler(mappedKey, row, col, keyState);
|
|
|
|
|
if (mappedKey.raw == Key_NoKey.raw)
|
|
|
|
|
return;
|
|
|
|
|
handle_key_event_default(mappedKey, row, col, keyState);
|
|
|
|
|
}
|
