From f7834f05fc3c0fb75a56e41dc31e80dba055484f Mon Sep 17 00:00:00 2001 From: Gergely Nagy Date: Mon, 13 Feb 2017 15:23:36 +0100 Subject: [PATCH] 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 --- src/Kaleidoscope.cpp | 62 +++++++++++++++++++++++++++++++++++++------- src/Kaleidoscope.h | 41 +++++++++++++++++++++++++++++ src/hooks.cpp | 49 ---------------------------------- src/hooks.h | 34 ------------------------ src/key_events.cpp | 9 +++---- src/key_events.h | 1 - 6 files changed, 97 insertions(+), 99 deletions(-) delete mode 100644 src/hooks.cpp delete mode 100644 src/hooks.h diff --git a/src/Kaleidoscope.cpp b/src/Kaleidoscope.cpp index 61ab7483..d7bbb0d7 100644 --- a/src/Kaleidoscope.cpp +++ b/src/Kaleidoscope.cpp @@ -1,9 +1,10 @@ #include "Kaleidoscope.h" #include +Kaleidoscope_::eventHandlerHook Kaleidoscope_::eventHandlers[HOOK_MAX]; +Kaleidoscope_::loopHook Kaleidoscope_::loopHooks[HOOK_MAX]; + Kaleidoscope_::Kaleidoscope_(void) { - memset(eventHandlers, 0, HOOK_MAX * sizeof(custom_handler_t)); - memset(loopHooks, 0, HOOK_MAX * sizeof(custom_handler_t)); } void @@ -13,20 +14,15 @@ Kaleidoscope_::setup(const byte keymap_count) { Keyboard.begin(); KeyboardHardware.setup(); - event_handler_hook_use (NULL); - loop_hook_use (NULL); - Layer.defaultLayer (KeyboardHardware.load_primary_layer (keymap_count)); } -custom_loop_t loopHooks[HOOK_MAX]; - void Kaleidoscope_::loop(void) { KeyboardHardware.scan_matrix(); for (byte i = 0; loopHooks[i] != NULL && i < HOOK_MAX; i++) { - custom_loop_t hook = loopHooks[i]; + loopHook hook = loopHooks[i]; (*hook)(false); } @@ -34,7 +30,7 @@ Kaleidoscope_::loop(void) { Keyboard.releaseAll(); for (byte i = 0; loopHooks[i] != NULL && i < HOOK_MAX; i++) { - custom_loop_t hook = loopHooks[i]; + loopHook hook = loopHooks[i]; (*hook)(true); } } @@ -52,4 +48,52 @@ Kaleidoscope_::use(KaleidoscopePlugin *plugin, ...) { va_end(ap); } +void +Kaleidoscope_::replaceEventHandlerHook(eventHandlerHook oldHook, eventHandlerHook newHook) { + for (byte i = 0; i < HOOK_MAX; i++) { + if (eventHandlers[i] == oldHook) { + eventHandlers[i] = newHook; + return; + } + } +} + +void +Kaleidoscope_::appendEventHandlerHook (eventHandlerHook hook) { + replaceEventHandlerHook((eventHandlerHook)NULL, hook); +} + +void +Kaleidoscope_::useEventHandlerHook (eventHandlerHook hook) { + for (byte i = 0; i < HOOK_MAX; i++) { + if (eventHandlers[i] == hook) + return; + } + appendEventHandlerHook(hook); +} + +void +Kaleidoscope_::replaceLoopHook(loopHook oldHook, loopHook newHook) { + for (byte i = 0; i < HOOK_MAX; i++) { + if (loopHooks[i] == oldHook) { + loopHooks[i] = newHook; + return; + } + } +} + +void +Kaleidoscope_::appendLoopHook(loopHook hook) { + replaceLoopHook((loopHook)NULL, hook); +} + +void +Kaleidoscope_::useLoopHook(loopHook hook) { + for (byte i = 0; i < HOOK_MAX; i++) { + if (loopHooks[i] == hook) + return; + } + appendLoopHook (hook); +} + Kaleidoscope_ Kaleidoscope; diff --git a/src/Kaleidoscope.h b/src/Kaleidoscope.h index 07022894..0f07e240 100644 --- a/src/Kaleidoscope.h +++ b/src/Kaleidoscope.h @@ -24,6 +24,8 @@ void setup(); #include "key_events.h" #include "layers.h" +#define HOOK_MAX 64 + extern HARDWARE_IMPLEMENTATION KeyboardHardware; #ifndef VERSION @@ -44,6 +46,45 @@ class Kaleidoscope_ { void setup(const byte keymap_count); void loop(void); void use(KaleidoscopePlugin *plugin, ...) __attribute__((sentinel)); + + // ---- hooks ---- + + /* + * In most cases, one only wants a single copy of a hook. On the other hand, + * plugins that depend on other plugins, may want to make it easier for the + * end-user to use the plugin, and call the setup function of the dependent + * plugins too. In case the end-user calls the same setup function, we'd end up + * with hooks registered multiple times. + * + * To avoid this, protection against double-registration has been introduced. + * The `event_handler_hook_use` and `loop_hook_use` functions will only allow + * one copy of the hook. The `event_handler_hook_append` and `loop_hook_append` + * functions will, on the other hand, just append the hooks, and not care about + * protection. + */ + typedef Key (*eventHandlerHook)(Key mappedKey, byte row, byte col, uint8_t keyState); + static eventHandlerHook eventHandlers[HOOK_MAX]; + + static void replaceEventHandlerHook(eventHandlerHook oldHook, eventHandlerHook newHook); + static void appendEventHandlerHook(eventHandlerHook hook); + static void useEventHandlerHook(eventHandlerHook hook); + + typedef void (*loopHook)(bool postClear); + static loopHook loopHooks[HOOK_MAX]; + + static void replaceLoopHook(loopHook oldHook, loopHook newHook); + static void appendLoopHook(loopHook hook); + static void useLoopHook(loopHook hook); }; extern Kaleidoscope_ Kaleidoscope; + +/* -- DEPRECATED aliases; remove them when there are no more users. -- */ + +#define event_handler_hook_use(hook) Kaleidoscope.useEventHandlerHook(hook); +#define event_handler_hook_append(hook) Kaleidoscope.appendEventHandlerHook(hook) +#define event_handler_hook_replace(oldHook, newHook) Kaleidoscope.replaceEventHandlerHook(oldHook, newHook) + +#define loop_hook_use(hook) Kaleidoscope.useLoopHook(hook) +#define loop_hook_append(hook) Kaleidoscope.appendLoopHook(hook) +#define loop_hook_replace(oldHook, newHook) Kaleidoscope.replaceLoopHook(oldHook, newHook) diff --git a/src/hooks.cpp b/src/hooks.cpp deleted file mode 100644 index f304b51a..00000000 --- a/src/hooks.cpp +++ /dev/null @@ -1,49 +0,0 @@ -#include "hooks.h" - -void -event_handler_hook_replace (custom_handler_t oldHook, custom_handler_t newHook) { - for (byte i = 0; i < HOOK_MAX; i++) { - if (eventHandlers[i] == oldHook) { - eventHandlers[i] = newHook; - return; - } - } -} - -void -event_handler_hook_append (custom_handler_t hook) { - event_handler_hook_replace ((custom_handler_t)NULL, hook); -} - -void -event_handler_hook_use (custom_handler_t hook) { - for (byte i = 0; i < HOOK_MAX; i++) { - if (eventHandlers[i] == hook) - return; - } - event_handler_hook_append (hook); -} - -void -loop_hook_replace (custom_loop_t oldHook, custom_loop_t newHook) { - for (byte i = 0; i < HOOK_MAX; i++) { - if (loopHooks[i] == oldHook) { - loopHooks[i] = newHook; - return; - } - } -} - -void -loop_hook_append (custom_loop_t hook) { - loop_hook_replace ((custom_loop_t)NULL, hook); -} - -void -loop_hook_use (custom_loop_t hook) { - for (byte i = 0; i < HOOK_MAX; i++) { - if (loopHooks[i] == hook) - return; - } - loop_hook_append (hook); -} diff --git a/src/hooks.h b/src/hooks.h deleted file mode 100644 index 29cedd61..00000000 --- a/src/hooks.h +++ /dev/null @@ -1,34 +0,0 @@ -#pragma once - -#include -#include "key_defs.h" - -#define HOOK_MAX 64 - -typedef Key (*custom_handler_t)(Key mappedKey, byte row, byte col, uint8_t keyState); -extern custom_handler_t eventHandlers[HOOK_MAX]; - -/* - * In most cases, one only wants a single copy of a hook. On the other hand, - * plugins that depend on other plugins, may want to make it easier for the - * end-user to use the plugin, and call the setup function of the dependent - * plugins too. In case the end-user calls the same setup function, we'd end up - * with hooks registered multiple times. - * - * To avoid this, protection against double-registration has been introduced. - * The `event_handler_hook_use` and `loop_hook_use` functions will only allow - * one copy of the hook. The `event_handler_hook_append` and `loop_hook_append` - * functions will, on the other hand, just append the hooks, and not care about - * protection. - */ - -void event_handler_hook_use (custom_handler_t hook); -void event_handler_hook_append (custom_handler_t hook); -void event_handler_hook_replace (custom_handler_t oldHook, custom_handler_t newHook); - -typedef void (*custom_loop_t)(bool postClear); -extern custom_loop_t loopHooks[HOOK_MAX]; - -void loop_hook_use (custom_loop_t hook); -void loop_hook_append (custom_loop_t hook); -void loop_hook_replace (custom_loop_t oldHook, custom_loop_t newHook); diff --git a/src/key_events.cpp b/src/key_events.cpp index cfc2b551..0e34355c 100644 --- a/src/key_events.cpp +++ b/src/key_events.cpp @@ -1,5 +1,4 @@ -#include "key_events.h" -#include "layers.h" +#include "Kaleidoscope.h" static bool handle_synthetic_key_event(Key mappedKey, uint8_t keyState) { if (mappedKey.flags & RESERVED) @@ -24,8 +23,6 @@ static bool handle_synthetic_key_event(Key mappedKey, uint8_t keyState) { return true; } -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 @@ -83,8 +80,8 @@ 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]; + for (byte i = 0; Kaleidoscope.eventHandlers[i] != NULL && i < HOOK_MAX; i++) { + Kaleidoscope_::eventHandlerHook handler = Kaleidoscope.eventHandlers[i]; mappedKey = (*handler)(mappedKey, row, col, keyState); if (mappedKey.raw == Key_NoKey.raw) return; diff --git a/src/key_events.h b/src/key_events.h index 0192d494..deb3e0f1 100644 --- a/src/key_events.h +++ b/src/key_events.h @@ -5,7 +5,6 @@ #include KALEIDOSCOPE_HARDWARE_H #include "key_defs.h" #include "keyswitch_state.h" -#include "hooks.h" extern const Key keymaps[][ROWS][COLS];