alpha
/
Kaleidoscope
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source 
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
52 changed files with 169 additions and 167 deletions
Show Stats Download Patch File Download Diff File

10
examples/Features/FocusSerial/FocusSerial.ino
Unescape View File

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

6
examples/LEDs/LED-Palette-Theme/LED-Palette-Theme.ino
Unescape View File

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

2
plugins/Kaleidoscope-AutoShift/src/kaleidoscope/plugin/AutoShift.h
Unescape View File

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

10
plugins/Kaleidoscope-AutoShift/src/kaleidoscope/plugin/AutoShiftConfig.cpp
Unescape View File

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

4
plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/Colormap.cpp
Unescape View File

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

2
plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/Colormap.h
Unescape View File

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

6
plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/DefaultColormap.cpp
Unescape View File

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

2
plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/DefaultColormap.h
Unescape View File

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

6
plugins/Kaleidoscope-DefaultLEDModeConfig/src/kaleidoscope/plugin/DefaultLEDModeConfig.cpp
Unescape View File

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

2
plugins/Kaleidoscope-DefaultLEDModeConfig/src/kaleidoscope/plugin/DefaultLEDModeConfig.h
Unescape View File

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

8
plugins/Kaleidoscope-DynamicMacros/src/kaleidoscope/plugin/DynamicMacros.cpp
Unescape View File

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

2
plugins/Kaleidoscope-DynamicMacros/src/kaleidoscope/plugin/DynamicMacros.h
Unescape View File

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

6
plugins/Kaleidoscope-DynamicTapDance/src/kaleidoscope/plugin/DynamicTapDance.cpp
Unescape View File

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

2
plugins/Kaleidoscope-DynamicTapDance/src/kaleidoscope/plugin/DynamicTapDance.h
Unescape View File

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

6
plugins/Kaleidoscope-EEPROM-Keymap-Programmer/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.cpp
Unescape View File

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

2
plugins/Kaleidoscope-EEPROM-Keymap-Programmer/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.h
Unescape View File

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

10
plugins/Kaleidoscope-EEPROM-Keymap/src/kaleidoscope/plugin/EEPROM-Keymap.cpp
Unescape View File

