|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
|
|
#include <Arduino.h>
|
|
|
|
|
|
|
|
|
|
//end of add your includes here
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
|
extern "C" {
|
|
|
|
|
#endif
|
|
|
|
|
void loop();
|
|
|
|
|
void setup();
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
|
} // extern "C"
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
//add your function definitions for the project KeyboardIO here
|
|
|
|
|
|
|
|
|
|
#define TS(X) //Serial.print(micros() );Serial.print("\t");Serial.println(X);
|
|
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <math.h>
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
#include <stdint.h>
|
|
|
|
|
|
|
|
|
|
#include KALEIDOSCOPE_HARDWARE_H
|
|
|
|
|
#include "key_events.h"
|
|
|
|
|
#include "kaleidoscope/hid.h"
|
|
|
|
|
#include "layers.h"
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
#include "macro_map.h"
|
|
|
|
|
#include "kaleidoscope_internal/event_dispatch.h"
|
|
|
|
|
#include "macro_helpers.h"
|
|
|
|
|
#include "plugin.h"
|
|
|
|
|
|
|
|
|
|
#define HOOK_MAX 64
|
|
|
|
|
|
|
|
|
|
extern HARDWARE_IMPLEMENTATION KeyboardHardware;
|
|
|
|
|
|
|
|
|
|
#ifndef VERSION
|
|
|
|
|
#define VERSION "locally-built"
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/** Kaleidoscope API (major) version.
|
|
|
|
|
*
|
|
|
|
|
* The API is guaranteed to be backwards compatible for the entire duration of a
|
|
|
|
|
* major version. However, breaking changes may come, and result in a major
|
|
|
|
|
* version bump. To help migration, the `KALEIDOSCOPE_API_VERSION` macro can be
|
|
|
|
|
* used to check the major version provided by the Kaleidoscope we are compiling
|
|
|
|
|
* against. This can be used to error out with a helpful message, or change how
|
|
|
|
|
* the API is used - it is entirely up to the plugin or sketch author. The point
|
|
|
|
|
* of this macro is to let them easily check the version.
|
|
|
|
|
*/
|
|
|
|
|
#define KALEIDOSCOPE_API_VERSION 1
|
|
|
|
|
|
|
|
|
|
/** Required Kaleidoscope major version.
|
|
|
|
|
*
|
|
|
|
|
* For the sake of convenience, defining `KALEIDOSCOPE_REQUIRED_API_VERSION`
|
|
|
|
|
* before including `Kaleidoscope.h` itself will result in comparing its value
|
|
|
|
|
* to `KALEIDOSCOPE_API_VERSION`. If they differ, a helpful error message is
|
|
|
|
|
* printed.
|
|
|
|
|
*
|
|
|
|
|
* Done so that a new API version would result in a helpful error message,
|
|
|
|
|
* instead of cryptic compile errors.
|
|
|
|
|
*/
|
|
|
|
|
#if defined(KALEIDOSCOPE_REQUIRED_API_VERSION) && (KALEIDOSCOPE_REQUIRED_API_VERSION != KALEIDOSCOPE_API_VERSION)
|
|
|
|
|
#define xstr(a) str(a)
|
|
|
|
|
#define str(a) #a
|
|
|
|
|
static_assert(KALEIDOSCOPE_REQUIRED_API_VERSION == KALEIDOSCOPE_API_VERSION,
|
|
|
|
|
"Kaleidoscope API version mismatch! We have version " xstr(KALEIDOSCOPE_API_VERSION)
|
|
|
|
|
" available, but version " xstr(KALEIDOSCOPE_REQUIRED_API_VERSION) " is required.");
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
const uint8_t KEYMAP_SIZE
|
|
|
|
|
__attribute__((deprecated("Kaleidoscope.setup() does not require KEYMAP_SIZE anymore."))) = 0;
|
|
|
|
|
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
namespace kaleidoscope {
|
|
|
|
|
|
|
|
|
|
class Kaleidoscope_ {
|
|
|
|
|
public:
|
|
|
|
|
Kaleidoscope_(void);
|
|
|
|
|
|
|
|
|
|
void setup(const byte keymap_count)
|
|
|
|
|
__attribute__((deprecated("The keymap_count argument (and the KEYMAP_SIZE macro) are unused, and can be safely removed."))) {
|
|
|
|
|
setup();
|
|
|
|
|
}
|
|
|
|
|
void setup(void);
|
|
|
|
|
void loop(void);
|
|
|
|
|
|
|
|
|
|
// ---- Kaleidoscope.use() ----
|
|
|
|
|
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
#if KALEIDOSCOPE_ENABLE_V1_PLUGIN_API
|
|
|
|
|
#define DEPRECATED_USE "\n" \
|
|
|
|
|
"------------------------------------------------------------------------\n" \
|
|
|
|
|
"Your sketch uses Kaleidoscope.use(), an old-style API to initialize\n" \
|
|
|
|
|
"plugins. To fix this, you need to modify your .ino sketch file, and\n" \
|
|
|
|
|
"replacing the text \"Kaleidoscope.use\" with \"KALEIDOSCOPE_INIT_PLUGINS\",\n" \
|
|
|
|
|
"then remove the & from all of the plugins inside it, and finally, move\n" \
|
|
|
|
|
"it outside of \"setup()\":\n" \
|
|
|
|
|
"\n" \
|
|
|
|
|
"If your current sketch looks like this: \n" \
|
|
|
|
|
" void setup() {\n" \
|
|
|
|
|
" Kaleidoscope.use(&Plugin1, &Plugin2);\n" \
|
|
|
|
|
" Kaleidoscope.setup();\n" \
|
|
|
|
|
" }\n" \
|
|
|
|
|
"\n" \
|
|
|
|
|
"You should change it so that it looks like this:\n" \
|
|
|
|
|
" KALEIDOSCOPE_INIT_PLUGINS(Plugin1, Plugin2);\n" \
|
|
|
|
|
" void setup() {\n" \
|
|
|
|
|
" Kaleidoscope.setup();\n" \
|
|
|
|
|
" }\n" \
|
|
|
|
|
"\n" \
|
|
|
|
|
"If this error doesn't make sense to you or you have any trouble, please\n" \
|
|
|
|
|
"send a copy of your .ino sketch file to help@keyboard.io and we can\n" \
|
|
|
|
|
"help fix it.\n" \
|
|
|
|
|
"------------------------------------------------------------------------\n"
|
|
|
|
|
|
|
|
|
|
// First, we have the zero-argument version, which will satisfy the tail case.
|
|
|
|
|
inline void use() {
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Then, the one-argument version, that gives us type safety for a single
|
|
|
|
|
// plugin.
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
inline void __attribute__((deprecated(DEPRECATED_USE))) use(kaleidoscope::Plugin *p) {
|
|
|
|
|
p->begin();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// We have a no-op with a int argument, as a temporary hack until we remove
|
|
|
|
|
// the last instance of a NULL-terminated Kaleidoscope.use() call.
|
|
|
|
|
inline void use(int) {
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// And the magic is in the last one, a template. The first parameter is
|
|
|
|
|
// matched out by the compiler, and passed to one of the functions above. The
|
|
|
|
|
// rest of the parameter pack (which may be an empty set in a recursive case),
|
|
|
|
|
// are passed back to either ourselves, or the zero-argument version a few
|
|
|
|
|
// lines above.
|
|
|
|
|
template <typename... Plugins>
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
void __attribute__((deprecated(DEPRECATED_USE))) use(kaleidoscope::Plugin *first, Plugins&&... plugins) {
|
|
|
|
|
#pragma GCC diagnostic push
|
|
|
|
|
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
|
|
|
|
|
use(first);
|
|
|
|
|
use(plugins...);
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
#pragma GCC diagnostic pop
|
|
|
|
|
}
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
// ---- 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];
|
|
|
|
|
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
static void replaceEventHandlerHook(eventHandlerHook oldHook, eventHandlerHook newHook)
|
|
|
|
|
__attribute__((deprecated("Please implement kaleidoscope::Plugin.onKeyswitchEvent(...) instead.")));
|
|
|
|
|
static void appendEventHandlerHook(eventHandlerHook hook)
|
|
|
|
|
__attribute__((deprecated("Please implement kaleidoscope::Plugin.onKeyswitchEvent(...) instead.")));
|
|
|
|
|
static void useEventHandlerHook(eventHandlerHook hook)
|
|
|
|
|
__attribute__((deprecated("Please implement kaleidoscope::Plugin.onKeyswitchEvent(...) instead.")));
|
|
|
|
|
|
|
|
|
|
typedef void (*loopHook)(bool postClear);
|
|
|
|
|
static loopHook loopHooks[HOOK_MAX];
|
|
|
|
|
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
static void replaceLoopHook(loopHook oldHook, loopHook newHook)
|
|
|
|
|
__attribute__((deprecated("Please implement kaleidoscope::Plugin.beforeEachCycle(), .beforeReportingState(...) or .afterEachCycle(...) instead.")));
|
|
|
|
|
static void appendLoopHook(loopHook hook)
|
|
|
|
|
__attribute__((deprecated("Please implement kaleidoscope::Plugin.beforeEachCycle(), .beforeReportingState(...) or .afterEachCycle(...) instead.")));
|
|
|
|
|
static void useLoopHook(loopHook hook)
|
|
|
|
|
__attribute__((deprecated("Please implement kaleidoscope::Plugin.beforeEachCycle(), .beforeReportingState(...) or .afterEachCycle(...) instead.")));
|
|
|
|
|
|
|
|
|
|
static bool focusHook(const char *command);
|
|
|
|
|
};
|
|
|
|
|
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
extern kaleidoscope::Kaleidoscope_ Kaleidoscope;
|
|
|
|
|
|
|
|
|
|
} // namespace kaleidoscope
|
|
|
|
|
|
|
|
|
|
// For compatibility reasons we enable class Kaleidoscope_ also to be available
|
|
|
|
|
// in global namespace.
|
|
|
|
|
//
|
|
|
|
|
typedef kaleidoscope::Kaleidoscope_ Kaleidoscope_;
|
|
|
|
|
|
|
|
|
|
// For compatibility reasons we enable the global variable Kaleidoscope
|
|
|
|
|
// in global namespace.
|
|
|
|
|
//
|
|
|
|
|
using kaleidoscope::Kaleidoscope;
|
|
|
|
|
|
|
|
|
|
#define FOCUS_HOOK_KALEIDOSCOPE FOCUS_HOOK(Kaleidoscope.focusHook, \
|
|
|
|
|
"layer.on\n" \
|
|
|
|
|
"layer.off\n" \
|
|
|
|
|
"layer.getState")
|
|
|
|
|
|
|
|
|
|
/* -- DEPRECATED aliases; remove them when there are no more users. -- */
|
|
|
|
|
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
void event_handler_hook_use(kaleidoscope::Kaleidoscope_::eventHandlerHook hook)
|
|
|
|
|
__attribute__((deprecated("Use Kaleidoscope.useEventHandlerHook instead")));
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
void loop_hook_use(kaleidoscope::Kaleidoscope_::loopHook hook)
|
|
|
|
|
__attribute__((deprecated("Use Kaleidoscope.useLoopHook instead")));
|
|
|
|
|
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
void __USE_PLUGINS(kaleidoscope::Plugin *plugin, ...)
|
|
|
|
|
__attribute__((deprecated("Use Kaleidoscope.use(...) instead")));
|
|
|
|
|
|
|
|
|
|
#define USE_PLUGINS(...) __USE_PLUGINS(__VA_ARGS__, NULL)
|
Major redesign of the plugin and hooking interface
With this redesign, we introduce a new way to create plugins, which is easier to
extend with new hook points, provides a better interface, uses less memory, less
program space, and is a tiny bit faster too.
It all begins with `kaleidoscope::Plugin` being the base class, which provides
the hook methods plugins can implement. Plugins should be declared with
`KALEIDOSCOPE_INIT_PLUGINS` instead of `Kaleidoscope.use()`. Behind this macro
is a bit of magic (see the in-code documentation) that allows us to unroll the
hook method calls, avoid vtables, and so on. It creates an override for
`kaleidoscope::Hooks::*` methods, each of which will call the respective methods
of each initialized plugin.
With the new API come new names: all of the methods plugins can implement
received new, more descriptive names that all follow a similar pattern.
The old (dubbed V1) API still remains in place, although deprecated. One can
turn it off by setting the `KALEIDOSCOPE_ENABLE_V1_PLUGIN_API` define to zero,
while compiling the firmware.
This work is based on #276, written by @noseglasses. @obra and @algernon did
some cleaning up and applied a little naming treatment.
Signed-off-by: noseglasses <shinynoseglasses@gmail.com>
Signed-off-by: Jesse Vincent <jesse@keyboard.io>
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
7 years ago
|
|
|
|
|
|
|
|
// Use this function macro to register plugins with Kaleidoscope's
|
|
|
|
|
// hooking system. The macro accepts a list of plugin instances that
|
|
|
|
|
// must have been instantiated at global scope.
|
|
|
|
|
//
|
|
|
|
|
#define KALEIDOSCOPE_INIT_PLUGINS(...) _KALEIDOSCOPE_INIT_PLUGINS(__VA_ARGS__)
|
