Merge pull request #316 from keyboardio/f/plugin-redesign-2.1
Plugin API redesign v2.1pull/319/head
Gergely Nagy
7 years ago
committed by
GitHub
commit
bddfc7b607
@ -0,0 +1,114 @@
|
|||||||
|
Deprecated APIs and their replacements
|
||||||
|
======================================
|
||||||
|
|
||||||
|
As the firmware evolves, there are - and will be - APIs that we deprecate, and
|
||||||
|
eventually remove. This document is a short guide that lists the deprecations -
|
||||||
|
along with when it happened, and when the functionality will be removed -,
|
||||||
|
suggested upgrade paths, and any other information that may be useful.
|
||||||
|
|
||||||
|
If any of this does not make sense to you, or you have trouble updating your
|
||||||
|
.ino sketch, do not hesitate to write us at help@keyboard.io, we can help you
|
||||||
|
fix it.
|
||||||
|
|
||||||
|
## Sheduled for removal by 2018-05-26
|
||||||
|
|
||||||
|
These APIs and functions have been deprecated for a long time, and as far as we
|
||||||
|
can tell, aren't used by any third party or user code anymore.
|
||||||
|
|
||||||
|
### Kaleidoscope.setup(KEYMAP_SIZE)
|
||||||
|
|
||||||
|
The `Kaleidoscope.setup()` method is still around, and is **not** deprecated,
|
||||||
|
but the variant of it that takes a keymap size is, and has been since October
|
||||||
|
2017.
|
||||||
|
|
||||||
|
Instead, one should use the argument-less `Kaleidoscope.setup()`, and the new
|
||||||
|
`KEYMAP()` macros to define a keymap.
|
||||||
|
|
||||||
|
### event_handler_hook_use, loop_hook_use, and USE_PLUGINS
|
||||||
|
|
||||||
|
Deprecated in October 2017, these are old aliases that should no longer be in
|
||||||
|
use. They were replaced by `Kaleidoscope.useEventHandlerHook`,
|
||||||
|
`Kaleidoscope.useLoopHook`, and `Kaleidoscope.use`, respectively.
|
||||||
|
|
||||||
|
The replacements themselves are also deprecated - see below -, but their removal
|
||||||
|
will come at a later date.
|
||||||
|
|
||||||
|
### MOMENTARY_OFFSET
|
||||||
|
|
||||||
|
Deprecated in October 2017, replaced by `LAYER_SHIFT_OFFSET`.
|
||||||
|
|
||||||
|
This symbol was meant to be used by plugins, not user code, and as far as we
|
||||||
|
know, no third party plugin ever used it.
|
||||||
|
|
||||||
|
### key_was_pressed, key_is_pressed, key_toggled_on, key_toggled_off
|
||||||
|
|
||||||
|
Deprecated in July 2017, replaced by `keyWasPressed`, `keyIsPressed`,
|
||||||
|
`keyToggledOn`, and `keyToggledOff`, respectively.
|
||||||
|
|
||||||
|
## Sheduled for removal by 2018-07-12
|
||||||
|
|
||||||
|
We aim at making a new release by mid-July, and APIs we deprecate now, will be
|
||||||
|
removed shortly before the major release. We may deprecate further APIs during
|
||||||
|
the next month (until mid-June), and those deprecations will share the same
|
||||||
|
removal date. We will try our best to minimize deprecations, and do them as soon
|
||||||
|
as possible, to give everyone at least a month to prepare and update.
|
||||||
|
|
||||||
|
### Kaleidoscope.use()
|
||||||
|
|
||||||
|
Deprecated in May 2018, this method is part of the old plugin API, replaced by
|
||||||
|
`KALEIDOSCOPE_INIT_PLUGINS`. To upgrade, you need to modify your .ino sketch
|
||||||
|
file, and replace the text `Kaleidoscope.use` with `KALEIDOSCOPE_INIT_PLUGINS`,
|
||||||
|
then remove the `&` from all of the plugins inside it, and finally, move it
|
||||||
|
outside of `setup()`.
|
||||||
|
|
||||||
|
If your current sketch looks like this:
|
||||||
|
|
||||||
|
```c++
|
||||||
|
void setup() {
|
||||||
|
Kaleidoscope.use(&Plugin1, &Plugin2);
|
||||||
|
Kaleidoscope.setup();
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
You should change it so that it looks like this instead:
|
||||||
|
|
||||||
|
```c++
|
||||||
|
KALEIDOSCOPE_INIT_PLUGINS(Plugin1, Plugin2);
|
||||||
|
|
||||||
|
void setup() {
|
||||||
|
Kaleidoscope.setup();
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
### The old-style (v1) plugin API
|
||||||
|
|
||||||
|
This includes using `KaleidoscopePlugin`, `Kaleidoscope.useEventHandlerHook`,
|
||||||
|
`Kaleidoscope.replaceEventHandlerHook`, `Kaleidoscope.appendEventHandlerHook`,
|
||||||
|
`Kaleidoscope.useLoopHook`, `Kaleidoscope.replaceLoopHook`,
|
||||||
|
`Kaleidoscope.appendLoopHook`. They were deprecated in May 2017.
|
||||||
|
|
||||||
|
Their replacement is the new plugin API:
|
||||||
|
|
||||||
|
```c++
|
||||||
|
namespace kaleidoscope {
|
||||||
|
|
||||||
|
enum class EventHandlerResult {
|
||||||
|
OK,
|
||||||
|
EVENT_CONSUMED,
|
||||||
|
ERROR,
|
||||||
|
};
|
||||||
|
|
||||||
|
class Plugin {
|
||||||
|
public:
|
||||||
|
EventHandlerResult onSetup();
|
||||||
|
EventHandlerResult beforeEachCycle();
|
||||||
|
EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state);
|
||||||
|
EventHandlerResult beforeReportingState();
|
||||||
|
EventHandlerResult afterEachCycle();
|
||||||
|
};
|
||||||
|
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
Plugins are supposed to implement this new API, and then be initialised via
|
||||||
|
`KALEIDOSCOPE_INIT_PLUGINS`.
|
||||||
@ -0,0 +1,13 @@
|
|||||||
|
# Glossary
|
||||||
|
|
||||||
|
This document is intended to name and describe the concepts, functions and data structures inside Kaleidoscope.
|
||||||
|
|
||||||
|
It is, as yet, incredibly incomplete.
|
||||||
|
|
||||||
|
Entries should be included in dictionary order. When describing an identifier of any kind from the codebase, it should be
|
||||||
|
written using identical capitalization to its use in the code and surrounded by backticks: `identifierName`
|
||||||
|
|
||||||
|
|
||||||
|
Event handler
|
||||||
|
|
||||||
|
: A function, usually provided by a `Plugin` that is run by a `Hook`
|
||||||
@ -0,0 +1,342 @@
|
|||||||
|
# Kaleidoscope Plugin API Internals
|
||||||
|
|
||||||
|
This document attempts to explain how the plugin system works internally, behind
|
||||||
|
the scenes. We feel this is necessary, because there are some unorthodox
|
||||||
|
solutions in play, which make the code incredibly hard to untangle. This is an
|
||||||
|
unavoidable side-effect of employing a system that lets us use non-virtual
|
||||||
|
functions, and save large amounts of RAM thereby. It would be a lot simpler
|
||||||
|
without this feature, but alas, saving hundreds of bytes of RAM is something we
|
||||||
|
felt is worth the complexity.
|
||||||
|
|
||||||
|
Lets start at the top:
|
||||||
|
|
||||||
|
## `KALEIDOSCOPE_INIT_PLUGINS`
|
||||||
|
|
||||||
|
```c++
|
||||||
|
#define KALEIDOSCOPE_INIT_PLUGINS(...) _KALEIDOSCOPE_INIT_PLUGINS(__VA_ARGS__)
|
||||||
|
```
|
||||||
|
|
||||||
|
So far so good, this is pretty simple. The reason we use an indirection here is
|
||||||
|
because this is in `Kaleidoscope.h`, and we do not want the complexity of the
|
||||||
|
`_KALEIDOSCOPE_INIT_PLUGINS` macro here, nor do we want to move the macro to
|
||||||
|
another header, because it belongs to `Kaleidoscope.h`.
|
||||||
|
|
||||||
|
## `_KALEIDOSCOPE_INIT_PLUGINS`
|
||||||
|
|
||||||
|
```c++
|
||||||
|
#define _KALEIDOSCOPE_INIT_PLUGINS(...) \
|
||||||
|
namespace kaleidoscope_internal { \
|
||||||
|
struct EventDispatcher { \
|
||||||
|
\
|
||||||
|
template<typename EventHandler__, typename... Args__ > \
|
||||||
|
static kaleidoscope::EventHandlerResult apply(Args__&&... hook_args) { \
|
||||||
|
\
|
||||||
|
kaleidoscope::EventHandlerResult result; \
|
||||||
|
MAP(_INLINE_EVENT_HANDLER_FOR_PLUGIN, __VA_ARGS__) \
|
||||||
|
\
|
||||||
|
return result; \
|
||||||
|
} \
|
||||||
|
}; \
|
||||||
|
\
|
||||||
|
} \
|
||||||
|
_FOR_EACH_EVENT_HANDLER(_REGISTER_EVENT_HANDLER)
|
||||||
|
```
|
||||||
|
|
||||||
|
This is where things get interesting. This macro does two things:
|
||||||
|
|
||||||
|
- It creates `kaleidoscope_internal::EventDispatcher`, a class with a single
|
||||||
|
method, `apply`. This is a templated method, the template argument is the
|
||||||
|
method `apply` will call. Thus, `EventDispatcher::template apply<foo>` will
|
||||||
|
resolve to a function that calls the `foo` method of each plugin we listed
|
||||||
|
for `KALEIDOSCOPE_INIT_PLUGINS`. We'll see in a bit how this happens.
|
||||||
|
|
||||||
|
- The other part creates overrides for the `Kaleidoscope::Hooks::` family of
|
||||||
|
functions. These are wrappers around `EventDispatcher::template apply<foo>`.
|
||||||
|
We have these so higher level code would not need to care about the
|
||||||
|
implementation details, so that it can invoke the hooks as if they were
|
||||||
|
ordinary functions.
|
||||||
|
|
||||||
|
## `_FOR_EACH_EVENT_HANDLER(_REGISTER_EVENT_HANDLER)`
|
||||||
|
|
||||||
|
Lets look at `_FOR_EACH_EVENT_HANDLER` and `_REGISTER_EVENT_HANDLER` first,
|
||||||
|
because that's easier to explain, and does not lead down another rabbit hole.
|
||||||
|
|
||||||
|
### `_REGISTER_EVENT_HANDLER`
|
||||||
|
|
||||||
|
```c++
|
||||||
|
#define _REGISTER_EVENT_HANDLER( \
|
||||||
|
HOOK_NAME, SHOULD_ABORT_ON_CONSUMED_EVENT, SIGNATURE, ARGS_LIST) \
|
||||||
|
\
|
||||||
|
namespace kaleidoscope_internal { \
|
||||||
|
\
|
||||||
|
struct EventHandler_##HOOK_NAME { \
|
||||||
|
\
|
||||||
|
static bool shouldAbortOnConsumedEvent() { \
|
||||||
|
return SHOULD_ABORT_ON_CONSUMED_EVENT; \
|
||||||
|
} \
|
||||||
|
\
|
||||||
|
template<typename Plugin__, typename... Args__> \
|
||||||
|
static kaleidoscope::EventHandlerResult \
|
||||||
|
call(Plugin__ &plugin, Args__&&... hook_args) { \
|
||||||
|
_VALIDATE_EVENT_HANDLER_SIGNATURE(HOOK_NAME, Plugin__) \
|
||||||
|
return plugin.HOOK_NAME(hook_args...); \
|
||||||
|
} \
|
||||||
|
}; \
|
||||||
|
\
|
||||||
|
} \
|
||||||
|
\
|
||||||
|
namespace kaleidoscope { \
|
||||||
|
\
|
||||||
|
EventHandlerResult Hooks::HOOK_NAME SIGNATURE { \
|
||||||
|
return kaleidoscope_internal::EventDispatcher::template \
|
||||||
|
apply<kaleidoscope_internal::EventHandler_ ## HOOK_NAME> \
|
||||||
|
ARGS_LIST; \
|
||||||
|
} \
|
||||||
|
\
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
This looks big and scary, but in practice, it isn't all that bad. Nevertheless,
|
||||||
|
this is where the magic happens!
|
||||||
|
|
||||||
|
We create two things: `EventHandler_SomeThing` and `Hooks::SomeThing`, the
|
||||||
|
latter being a wrapper around the first, that uses `EventDispatcher::template
|
||||||
|
apply<>` discussed above.
|
||||||
|
|
||||||
|
Lets take `onSetup` as an example! For that, the above expands to:
|
||||||
|
|
||||||
|
```c++
|
||||||
|
namespace kaleidoscope_internal {
|
||||||
|
|
||||||
|
struct EventHandler_onSetup {
|
||||||
|
static bool shouldAbortOnConsumedEvent() {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename Plugin__, typename... Args__>
|
||||||
|
static kaleidoscope::EventHandlerResult
|
||||||
|
call(Plugin__ &plugin, Args__&&... hook_args) {
|
||||||
|
return plugin.onSetup(hook_args...);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
namespace kaleidoscope {
|
||||||
|
|
||||||
|
EventHandlerResult Hooks::onSetup() {
|
||||||
|
return kaleidoscope_internal::EventDispatcher::template
|
||||||
|
apply<kaleidoscope_internal::EventHandler_onSetup>();
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
This still looks scary... but please read a bit further, and it will all make
|
||||||
|
sense!
|
||||||
|
|
||||||
|
### `_FOR_EACH_EVENT_HANDLER`
|
||||||
|
|
||||||
|
This just evaluates its argument for each event handler supported by
|
||||||
|
Kaleidoscope core. Very simple macro expansion, which we will not expand here,
|
||||||
|
because that would take up a lot of space, and they all look the same (see
|
||||||
|
above).
|
||||||
|
|
||||||
|
## `EventDispatcher`
|
||||||
|
|
||||||
|
```c++
|
||||||
|
namespace kaleidoscope_internal {
|
||||||
|
struct EventDispatcher {
|
||||||
|
template<typename EventHandler__, typename... Args__ >
|
||||||
|
static kaleidoscope::EventHandlerResult apply(Args__&&... hook_args) {
|
||||||
|
|
||||||
|
kaleidoscope::EventHandlerResult result;
|
||||||
|
MAP(_INLINE_EVENT_HANDLER_FOR_PLUGIN, __VA_ARGS__)
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
```
|
||||||
|
|
||||||
|
This is where the other part of the magic happens, and we need to understand
|
||||||
|
this to be able to make sense of `_REGISTER_EVENT_HANDLER` above.
|
||||||
|
|
||||||
|
### `_INLINE_EVENT_HANDLER_FOR_PLUGIN`
|
||||||
|
|
||||||
|
This in isolation, is not very interesting, and is closely tied to
|
||||||
|
`EventDispatcher`. The definition is here so we can look at it while we learn
|
||||||
|
the details of `EventDispatcher` below.
|
||||||
|
|
||||||
|
```c++
|
||||||
|
#define _INLINE_EVENT_HANDLER_FOR_PLUGIN(PLUGIN) \
|
||||||
|
\
|
||||||
|
result = EventHandler__::call(PLUGIN, hook_args...); \
|
||||||
|
\
|
||||||
|
if (EventHandler__::shouldAbortOnConsumedEvent() && \
|
||||||
|
result == kaleidoscope::EventHandlerResult::EVENT_CONSUMED) { \
|
||||||
|
return result; \
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
### Back to `EventDispatcher`...
|
||||||
|
|
||||||
|
The `EventDispatcher` structure has a single method: `apply<>`, which needs an
|
||||||
|
event handler as its template argument. What the macro does, is call the event
|
||||||
|
handler given in the template argument for each and every initialised plugin.
|
||||||
|
It's best explained with an example! Lets use two plugins, `SomePlugin` and
|
||||||
|
`ExampleEffect`:
|
||||||
|
|
||||||
|
```c++
|
||||||
|
namespace kaleidoscope_internal {
|
||||||
|
struct EventDispatcher {
|
||||||
|
template<typename EventHandler__, typename... Args__ >
|
||||||
|
static kaleidoscope::EventHandlerResult apply(Args__&&... hook_args) {
|
||||||
|
|
||||||
|
kaleidoscope::EventHandlerResult result;
|
||||||
|
|
||||||
|
result = EventHandler__::call(SomePlugin);
|
||||||
|
if (EventHandler__::shouldAbortOnConsumedEvent() &&
|
||||||
|
result == kaleidoscope::EventHandlerResult::EVENT_CONSUMED) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
result = EventHandler__::call(ExampleEffect);
|
||||||
|
if (EventHandler__::shouldAbortOnConsumedEvent() &&
|
||||||
|
result == kaleidoscope::EventHandlerResult::EVENT_CONSUMED) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
```
|
||||||
|
|
||||||
|
See? It's unrolled! But how do we get from here to - say - calling the
|
||||||
|
`onSetup()` method of the plugins? Why, by way of `EventDispatcher::template
|
||||||
|
apply<EventHandler_onSetup>`! Lets see what happens when we do a call like that:
|
||||||
|
|
||||||
|
```c++
|
||||||
|
namespace kaleidoscope_internal {
|
||||||
|
struct EventDispatcher {
|
||||||
|
template<typename EventHandler_onSetup, typename... Args__ >
|
||||||
|
static kaleidoscope::EventHandlerResult apply(Args__&&... hook_args) {
|
||||||
|
|
||||||
|
kaleidoscope::EventHandlerResult result;
|
||||||
|
|
||||||
|
result = EventHandler_onSetup::call(SomePlugin);
|
||||||
|
if (EventHandler_onSetup::shouldAbortOnConsumedEvent() &&
|
||||||
|
result == kaleidoscope::EventHandlerResult::EVENT_CONSUMED) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
result = EventHandler_onSetup::call(ExampleEffect);
|
||||||
|
if (EventHandler_onSetup::shouldAbortOnConsumedEvent() &&
|
||||||
|
result == kaleidoscope::EventHandlerResult::EVENT_CONSUMED) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
```
|
||||||
|
|
||||||
|
Because we call `EventHandler_onSetup::call` with the plugin as the first
|
||||||
|
argument, and because `call` is also a templated function, where the first
|
||||||
|
argument is templated, we get a method that is polimorphic on its first
|
||||||
|
argument. Meaning, for each and every plugin, we'll have a matching
|
||||||
|
`EventHandler_onSetup::call`, that is tied to that plugin. *This* is the magic
|
||||||
|
that lets us use non-virtual methods!
|
||||||
|
|
||||||
|
## Exploring what the compiler does
|
||||||
|
|
||||||
|
Because all hooks are called via `kaleidoscope::Hooks::NAME`, lets explore how
|
||||||
|
the compiler will optimize the code for `onSetup`, assuming we use two plugins,
|
||||||
|
`SomePlugin` and `ExampleEffect`.
|
||||||
|
|
||||||
|
Our entry point is this:
|
||||||
|
|
||||||
|
```c++
|
||||||
|
return kaleidoscope::Hooks::onSetup();
|
||||||
|
```
|
||||||
|
|
||||||
|
`_REGISTER_EVENT_HANDLER` created `Hooks::onSetup()` for us:
|
||||||
|
|
||||||
|
```c++
|
||||||
|
EventHandlerResult kaleidoscope::Hooks::onSetup() {
|
||||||
|
return kaleidoscope_internal::EventDispatcher::template
|
||||||
|
apply<kaleidoscope_internal::EventHandler_onSetup>();
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
If we inline the call to `EventDispatcher::template apply<>`, we end up with the
|
||||||
|
following:
|
||||||
|
|
||||||
|
```c++
|
||||||
|
EventHandlerResult kaleidoscope::Hooks::onSetup() {
|
||||||
|
kaleidoscope::EventHandlerResult result;
|
||||||
|
|
||||||
|
result = EventHandler_onSetup::call(SomePlugin);
|
||||||
|
if (EventHandler_onSetup::shouldAbortOnConsumedEvent() &&
|
||||||
|
result == kaleidoscope::EventHandlerResult::EVENT_CONSUMED) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
result = EventHandler_onSetup::call(ExampleEffect);
|
||||||
|
if (EventHandler_onSetup::shouldAbortOnConsumedEvent() &&
|
||||||
|
result == kaleidoscope::EventHandlerResult::EVENT_CONSUMED) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
This is starting to look human readable, doesn't it? But we can go further,
|
||||||
|
because `EventHandler::onSetup::call` and
|
||||||
|
`EventHandler_onSetup::shouldAbortOnConsumedEvent` are evaluated at compile-time
|
||||||
|
too!
|
||||||
|
|
||||||
|
```c++
|
||||||
|
EventHandlerResult kaleidoscope::Hooks::onSetup() {
|
||||||
|
kaleidoscope::EventHandlerResult result;
|
||||||
|
|
||||||
|
result = SomePlugin.onSetup();
|
||||||
|
if (false &&
|
||||||
|
result == kaleidoscope::EventHandlerResult::EVENT_CONSUMED) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
result = ExampleEffect.onSetup();
|
||||||
|
if (false &&
|
||||||
|
result == kaleidoscope::EventHandlerResult::EVENT_CONSUMED) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
Which in turn, may be optimized further to something like the following:
|
||||||
|
|
||||||
|
```c++
|
||||||
|
EventHandlerResult kaleidoscope::Hooks::onSetup() {
|
||||||
|
kaleidoscope::EventHandlerResult result;
|
||||||
|
|
||||||
|
result = SomePlugin.onSetup();
|
||||||
|
result = ExampleEffect.onSetup();
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
And this, is the end of the magic. This is roughly how much the code gets
|
||||||
|
transformed *at compile time*, so that at run-time, none of this indirection is
|
||||||
|
present.
|
||||||
|
|
||||||
|
## Summary
|
||||||
|
|
||||||
|
As we can see, there is a lot going on behind the scenes, and a combination of
|
||||||
|
template meta programming and pre-processor macros is used to accomplish our
|
||||||
|
goal. But following the code path like we did above allows us to see what the
|
||||||
|
compiler sees (more or less), and inlining all the things that are done
|
||||||
|
compile-time gives us the final code, which is pretty simple by that point.
|
||||||
@ -0,0 +1,51 @@
|
|||||||
|
/* -*- mode: c++ -*-
|
||||||
|
* Basic -- A very basic Kaleidoscope example
|
||||||
|
* Copyright (C) 2018 Gergely Nagy
|
||||||
|
*
|
||||||
|
* This program is free software; you can redistribute it and/or modify
|
||||||
|
* it under the terms of the GNU General Public License as published by
|
||||||
|
* the Free Software Foundation; either version 2 of the License, or
|
||||||
|
* (at your option) any later version.
|
||||||
|
*
|
||||||
|
* This program is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU General Public License along
|
||||||
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||||
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "Kaleidoscope.h"
|
||||||
|
|
||||||
|
/* *INDENT-OFF* */
|
||||||
|
KEYMAPS(
|
||||||
|
[0] = KEYMAP_STACKED
|
||||||
|
(
|
||||||
|
Key_NoKey, Key_1, Key_2, Key_3, Key_4, Key_5, Key_NoKey,
|
||||||
|
Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab,
|
||||||
|
Key_PageUp, Key_A, Key_S, Key_D, Key_F, Key_G,
|
||||||
|
Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape,
|
||||||
|
|
||||||
|
Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,
|
||||||
|
Key_NoKey,
|
||||||
|
|
||||||
|
Key_skip, Key_6, Key_7, Key_8, Key_9, Key_0, Key_skip,
|
||||||
|
Key_Enter, Key_Y, Key_U, Key_I, Key_O, Key_P, Key_Equals,
|
||||||
|
Key_H, Key_J, Key_K, Key_L, Key_Semicolon, Key_Quote,
|
||||||
|
Key_skip, Key_N, Key_M, Key_Comma, Key_Period, Key_Slash, Key_Minus,
|
||||||
|
|
||||||
|
Key_RightShift, Key_RightAlt, Key_Spacebar, Key_RightControl,
|
||||||
|
Key_NoKey
|
||||||
|
),
|
||||||
|
)
|
||||||
|
/* *INDENT-ON* */
|
||||||
|
|
||||||
|
void setup() {
|
||||||
|
Kaleidoscope.setup();
|
||||||
|
}
|
||||||
|
|
||||||
|
void loop() {
|
||||||
|
Kaleidoscope.loop();
|
||||||
|
}
|
||||||
@ -0,0 +1,57 @@
|
|||||||
|
#pragma once
|
||||||
|
|
||||||
|
// This file defines the names and argument signatures for all event handlers
|
||||||
|
// in the Kaleidoscope core.
|
||||||
|
//
|
||||||
|
// When adding a new hook or event handler to Kaleidoscope, it needs only
|
||||||
|
// to be added here and to the place in the codebase where it should be called.
|
||||||
|
//
|
||||||
|
// _FOR_EACH_EVENT_HANDLER is what's called an "X Macro". Its first argument,
|
||||||
|
// OPERATION, is the name of another macro. When called, it will execute
|
||||||
|
// OPERATION once for each event handler defined herein with the following
|
||||||
|
// parameters:
|
||||||
|
//
|
||||||
|
// HOOK_NAME, SHOULD_ABORT_ON_CONSUMED_EVENT, SIGNATURE, ARGS_LIST, ...
|
||||||
|
//
|
||||||
|
// Any additional parameters that are added to an invokation
|
||||||
|
// of _FOR_EACH_EVENT_HANDLER are passed through to OP.
|
||||||
|
|
||||||
|
#define _ABORTABLE true
|
||||||
|
#define _NOT_ABORTABLE false
|
||||||
|
|
||||||
|
#define _FOR_EACH_EVENT_HANDLER(OPERATION, ...) __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
OPERATION(onSetup, __NL__ \
|
||||||
|
_NOT_ABORTABLE, __NL__ \
|
||||||
|
(),(), ##__VA_ARGS__) __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
/* Called at the very start of each cycle, before gathering */ __NL__ \
|
||||||
|
/* events, before doing anything else. */ __NL__ \
|
||||||
|
OPERATION(beforeEachCycle, __NL__ \
|
||||||
|
_NOT_ABORTABLE, __NL__ \
|
||||||
|
(), (), ##__VA_ARGS__) __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
/* Function called for every non-idle key, every cycle, so it */ __NL__ \
|
||||||
|
/* can decide what to do with it. It can modify the key (which is */ __NL__ \
|
||||||
|
/* passed by reference for this reason), and decide whether */ __NL__ \
|
||||||
|
/* further handles should be tried. If it returns */ __NL__ \
|
||||||
|
/* EventHandlerResult::OK, other handlers will also get a chance */ __NL__ \
|
||||||
|
/* to react to the event. If it returns anything else, Kaleidoscope */ __NL__ \
|
||||||
|
/* will stop processing there. */ __NL__ \
|
||||||
|
OPERATION(onKeyswitchEvent, __NL__ \
|
||||||
|
_ABORTABLE, __NL__ \
|
||||||
|
(Key &mappedKey, byte row, byte col, uint8_t keyState), __NL__ \
|
||||||
|
(mappedKey, row, col, keyState), ##__VA_ARGS__) __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
/* Called before reporting our state to the host. This is the */ __NL__ \
|
||||||
|
/* last point in a cycle where a plugin can alter what gets */ __NL__ \
|
||||||
|
/* reported to the host. */ __NL__ \
|
||||||
|
OPERATION(beforeReportingState, __NL__ \
|
||||||
|
_NOT_ABORTABLE, __NL__ \
|
||||||
|
(),(),##__VA_ARGS__) __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
/* Called at the very end of a cycle, after everything's */ __NL__ \
|
||||||
|
/* said and done. */ __NL__ \
|
||||||
|
OPERATION(afterEachCycle, __NL__ \
|
||||||
|
_NOT_ABORTABLE, __NL__ \
|
||||||
|
(),(),##__VA_ARGS__)
|
||||||
@ -0,0 +1,11 @@
|
|||||||
|
#pragma once
|
||||||
|
|
||||||
|
namespace kaleidoscope {
|
||||||
|
|
||||||
|
enum class EventHandlerResult {
|
||||||
|
OK,
|
||||||
|
EVENT_CONSUMED,
|
||||||
|
ERROR,
|
||||||
|
};
|
||||||
|
|
||||||
|
}
|
||||||
@ -0,0 +1,27 @@
|
|||||||
|
#include "kaleidoscope/hooks.h"
|
||||||
|
|
||||||
|
namespace kaleidoscope {
|
||||||
|
|
||||||
|
// The following weak symbols are overwritten by
|
||||||
|
// using the KALEIDOSCOPE_INIT_PLUGINS(...) macro
|
||||||
|
// in the the firmware sketch. Their only purpose is
|
||||||
|
// to provide backwards compatibility during the transition
|
||||||
|
// from the old implementation of the hooking/plugin system
|
||||||
|
// to the new one. The weak symbols ensure that there
|
||||||
|
// are no undefined symbols if KALEIDOSCOPE_INIT_PLUGINS(...)
|
||||||
|
// is not used. This allows legacy sketches to be used
|
||||||
|
// during the transition phase.
|
||||||
|
|
||||||
|
#define INSTANTIATE_WEAK_HOOK_FUNCTION( \
|
||||||
|
HOOK_NAME, SHOULD_ABORT_ON_CONSUMED_EVENT, SIGNATURE, ARGS_LIST) __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
__attribute__((weak)) __NL__ \
|
||||||
|
EventHandlerResult Hooks::HOOK_NAME SIGNATURE { __NL__ \
|
||||||
|
return EventHandlerResult::OK; __NL__ \
|
||||||
|
}
|
||||||
|
|
||||||
|
_FOR_EACH_EVENT_HANDLER(INSTANTIATE_WEAK_HOOK_FUNCTION)
|
||||||
|
|
||||||
|
#undef INSTANTIATE_WEAK_HOOK_FUNCTION
|
||||||
|
|
||||||
|
} // namespace kaleidoscope
|
||||||
@ -0,0 +1,56 @@
|
|||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <Arduino.h>
|
||||||
|
|
||||||
|
namespace kaleidoscope {
|
||||||
|
union Key;
|
||||||
|
}
|
||||||
|
|
||||||
|
#include "plugin.h"
|
||||||
|
#include "event_handlers.h"
|
||||||
|
|
||||||
|
// Forward declaration required to enable friend declarations
|
||||||
|
// in class Hooks.
|
||||||
|
class kaleidoscope_;
|
||||||
|
extern void handleKeyswitchEvent(kaleidoscope::Key mappedKey, byte row, byte col, uint8_t keyState);
|
||||||
|
|
||||||
|
namespace kaleidoscope {
|
||||||
|
|
||||||
|
// The reason why the hook routing entry point functions live within
|
||||||
|
// class Hooks and not directly within a namespace is, that we want
|
||||||
|
// to restrict who is allowed to trigger hooks, mainly to prevent
|
||||||
|
// user code from calling hook methods.
|
||||||
|
//
|
||||||
|
// A note to maintainers: When you add new hooks that are supposed to
|
||||||
|
// be called from other places than the friend classes and functions listed
|
||||||
|
// below, just add a suitable friend declaration.
|
||||||
|
|
||||||
|
class Hooks {
|
||||||
|
|
||||||
|
// The following friend declarations restrict access to
|
||||||
|
// the hook routing system.
|
||||||
|
|
||||||
|
// Kaleidoscope_ calls Hooks::onSetup, Hooks::beforeReportingState
|
||||||
|
// and Hooks::afterEachCycle.
|
||||||
|
friend class Kaleidoscope_;
|
||||||
|
|
||||||
|
// ::handleKeyswitchEvent(...) calls Hooks::onKeyswitchEvent.
|
||||||
|
friend void ::handleKeyswitchEvent(kaleidoscope::Key mappedKey,
|
||||||
|
byte row, byte col, uint8_t keyState);
|
||||||
|
|
||||||
|
private:
|
||||||
|
|
||||||
|
// The following private functions are just to be called by classes
|
||||||
|
// and functions that are declared as friends above.
|
||||||
|
|
||||||
|
#define DEFINE_WEAK_HOOK_FUNCTION( \
|
||||||
|
HOOK_NAME, SHOULD_ABORT_ON_CONSUMED_EVENT, SIGNATURE, ARGS_LIST) __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
static EventHandlerResult HOOK_NAME SIGNATURE;
|
||||||
|
|
||||||
|
_FOR_EACH_EVENT_HANDLER(DEFINE_WEAK_HOOK_FUNCTION)
|
||||||
|
|
||||||
|
#undef DEFINE_WEAK_HOOK_FUNCTION
|
||||||
|
};
|
||||||
|
|
||||||
|
}
|
||||||
@ -0,0 +1,133 @@
|
|||||||
|
/*
|
||||||
|
* This file contains pre-processor macros, which are not namespaced, the
|
||||||
|
* vast majority of code these macros generate will live under the
|
||||||
|
* kaleidoscope_internal namespace. That is why this header is here.
|
||||||
|
*
|
||||||
|
* The only exception to this is the _KALEIDOSCOPE_INIT_PLUGINS macro, which
|
||||||
|
* also places a few symbols under the kaleidoscope namespace. But that code is
|
||||||
|
* tightly coupled with the other parts, which are in kaleidoscope_internal.
|
||||||
|
*
|
||||||
|
* The reason we use an entirely separate namespace is that
|
||||||
|
* Some plugins' classes are in the kaleidoscope namespace, and the instances
|
||||||
|
* of those classes have the same names as the classes, but in the global
|
||||||
|
* namespace. In these cases, the macros herein would resolve to the classes,
|
||||||
|
* when we want them to resolve to instances. To avoid this, we put the
|
||||||
|
* generated code in an entirely different namespace.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "macro_helpers.h"
|
||||||
|
#include "plugin.h"
|
||||||
|
#include "kaleidoscope/hooks.h"
|
||||||
|
#include "eventhandler_signature_check.h"
|
||||||
|
#include "event_handlers.h"
|
||||||
|
|
||||||
|
// Some words about the design of hook routing:
|
||||||
|
//
|
||||||
|
// The EventDispatcher class implements a compile-time loop over all plugins, which
|
||||||
|
// calls an event handler on each plugin.
|
||||||
|
//
|
||||||
|
// Each hook called by the firmware core compiles down to only a single
|
||||||
|
// static function call (in class Hooks), rather than one for each plugin.
|
||||||
|
//
|
||||||
|
// This approach is better than using virtual event handlers in classes
|
||||||
|
// derived from kaleidoscope::Plugin because it results in significantly fewer
|
||||||
|
// virtual function calls and virtual function tables (vtables).
|
||||||
|
//
|
||||||
|
// The call to event handlers through kaleidoscope::Hooks and
|
||||||
|
// kaleidoscope_internal::EventDispatcher is templated to allow for compile time
|
||||||
|
// static polymorphisms (plugins' EventHandlers aren't virtual).
|
||||||
|
//
|
||||||
|
// Technically, plugins don't need to be derived from kaleidoscope::Plugin, but
|
||||||
|
// only need to implement a set of event handlers whose call signature match the
|
||||||
|
// API definition. This approach is similar to duck typing in scripting languages:
|
||||||
|
// The compiler only cares that a method's signature matches, not that the plugin
|
||||||
|
// is derived from kaleidoscope::Plugin.
|
||||||
|
//
|
||||||
|
// Static hook functions inside the Hooks class each use the EventDispatcher
|
||||||
|
// helper class to cast an associated EventHandler on each plugin instance.
|
||||||
|
|
||||||
|
|
||||||
|
// This defines an auxiliary class 'EventHandler_Foo' for each hook 'Foo'.
|
||||||
|
// Kaleidoscope::Hooks calls the EventDispatcher class, which in turn invokes
|
||||||
|
// the event handler method 'Foo' of each registered plugin with a given
|
||||||
|
// set of arguments.
|
||||||
|
|
||||||
|
#define _REGISTER_EVENT_HANDLER( \
|
||||||
|
HOOK_NAME, SHOULD_ABORT_ON_CONSUMED_EVENT, SIGNATURE, ARGS_LIST) __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
namespace kaleidoscope_internal { __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
struct EventHandler_##HOOK_NAME { __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
static bool shouldAbortOnConsumedEvent() { __NL__ \
|
||||||
|
return SHOULD_ABORT_ON_CONSUMED_EVENT; __NL__ \
|
||||||
|
} __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
template<typename Plugin__, typename... Args__> __NL__ \
|
||||||
|
static kaleidoscope::EventHandlerResult __NL__ \
|
||||||
|
call(Plugin__ &plugin, Args__&&... hook_args) { __NL__ \
|
||||||
|
_VALIDATE_EVENT_HANDLER_SIGNATURE(HOOK_NAME, Plugin__) __NL__ \
|
||||||
|
return plugin.HOOK_NAME(hook_args...); __NL__ \
|
||||||
|
} __NL__ \
|
||||||
|
}; __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
} __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
namespace kaleidoscope { __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
EventHandlerResult Hooks::HOOK_NAME SIGNATURE { __NL__ \
|
||||||
|
return kaleidoscope_internal::EventDispatcher::template __NL__ \
|
||||||
|
apply<kaleidoscope_internal::EventHandler_ ## HOOK_NAME> __NL__ \
|
||||||
|
ARGS_LIST; __NL__ \
|
||||||
|
} __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
}
|
||||||
|
|
||||||
|
#define _INLINE_EVENT_HANDLER_FOR_PLUGIN(PLUGIN) \
|
||||||
|
__NL__ \
|
||||||
|
result = EventHandler__::call(PLUGIN, hook_args...); __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
if (EventHandler__::shouldAbortOnConsumedEvent() && __NL__ \
|
||||||
|
result == kaleidoscope::EventHandlerResult::EVENT_CONSUMED) { __NL__ \
|
||||||
|
return result; __NL__ \
|
||||||
|
} __NL__
|
||||||
|
|
||||||
|
// _KALEIDOSCOPE_INIT_PLUGINS builds the loops that execute the plugins'
|
||||||
|
// implementations of the various event handlers.
|
||||||
|
//
|
||||||
|
// Its arguments are a list of references to plugin instances that have been
|
||||||
|
// instantiated in the global scope.
|
||||||
|
|
||||||
|
// EventDispatcher::apply() implements a compile time for-each loop over all
|
||||||
|
// plugins. The compiler automatically optimizes away calls to any plugin that
|
||||||
|
// doesn't implement an EventHandler for a given hook.
|
||||||
|
|
||||||
|
#define _KALEIDOSCOPE_INIT_PLUGINS(...) __NL__ \
|
||||||
|
namespace kaleidoscope_internal { __NL__ \
|
||||||
|
struct EventDispatcher { __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
/* Iterate through plugins, calling each one's event handler with */ __NL__ \
|
||||||
|
/* the arguments passed to the hook */ __NL__ \
|
||||||
|
template<typename EventHandler__, typename... Args__ > __NL__ \
|
||||||
|
static kaleidoscope::EventHandlerResult apply(Args__&&... hook_args) { __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
kaleidoscope::EventHandlerResult result; __NL__ \
|
||||||
|
MAP(_INLINE_EVENT_HANDLER_FOR_PLUGIN, __VA_ARGS__) __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
return result; __NL__ \
|
||||||
|
} __NL__ \
|
||||||
|
}; __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
} __NL__ \
|
||||||
|
/* We register event handlers here - which is not technically related */ __NL__ \
|
||||||
|
/* to initialization, nor is it in the same namespace - to support the */ __NL__ \
|
||||||
|
/* transition from the old APIs. When the user sketch does not use */ __NL__ \
|
||||||
|
/* KALEIDOSCOPE_INIT_PLUGINS(), the event handlers will not exist */ __NL__ \
|
||||||
|
/* either, thus wrapping them would produce a compile error. For this */ __NL__ \
|
||||||
|
/* reason, we do the wrapping here, tied to _KALEIDOSCOPE_INIT_PLUGINS. */ __NL__ \
|
||||||
|
/* */ __NL__ \
|
||||||
|
/* TODO(anyone): Move this somewhere else, outside of _internal, once */ __NL__ \
|
||||||
|
/* the V1 API is removed. */ __NL__ \
|
||||||
|
_FOR_EACH_EVENT_HANDLER(_REGISTER_EVENT_HANDLER)
|
||||||
@ -0,0 +1,124 @@
|
|||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "macro_helpers.h"
|
||||||
|
#include "plugin.h"
|
||||||
|
|
||||||
|
|
||||||
|
// *************************************************************************
|
||||||
|
// *************************************************************************
|
||||||
|
// NOTHING IN THIS HEADER WILL RESULT IN ANY CODE COMPILED INTO KALEIDOSCOPE
|
||||||
|
//
|
||||||
|
// YOU DO NOT NEED TO LOOK INSIDE THIS FILE IF YOU'RE TRYING TO UNDERSTAND
|
||||||
|
// HOW KALEIDOSCOPE WORKS.
|
||||||
|
// *************************************************************************
|
||||||
|
// *************************************************************************
|
||||||
|
|
||||||
|
// This header file implements compile-time method signature verification for
|
||||||
|
// plugins' event handlers as the _VALIDATE_EVENT_HANDLER_SIGNATURE macro.
|
||||||
|
|
||||||
|
// If the method signatures don't match the API definitions, compilation
|
||||||
|
// should fail with a helpful error message.
|
||||||
|
|
||||||
|
// *************************************************************************
|
||||||
|
// *************************************************************************
|
||||||
|
|
||||||
|
// We use non-virtual methods for event handlers. This reduces RAM (and to a
|
||||||
|
// smaller extent, PROGMEM) consumption, runtime call overhead, and allows the
|
||||||
|
// compiler to a better job removing dead code.
|
||||||
|
//
|
||||||
|
// The downside is that event handler methods in derived plugins are hidden,
|
||||||
|
// rather than overridden. Because only virtual methods can be overridden, we
|
||||||
|
// can't apply C++'s `override` keyword to hook methods.
|
||||||
|
//
|
||||||
|
// To make it easier to debug issues with plugins' event handler method
|
||||||
|
// signatures, the _VALIDATE_EVENT_HANDLER_SIGNATURE macro compares a plugin's
|
||||||
|
// event handler signatures with those of the kaleidoscope::Plugin baseclass. If
|
||||||
|
// any differences are detected, it outputs a compile-time error message.
|
||||||
|
//
|
||||||
|
// Ideally, we'd be able to use this (much simpler) code.
|
||||||
|
//
|
||||||
|
// decltype(&::kaleidoscope::Plugin::fooEventHandler)
|
||||||
|
// == decltype(&childPlugin::fooEventHandler)
|
||||||
|
//
|
||||||
|
// Unfortunately, this is not possible with C++-11, as it does not allow
|
||||||
|
// comparing function-types for equality. As a workaround, we can use the trait
|
||||||
|
// class EventHandlerSignaturesMatch to perform the comparison.
|
||||||
|
//
|
||||||
|
// It defines the bool constant 'value' as true if both signatures match.
|
||||||
|
// It checks the return value, argument types and const specification.
|
||||||
|
// (As of this writing, we don't have any const hook method.)
|
||||||
|
|
||||||
|
template<typename T1, typename T2>
|
||||||
|
struct EventHandlerSignaturesMatch {
|
||||||
|
static constexpr bool value = false;
|
||||||
|
};
|
||||||
|
|
||||||
|
// R: The return value,
|
||||||
|
// T1: Type of the first class (plugin),
|
||||||
|
// T2: Type of the second class (plugin),
|
||||||
|
// EventHandlerArgs: Variadic types of plugin event handler arguments.
|
||||||
|
|
||||||
|
template<typename R, typename T1, typename T2, typename... EventHandlerArgs>
|
||||||
|
struct EventHandlerSignaturesMatch<R(T1::*)(EventHandlerArgs...), R(T2::*)(EventHandlerArgs...)> {
|
||||||
|
static constexpr bool value = true;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Equivalent to allow for const-eventhandlers, e.g. bool getFooEventHandler() const
|
||||||
|
template<typename R, typename T1, typename T2, typename... EventHandlerArgs> struct
|
||||||
|
EventHandlerSignaturesMatch<R(T1::*)(EventHandlerArgs...) const, R(T2::*)(EventHandlerArgs...) const> {
|
||||||
|
static constexpr bool value = true;
|
||||||
|
};
|
||||||
|
|
||||||
|
// This template is instantiated when something goes wrong.
|
||||||
|
// Because it does not define a constant 'value', it triggers a compiler error.
|
||||||
|
|
||||||
|
template<typename Plugin__, bool result> struct
|
||||||
|
___________Culprit_Plugin___________ { };
|
||||||
|
|
||||||
|
// This specialization is instantiated when everything is ok.
|
||||||
|
template<typename Plugin__> struct
|
||||||
|
___________Culprit_Plugin___________ <Plugin__, true> {
|
||||||
|
static constexpr bool value = true;
|
||||||
|
};
|
||||||
|
|
||||||
|
// If the pointer types are the same, the signatures match, causing
|
||||||
|
// the first or second specialization to be instantiated. This makes
|
||||||
|
// the causes the compile time constant `value` to be defined as `true`.
|
||||||
|
// Otherwise, the unspecialized version of the template class is instantiated
|
||||||
|
// and `value` is defined as `false`
|
||||||
|
|
||||||
|
#define _VALIDATE_EVENT_HANDLER_SIGNATURE(EVENTHANDLER, PLUGIN) \
|
||||||
|
{ __NL__ \
|
||||||
|
/* Check if the signatures match. If not, the plugin has implemented */ __NL__ \
|
||||||
|
/* a method with a hook's name, but a different signature. */ __NL__ \
|
||||||
|
typedef EventHandlerSignaturesMatch< __NL__ \
|
||||||
|
decltype(&::kaleidoscope::Plugin::EVENTHANDLER), __NL__ \
|
||||||
|
decltype(&PLUGIN::EVENTHANDLER) __NL__ \
|
||||||
|
> Check; __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
static_assert(Check::value, __NL__ \
|
||||||
|
VERBOSE_STATIC_ASSERT_HEADER __NL__ \
|
||||||
|
"\nOne of your plugins implemented the \"" #EVENTHANDLER "\"" __NL__ \
|
||||||
|
"\nevent handler, but its signature didn't match the base class." __NL__ \
|
||||||
|
"\n" __NL__ \
|
||||||
|
"\nThe plugin with this issue will be marked in the compiler" __NL__ \
|
||||||
|
"\noutput with the string:" __NL__ \
|
||||||
|
"\n" __NL__ \
|
||||||
|
"\n ___________Culprit_Plugin___________." __NL__ \
|
||||||
|
"\n" __NL__ \
|
||||||
|
"\nYou should compare the event handlers implemented in this plugin" __NL__ \
|
||||||
|
"\nto those in \"kaleidoscope::Plugin\"." __NL__ \
|
||||||
|
"\n" __NL__ \
|
||||||
|
"\nAll of the event handler's argument types, return values and" __NL__ \
|
||||||
|
"\nconst qualifiers need to match." __NL__ \
|
||||||
|
"\n" __NL__ \
|
||||||
|
VERBOSE_STATIC_ASSERT_FOOTER __NL__ \
|
||||||
|
); __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
/* The following construct is necessary enable reporting of the */ __NL__ \
|
||||||
|
/* type of a plugin that implements an event handler with an */ __NL__ \
|
||||||
|
/* incorrect signature, because it's not possible to include any */ __NL__ \
|
||||||
|
/* non-literal string constant in a static_assert error message. */ __NL__ \
|
||||||
|
constexpr bool dummy = ___________Culprit_Plugin___________ __NL__ \
|
||||||
|
<PLUGIN, Check::value>::value; __NL__ \
|
||||||
|
}
|
||||||
@ -0,0 +1,67 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2012 William Swanson
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation
|
||||||
|
* files (the "Software"), to deal in the Software without
|
||||||
|
* restriction, including without limitation the rights to use, copy,
|
||||||
|
* modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||||
|
* of the Software, and to permit persons to whom the Software is
|
||||||
|
* furnished to do so, subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or substantial portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
|
||||||
|
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
|
||||||
|
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||||
|
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||||
|
*
|
||||||
|
* Except as contained in this notice, the names of the authors or
|
||||||
|
* their institutions shall not be used in advertising or otherwise to
|
||||||
|
* promote the sale, use or other dealings in this Software without
|
||||||
|
* prior written authorization from the authors.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#define EVAL0(...) __VA_ARGS__
|
||||||
|
#define EVAL1(...) EVAL0(EVAL0(EVAL0(__VA_ARGS__)))
|
||||||
|
#define EVAL2(...) EVAL1(EVAL1(EVAL1(__VA_ARGS__)))
|
||||||
|
#define EVAL3(...) EVAL2(EVAL2(EVAL2(__VA_ARGS__)))
|
||||||
|
#define EVAL4(...) EVAL3(EVAL3(EVAL3(__VA_ARGS__)))
|
||||||
|
#define EVAL(...) EVAL4(EVAL4(EVAL4(__VA_ARGS__)))
|
||||||
|
|
||||||
|
#define MAP_END(...)
|
||||||
|
#define MAP_OUT
|
||||||
|
#define MAP_COMMA ,
|
||||||
|
|
||||||
|
#define MAP_GET_END2() 0, MAP_END
|
||||||
|
#define MAP_GET_END1(...) MAP_GET_END2
|
||||||
|
#define MAP_GET_END(...) MAP_GET_END1
|
||||||
|
#define MAP_NEXT0(test, next, ...) next MAP_OUT
|
||||||
|
#define MAP_NEXT1(test, next) MAP_NEXT0(test, next, 0)
|
||||||
|
#define MAP_NEXT(test, next) MAP_NEXT1(MAP_GET_END test, next)
|
||||||
|
|
||||||
|
#define MAP0(f, x, peek, ...) f(x) MAP_NEXT(peek, MAP1)(f, peek, __VA_ARGS__)
|
||||||
|
#define MAP1(f, x, peek, ...) f(x) MAP_NEXT(peek, MAP0)(f, peek, __VA_ARGS__)
|
||||||
|
|
||||||
|
#define MAP_LIST_NEXT1(test, next) MAP_NEXT0(test, MAP_COMMA next, 0)
|
||||||
|
#define MAP_LIST_NEXT(test, next) MAP_LIST_NEXT1(MAP_GET_END test, next)
|
||||||
|
|
||||||
|
#define MAP_LIST0(f, x, peek, ...) f(x) MAP_LIST_NEXT(peek, MAP_LIST1)(f, peek, __VA_ARGS__)
|
||||||
|
#define MAP_LIST1(f, x, peek, ...) f(x) MAP_LIST_NEXT(peek, MAP_LIST0)(f, peek, __VA_ARGS__)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Applies the function macro `f` to each of the remaining parameters.
|
||||||
|
*/
|
||||||
|
#define MAP(f, ...) EVAL(MAP1(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Applies the function macro `f` to each of the remaining parameters and
|
||||||
|
* inserts commas between the results.
|
||||||
|
*/
|
||||||
|
#define MAP_LIST(f, ...) EVAL(MAP_LIST1(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
|
||||||
@ -0,0 +1,94 @@
|
|||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "kaleidoscope/event_handler_result.h"
|
||||||
|
#include "kaleidoscope_internal/event_dispatch.h"
|
||||||
|
#include "event_handlers.h"
|
||||||
|
|
||||||
|
#ifndef KALEIDOSCOPE_ENABLE_V1_PLUGIN_API
|
||||||
|
#define KALEIDOSCOPE_ENABLE_V1_PLUGIN_API 1
|
||||||
|
#endif
|
||||||
|
|
||||||
|
namespace kaleidoscope {
|
||||||
|
|
||||||
|
class Kaleidoscope_;
|
||||||
|
|
||||||
|
// A base class that implements default noop versions of all event
|
||||||
|
// handler methods.
|
||||||
|
//
|
||||||
|
// A note to developers:
|
||||||
|
//
|
||||||
|
// The only purpose of class EventHandlerBasePlugin
|
||||||
|
// is to enable the use of _FOR_EACH_EVENT_HANDLER
|
||||||
|
// to define default event handlers. This is currently not possible
|
||||||
|
// inside class Plugin directly as it would collide with
|
||||||
|
// the separate definition of onSetup(). This additional
|
||||||
|
// definition is, however, necessary to support the V1 plugin API.
|
||||||
|
//
|
||||||
|
// TODO(anyone): As soon as the V1 plugin API is removed from Kaleidoscope,
|
||||||
|
// class EventHandlerBasePlugin can be removed and its content be moved to
|
||||||
|
// class Plugin.
|
||||||
|
//
|
||||||
|
class EventHandlerBasePlugin {
|
||||||
|
|
||||||
|
public:
|
||||||
|
|
||||||
|
#define DEFINE_AND_IMPLEMENT_EVENT_HANDLER_METHOD( \
|
||||||
|
HOOK_NAME, SHOULD_ABORT_ON_CONSUMED_EVENT, SIGNATURE, ARGS_LIST) __NL__ \
|
||||||
|
__NL__ \
|
||||||
|
EventHandlerResult HOOK_NAME SIGNATURE { __NL__ \
|
||||||
|
return EventHandlerResult::OK; __NL__ \
|
||||||
|
}
|
||||||
|
|
||||||
|
_FOR_EACH_EVENT_HANDLER(DEFINE_AND_IMPLEMENT_EVENT_HANDLER_METHOD)
|
||||||
|
|
||||||
|
#undef DEFINE_AND_IMPLEMENT_EVENT_HANDLER_METHOD
|
||||||
|
};
|
||||||
|
|
||||||
|
class Plugin : public EventHandlerBasePlugin {
|
||||||
|
|
||||||
|
friend class Kaleidoscope_;
|
||||||
|
|
||||||
|
protected:
|
||||||
|
|
||||||
|
#if KALEIDOSCOPE_ENABLE_V1_PLUGIN_API
|
||||||
|
/** Legacy plugin setup hook.
|
||||||
|
|
||||||
|
* In version one of the plugin API, `plugin->begin()` was called at
|
||||||
|
* `Kaleidoscope.use()` time, to perform boot-time initialization. We needed
|
||||||
|
* this because plugins are supposed to provide a singleton object, statically
|
||||||
|
* initialized at compile-time (with few exceptions). Because of this, the
|
||||||
|
* order in which they are instantiated is unspecified, and cannot be relied
|
||||||
|
* upon. For this reason, one's expected to explicitly initialize, "use" the
|
||||||
|
* plugins one wishes to, by calling `Kaleidoscope.use()` with a list of
|
||||||
|
* plugin object pointers.
|
||||||
|
*
|
||||||
|
* This is the only time this function will be called. It is intentionally
|
||||||
|
* protected, and accessible by the `Kaleidoscope` class only.
|
||||||
|
*
|
||||||
|
* Also, this method is deprecated in favour of the V2 API, which you can read
|
||||||
|
* about below.
|
||||||
|
*/
|
||||||
|
virtual void begin() {}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
public:
|
||||||
|
// Please see "event_handlers.h" for a list of supported event handlers and
|
||||||
|
// their documentation!
|
||||||
|
|
||||||
|
EventHandlerResult onSetup() {
|
||||||
|
#if KALEIDOSCOPE_ENABLE_V1_PLUGIN_API
|
||||||
|
// By letting the new `onSetup()` method call the legacy begin() method, we
|
||||||
|
// make sure that the old hooking interface is supported even if
|
||||||
|
// KALEIDOSCOPE_INIT_PLUGINS() is used to register a plugin that relies on
|
||||||
|
// the legacy `begin()` method to initialize itself and register hooks.
|
||||||
|
//
|
||||||
|
this->begin();
|
||||||
|
#endif
|
||||||
|
return EventHandlerResult::OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace kaleidoscope
|
||||||
|
|
||||||
|
typedef kaleidoscope::Plugin KaleidoscopePlugin __attribute__((deprecated("class KaleidoscopePlugin is deprecated. Please derive plugins from kaleidoscope::Plugin instead.")));
|
||||||
Loading…
Reference in new issue