@ -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_default = PSTR("keymap.default");
const char *cmd_onlyCustom = PSTR("keymap.onlyCustom");
if (::Focus.inputMatchesHelp(command))
if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_custom, cmd_default, cmd_onlyCustom);
if (::Focus.inputMatchesCommand(command, cmd_onlyCustom)) {
if (::Focus.inputMatchesCommand(input, cmd_onlyCustom)) {
if (::Focus.isEOL()) {
::Focus.send((uint8_t)::EEPROMSettings.ignoreHardcodedLayers());
} else {
@ -129,7 +129,7 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) {
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,
// tell the compiler which overload of getKeyFromPROGMEM
// we actully want.
@ -139,7 +139,7 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) {
return EventHandlerResult::EVENT_CONSUMED;
}
if (!::Focus.inputMatchesCommand(command, cmd_custom))
if (!::Focus.inputMatchesCommand(input, cmd_custom))
return EventHandlerResult::OK;
if (::Focus.isEOL()) {

2
plugins/Kaleidoscope-EEPROM-Keymap/src/kaleidoscope/plugin/EEPROM-Keymap.h
Unescape View File

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

22
plugins/Kaleidoscope-EEPROM-Settings/src/kaleidoscope/plugin/EEPROM-Settings.cpp
Unescape View File

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

4
plugins/Kaleidoscope-EEPROM-Settings/src/kaleidoscope/plugin/EEPROM-Settings.h
Unescape View File

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

6
plugins/Kaleidoscope-Escape-OneShot/src/kaleidoscope/plugin/Escape-OneShot-Config.cpp
Unescape View File

@ -48,12 +48,12 @@ EventHandlerResult EscapeOneShotConfig::onNameQuery() {
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");
if (::Focus.inputMatchesHelp(command))
if (::Focus.inputMatchesHelp(input))
return ::Focus.printHelp(cmd_cancel_key);
if (!::Focus.inputMatchesCommand(command, cmd_cancel_key))
if (!::Focus.inputMatchesCommand(input, cmd_cancel_key))
return EventHandlerResult::OK;
if (::Focus.isEOL()) {

2
plugins/Kaleidoscope-Escape-OneShot/src/kaleidoscope/plugin/Escape-OneShot.h
Unescape View File

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

8
plugins/Kaleidoscope-FingerPainter/src/kaleidoscope/plugin/FingerPainter.cpp
Unescape View File

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

2
plugins/Kaleidoscope-FingerPainter/src/kaleidoscope/plugin/FingerPainter.h
Unescape View File

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

6
plugins/Kaleidoscope-FirmwareDump/src/kaleidoscope/plugin/FirmwareDump.cpp
Unescape View File

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

2
plugins/Kaleidoscope-FirmwareDump/src/kaleidoscope/plugin/FirmwareDump.h
Unescape View File

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

6
plugins/Kaleidoscope-FirmwareVersion/src/kaleidoscope/plugin/FirmwareVersion.h
Unescape View File

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

4
plugins/Kaleidoscope-FocusSerial/README.md
Unescape View File

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

22
plugins/Kaleidoscope-FocusSerial/src/kaleidoscope/plugin/FocusSerial.cpp
Unescape View File

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

6
plugins/Kaleidoscope-FocusSerial/src/kaleidoscope/plugin/FocusSerial.h
Unescape View File

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

25
plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/Focus.cpp
Unescape View File

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

2
plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/Focus.h
Unescape View File

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

13
plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/SideFlash.h
Unescape View File

@ -34,12 +34,13 @@ class SideFlash : public kaleidoscope::Plugin {
_Firmware firmware;
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_right = PSTR("hardware.flash_right_side");
const char *cmd_verify_left = PSTR("hardware.verify_left_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);
auto sideFlasher = Runtime.device().sideFlasher();
@ -51,16 +52,16 @@ class SideFlash : public kaleidoscope::Plugin {
} sub_command;
uint8_t address = 0;
if (::Focus.inputMatchesCommand(command, cmd_flash_left)) {
if (::Focus.inputMatchesCommand(input, cmd_flash_left)) {
sub_command = FLASH;
address = left_boot_address;
} else if (::Focus.inputMatchesCommand(command, cmd_flash_right)) {
} else if (::Focus.inputMatchesCommand(input, cmd_flash_right)) {
sub_command = FLASH;
address = right_boot_address;
} else if (::Focus.inputMatchesCommand(command, cmd_verify_left)) {
} else if (::Focus.inputMatchesCommand(input, cmd_verify_left)) {
sub_command = VERIFY;
address = left_boot_address;
} else if (::Focus.inputMatchesCommand(command, cmd_verify_right)) {
} else if (::Focus.inputMatchesCommand(input, cmd_verify_right)) {
sub_command = VERIFY;
address = right_boot_address;
} else {

6
plugins/Kaleidoscope-HostOS/src/kaleidoscope/plugin/HostOS-Focus.cpp
Unescape View File

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

2
plugins/Kaleidoscope-HostOS/src/kaleidoscope/plugin/HostOS-Focus.h
Unescape View File

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

6
plugins/Kaleidoscope-IdleLEDs/src/kaleidoscope/plugin/IdleLEDs.cpp
Unescape View File

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

2
plugins/Kaleidoscope-IdleLEDs/src/kaleidoscope/plugin/IdleLEDs.h
Unescape View File

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

6
plugins/Kaleidoscope-LED-Palette-Theme/README.md
Unescape View File

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

16
plugins/Kaleidoscope-LED-Palette-Theme/src/kaleidoscope/plugin/LED-Palette-Theme.cpp
Unescape View File

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

6
plugins/Kaleidoscope-LED-Palette-Theme/src/kaleidoscope/plugin/LED-Palette-Theme.h
Unescape View File

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

14
plugins/Kaleidoscope-LayerFocus/src/kaleidoscope/plugin/LayerFocus.cpp
Unescape View File

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

2
plugins/Kaleidoscope-LayerFocus/src/kaleidoscope/plugin/LayerFocus.h
Unescape View File

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

6
plugins/Kaleidoscope-LayerNames/src/kaleidoscope/plugin/LayerNames.cpp
Unescape View File

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

2
plugins/Kaleidoscope-LayerNames/src/kaleidoscope/plugin/LayerNames.h
Unescape View File

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

2
plugins/Kaleidoscope-SpaceCadet/src/kaleidoscope/plugin/SpaceCadet.h
Unescape View File

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

8
plugins/Kaleidoscope-SpaceCadet/src/kaleidoscope/plugin/SpaceCadetConfig.cpp
Unescape View File

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

14
plugins/Kaleidoscope-TypingBreaks/src/kaleidoscope/plugin/TypingBreaks.cpp
Unescape View File

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

2
plugins/Kaleidoscope-TypingBreaks/src/kaleidoscope/plugin/TypingBreaks.h
Unescape View File

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

4
src/kaleidoscope/Runtime.h
Unescape View File

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

4
src/kaleidoscope/event_handlers.h
Unescape View File

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

14
src/kaleidoscope/plugin/LEDControl.cpp
Unescape View File

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

2
src/kaleidoscope/plugin/LEDControl.h
Unescape View File

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

Write Preview
Loading…
Cancel
Save