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 '4b110b517d'
${ noResults }
Kaleidoscope/src/hooks.cpp

50 lines
1.1 KiB
Raw Normal View History Unescape

Small hook rework Two things are done here: loop() hooks are introduced, and both loop and event handler hooks are pre-allocated for HOOK_MAX (64 by default) elements. Two helpers are introduced too, that make it easier to append a new hook to the end of these arrays. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
#include "hooks.h"
void
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
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;
}
Small hook rework Two things are done here: loop() hooks are introduced, and both loop and event handler hooks are pre-allocated for HOOK_MAX (64 by default) elements. Two helpers are introduced too, that make it easier to append a new hook to the end of these arrays. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
}
}
void
hooks: Double-registration protection 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 new `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. The `event_handler_hook_add` and `loop_hook_add` functions are gone, but for the time being, they are aliases to the `_use` functions, until all plugins have been updated, and the aliases can be removed. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
event_handler_hook_append (custom_handler_t hook) {
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
event_handler_hook_replace ((custom_handler_t)NULL, hook);
}
Small hook rework Two things are done here: loop() hooks are introduced, and both loop and event handler hooks are pre-allocated for HOOK_MAX (64 by default) elements. Two helpers are introduced too, that make it easier to append a new hook to the end of these arrays. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
hooks: Double-registration protection 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 new `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. The `event_handler_hook_add` and `loop_hook_add` functions are gone, but for the time being, they are aliases to the `_use` functions, until all plugins have been updated, and the aliases can be removed. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
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);
}
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
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;
}
Small hook rework Two things are done here: loop() hooks are introduced, and both loop and event handler hooks are pre-allocated for HOOK_MAX (64 by default) elements. Two helpers are introduced too, that make it easier to append a new hook to the end of these arrays. 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
}
Small hook rework Two things are done here: loop() hooks are introduced, and both loop and event handler hooks are pre-allocated for HOOK_MAX (64 by default) elements. Two helpers are introduced too, that make it easier to append a new hook to the end of these arrays. 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
void
hooks: Double-registration protection 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 new `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. The `event_handler_hook_add` and `loop_hook_add` functions are gone, but for the time being, they are aliases to the `_use` functions, until all plugins have been updated, and the aliases can be removed. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
loop_hook_append (custom_loop_t hook) {
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
loop_hook_replace ((custom_loop_t)NULL, hook);
Small hook rework Two things are done here: loop() hooks are introduced, and both loop and event handler hooks are pre-allocated for HOOK_MAX (64 by default) elements. Two helpers are introduced too, that make it easier to append a new hook to the end of these arrays. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
}
hooks: Double-registration protection 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 new `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. The `event_handler_hook_add` and `loop_hook_add` functions are gone, but for the time being, they are aliases to the `_use` functions, until all plugins have been updated, and the aliases can be removed. Signed-off-by: Gergely Nagy <algernon@madhouse-project.org>
8 years ago
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);
}