From 184981ff9a89f19e4670879f206f1b5e61f2e52c Mon Sep 17 00:00:00 2001 From: Gergely Nagy Date: Fri, 5 Oct 2018 14:07:45 +0200 Subject: [PATCH] Migrate to the onFocusEvent API While there, drop the `keymap.layer` command, which was a workaround to a Chrysalis bug fixed since. Signed-off-by: Gergely Nagy --- README.md | 40 ++++-------- examples/EEPROM-Keymap/EEPROM-Keymap.ino | 12 +--- src/Kaleidoscope-EEPROM-Keymap.h | 2 +- src/Kaleidoscope/EEPROM-Keymap-Transfer.cpp | 50 +++++++++++++++ ...eymap-Focus.h => EEPROM-Keymap-Transfer.h} | 17 +++-- src/Kaleidoscope/EEPROM-Keymap.cpp | 62 +++---------------- src/Kaleidoscope/EEPROM-Keymap.h | 5 +- 7 files changed, 87 insertions(+), 101 deletions(-) create mode 100644 src/Kaleidoscope/EEPROM-Keymap-Transfer.cpp rename src/Kaleidoscope/{EEPROM-Keymap-Focus.h => EEPROM-Keymap-Transfer.h} (65%) diff --git a/README.md b/README.md index 3fab8197..6baff5ff 100644 --- a/README.md +++ b/README.md @@ -18,38 +18,32 @@ overlay there. In the latter case, whenever there is a non-transparent key on the overlay, we will use that instead of the keyboard default. In short, this plugin allows us to change our keymaps, without having to compile -and flash new firmware. It does so through the use of the [Focus][plugin:focus] -plugin. +and flash new firmware. It does so through the use of the +[FocusSerial][plugin:focusSerial] plugin. - [plugin:focus]: https://github.com/keyboardio/Kaleidoscope-Focus + [plugin:focusSerial]: https://github.com/keyboardio/Kaleidoscope-FocusSerial ## Using the plugin Using the plugin is reasonably simple: after including the header, enable the -plugin, and let the `Layer` object know that we'll be using `EEPROMKeymap` to -figure out which keys to use. We can either use the `getKeyOverride` or the -`getKey` method, depending on whether we want to override, or fully replace the -built-in keymap. Then we need to set at most how many layers we want to store in -`EEPROM`, and that is about it. +plugin, and configure how many layers at most we want to store in `EEPROM`. +There are other settings one can tweak, but these two steps are enough to get +started with. -We can then update the keymap via [Focus][plugin:focus]. +Once these are set up, we can update the keymap via [Focus][plugin:focusSerial]. ```c++ #include #include -#include +#include KALEIDOSCOPE_INIT_PLUGINS(EEPROMKeymap, - Focus); + Focus, + FocusKeymapTransferCommand); void setup() { - Serial.begin(9600); - Kaleidoscope.setup(); - Focus.addHook(FOCUS_HOOK_KEYMAP); - Focus.addHook(FOCUS_HOOK_KEYMAP_TRANSFER); - EEPROMKeymap.max_layers(1); } ``` @@ -68,9 +62,8 @@ The plugin provides the `EEPROMKeymap` object, which has the following methods: ## Focus commands -The plugin provides three `Focus` hooks: `FOCUS_HOOK_KEYMAP`, `FOCUS_HOOK_KEYMAP_LAYER`, -and `FOCUS_HOOK_KEYMAP_TRANSFER`. Together, they make the following commands -available, respectively: +The plugin provides a `keymap.map` Focus command unconditionally, and a +`keymap.transfer` via the `FocusKeymapTransferCommand` object. ### `keymap.map [codes...]` @@ -82,13 +75,6 @@ available, respectively: > layer, and go on as long as it has input. It will not go past the layer set > via the `.max_layers()` method. -### `keymap.layer LAYER [codes...]` - -> Without codes, prints the keymap for the given layer (zero-indexed). -> Prints each key as its raw 16-bit keycode. - -> With codes, stores them as the keymap for the given layer. - ### `keymap.transfer LAYER` > Transfers the `LAYER` from the built-in memory of the keyboard into `EEPROM` @@ -103,7 +89,7 @@ available, respectively: ## Dependencies * [Kaleidoscope-EEPROM-Settings](https://github.com/keyboardio/Kaleidoscope-EEPROM-Settings) -* [Kaleidoscope-Focus](https://github.com/keyboardio/Kaleidoscope-Focus) +* [Kaleidoscope-FocusSerial](https://github.com/keyboardio/Kaleidoscope-FocusSerial) ## Further reading diff --git a/examples/EEPROM-Keymap/EEPROM-Keymap.ino b/examples/EEPROM-Keymap/EEPROM-Keymap.ino index e7771534..50f3b4b8 100644 --- a/examples/EEPROM-Keymap/EEPROM-Keymap.ino +++ b/examples/EEPROM-Keymap/EEPROM-Keymap.ino @@ -17,7 +17,7 @@ #include #include -#include +#include // *INDENT-OFF* KEYMAPS( @@ -40,19 +40,11 @@ KEYMAPS( ) // *INDENT-ON* -KALEIDOSCOPE_INIT_PLUGINS(EEPROMKeymap, Focus); +KALEIDOSCOPE_INIT_PLUGINS(EEPROMKeymap, Focus, FocusKeymapTransfer); void setup() { - Serial.begin(9600); - Kaleidoscope.setup(); - Focus.addHook(FOCUS_HOOK_SETTINGS); - Focus.addHook(FOCUS_HOOK_KEYMAP); - Focus.addHook(FOCUS_HOOK_KEYMAP_TRANSFER); - Focus.addHook(FOCUS_HOOK_HELP); - Focus.addHook(FOCUS_HOOK_VERSION); - EEPROMKeymap.max_layers(1); } diff --git a/src/Kaleidoscope-EEPROM-Keymap.h b/src/Kaleidoscope-EEPROM-Keymap.h index 9ab581bd..3bcb13c8 100644 --- a/src/Kaleidoscope-EEPROM-Keymap.h +++ b/src/Kaleidoscope-EEPROM-Keymap.h @@ -18,4 +18,4 @@ #pragma once #include -#include +#include diff --git a/src/Kaleidoscope/EEPROM-Keymap-Transfer.cpp b/src/Kaleidoscope/EEPROM-Keymap-Transfer.cpp new file mode 100644 index 00000000..77ec771b --- /dev/null +++ b/src/Kaleidoscope/EEPROM-Keymap-Transfer.cpp @@ -0,0 +1,50 @@ +/* -*- mode: c++ -*- + * Kaleidoscope-EEPROM-Keymap -- EEPROM-based keymap support. + * Copyright (C) 2017, 2018 Keyboard.io, Inc + * + * 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, version 3. + * + * 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, see . + */ + +#include +#include +#include + +namespace kaleidoscope { +namespace eeprom { + +EventHandlerResult FocusKeymapTransferCommand::onFocusEvent(const char *command) { + const char *cmd = PSTR("keymap.transfer"); + + if (::Focus.handleHelp(command, cmd)) + return EventHandlerResult::OK; + if (strcmp_P(command, cmd) != 0) + return EventHandlerResult::OK; + + uint8_t layer = Serial.parseInt(); + + for (uint8_t row = 0; row < ROWS; row++) { + for (uint8_t col = 0; col < COLS; col++) { + Key k = Layer.getKeyFromPROGMEM(layer, row, col); + uint16_t pos = ((layer * ROWS * COLS) + (row * COLS) + col); + + ::EEPROMKeymap.updateKey(pos, k); + } + } + + return EventHandlerResult::EVENT_CONSUMED; +} + +} +} + +kaleidoscope::eeprom::FocusKeymapTransferCommand FocusKeymapTransferCommand; diff --git a/src/Kaleidoscope/EEPROM-Keymap-Focus.h b/src/Kaleidoscope/EEPROM-Keymap-Transfer.h similarity index 65% rename from src/Kaleidoscope/EEPROM-Keymap-Focus.h rename to src/Kaleidoscope/EEPROM-Keymap-Transfer.h index dce6ee3f..6dfee13c 100644 --- a/src/Kaleidoscope/EEPROM-Keymap-Focus.h +++ b/src/Kaleidoscope/EEPROM-Keymap-Transfer.h @@ -1,6 +1,6 @@ /* -*- mode: c++ -*- * Kaleidoscope-EEPROM-Keymap -- EEPROM-based keymap support. - * Copyright (C) 2017 Keyboard.io, Inc + * Copyright (C) 2017-2018 Keyboard.io, Inc * * 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 @@ -20,10 +20,15 @@ #include #include -#define FOCUS_HOOK_KEYMAP FOCUS_HOOK(EEPROMKeymap.focusKeymap, "keymap.map") +namespace kaleidoscope { +namespace eeprom { +class FocusKeymapTransferCommand : public Plugin { + public: + FocusKeymapTransferCommand() {} -#define FOCUS_HOOK_KEYMAP_LAYER FOCUS_HOOK(EEPROMKeymap.focusKeymapLayer, \ - "keymap.layer") + EventHandlerResult onFocusEvent(const char *command); +}; +} +} -#define FOCUS_HOOK_KEYMAP_TRANSFER FOCUS_HOOK(EEPROMKeymap.focusKeymapTransfer, \ - "keymap.transfer") +extern kaleidoscope::eeprom::FocusKeymapTransferCommand FocusKeymapTransferCommand; diff --git a/src/Kaleidoscope/EEPROM-Keymap.cpp b/src/Kaleidoscope/EEPROM-Keymap.cpp index 2084ceb1..28e5c608 100644 --- a/src/Kaleidoscope/EEPROM-Keymap.cpp +++ b/src/Kaleidoscope/EEPROM-Keymap.cpp @@ -17,7 +17,7 @@ #include #include -#include +#include namespace kaleidoscope { uint16_t EEPROMKeymap::keymap_base_; @@ -88,9 +88,13 @@ void EEPROMKeymap::printKey(Key k) { ::Focus.printNumber(k.raw); } -bool EEPROMKeymap::focusKeymap(const char *command) { - if (strcmp_P(command, PSTR("keymap.map")) != 0) - return false; +EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) { + const char *cmd = PSTR("keymap.map"); + if (::Focus.handleHelp(command, cmd)) + return EventHandlerResult::OK; + + if (strcmp_P(command, cmd) != 0) + return EventHandlerResult::OK; if (Serial.peek() == '\n') { for (uint8_t layer = 0; layer < max_layers_; layer++) { @@ -112,55 +116,7 @@ bool EEPROMKeymap::focusKeymap(const char *command) { } } - return true; -} - -bool EEPROMKeymap::focusKeymapLayer(const char *command) { - if (strcmp_P(command, PSTR("keymap.layer")) != 0) { - return false; - } - - uint8_t layer = Serial.parseInt(); - if (layer >= max_layers_) { - return false; - } - if (Serial.peek() == '\n') { - for (uint8_t row = 0; row < ROWS; row++) { - for (uint8_t col = 0; col < COLS; col++) { - Key k = Layer.getKey(layer, row, col); - printKey(k); - ::Focus.printSpace(); - } - } - Serial.println(); - } else { - uint16_t keysPerLayer = ROWS * COLS; - uint16_t offset = layer * keysPerLayer; - for (uint16_t k = 0; (k < keysPerLayer) && (Serial.peek() != '\n'); k++) { - updateKey(offset + k, parseKey()); - } - } - - return true; - -} - -bool EEPROMKeymap::focusKeymapTransfer(const char *command) { - if (strcmp_P(command, PSTR("keymap.transfer")) != 0) - return false; - - uint8_t layer = Serial.parseInt(); - - for (uint8_t row = 0; row < ROWS; row++) { - for (uint8_t col = 0; col < COLS; col++) { - Key k = Layer.getKeyFromPROGMEM(layer, row, col); - uint16_t pos = ((layer * ROWS * COLS) + (row * COLS) + col); - - updateKey(pos, k); - } - } - - return true; + return EventHandlerResult::EVENT_CONSUMED; } } diff --git a/src/Kaleidoscope/EEPROM-Keymap.h b/src/Kaleidoscope/EEPROM-Keymap.h index 631e51b3..86368f3a 100644 --- a/src/Kaleidoscope/EEPROM-Keymap.h +++ b/src/Kaleidoscope/EEPROM-Keymap.h @@ -26,6 +26,7 @@ class EEPROMKeymap : public kaleidoscope::Plugin { EEPROMKeymap(void) {} EventHandlerResult onSetup(); + EventHandlerResult onFocusEvent(const char *command); static void max_layers(uint8_t max); @@ -34,10 +35,6 @@ class EEPROMKeymap : public kaleidoscope::Plugin { static Key getKey(uint8_t layer, byte row, byte col); static Key getKeyOverride(uint8_t layer, byte row, byte col); - static bool focusKeymap(const char *command); - static bool focusKeymapLayer(const char *command); - static bool focusKeymapTransfer(const char *command); - static void updateKey(uint16_t base_pos, Key key); private: