Rename the `command` arg of `onFocusEvent` to `input`

With the new patterns, `Focus.inputMatchesCommand(command, cmd)` felt wrong, so
this patch renames the `command` argument of `onFocusEvent()` to `input`, to
better match what it really is.

Signed-off-by: Gergely Nagy <algernon@keyboard.io>
pull/1231/head
Gergely Nagy 2 years ago
parent 8ac4d9f5c1
commit 26340b7edb
No known key found for this signature in database
GPG Key ID: AC1E90BAC433F68F

@ -44,13 +44,13 @@ class FocusTestCommand : public Plugin {
public: public:
FocusTestCommand() {} FocusTestCommand() {}
EventHandlerResult onFocusEvent(const char *command) { EventHandlerResult onFocusEvent(const char *input) {
const char *cmd = PSTR("test"); const char *cmd = PSTR("test");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd); return ::Focus.printHelp(cmd);
if (::Focus.inputMatchesCommand(command, cmd)) { if (::Focus.inputMatchesCommand(input, cmd)) {
::Focus.send(F("ok!")); ::Focus.send(F("ok!"));
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }
@ -63,8 +63,8 @@ class FocusHelpCommand : public Plugin {
public: public:
FocusHelpCommand() {} FocusHelpCommand() {}
EventHandlerResult onFocusEvent(const char *command) { EventHandlerResult onFocusEvent(const char *input) {
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(PSTR("help")); return ::Focus.printHelp(PSTR("help"));
return EventHandlerResult::OK; return EventHandlerResult::OK;

@ -27,7 +27,7 @@ class TestLEDMode : public kaleidoscope::plugin::LEDMode {
public: public:
TestLEDMode() {} TestLEDMode() {}
kaleidoscope::EventHandlerResult onFocusEvent(const char *command); kaleidoscope::EventHandlerResult onFocusEvent(const char *input);
protected: protected:
void setup() final; void setup() final;
@ -48,8 +48,8 @@ void TestLEDMode::update(void) {
} }
kaleidoscope::EventHandlerResult kaleidoscope::EventHandlerResult
TestLEDMode::onFocusEvent(const char *command) { TestLEDMode::onFocusEvent(const char *input) {
return LEDPaletteTheme.themeFocusEvent(command, PSTR("testLedMode.map"), map_base_, 1); return LEDPaletteTheme.themeFocusEvent(input, PSTR("testLedMode.map"), map_base_, 1);
} }
} // namespace example } // namespace example

@ -275,7 +275,7 @@ class AutoShift : public Plugin {
class AutoShiftConfig : public Plugin { class AutoShiftConfig : public Plugin {
public: public:
EventHandlerResult onSetup(); EventHandlerResult onSetup();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
private: private:
// The base address in persistent storage for configuration data // The base address in persistent storage for configuration data

@ -47,7 +47,7 @@ EventHandlerResult AutoShiftConfig::onSetup() {
return EventHandlerResult::OK; return EventHandlerResult::OK;
} }
EventHandlerResult AutoShiftConfig::onFocusEvent(const char *command) { EventHandlerResult AutoShiftConfig::onFocusEvent(const char *input) {
enum { enum {
ENABLED, ENABLED,
TIMEOUT, TIMEOUT,
@ -58,14 +58,14 @@ EventHandlerResult AutoShiftConfig::onFocusEvent(const char *command) {
const char *cmd_timeout = PSTR("autoshift.timeout"); const char *cmd_timeout = PSTR("autoshift.timeout");
const char *cmd_categories = PSTR("autoshift.categories"); const char *cmd_categories = PSTR("autoshift.categories");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_enabled, cmd_timeout, cmd_categories); return ::Focus.printHelp(cmd_enabled, cmd_timeout, cmd_categories);
if (::Focus.inputMatchesCommand(command, cmd_enabled)) if (::Focus.inputMatchesCommand(input, cmd_enabled))
subCommand = ENABLED; subCommand = ENABLED;
else if (::Focus.inputMatchesCommand(command, cmd_timeout)) else if (::Focus.inputMatchesCommand(input, cmd_timeout))
subCommand = TIMEOUT; subCommand = TIMEOUT;
else if (::Focus.inputMatchesCommand(command, cmd_categories)) else if (::Focus.inputMatchesCommand(input, cmd_categories))
subCommand = CATEGORIES; subCommand = CATEGORIES;
else else
return EventHandlerResult::OK; return EventHandlerResult::OK;

@ -78,8 +78,8 @@ EventHandlerResult ColormapEffect::onLayerChange() {
return EventHandlerResult::OK; return EventHandlerResult::OK;
} }
EventHandlerResult ColormapEffect::onFocusEvent(const char *command) { EventHandlerResult ColormapEffect::onFocusEvent(const char *input) {
return ::LEDPaletteTheme.themeFocusEvent(command, PSTR("colormap.map"), map_base_, max_layers_); return ::LEDPaletteTheme.themeFocusEvent(input, PSTR("colormap.map"), map_base_, max_layers_);
} }
} // namespace plugin } // namespace plugin

@ -36,7 +36,7 @@ class ColormapEffect : public Plugin,
EventHandlerResult onLayerChange(); EventHandlerResult onLayerChange();
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
static bool isUninitialized(); static bool isUninitialized();
static void updateColorIndexAtPosition(uint8_t layer, uint16_t position, uint8_t palette_index); static void updateColorIndexAtPosition(uint8_t layer, uint16_t position, uint8_t palette_index);

@ -72,16 +72,16 @@ void DefaultColormap::install() {
::LEDControl.refreshAll(); ::LEDControl.refreshAll();
} }
EventHandlerResult DefaultColormap::onFocusEvent(const char *command) { EventHandlerResult DefaultColormap::onFocusEvent(const char *input) {
if (!Runtime.has_leds) if (!Runtime.has_leds)
return EventHandlerResult::OK; return EventHandlerResult::OK;
const char *cmd = PSTR("colormap.install"); const char *cmd = PSTR("colormap.install");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd); return ::Focus.printHelp(cmd);
if (!::Focus.inputMatchesCommand(command, cmd)) if (!::Focus.inputMatchesCommand(input, cmd))
return EventHandlerResult::OK; return EventHandlerResult::OK;
install(); install();

@ -87,7 +87,7 @@ class DefaultColormap : public Plugin {
static void setup(); static void setup();
static void install(); static void install();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
}; };
} // namespace plugin } // namespace plugin

@ -48,13 +48,13 @@ EventHandlerResult DefaultLEDModeConfig::onSetup() {
return EventHandlerResult::OK; return EventHandlerResult::OK;
} }
EventHandlerResult DefaultLEDModeConfig::onFocusEvent(const char *command) { EventHandlerResult DefaultLEDModeConfig::onFocusEvent(const char *input) {
const char *cmd = PSTR("led_mode.default"); const char *cmd = PSTR("led_mode.default");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd); return ::Focus.printHelp(cmd);
if (!::Focus.inputMatchesCommand(command, cmd)) if (!::Focus.inputMatchesCommand(input, cmd))
return EventHandlerResult::OK; return EventHandlerResult::OK;
if (::Focus.isEOL()) { if (::Focus.isEOL()) {

@ -30,7 +30,7 @@ class DefaultLEDModeConfig : public kaleidoscope::Plugin {
public: public:
EventHandlerResult onSetup(); EventHandlerResult onSetup();
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
void activateLEDModeIfUnconfigured(LEDModeInterface *plugin); void activateLEDModeIfUnconfigured(LEDModeInterface *plugin);

@ -214,14 +214,14 @@ EventHandlerResult DynamicMacros::onNameQuery() {
return ::Focus.sendName(F("DynamicMacros")); return ::Focus.sendName(F("DynamicMacros"));
} }
EventHandlerResult DynamicMacros::onFocusEvent(const char *command) { EventHandlerResult DynamicMacros::onFocusEvent(const char *input) {
const char *cmd_map = PSTR("macros.map"); const char *cmd_map = PSTR("macros.map");
const char *cmd_trigger = PSTR("macros.trigger"); const char *cmd_trigger = PSTR("macros.trigger");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_map, cmd_trigger); return ::Focus.printHelp(cmd_map, cmd_trigger);
if (::Focus.inputMatchesCommand(command, cmd_map)) { if (::Focus.inputMatchesCommand(input, cmd_map)) {
if (::Focus.isEOL()) { if (::Focus.isEOL()) {
for (uint16_t i = 0; i < storage_size_; i++) { for (uint16_t i = 0; i < storage_size_; i++) {
uint8_t b; uint8_t b;
@ -241,7 +241,7 @@ EventHandlerResult DynamicMacros::onFocusEvent(const char *command) {
macro_count_ = updateDynamicMacroCache(); macro_count_ = updateDynamicMacroCache();
} }
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} else if (::Focus.inputMatchesCommand(command, cmd_trigger)) { } else if (::Focus.inputMatchesCommand(input, cmd_trigger)) {
uint8_t id = 0; uint8_t id = 0;
::Focus.read(id); ::Focus.read(id);
play(id); play(id);

@ -38,7 +38,7 @@ class DynamicMacros : public kaleidoscope::Plugin {
public: public:
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
EventHandlerResult onKeyEvent(KeyEvent &event); EventHandlerResult onKeyEvent(KeyEvent &event);
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
EventHandlerResult beforeReportingState(const KeyEvent &event) { EventHandlerResult beforeReportingState(const KeyEvent &event) {
return ::MacroSupport.beforeReportingState(event); return ::MacroSupport.beforeReportingState(event);
} }

@ -93,13 +93,13 @@ EventHandlerResult DynamicTapDance::onNameQuery() {
return ::Focus.sendName(F("DynamicTapDance")); return ::Focus.sendName(F("DynamicTapDance"));
} }
EventHandlerResult DynamicTapDance::onFocusEvent(const char *command) { EventHandlerResult DynamicTapDance::onFocusEvent(const char *input) {
const char *cmd_map = PSTR("tapdance.map"); const char *cmd_map = PSTR("tapdance.map");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_map); return ::Focus.printHelp(cmd_map);
if (!::Focus.inputMatchesCommand(command, cmd_map)) if (!::Focus.inputMatchesCommand(input, cmd_map))
return EventHandlerResult::OK; return EventHandlerResult::OK;
if (::Focus.isEOL()) { if (::Focus.isEOL()) {

@ -31,7 +31,7 @@ namespace plugin {
class DynamicTapDance : public kaleidoscope::Plugin { class DynamicTapDance : public kaleidoscope::Plugin {
public: public:
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
void setup(uint8_t dynamic_offset, uint16_t size); void setup(uint8_t dynamic_offset, uint16_t size);

@ -106,13 +106,13 @@ EventHandlerResult EEPROMKeymapProgrammer::onKeyEvent(KeyEvent &event) {
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }
EventHandlerResult EEPROMKeymapProgrammer::onFocusEvent(const char *command) { EventHandlerResult EEPROMKeymapProgrammer::onFocusEvent(const char *input) {
const char *cmd = PSTR("keymap.toggleProgrammer"); const char *cmd = PSTR("keymap.toggleProgrammer");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd); return ::Focus.printHelp(cmd);
if (!::Focus.inputMatchesCommand(command, cmd)) if (!::Focus.inputMatchesCommand(input, cmd))
return EventHandlerResult::OK; return EventHandlerResult::OK;
if (state_ == INACTIVE) if (state_ == INACTIVE)

@ -41,7 +41,7 @@ class EEPROMKeymapProgrammer : public kaleidoscope::Plugin {
void cancel(); void cancel();
EventHandlerResult onKeyEvent(KeyEvent &event); EventHandlerResult onKeyEvent(KeyEvent &event);
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
private: private:
typedef enum { typedef enum {

@ -101,15 +101,15 @@ void EEPROMKeymap::dumpKeymap(uint8_t layers, Key (*getkey)(uint8_t, KeyAddr)) {
} }
} }
EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) { EventHandlerResult EEPROMKeymap::onFocusEvent(const char *input) {
const char *cmd_custom = PSTR("keymap.custom"); const char *cmd_custom = PSTR("keymap.custom");
const char *cmd_default = PSTR("keymap.default"); const char *cmd_default = PSTR("keymap.default");
const char *cmd_onlyCustom = PSTR("keymap.onlyCustom"); const char *cmd_onlyCustom = PSTR("keymap.onlyCustom");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_custom, cmd_default, cmd_onlyCustom); return ::Focus.printHelp(cmd_custom, cmd_default, cmd_onlyCustom);
if (::Focus.inputMatchesCommand(command, cmd_onlyCustom)) { if (::Focus.inputMatchesCommand(input, cmd_onlyCustom)) {
if (::Focus.isEOL()) { if (::Focus.isEOL()) {
::Focus.send((uint8_t)::EEPROMSettings.ignoreHardcodedLayers()); ::Focus.send((uint8_t)::EEPROMSettings.ignoreHardcodedLayers());
} else { } else {
@ -129,7 +129,7 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) {
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }
if (::Focus.inputMatchesCommand(command, cmd_default)) { if (::Focus.inputMatchesCommand(input, cmd_default)) {
// By using a cast to the appropriate function type, // By using a cast to the appropriate function type,
// tell the compiler which overload of getKeyFromPROGMEM // tell the compiler which overload of getKeyFromPROGMEM
// we actully want. // we actully want.
@ -139,7 +139,7 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) {
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }
if (!::Focus.inputMatchesCommand(command, cmd_custom)) if (!::Focus.inputMatchesCommand(input, cmd_custom))
return EventHandlerResult::OK; return EventHandlerResult::OK;
if (::Focus.isEOL()) { if (::Focus.isEOL()) {

@ -35,7 +35,7 @@ class EEPROMKeymap : public kaleidoscope::Plugin {
EventHandlerResult onSetup(); EventHandlerResult onSetup();
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
static void setup(uint8_t max); static void setup(uint8_t max);

@ -156,7 +156,7 @@ void EEPROMSettings::update() {
} }
/** Focus **/ /** Focus **/
EventHandlerResult FocusSettingsCommand::onFocusEvent(const char *command) { EventHandlerResult FocusSettingsCommand::onFocusEvent(const char *input) {
enum { enum {
DEFAULT_LAYER, DEFAULT_LAYER,
IS_VALID, IS_VALID,
@ -169,16 +169,16 @@ EventHandlerResult FocusSettingsCommand::onFocusEvent(const char *command) {
const char *cmd_version = PSTR("settings.version"); const char *cmd_version = PSTR("settings.version");
const char *cmd_crc = PSTR("settings.crc"); const char *cmd_crc = PSTR("settings.crc");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_defaultLayer, cmd_isValid, cmd_version, cmd_crc); return ::Focus.printHelp(cmd_defaultLayer, cmd_isValid, cmd_version, cmd_crc);
if (::Focus.inputMatchesCommand(command, cmd_defaultLayer)) if (::Focus.inputMatchesCommand(input, cmd_defaultLayer))
sub_command = DEFAULT_LAYER; sub_command = DEFAULT_LAYER;
else if (::Focus.inputMatchesCommand(command, cmd_isValid)) else if (::Focus.inputMatchesCommand(input, cmd_isValid))
sub_command = IS_VALID; sub_command = IS_VALID;
else if (::Focus.inputMatchesCommand(command, cmd_version)) else if (::Focus.inputMatchesCommand(input, cmd_version))
sub_command = GET_VERSION; sub_command = GET_VERSION;
else if (::Focus.inputMatchesCommand(command, cmd_crc)) else if (::Focus.inputMatchesCommand(input, cmd_crc))
sub_command = GET_CRC; sub_command = GET_CRC;
else else
return EventHandlerResult::OK; return EventHandlerResult::OK;
@ -208,7 +208,7 @@ EventHandlerResult FocusSettingsCommand::onFocusEvent(const char *command) {
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }
EventHandlerResult FocusEEPROMCommand::onFocusEvent(const char *command) { EventHandlerResult FocusEEPROMCommand::onFocusEvent(const char *input) {
enum { enum {
CONTENTS, CONTENTS,
FREE, FREE,
@ -219,14 +219,14 @@ EventHandlerResult FocusEEPROMCommand::onFocusEvent(const char *command) {
const char *cmd_free = PSTR("eeprom.free"); const char *cmd_free = PSTR("eeprom.free");
const char *cmd_erase = PSTR("eeprom.erase"); const char *cmd_erase = PSTR("eeprom.erase");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_contents, cmd_free, cmd_erase); return ::Focus.printHelp(cmd_contents, cmd_free, cmd_erase);
if (::Focus.inputMatchesCommand(command, cmd_contents)) if (::Focus.inputMatchesCommand(input, cmd_contents))
sub_command = CONTENTS; sub_command = CONTENTS;
else if (::Focus.inputMatchesCommand(command, cmd_free)) else if (::Focus.inputMatchesCommand(input, cmd_free))
sub_command = FREE; sub_command = FREE;
else if (::Focus.inputMatchesCommand(command, cmd_erase)) else if (::Focus.inputMatchesCommand(input, cmd_erase))
sub_command = ERASE; sub_command = ERASE;
else else
return EventHandlerResult::OK; return EventHandlerResult::OK;

@ -86,12 +86,12 @@ class EEPROMSettings : public kaleidoscope::Plugin {
class FocusSettingsCommand : public kaleidoscope::Plugin { class FocusSettingsCommand : public kaleidoscope::Plugin {
public: public:
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
}; };
class FocusEEPROMCommand : public kaleidoscope::Plugin { class FocusEEPROMCommand : public kaleidoscope::Plugin {
public: public:
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
}; };
} // namespace plugin } // namespace plugin

@ -48,12 +48,12 @@ EventHandlerResult EscapeOneShotConfig::onNameQuery() {
return ::Focus.sendName(F("EscapeOneShot")); return ::Focus.sendName(F("EscapeOneShot"));
} }
EventHandlerResult EscapeOneShotConfig::onFocusEvent(const char *command) { EventHandlerResult EscapeOneShotConfig::onFocusEvent(const char *input) {
const char *cmd_cancel_key = PSTR("escape_oneshot.cancel_key"); const char *cmd_cancel_key = PSTR("escape_oneshot.cancel_key");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_cancel_key); return ::Focus.printHelp(cmd_cancel_key);
if (!::Focus.inputMatchesCommand(command, cmd_cancel_key)) if (!::Focus.inputMatchesCommand(input, cmd_cancel_key))
return EventHandlerResult::OK; return EventHandlerResult::OK;
if (::Focus.isEOL()) { if (::Focus.isEOL()) {

@ -56,7 +56,7 @@ class EscapeOneShot : public kaleidoscope::Plugin {
class EscapeOneShotConfig : public Plugin { class EscapeOneShotConfig : public Plugin {
public: public:
EventHandlerResult onSetup(); EventHandlerResult onSetup();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
private: private:

@ -94,7 +94,7 @@ EventHandlerResult FingerPainter::onKeyEvent(KeyEvent &event) {
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }
EventHandlerResult FingerPainter::onFocusEvent(const char *command) { EventHandlerResult FingerPainter::onFocusEvent(const char *input) {
enum { enum {
TOGGLE, TOGGLE,
CLEAR, CLEAR,
@ -103,12 +103,12 @@ EventHandlerResult FingerPainter::onFocusEvent(const char *command) {
const char *cmd_toggle = PSTR("fingerpainter.toggle"); const char *cmd_toggle = PSTR("fingerpainter.toggle");
const char *cmd_clear = PSTR("fingerpainter.clear"); const char *cmd_clear = PSTR("fingerpainter.clear");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_toggle, cmd_clear); return ::Focus.printHelp(cmd_toggle, cmd_clear);
if (::Focus.inputMatchesCommand(command, cmd_toggle)) if (::Focus.inputMatchesCommand(input, cmd_toggle))
sub_command = TOGGLE; sub_command = TOGGLE;
else if (::Focus.inputMatchesCommand(command, cmd_clear)) else if (::Focus.inputMatchesCommand(input, cmd_clear))
sub_command = CLEAR; sub_command = CLEAR;
else else
return EventHandlerResult::OK; return EventHandlerResult::OK;

@ -36,7 +36,7 @@ class FingerPainter : public LEDMode {
void toggle(); void toggle();
EventHandlerResult onKeyEvent(KeyEvent &event); EventHandlerResult onKeyEvent(KeyEvent &event);
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
EventHandlerResult onSetup(); EventHandlerResult onSetup();
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();

@ -50,13 +50,13 @@ EventHandlerResult FirmwareDump::onSetup() {
return EventHandlerResult::OK; return EventHandlerResult::OK;
} }
EventHandlerResult FirmwareDump::onFocusEvent(const char *command) { EventHandlerResult FirmwareDump::onFocusEvent(const char *input) {
const char *cmd = PSTR("firmware.dump"); const char *cmd = PSTR("firmware.dump");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd); return ::Focus.printHelp(cmd);
if (!::Focus.inputMatchesCommand(command, cmd)) if (!::Focus.inputMatchesCommand(input, cmd))
return EventHandlerResult::OK; return EventHandlerResult::OK;
uint16_t flash_size = (FLASHEND + 1L); uint16_t flash_size = (FLASHEND + 1L);

@ -34,7 +34,7 @@ namespace plugin {
class FirmwareDump : public kaleidoscope::Plugin { class FirmwareDump : public kaleidoscope::Plugin {
public: public:
EventHandlerResult onSetup(); EventHandlerResult onSetup();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
private: private:
uint16_t bootloader_size_; uint16_t bootloader_size_;

@ -31,13 +31,13 @@ namespace plugin {
class FirmwareVersion : public Plugin { class FirmwareVersion : public Plugin {
public: public:
EventHandlerResult onFocusEvent(const char *command) { EventHandlerResult onFocusEvent(const char *input) {
const char *cmd_version = PSTR("version"); const char *cmd_version = PSTR("version");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_version); return ::Focus.printHelp(cmd_version);
if (!::Focus.inputMatchesCommand(command, cmd_version)) if (!::Focus.inputMatchesCommand(input, cmd_version))
return EventHandlerResult::OK; return EventHandlerResult::OK;
#ifdef KALEIDOSCOPE_FIRMWARE_VERSION #ifdef KALEIDOSCOPE_FIRMWARE_VERSION

@ -24,8 +24,8 @@ class FocusTestCommand : public Plugin {
return ::Focus.sendName(F("FocusTestCommand")); return ::Focus.sendName(F("FocusTestCommand"));
} }
EventHandlerResult onFocusEvent(const char *command) { EventHandlerResult onFocusEvent(const char *input) {
if (!::Focus.inputMatchesCommand(command, PSTR("test"))) if (!::Focus.inputMatchesCommand(input, PSTR("test")))
return EventHandlerResult::OK; return EventHandlerResult::OK;
::Focus.send(F("Congratulations, the test command works!")); ::Focus.send(F("Congratulations, the test command works!"));

@ -51,17 +51,17 @@ EventHandlerResult FocusSerial::afterEachCycle() {
if (c == SEPARATOR) { if (c == SEPARATOR) {
break; break;
} }
command_[buf_cursor_++] = c; input_[buf_cursor_++] = c;
} while (buf_cursor_ < (sizeof(command_) - 1) && Runtime.serialPort().available()); } while (buf_cursor_ < (sizeof(input_) - 1) && Runtime.serialPort().available());
if ((c != SEPARATOR) && (Runtime.serialPort().peek() != NEWLINE) && buf_cursor_ < (sizeof(command_) - 1)) { if ((c != SEPARATOR) && (Runtime.serialPort().peek() != NEWLINE) && buf_cursor_ < (sizeof(input_) - 1)) {
// We don't have enough command to work with yet. // We don't have enough command to work with yet.
// Let's leave the buffer around for another cycle // Let's leave the buffer around for another cycle
return EventHandlerResult::OK; return EventHandlerResult::OK;
} }
// Then process the command // Then process the command
Runtime.onFocusEvent(command_); Runtime.onFocusEvent(input_);
while (Runtime.serialPort().available()) { while (Runtime.serialPort().available()) {
c = Runtime.serialPort().read(); c = Runtime.serialPort().read();
if (c == NEWLINE) { if (c == NEWLINE) {
@ -73,23 +73,23 @@ EventHandlerResult FocusSerial::afterEachCycle() {
// End of command processing is signalled with a CRLF followed by a single period // End of command processing is signalled with a CRLF followed by a single period
Runtime.serialPort().println(F("\r\n.")); Runtime.serialPort().println(F("\r\n."));
buf_cursor_ = 0; buf_cursor_ = 0;
memset(command_, 0, sizeof(command_)); memset(input_, 0, sizeof(input_));
return EventHandlerResult::OK; return EventHandlerResult::OK;
} }
EventHandlerResult FocusSerial::onFocusEvent(const char *command) { EventHandlerResult FocusSerial::onFocusEvent(const char *input) {
const char *cmd_help = PSTR("help"); const char *cmd_help = PSTR("help");
const char *cmd_reset = PSTR("device.reset"); const char *cmd_reset = PSTR("device.reset");
const char *cmd_plugins = PSTR("plugins"); const char *cmd_plugins = PSTR("plugins");
if (inputMatchesHelp(command)) if (inputMatchesHelp(input))
return printHelp(cmd_help, cmd_reset, cmd_plugins); return printHelp(cmd_help, cmd_reset, cmd_plugins);
if (inputMatchesCommand(command, cmd_reset)) { if (inputMatchesCommand(input, cmd_reset)) {
Runtime.device().rebootBootloader(); Runtime.device().rebootBootloader();
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }
if (inputMatchesCommand(command, cmd_plugins)) { if (inputMatchesCommand(input, cmd_plugins)) {
kaleidoscope::Hooks::onNameQuery(); kaleidoscope::Hooks::onNameQuery();
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }
@ -98,8 +98,8 @@ EventHandlerResult FocusSerial::onFocusEvent(const char *command) {
} }
#ifndef NDEPRECATED #ifndef NDEPRECATED
bool FocusSerial::handleHelp(const char *command, const char *help_message) { bool FocusSerial::handleHelp(const char *input, const char *help_message) {
if (!inputMatchesHelp(command)) return false; if (!inputMatchesHelp(input)) return false;
printHelp(help_message); printHelp(help_message);
return true; return true;

@ -48,7 +48,7 @@ class FocusSerial : public kaleidoscope::Plugin {
#ifndef NDEPRECATED #ifndef NDEPRECATED
DEPRECATED(FOCUS_HANDLEHELP) DEPRECATED(FOCUS_HANDLEHELP)
bool handleHelp(const char *command, const char *help_message); bool handleHelp(const char *input, const char *help_message);
#endif #endif
bool inputMatchesHelp(const char *input); bool inputMatchesHelp(const char *input);
@ -137,10 +137,10 @@ class FocusSerial : public kaleidoscope::Plugin {
/* Hooks */ /* Hooks */
EventHandlerResult afterEachCycle(); EventHandlerResult afterEachCycle();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
private: private:
char command_[32]; char input_[32];
uint8_t buf_cursor_ = 0; uint8_t buf_cursor_ = 0;
void printBool(bool b); void printBool(bool b);

@ -33,7 +33,7 @@ namespace raise {
#define RAISE_FIRMWARE_VERSION "<unknown>" #define RAISE_FIRMWARE_VERSION "<unknown>"
#endif #endif
EventHandlerResult Focus::onFocusEvent(const char *command) { EventHandlerResult Focus::onFocusEvent(const char *input) {
const char *cmd_version = PSTR("hardware.version"); const char *cmd_version = PSTR("hardware.version");
const char *cmd_side_power = PSTR("hardware.side_power"); const char *cmd_side_power = PSTR("hardware.side_power");
const char *cmd_side_ver = PSTR("hardware.side_ver"); const char *cmd_side_ver = PSTR("hardware.side_ver");
@ -44,7 +44,8 @@ EventHandlerResult Focus::onFocusEvent(const char *command) {
const char *cmd_keyscan = PSTR("hardware.keyscan"); const char *cmd_keyscan = PSTR("hardware.keyscan");
const char *cmd_crc_errors = PSTR("hardware.crc_errors"); const char *cmd_crc_errors = PSTR("hardware.crc_errors");
const char *cmd_firmware = PSTR("hardware.firmware"); const char *cmd_firmware = PSTR("hardware.firmware");
if (::Focus.inputMatchesHelp(command))
if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_version, return ::Focus.printHelp(cmd_version,
cmd_side_power, cmd_side_power,
cmd_side_ver, cmd_side_ver,
@ -56,13 +57,13 @@ EventHandlerResult Focus::onFocusEvent(const char *command) {
cmd_crc_errors, cmd_crc_errors,
cmd_firmware); cmd_firmware);
if (::Focus.inputMatchesCommand(command, cmd_version)) { if (::Focus.inputMatchesCommand(input, cmd_version)) {
::Focus.send("Dygma Raise"); ::Focus.send("Dygma Raise");
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} else if (::Focus.inputMatchesCommand(command, cmd_firmware)) { } else if (::Focus.inputMatchesCommand(input, cmd_firmware)) {
::Focus.send(RAISE_FIRMWARE_VERSION); ::Focus.send(RAISE_FIRMWARE_VERSION);
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} else if (::Focus.inputMatchesCommand(command, cmd_side_power)) { } else if (::Focus.inputMatchesCommand(input, cmd_side_power)) {
if (::Focus.isEOL()) { if (::Focus.isEOL()) {
::Focus.send(Runtime.device().side.getPower()); ::Focus.send(Runtime.device().side.getPower());
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
@ -72,25 +73,25 @@ EventHandlerResult Focus::onFocusEvent(const char *command) {
Runtime.device().side.setPower(power); Runtime.device().side.setPower(power);
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }
} else if (::Focus.inputMatchesCommand(command, cmd_side_ver)) { } else if (::Focus.inputMatchesCommand(input, cmd_side_ver)) {
::Focus.send("left:"); ::Focus.send("left:");
::Focus.send(Runtime.device().side.leftVersion()); ::Focus.send(Runtime.device().side.leftVersion());
::Focus.send("\r\nright:"); ::Focus.send("\r\nright:");
::Focus.send(Runtime.device().side.rightVersion()); ::Focus.send(Runtime.device().side.rightVersion());
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} else if (::Focus.inputMatchesCommand(command, cmd_crc_errors)) { } else if (::Focus.inputMatchesCommand(input, cmd_crc_errors)) {
::Focus.send("left:"); ::Focus.send("left:");
::Focus.send(Runtime.device().side.leftCRCErrors()); ::Focus.send(Runtime.device().side.leftCRCErrors());
::Focus.send("\r\nright:"); ::Focus.send("\r\nright:");
::Focus.send(Runtime.device().side.rightCRCErrors()); ::Focus.send(Runtime.device().side.rightCRCErrors());
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} else if (::Focus.inputMatchesCommand(command, cmd_sled_ver)) { } else if (::Focus.inputMatchesCommand(input, cmd_sled_ver)) {
::Focus.send("left:"); ::Focus.send("left:");
::Focus.send(Runtime.device().side.leftSLEDVersion()); ::Focus.send(Runtime.device().side.leftSLEDVersion());
::Focus.send("\r\nright:"); ::Focus.send("\r\nright:");
::Focus.send(Runtime.device().side.rightSLEDVersion()); ::Focus.send(Runtime.device().side.rightSLEDVersion());
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} else if (::Focus.inputMatchesCommand(command, cmd_sled_current)) { } else if (::Focus.inputMatchesCommand(input, cmd_sled_current)) {
if (::Focus.isEOL()) { if (::Focus.isEOL()) {
::Focus.send("left:"); ::Focus.send("left:");
::Focus.send(Runtime.device().side.leftSLEDCurrent()); ::Focus.send(Runtime.device().side.leftSLEDCurrent());
@ -103,14 +104,14 @@ EventHandlerResult Focus::onFocusEvent(const char *command) {
Runtime.device().side.setSLEDCurrent(current); Runtime.device().side.setSLEDCurrent(current);
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }
} else if (::Focus.inputMatchesCommand(command, cmd_layout)) { } else if (::Focus.inputMatchesCommand(input, cmd_layout)) {
static const auto ANSI = Runtime.device().settings.Layout::ANSI; static const auto ANSI = Runtime.device().settings.Layout::ANSI;
::Focus.send(Runtime.device().settings.layout() == ANSI ? "ANSI" : "ISO"); ::Focus.send(Runtime.device().settings.layout() == ANSI ? "ANSI" : "ISO");
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} else if (::Focus.inputMatchesCommand(command, cmd_joint)) { } else if (::Focus.inputMatchesCommand(input, cmd_joint)) {
::Focus.send(Runtime.device().settings.joint()); ::Focus.send(Runtime.device().settings.joint());
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} else if (::Focus.inputMatchesCommand(command, cmd_keyscan)) { } else if (::Focus.inputMatchesCommand(input, cmd_keyscan)) {
if (::Focus.isEOL()) { if (::Focus.isEOL()) {
::Focus.send(Runtime.device().settings.keyscanInterval()); ::Focus.send(Runtime.device().settings.keyscanInterval());
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;

@ -29,7 +29,7 @@ namespace raise {
class Focus : public kaleidoscope::Plugin { class Focus : public kaleidoscope::Plugin {
public: public:
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
}; };
} // namespace raise } // namespace raise

@ -34,12 +34,13 @@ class SideFlash : public kaleidoscope::Plugin {
_Firmware firmware; _Firmware firmware;
public: public:
EventHandlerResult onFocusEvent(const char *command) { EventHandlerResult onFocusEvent(const char *input) {
const char *cmd_flash_left = PSTR("hardware.flash_left_side"); const char *cmd_flash_left = PSTR("hardware.flash_left_side");
const char *cmd_flash_right = PSTR("hardware.flash_right_side"); const char *cmd_flash_right = PSTR("hardware.flash_right_side");
const char *cmd_verify_left = PSTR("hardware.verify_left_side"); const char *cmd_verify_left = PSTR("hardware.verify_left_side");
const char *cmd_verify_right = PSTR("hardware.verify_right_side"); const char *cmd_verify_right = PSTR("hardware.verify_right_side");
if (::Focus.inputMatchesHelp(command))
if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_flash_left, cmd_flash_right, cmd_verify_left, cmd_verify_right); return ::Focus.printHelp(cmd_flash_left, cmd_flash_right, cmd_verify_left, cmd_verify_right);
auto sideFlasher = Runtime.device().sideFlasher(); auto sideFlasher = Runtime.device().sideFlasher();
@ -51,16 +52,16 @@ class SideFlash : public kaleidoscope::Plugin {
} sub_command; } sub_command;
uint8_t address = 0; uint8_t address = 0;
if (::Focus.inputMatchesCommand(command, cmd_flash_left)) { if (::Focus.inputMatchesCommand(input, cmd_flash_left)) {
sub_command = FLASH; sub_command = FLASH;
address = left_boot_address; address = left_boot_address;
} else if (::Focus.inputMatchesCommand(command, cmd_flash_right)) { } else if (::Focus.inputMatchesCommand(input, cmd_flash_right)) {
sub_command = FLASH; sub_command = FLASH;
address = right_boot_address; address = right_boot_address;
} else if (::Focus.inputMatchesCommand(command, cmd_verify_left)) { } else if (::Focus.inputMatchesCommand(input, cmd_verify_left)) {
sub_command = VERIFY; sub_command = VERIFY;
address = left_boot_address; address = left_boot_address;
} else if (::Focus.inputMatchesCommand(command, cmd_verify_right)) { } else if (::Focus.inputMatchesCommand(input, cmd_verify_right)) {
sub_command = VERIFY; sub_command = VERIFY;
address = right_boot_address; address = right_boot_address;
} else { } else {

@ -27,13 +27,13 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
EventHandlerResult FocusHostOSCommand::onFocusEvent(const char *command) { EventHandlerResult FocusHostOSCommand::onFocusEvent(const char *input) {
const char *cmd = PSTR("hostos.type"); const char *cmd = PSTR("hostos.type");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd); return ::Focus.printHelp(cmd);
if (!::Focus.inputMatchesCommand(command, cmd)) if (!::Focus.inputMatchesCommand(input, cmd))
return EventHandlerResult::OK; return EventHandlerResult::OK;
if (::Focus.isEOL()) { if (::Focus.isEOL()) {

@ -25,7 +25,7 @@ namespace plugin {
class FocusHostOSCommand : public kaleidoscope::Plugin { class FocusHostOSCommand : public kaleidoscope::Plugin {
public: public:
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
}; };
} // namespace plugin } // namespace plugin

@ -97,13 +97,13 @@ void PersistentIdleLEDs::setIdleTimeoutSeconds(uint32_t new_limit) {
Runtime.storage().commit(); Runtime.storage().commit();
} }
EventHandlerResult PersistentIdleLEDs::onFocusEvent(const char *command) { EventHandlerResult PersistentIdleLEDs::onFocusEvent(const char *input) {
const char *cmd = PSTR("idleleds.time_limit"); const char *cmd = PSTR("idleleds.time_limit");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd); return ::Focus.printHelp(cmd);
if (!::Focus.inputMatchesCommand(command, cmd)) if (!::Focus.inputMatchesCommand(input, cmd))
return EventHandlerResult::OK; return EventHandlerResult::OK;
if (::Focus.isEOL()) { if (::Focus.isEOL()) {

@ -46,7 +46,7 @@ class PersistentIdleLEDs : public IdleLEDs {
public: public:
EventHandlerResult onSetup(); EventHandlerResult onSetup();
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
static void setIdleTimeoutSeconds(uint32_t new_limit); static void setIdleTimeoutSeconds(uint32_t new_limit);

@ -24,7 +24,7 @@ class TestLEDMode : public LEDMode {
void setup() final; void setup() final;
void update() final; void update() final;
kaleidoscope::EventHandlerResult onFocusEvent(const char *command); kaleidoscope::EventHandlerResult onFocusEvent(const char *input);
private: private:
static uint16_t map_base_; static uint16_t map_base_;
@ -41,8 +41,8 @@ void TestLEDMode::update() {
} }
kaleidoscope::EventHandlerResult kaleidoscope::EventHandlerResult
TestLEDMode::onFocusEvent(const char *command) { TestLEDMode::onFocusEvent(const char *input) {
return LEDPaletteTheme.themeFocusEvent(command, PSTR("testLedMode.map"), map_base_, 1); return LEDPaletteTheme.themeFocusEvent(input, PSTR("testLedMode.map"), map_base_, 1);
} }
} }

@ -122,16 +122,16 @@ bool LEDPaletteTheme::isThemeUninitialized(uint16_t theme_base, uint8_t max_them
return paletteEmpty && themeEmpty; return paletteEmpty && themeEmpty;
} }
EventHandlerResult LEDPaletteTheme::onFocusEvent(const char *command) { EventHandlerResult LEDPaletteTheme::onFocusEvent(const char *input) {
if (!Runtime.has_leds) if (!Runtime.has_leds)
return EventHandlerResult::OK; return EventHandlerResult::OK;
const char *cmd = PSTR("palette"); const char *cmd = PSTR("palette");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd); return ::Focus.printHelp(cmd);
if (!::Focus.inputMatchesCommand(command, cmd)) if (!::Focus.inputMatchesCommand(input, cmd))
return EventHandlerResult::OK; return EventHandlerResult::OK;
if (::Focus.isEOL()) { if (::Focus.isEOL()) {
@ -159,17 +159,17 @@ EventHandlerResult LEDPaletteTheme::onFocusEvent(const char *command) {
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }
EventHandlerResult LEDPaletteTheme::themeFocusEvent(const char *command, EventHandlerResult LEDPaletteTheme::themeFocusEvent(const char *input,
const char *expected_command, const char *expected_input,
uint16_t theme_base, uint16_t theme_base,
uint8_t max_themes) { uint8_t max_themes) {
if (!Runtime.has_leds) if (!Runtime.has_leds)
return EventHandlerResult::OK; return EventHandlerResult::OK;
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(expected_command); return ::Focus.printHelp(expected_input);
if (!::Focus.inputMatchesCommand(command, expected_command)) if (!::Focus.inputMatchesCommand(input, expected_input))
return EventHandlerResult::OK; return EventHandlerResult::OK;
uint16_t max_index = (max_themes * Runtime.device().led_count) / 2; uint16_t max_index = (max_themes * Runtime.device().led_count) / 2;

@ -40,9 +40,9 @@ class LEDPaletteTheme : public kaleidoscope::Plugin {
static void updatePaletteColor(uint8_t palette_index, cRGB color); static void updatePaletteColor(uint8_t palette_index, cRGB color);
static const cRGB lookupPaletteColor(uint8_t palette_index); static const cRGB lookupPaletteColor(uint8_t palette_index);
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
EventHandlerResult themeFocusEvent(const char *command, EventHandlerResult themeFocusEvent(const char *input,
const char *expected_command, const char *expected_input,
uint16_t theme_base, uint16_t theme_base,
uint8_t max_themes); uint8_t max_themes);
static bool isThemeUninitialized(uint16_t theme_base, uint8_t max_themes); static bool isThemeUninitialized(uint16_t theme_base, uint8_t max_themes);

@ -32,45 +32,45 @@ EventHandlerResult LayerFocus::onNameQuery() {
return ::Focus.sendName(F("LayerFocus")); return ::Focus.sendName(F("LayerFocus"));
} }
EventHandlerResult LayerFocus::onFocusEvent(const char *command) { EventHandlerResult LayerFocus::onFocusEvent(const char *input) {
const char *cmd_activate = PSTR("layer.activate"); const char *cmd_activate = PSTR("layer.activate");
const char *cmd_deactivate = PSTR("layer.deactivate"); const char *cmd_deactivate = PSTR("layer.deactivate");
const char *cmd_isActive = PSTR("layer.isActive"); const char *cmd_isActive = PSTR("layer.isActive");
const char *cmd_moveTo = PSTR("layer.moveTo"); const char *cmd_moveTo = PSTR("layer.moveTo");
const char *cmd_state = PSTR("layer.state"); const char *cmd_state = PSTR("layer.state");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_activate, return ::Focus.printHelp(cmd_activate,
cmd_deactivate, cmd_deactivate,
cmd_isActive, cmd_isActive,
cmd_moveTo, cmd_moveTo,
cmd_state); cmd_state);
if (::Focus.inputMatchesCommand(command, cmd_activate)) { if (::Focus.inputMatchesCommand(input, cmd_activate)) {
if (!::Focus.isEOL()) { if (!::Focus.isEOL()) {
uint8_t layer; uint8_t layer;
::Focus.read(layer); ::Focus.read(layer);
::Layer.activate(layer); ::Layer.activate(layer);
} }
} else if (::Focus.inputMatchesCommand(command, cmd_deactivate)) { } else if (::Focus.inputMatchesCommand(input, cmd_deactivate)) {
if (!::Focus.isEOL()) { if (!::Focus.isEOL()) {
uint8_t layer; uint8_t layer;
::Focus.read(layer); ::Focus.read(layer);
::Layer.deactivate(layer); ::Layer.deactivate(layer);
} }
} else if (::Focus.inputMatchesCommand(command, cmd_isActive)) { } else if (::Focus.inputMatchesCommand(input, cmd_isActive)) {
if (!::Focus.isEOL()) { if (!::Focus.isEOL()) {
uint8_t layer; uint8_t layer;
::Focus.read(layer); ::Focus.read(layer);
::Focus.send(::Layer.isActive(layer)); ::Focus.send(::Layer.isActive(layer));
} }
} else if (::Focus.inputMatchesCommand(command, cmd_moveTo)) { } else if (::Focus.inputMatchesCommand(input, cmd_moveTo)) {
if (!::Focus.isEOL()) { if (!::Focus.isEOL()) {
uint8_t layer; uint8_t layer;
::Focus.read(layer); ::Focus.read(layer);
::Layer.move(layer); ::Layer.move(layer);
} }
} else if (::Focus.inputMatchesCommand(command, cmd_state)) { } else if (::Focus.inputMatchesCommand(input, cmd_state)) {
if (::Focus.isEOL()) { if (::Focus.isEOL()) {
for (uint8_t i = 0; i < 32; i++) { for (uint8_t i = 0; i < 32; i++) {
::Focus.send(::Layer.isActive(i) ? 1 : 0); ::Focus.send(::Layer.isActive(i) ? 1 : 0);

@ -27,7 +27,7 @@ namespace plugin {
class LayerFocus : public kaleidoscope::Plugin { class LayerFocus : public kaleidoscope::Plugin {
public: public:
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
}; };
} // namespace plugin } // namespace plugin

@ -31,13 +31,13 @@ EventHandlerResult LayerNames::onNameQuery() {
return ::Focus.sendName(F("LayerNames")); return ::Focus.sendName(F("LayerNames"));
} }
EventHandlerResult LayerNames::onFocusEvent(const char *command) { EventHandlerResult LayerNames::onFocusEvent(const char *input) {
const char *cmd_layerNames = PSTR("keymap.layerNames"); const char *cmd_layerNames = PSTR("keymap.layerNames");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_layerNames); return ::Focus.printHelp(cmd_layerNames);
if (!::Focus.inputMatchesCommand(command, cmd_layerNames)) if (!::Focus.inputMatchesCommand(input, cmd_layerNames))
return EventHandlerResult::OK; return EventHandlerResult::OK;
if (::Focus.isEOL()) { if (::Focus.isEOL()) {

@ -27,7 +27,7 @@ namespace plugin {
class LayerNames : public kaleidoscope::Plugin { class LayerNames : public kaleidoscope::Plugin {
public: public:
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
void reserve_storage(uint16_t size); void reserve_storage(uint16_t size);

@ -142,7 +142,7 @@ class SpaceCadet : public kaleidoscope::Plugin {
class SpaceCadetConfig : public kaleidoscope::Plugin { class SpaceCadetConfig : public kaleidoscope::Plugin {
public: public:
EventHandlerResult onSetup(); EventHandlerResult onSetup();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
void disableSpaceCadetIfUnconfigured(); void disableSpaceCadetIfUnconfigured();

@ -47,14 +47,14 @@ void SpaceCadetConfig::disableSpaceCadetIfUnconfigured() {
::SpaceCadet.disable(); ::SpaceCadet.disable();
} }
EventHandlerResult SpaceCadetConfig::onFocusEvent(const char *command) { EventHandlerResult SpaceCadetConfig::onFocusEvent(const char *input) {
const char *cmd_mode = PSTR("spacecadet.mode"); const char *cmd_mode = PSTR("spacecadet.mode");
const char *cmd_timeout = PSTR("spacecadet.timeout"); const char *cmd_timeout = PSTR("spacecadet.timeout");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_mode, cmd_timeout); return ::Focus.printHelp(cmd_mode, cmd_timeout);
if (::Focus.inputMatchesCommand(command, cmd_mode)) { if (::Focus.inputMatchesCommand(input, cmd_mode)) {
if (::Focus.isEOL()) { if (::Focus.isEOL()) {
::Focus.send(::SpaceCadet.settings_.mode); ::Focus.send(::SpaceCadet.settings_.mode);
} else { } else {
@ -76,7 +76,7 @@ EventHandlerResult SpaceCadetConfig::onFocusEvent(const char *command) {
Runtime.storage().put(settings_base_, ::SpaceCadet.settings_); Runtime.storage().put(settings_base_, ::SpaceCadet.settings_);
Runtime.storage().commit(); Runtime.storage().commit();
} }
} else if (::Focus.inputMatchesCommand(command, cmd_timeout)) { } else if (::Focus.inputMatchesCommand(input, cmd_timeout)) {
if (::Focus.isEOL()) { if (::Focus.isEOL()) {
::Focus.send(::SpaceCadet.settings_.timeout); ::Focus.send(::SpaceCadet.settings_.timeout);
} else { } else {

@ -139,7 +139,7 @@ EventHandlerResult TypingBreaks::onSetup() {
"typingbreaks.leftMaxKeys\r\n" \ "typingbreaks.leftMaxKeys\r\n" \
"typingbreaks.rightMaxKeys") "typingbreaks.rightMaxKeys")
EventHandlerResult TypingBreaks::onFocusEvent(const char *command) { EventHandlerResult TypingBreaks::onFocusEvent(const char *input) {
enum { enum {
IDLE_TIME_LIMIT, IDLE_TIME_LIMIT,
LOCK_TIMEOUT, LOCK_TIMEOUT,
@ -153,22 +153,22 @@ EventHandlerResult TypingBreaks::onFocusEvent(const char *command) {
const char *cmd_lockLength = PSTR("typingbreaks.lockLength"); const char *cmd_lockLength = PSTR("typingbreaks.lockLength");
const char *cmd_leftMaxKeys = PSTR("typingbreaks.leftMaxKeys"); const char *cmd_leftMaxKeys = PSTR("typingbreaks.leftMaxKeys");
const char *cmd_rightMaxKeys = PSTR("typingbreaks.rightMaxKeys"); const char *cmd_rightMaxKeys = PSTR("typingbreaks.rightMaxKeys");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_idleTimeLimit, return ::Focus.printHelp(cmd_idleTimeLimit,
cmd_lockTimeOut, cmd_lockTimeOut,
cmd_lockLength, cmd_lockLength,
cmd_leftMaxKeys, cmd_leftMaxKeys,
cmd_rightMaxKeys); cmd_rightMaxKeys);
if (::Focus.inputMatchesCommand(command, cmd_idleTimeLimit)) if (::Focus.inputMatchesCommand(input, cmd_idleTimeLimit))
subCommand = IDLE_TIME_LIMIT; subCommand = IDLE_TIME_LIMIT;
else if (::Focus.inputMatchesCommand(command, cmd_lockTimeOut)) else if (::Focus.inputMatchesCommand(input, cmd_lockTimeOut))
subCommand = LOCK_TIMEOUT; subCommand = LOCK_TIMEOUT;
else if (::Focus.inputMatchesCommand(command, cmd_lockLength)) else if (::Focus.inputMatchesCommand(input, cmd_lockLength))
subCommand = LOCK_LENGTH; subCommand = LOCK_LENGTH;
else if (::Focus.inputMatchesCommand(command, cmd_leftMaxKeys)) else if (::Focus.inputMatchesCommand(input, cmd_leftMaxKeys))
subCommand = LEFT_MAX; subCommand = LEFT_MAX;
else if (::Focus.inputMatchesCommand(command, cmd_rightMaxKeys)) else if (::Focus.inputMatchesCommand(input, cmd_rightMaxKeys))
subCommand = RIGHT_MAX; subCommand = RIGHT_MAX;
else else
return EventHandlerResult::OK; return EventHandlerResult::OK;

@ -40,7 +40,7 @@ class TypingBreaks : public kaleidoscope::Plugin {
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
EventHandlerResult onKeyEvent(KeyEvent &event); EventHandlerResult onKeyEvent(KeyEvent &event);
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
EventHandlerResult onSetup(); EventHandlerResult onSetup();
private: private:

@ -132,8 +132,8 @@ class Runtime_ {
return (elapsed_time >= ttl); return (elapsed_time >= ttl);
} }
EventHandlerResult onFocusEvent(const char *command) { EventHandlerResult onFocusEvent(const char *input) {
return kaleidoscope::Hooks::onFocusEvent(command); return kaleidoscope::Hooks::onFocusEvent(input);
} }
/** Handle a physical keyswitch event /** Handle a physical keyswitch event

@ -199,8 +199,8 @@ class SignatureCheckDummy {};
_CURRENT_IMPLEMENTATION, __NL__ \ _CURRENT_IMPLEMENTATION, __NL__ \
_ABORTABLE, __NL__ \ _ABORTABLE, __NL__ \
(),(),(), /* non template */ __NL__ \ (),(),(), /* non template */ __NL__ \
(const char *command), __NL__ \ (const char *input), __NL__ \
(command), ##__VA_ARGS__) __NL__ \ (input), ##__VA_ARGS__) __NL__ \
__NL__ \ __NL__ \
/* Called when the layer state changes. Which layes changed are */ __NL__ \ /* Called when the layer state changes. Which layes changed are */ __NL__ \
/* not passed as arguments. If one needs that info, they should */ __NL__ \ /* not passed as arguments. If one needs that info, they should */ __NL__ \

@ -212,7 +212,7 @@ EventHandlerResult LEDControl::afterEachCycle() {
return EventHandlerResult::OK; return EventHandlerResult::OK;
} }
EventHandlerResult FocusLEDCommand::onFocusEvent(const char *command) { EventHandlerResult FocusLEDCommand::onFocusEvent(const char *input) {
enum { enum {
SETALL, SETALL,
MODE, MODE,
@ -230,22 +230,22 @@ EventHandlerResult FocusLEDCommand::onFocusEvent(const char *command) {
const char *cmd_brightness = PSTR("led.brightness"); const char *cmd_brightness = PSTR("led.brightness");
const char *cmd_theme = PSTR("led.theme"); const char *cmd_theme = PSTR("led.theme");
if (::Focus.inputMatchesHelp(command)) if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_at, return ::Focus.printHelp(cmd_at,
cmd_setAll, cmd_setAll,
cmd_mode, cmd_mode,
cmd_brightness, cmd_brightness,
cmd_theme); cmd_theme);
if (::Focus.inputMatchesCommand(command, cmd_at)) if (::Focus.inputMatchesCommand(input, cmd_at))
subCommand = AT; subCommand = AT;
else if (::Focus.inputMatchesCommand(command, cmd_setAll)) else if (::Focus.inputMatchesCommand(input, cmd_setAll))
subCommand = SETALL; subCommand = SETALL;
else if (::Focus.inputMatchesCommand(command, cmd_mode)) else if (::Focus.inputMatchesCommand(input, cmd_mode))
subCommand = MODE; subCommand = MODE;
else if (::Focus.inputMatchesCommand(command, cmd_theme)) else if (::Focus.inputMatchesCommand(input, cmd_theme))
subCommand = THEME; subCommand = THEME;
else if (::Focus.inputMatchesCommand(command, cmd_brightness)) else if (::Focus.inputMatchesCommand(input, cmd_brightness))
subCommand = BRIGHTNESS; subCommand = BRIGHTNESS;
else else
return EventHandlerResult::OK; return EventHandlerResult::OK;

@ -132,7 +132,7 @@ class FocusLEDCommand : public Plugin {
public: public:
FocusLEDCommand() {} FocusLEDCommand() {}
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *input);
}; };
} // namespace plugin } // namespace plugin

Loading…
Cancel
Save