From d668dce1270bed29151499735fc9f3cf72dc5559 Mon Sep 17 00:00:00 2001 From: Gergely Nagy Date: Sun, 13 May 2018 10:32:51 +0200 Subject: [PATCH] Updated to use the new plugin APIs Signed-off-by: Gergely Nagy --- README.md | 4 +- examples/OneShot/OneShot.ino | 12 ++-- src/Kaleidoscope/OneShot.cpp | 130 ++++++++++++++++++++--------------- src/Kaleidoscope/OneShot.h | 22 +++--- 4 files changed, 99 insertions(+), 69 deletions(-) diff --git a/README.md b/README.md index a65ed924..830bf079 100644 --- a/README.md +++ b/README.md @@ -64,9 +64,9 @@ plugin: // somewhere in the keymap... OSM(LeftControl), OSL(_FN) -void setup() { - Kaleidoscope.use(&OneShot); +KALEIDOSCOPE_INIT_PLUGINS(OneShot); +void setup() { Kaleidoscope.setup(); } ``` diff --git a/examples/OneShot/OneShot.ino b/examples/OneShot/OneShot.ino index 1711f680..78e74eaf 100644 --- a/examples/OneShot/OneShot.ino +++ b/examples/OneShot/OneShot.ino @@ -1,6 +1,6 @@ /* -*- mode: c++ -*- * Kaleidoscope-OneShot -- One-shot modifiers and layers - * Copyright (C) 2016, 2017 Gergely Nagy + * Copyright (C) 2016, 2017, 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 @@ -19,6 +19,7 @@ #include #include +// *INDENT-OFF* const Key keymaps[][ROWS][COLS] PROGMEM = { [0] = KEYMAP_STACKED ( @@ -32,7 +33,7 @@ const Key keymaps[][ROWS][COLS] PROGMEM = { 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_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, OSM(RightAlt), Key_Spacebar, OSM(RightControl), @@ -50,16 +51,17 @@ const Key keymaps[][ROWS][COLS] PROGMEM = { ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, - Key_UpArrow, Key_DownArrow, Key_LeftArrow, Key_RightArrow, ___, ___, + Key_UpArrow, Key_DownArrow, Key_LeftArrow, Key_RightArrow,___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___), }; +// *INDENT-ON* -void setup() { - Kaleidoscope.use(&OneShot); +KALEIDOSCOPE_INIT_PLUGINS(OneShot); +void setup() { Kaleidoscope.setup(); } diff --git a/src/Kaleidoscope/OneShot.cpp b/src/Kaleidoscope/OneShot.cpp index 2634e144..0da3ff93 100644 --- a/src/Kaleidoscope/OneShot.cpp +++ b/src/Kaleidoscope/OneShot.cpp @@ -78,7 +78,7 @@ void OneShot::injectNormalKey(uint8_t idx, uint8_t key_state) { key.keyCode = LAYER_SHIFT_OFFSET + idx - 8; } - positionToCoords(idx, &row, &col); + positionToCoords(positions_[idx], &row, &col); handleKeyswitchEvent(key, row, col, key_state | INJECTED); } @@ -91,24 +91,24 @@ void OneShot::cancelOneShot(uint8_t idx) { injectNormalKey(idx, WAS_PRESSED); } -Key OneShot::eventHandlerHook(Key mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult OneShot::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState) { uint8_t idx = mapped_key.raw - ranges::OS_FIRST; - if (key_state & INJECTED) - return mapped_key; + if (keyState & INJECTED) + return EventHandlerResult::OK; if (!state_.all) { if (!isOneShotKey(mapped_key)) { - return mapped_key; + return EventHandlerResult::OK; } - if (keyToggledOff(key_state)) { + if (keyToggledOff(keyState)) { clearPressed(idx); if (mapped_key >= ranges::OSL_FIRST && mapped_key <= ranges::OSL_LAST) { should_mask_on_interrupt_ = true; } - } else if (keyToggledOn(key_state)) { + } else if (keyToggledOn(keyState)) { start_time_ = millis(); positions_[idx] = row * COLS + col; setPressed(idx); @@ -118,21 +118,21 @@ Key OneShot::eventHandlerHook(Key mapped_key, byte row, byte col, uint8_t key_st activateOneShot(idx); } - return Key_NoKey; + return EventHandlerResult::EVENT_CONSUMED; } - if (!keyIsPressed(key_state) && !keyWasPressed(key_state)) - return mapped_key; + if (!keyIsPressed(keyState) && !keyWasPressed(keyState)) + return EventHandlerResult::OK; if (isOneShotKey(mapped_key)) { if (isSticky_(idx)) { - if (keyToggledOn(key_state)) { // maybe on _off instead? + if (keyToggledOn(keyState)) { // maybe on _off instead? saveAsPrevious(mapped_key); clearSticky(idx); cancelOneShot(idx); } } else { - if (keyToggledOff(key_state)) { + if (keyToggledOff(keyState)) { clearPressed(idx); if ((millis() - start_time_) >= hold_time_out) { cancelOneShot(idx); @@ -140,7 +140,7 @@ Key OneShot::eventHandlerHook(Key mapped_key, byte row, byte col, uint8_t key_st } } - if (keyToggledOn(key_state)) { + if (keyToggledOn(keyState)) { setPressed(idx); bool set_sticky = false; @@ -169,12 +169,12 @@ Key OneShot::eventHandlerHook(Key mapped_key, byte row, byte col, uint8_t key_st } } - return Key_NoKey; + return EventHandlerResult::EVENT_CONSUMED; } // ordinary key here, with some event - if (keyIsPressed(key_state)) { + if (keyIsPressed(keyState)) { saveAsPrevious(mapped_key); if (!isModifier(mapped_key) && (mapped_key.flags != (KEY_FLAGS | SYNTHETIC | SWITCH_TO_KEYMAP))) { if (should_mask_on_interrupt_) @@ -183,59 +183,62 @@ Key OneShot::eventHandlerHook(Key mapped_key, byte row, byte col, uint8_t key_st } } - return mapped_key; + return EventHandlerResult::OK; } -void OneShot::loopHook(bool is_post_clear) { +EventHandlerResult OneShot::beforeReportingState() { if (!state_.all) - return; + return EventHandlerResult::OK; - if (is_post_clear) { - if (hasTimedOut()) - cancel(); - - bool is_cancelled = false; - - for (uint8_t i = 0; i < 32; i++) { - if (should_cancel_) { - if (isSticky_(i)) { - if (should_cancel_stickies_) { - is_cancelled = true; - clearSticky(i); - cancelOneShot(i); - clearPressed(i); - } - } else if (isOneShot(i) && !isPressed(i)) { + for (uint8_t i = 0; i < 8; i++) { + if (isOneShot(i)) { + activateOneShot(i); + } + } + + return EventHandlerResult::OK; +} + +EventHandlerResult OneShot::afterEachCycle() { + if (!state_.all) + return EventHandlerResult::OK; + + if (hasTimedOut()) + cancel(); + + bool is_cancelled = false; + + for (uint8_t i = 0; i < 32; i++) { + if (should_cancel_) { + if (isSticky_(i)) { + if (should_cancel_stickies_) { is_cancelled = true; + clearSticky(i); cancelOneShot(i); + clearPressed(i); } - } - } - - if (is_cancelled) { - should_cancel_ = false; - should_cancel_stickies_ = false; - should_mask_on_interrupt_ = false; - } - } else { - for (uint8_t i = 0; i < 8; i++) { - if (isOneShot(i)) { - activateOneShot(i); + } else if (isOneShot(i) && !isPressed(i)) { + is_cancelled = true; + cancelOneShot(i); } } } -} -// --- glue code --- + if (is_cancelled) { + should_cancel_ = false; + should_cancel_stickies_ = false; + should_mask_on_interrupt_ = false; + } -OneShot::OneShot(void) { + return EventHandlerResult::OK; } -void OneShot::begin(void) { - Kaleidoscope.useEventHandlerHook(eventHandlerHook); - Kaleidoscope.useLoopHook(loopHook); +void OneShot::inject(Key mapped_key, uint8_t key_state) { + onKeyswitchEvent(mapped_key, UNKNOWN_KEYSWITCH_LOCATION, key_state); } +// --- glue code --- + bool OneShot::isActive(void) { return (state_.all && !hasTimedOut()) || (pressed_state_.all) || (sticky_state_.all); } @@ -264,9 +267,28 @@ void OneShot::cancel(bool with_stickies) { should_cancel_stickies_ = with_stickies; } -void OneShot::inject(Key key, uint8_t key_state) { - eventHandlerHook(key, UNKNOWN_KEYSWITCH_LOCATION, key_state); +// Legacy V1 API +#if KALEIDOSCOPE_ENABLE_V1_PLUGIN_API +void OneShot::begin() { + Kaleidoscope.useEventHandlerHook(legacyEventHandler); + Kaleidoscope.useLoopHook(legacyLoopHook); +} + +Key OneShot::legacyEventHandler(Key mapped_key, byte row, byte col, uint8_t key_state) { + EventHandlerResult r = ::OneShot.onKeyswitchEvent(mapped_key, row, col, key_state); + if (r == EventHandlerResult::OK) + return mapped_key; + return Key_NoKey; +} + +void OneShot::legacyLoopHook(bool is_post_clear) { + if (is_post_clear) { + ::OneShot.afterEachCycle(); + } else { + ::OneShot.beforeReportingState(); + } } +#endif } diff --git a/src/Kaleidoscope/OneShot.h b/src/Kaleidoscope/OneShot.h index 2c9c5662..0abfdd55 100644 --- a/src/Kaleidoscope/OneShot.h +++ b/src/Kaleidoscope/OneShot.h @@ -26,11 +26,9 @@ namespace kaleidoscope { -class OneShot : public KaleidoscopePlugin { +class OneShot : public kaleidoscope::Plugin { public: - OneShot(void); - - void begin(void) final; + OneShot(void) {} static bool isOneShotKey(Key key) { return (key.raw >= kaleidoscope::ranges::OS_FIRST && key.raw <= kaleidoscope::ranges::OS_LAST); @@ -50,7 +48,18 @@ class OneShot : public KaleidoscopePlugin { static bool isModifierActive(Key key); - void inject(Key key, uint8_t key_state); + EventHandlerResult beforeReportingState(); + EventHandlerResult afterEachCycle(); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState); + + void inject(Key mapped_key, uint8_t key_state); + +#if KALEIDOSCOPE_ENABLE_V1_PLUGIN_API + protected: + void begin(); + static Key legacyEventHandler(Key mapped_key, byte row, byte col, uint8_t key_state); + static void legacyLoopHook(bool is_post_clear); +#endif private: typedef union { @@ -75,9 +84,6 @@ class OneShot : public KaleidoscopePlugin { static void injectNormalKey(uint8_t idx, uint8_t key_state); static void activateOneShot(uint8_t idx); static void cancelOneShot(uint8_t idx); - - static Key eventHandlerHook(Key mapped_key, byte row, byte col, uint8_t key_state); - static void loopHook(bool is_post_clear); }; }