A very rough WIP of a potential refactor of focus. It compiles but I

haven't even uploaded it to a device.

.gitignore

@@ -13,4 +13,3 @@
 /results/
 generated-testcase.cpp
 .arduino
-/bin/arduino-cli

README.md

@@ -5,7 +5,7 @@ Flexible firmware for Arduino-powered keyboards.
 
 This package contains the "core" of Kaleidoscope and a number of [example firmware "Sketches"](https://github.com/keyboardio/Kaleidoscope/tree/master/examples).
 
-If you're just getting started with the Keyboardio Model 01, the [introductory docs are here](https://github.com/keyboardio/Kaleidoscope/wiki/Keyboardio-Model-01-Introduction) and the source for the basic firmware package is here: https://github.com/keyboardio/Model01-Firmware. It's probably a good idea to start there, learn how to modify your keymap and maybe turn some modules on or off, and then come back to the full repository when you have more complex changes in mind. (The firmware for all other devices is inside examples/Devices in this Kaleidoscope repo.)
+If you're just getting started with the Keyboardio Model 01, the [introductory docs are here](https://github.com/keyboardio/Kaleidoscope/wiki/Keyboardio-Model-01-Introduction) and the source for the basic firmware package is here: https://github.com/keyboardio/Model01-Firmware. It's probably a good idea to start there, learn how to modify your keymap and maybe turn some modules on or off, and then come back to the full repository when you have more complex changes in mind.
 
 # Getting Started
 

docs/UPGRADING.md

@@ -273,13 +273,8 @@ class FocusExampleCommand : public Plugin {
     return ::Focus.sendName(F("FocusExampleCommand"));
   }
 
-  EventHandlerResult onFocusEvent(const char *input) {
+  EventHandlerResult onFocusEvent(const char *command) {
-    const char *cmd = PSTR("example");
+    if (strcmp_P(command, PSTR("example")) != 0)
-
-    if (::Focus.inputMatchesHelp(input))
-      return ::Focus.printHelp(cmd);
-
-    if (!::Focus.inputMatchesCommand(input, cmd))
       return EventHandlerResult::OK;
 
     ::Focus.send(F("This is an example response. Hello world!"));
@@ -353,8 +348,8 @@ class ExamplePlugin : public Plugin {
  public:
   ExamplePlugin();
 
-  EventHandlerResult onFocusEvent(const char *input) {
+  EventHandlerResult onFocusEvent(const char *command) {
-    if (!::Focus.inputMatchesCommand(input, PSTR("example.toggle")))
+    if (strcmp_P(command, PSTR("example.toggle")) != 0)
       return EventHandlerResult::OK;
 
     example_toggle_ = !example_toggle_;
@@ -413,8 +408,8 @@ class ExampleOptionalCommand : public Plugin {
  public:
   ExampleOptionalCommand() {}
 
-  EventHandlerResult onFocusEvent(const char *input) {
+  EventHandlerResult onFocusEvent(const char *command) {
-    if (!::Focus.inputMatchesCommand(input, PSTR("optional")))
+    if (strcmp_P(command, PSTR("optional")) != 0)
       return EventHandlerResult::OK;
 
     ::Focus.send(Layer.getLayerState());
@@ -798,7 +793,7 @@ void macroNewSentence(KeyEvent &event) {
 
 `kaleidoscope-builder` has been removed.
 
-We replaced it with a new Makefile based build system that uses `arduino-cli` instead of of the full Arduino IDE. This means that you can now check out development copies of Kaliedoscope into any directory, using the `KALEIDOSCOPE_DIR` environment variable to point to your installation.
+We replaced it with a new Makefile based build system that uses `arduino-cli` instead of of the full Arduino IDE. This means that you can now check out development copies of Kaliedoscope into any directory, using the `KALEIDOSCOPE_DIR` environment variable to point to your installation. 
 
 ### OneShot meta keys
 

etc/60-kaleidoscope.rules

@@ -14,5 +14,3 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="1209", ATTRS{idProduct}=="2300", SYMLINK+="
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="1209", ATTRS{idProduct}=="2301", SYMLINK+="model01", ENV{ID_MM_DEVICE_IGNORE}:="1", ENV{ID_MM_CANDIDATE}:="0", TAG+="uaccess", TAG+="seat"
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="1209", ATTRS{idProduct}=="2302", SYMLINK+="Atreus2", ENV{ID_MM_DEVICE_IGNORE}:="1", ENV{ID_MM_CANDIDATE}:="0", TAG+="uaccess", TAG+="seat"
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="1209", ATTRS{idProduct}=="2303", SYMLINK+="Atreus2", ENV{ID_MM_DEVICE_IGNORE}:="1", ENV{ID_MM_CANDIDATE}:="0", TAG+="uaccess", TAG+="seat"
-SUBSYSTEMS=="usb", ATTRS{idVendor}=="3496", ATTRS{idProduct}=="0005", SYMLINK+="model100", ENV{ID_MM_DEVICE_IGNORE}:="1", ENV{ID_MM_CANDIDATE}:="0", TAG+="uaccess", TAG+="seat"
-SUBSYSTEMS=="usb", ATTRS{idVendor}=="3496", ATTRS{idProduct}=="0006", SYMLINK+="model100", ENV{ID_MM_DEVICE_IGNORE}:="1", ENV{ID_MM_CANDIDATE}:="0", TAG+="uaccess", TAG+="seat"

etc/makefiles/sketch.mk

@@ -164,7 +164,7 @@ endif
 compile: kaleidoscope-hardware-configured
 
 
-	-$(QUIET) install -d "${OUTPUT_PATH}"
+	$(QUIET) install -d "${OUTPUT_PATH}"
 	$(QUIET) $(ARDUINO_CLI) compile --fqbn "${FQBN}" ${ARDUINO_VERBOSE} ${ccache_wrapper_property} ${local_cflags_property} \
 	  ${_arduino_local_libraries_prop} ${_ARDUINO_CLI_COMPILE_CUSTOM_FLAGS} \
 	  --library "${KALEIDOSCOPE_DIR}" \
@@ -191,9 +191,10 @@ endif
 #TODO (arduino team) I'd love to do this with their json output
 #but it's short some of the data we kind of need
 
-
 flashing_instructions = $(call _arduino_prop,build.flashing_instructions)
 
+_device_port = $(shell $(ARDUINO_CLI) board list --format=text | grep $(FQBN) |cut -d' ' -f 1)
+
 flash: ${HEX_FILE_PATH}
 ifneq ($(flashing_instructions),)
 	$(info $(shell printf $(flashing_instructions)))
@@ -204,11 +205,11 @@ endif
 	$(info When you're ready to proceed, press 'Enter'.)
 	$(info )
 	@$(shell read _)
-	# If we have a device serial port available, try to trigger a Kaliedoscope reset
+# If we have a device serial port available, try to trigger a Kaliedoscope reset
-	-$(QUIET) export DEVICE=$(shell $(ARDUINO_CLI) board list --format=text | grep $(FQBN) |cut -d' ' -f 1) && \
+ifneq ($(_device_port),)
-		[ -e "$$DEVICE" ] && \
+	$(QUIET) DEVICE=$(_device_port) $(KALEIDOSCOPE_DIR)/bin/focus-send "device.reset"
-		$(KALEIDOSCOPE_DIR)/bin/focus-send "device.reset" && \
+	sleep 2
-		sleep 2
+endif
 	$(QUIET) $(ARDUINO_CLI) upload --fqbn $(FQBN) \
 	$(shell $(ARDUINO_CLI) board list --format=text | grep $(FQBN) |cut -d' ' -f 1 | xargs -n 1 echo "--port" ) \
 	--input-dir "${OUTPUT_PATH}" \

examples/Devices/Keyboardio/Atreus/Atreus.ino

@@ -1,6 +1,6 @@
 /* -*- mode: c++ -*-
  * Atreus -- Chrysalis-enabled Sketch for the Keyboardio Atreus
- * Copyright (C) 2018-2022  Keyboard.io, Inc
+ * Copyright (C) 2018, 2019  Keyboard.io, Inc
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,16 +24,13 @@
 #include "Kaleidoscope.h"
 #include "Kaleidoscope-EEPROM-Settings.h"
 #include "Kaleidoscope-EEPROM-Keymap.h"
-#include "Kaleidoscope-Escape-OneShot.h"
-#include "Kaleidoscope-FirmwareVersion.h"
 #include "Kaleidoscope-FocusSerial.h"
 #include "Kaleidoscope-Macros.h"
 #include "Kaleidoscope-MouseKeys.h"
 #include "Kaleidoscope-OneShot.h"
 #include "Kaleidoscope-Qukeys.h"
 #include "Kaleidoscope-SpaceCadet.h"
-#include "Kaleidoscope-DynamicMacros.h"
+
-#include "Kaleidoscope-LayerNames.h"
 
 #define MO(n) ShiftToLayer(n)
 #define TG(n) LockLayer(n)
@@ -103,7 +100,6 @@ KEYMAPS(
 // clang-format on
 
 KALEIDOSCOPE_INIT_PLUGINS(
-  EscapeOneShot,
   EEPROMSettings,
   EEPROMKeymap,
   Focus,
@@ -113,11 +109,7 @@ KALEIDOSCOPE_INIT_PLUGINS(
   SpaceCadet,
   OneShot,
   Macros,
-  DynamicMacros,
+  MouseKeys);
-  MouseKeys,
-  EscapeOneShotConfig,
-  FirmwareVersion,
-  LayerNames);
 
 const macro_t *macroAction(uint8_t macro_id, KeyEvent &event) {
   if (keyToggledOn(event.state)) {
@@ -143,13 +135,7 @@ const macro_t *macroAction(uint8_t macro_id, KeyEvent &event) {
 void setup() {
   Kaleidoscope.setup();
   SpaceCadet.disable();
-  EEPROMKeymap.setup(9);
+  EEPROMKeymap.setup(10);
-
-  DynamicMacros.reserve_storage(48);
-
-  LayerNames.reserve_storage(63);
-
-  Layer.move(EEPROMSettings.default_layer());
 }
 
 void loop() {

examples/Devices/Keyboardio/Model01/Makefile

@@ -1,8 +1,6 @@
 # This makefile for a Kaleidoscope sketch pulls in all the targets
 # required to build the example
 
-# Compile without deprecated code to save space
-LOCAL_CFLAGS ?= -DNDEPRECATED -DONESHOT_WITHOUT_METASTICKY
 
 
 

examples/Devices/Keyboardio/Model01/Model01.ino

@@ -1,522 +1,106 @@
-// -*- mode: c++ -*-
+/* -*- mode: c++ -*-
-// Copyright 2016 Keyboardio, inc. <jesse@keyboard.io>
+ * Kaleidoscope - A Kaleidoscope example
-// See "LICENSE" for license details
+ * Copyright (C) 2016-2019  Keyboard.io, Inc.
-
+ *
-#ifndef BUILD_INFORMATION
+ * This program is free software: you can redistribute it and/or modify it under
-#define BUILD_INFORMATION "locally built on " __DATE__ " at " __TIME__
+ * the terms of the GNU General Public License as published by the Free Software
-#endif
+ * Foundation, version 3.
-
+ *
-
+ * This program is distributed in the hope that it will be useful, but WITHOUT
-/**
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * These #include directives pull in the Kaleidoscope firmware core,
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
- * as well as the Kaleidoscope plugins we use in the Model 01's firmware
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#define DEBUG_SERIAL false
 
-// The Kaleidoscope core
 #include "Kaleidoscope.h"
-
-// Support for storing the keymap in EEPROM
-#include "Kaleidoscope-EEPROM-Settings.h"
-#include "Kaleidoscope-EEPROM-Keymap.h"
-
-// Support for communicating with the host via a simple Serial protocol
-#include "Kaleidoscope-FocusSerial.h"
-
-// Support for querying the firmware version via Focus
-#include "Kaleidoscope-FirmwareVersion.h"
-
-// Support for keys that move the mouse
 #include "Kaleidoscope-MouseKeys.h"
-
-// Support for macros & dynamic macros
 #include "Kaleidoscope-Macros.h"
-#include "Kaleidoscope-DynamicMacros.h"
-
-// Support for controlling the keyboard's LEDs
 #include "Kaleidoscope-LEDControl.h"
-
-// Support for "Numpad" mode, which is mostly just the Numpad specific LED mode
 #include "Kaleidoscope-NumPad.h"
+#include "Kaleidoscope-HardwareTestMode.h"
+#include "Kaleidoscope-MagicCombo.h"
 
-// Support for the "Boot greeting" effect, which pulses the 'LED' button for 10s
-// when the keyboard is connected to a computer (or that computer is powered on)
-#include "Kaleidoscope-LEDEffect-BootGreeting.h"
-
-// Support for LED modes that set all LEDs to a single color
 #include "Kaleidoscope-LEDEffect-SolidColor.h"
-
-// Support for an LED mode that makes all the LEDs 'breathe'
 #include "Kaleidoscope-LEDEffect-Breathe.h"
-
-// Support for an LED mode that makes a red pixel chase a blue pixel across the keyboard
 #include "Kaleidoscope-LEDEffect-Chase.h"
-
-// Support for LED modes that pulse the keyboard's LED in a rainbow pattern
 #include "Kaleidoscope-LEDEffect-Rainbow.h"
 
-// Support for shared palettes for other plugins, like Colormap below
+#define NUMPAD_KEYMAP 2
-#include "Kaleidoscope-LED-Palette-Theme.h"
+
-
+// clang-format off
-// Support for an LED mode that lets one configure per-layer color maps
+#define GENERIC_FN2  KEYMAP_STACKED ( \
-#include "Kaleidoscope-Colormap.h"
+         ___,      Key_F1,        Key_F2,      Key_F3,     Key_F4,          Key_F5,          XXX,            \
-
+        Key_Tab,  Key_mouseBtnM, Key_mouseUp, ___,        Key_mouseWarpNW, Key_mouseWarpNE, Consumer_ScanNextTrack, \
-// Support for Keyboardio's internal keyboard testing mode
+        Key_Home, Key_mouseL,    Key_mouseDn, Key_mouseR, Key_mouseWarpSW, Key_mouseWarpSE, \
-#include "Kaleidoscope-HardwareTestMode.h"
+        Key_End,  Key_Z,         Key_X,       Key_C,      Key_V,           Key_mouseWarpEnd, ___,    \
-
+                                                        Key_LeftControl, Key_mouseBtnL, Key_LeftGui, Key_LeftShift,                \
-// Support for host power management (suspend & wakeup)
+                                                                                    ___, \
-#include "Kaleidoscope-HostPowerManagement.h"
+\
-
+        XXX,        Key_F6,         Key_F7,            Key_F8,                   Key_F9,              ___,                   ___, \
-// Support for magic combos (key chords that trigger an action)
+        Key_Delete, Consumer_PlaySlashPause,  Key_LeftCurlyBracket, Key_RightCurlyBracket, Key_LeftBracket, Key_RightBracket, System_Sleep, \
-#include "Kaleidoscope-MagicCombo.h"
+                    Key_LeftArrow,            Key_DownArrow,        Key_UpArrow,           Key_RightArrow,  Key_F11,                   Key_F12, \
-
+        ___,        Consumer_VolumeDecrement, Consumer_VolumeIncrement,   Key_BacklightDown,   Key_BacklightUp,    Key_Backslash,      Key_Pipe, \
-// Support for secondary actions (one action when tapped, another when held)
+        Key_RightShift, Key_RightAlt, Key_mouseBtnR, Key_RightControl, \
-#include "Kaleidoscope-Qukeys.h"
+        ___\
-
+)
-// Support for USB quirks, like changing the key state report protocol
+
-#include "Kaleidoscope-USB-Quirks.h"
+#define NUMPAD KEYMAP  (\
-
+         ___, ___, ___, ___, ___, ___, ___,                           ___, ___, Key_Keypad7, Key_Keypad8,   Key_Keypad9,        Key_KeypadSubtract, ___, \
-/** This 'enum' is a list of all the macros used by the Model 01's firmware
+        ___, ___, ___, ___, ___, ___, ___,                            ___, ___, Key_Keypad4, Key_Keypad5,   Key_Keypad6,        Key_KeypadAdd,  ___, \
-  * The names aren't particularly important. What is important is that each
+        ___, ___, ___, ___, ___, ___,                                      ___, Key_Keypad1, Key_Keypad2,   Key_Keypad3,        Key_Equals,      Key_Quote, \
-  * is unique.
+        ___, ___, ___, ___, ___, ___, ___,                            ___, ___, Key_Keypad0, Key_KeypadDot, Key_KeypadMultiply, Key_KeypadDivide, Key_Enter, \
-  *
+       Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,    Key_RightShift, Key_RightAlt, Key_Spacebar, Key_RightControl, \
-  * These are the names of your macros. They'll be used in two places.
+                                 Key_Keymap1_Momentary,               Key_Keymap1_Momentary \
-  * The first is in your keymap definitions. There, you'll use the syntax
+)
-  * `M(MACRO_NAME)` to mark a specific keymap position as triggering `MACRO_NAME`
+
-  *
+#define QWERTY KEYMAP ( \
-  * The second usage is in the 'switch' statement in the `macroAction` function.
+        ___,          Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext,         ___,        Key_6, Key_7, Key_8,     Key_9,      Key_0,         Key_KeypadNumLock, \
-  * That switch statement actually runs the code associated with a macro when
+        Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab,                   Key_Enter,  Key_Y, Key_U, Key_I,     Key_O,      Key_P,         Key_Equals, \
-  * a macro key is pressed.
+        Key_PageUp,   Key_A, Key_S, Key_D, Key_F, Key_G,                                        Key_H, Key_J, Key_K,     Key_L,      Key_Semicolon, Key_Quote, \
-  */
+        Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape,                 ___,       Key_N, Key_M, Key_Comma, Key_Period, Key_Slash,     Key_Minus, \
-
+                 Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,        Key_RightShift, Key_RightAlt, Key_Spacebar, Key_RightControl, \
-enum { MACRO_VERSION_INFO,
+                                              Key_KeymapNext_Momentary,         Key_KeymapNext_Momentary \
-       MACRO_ANY
+)
-};
-
-
-/** The Model 01's key layouts are defined as 'keymaps'. By default, there are three
-  * keymaps: The standard QWERTY keymap, the "Function layer" keymap and the "Numpad"
-  * keymap.
-  *
-  * Each keymap is defined as a list using the 'KEYMAP_STACKED' macro, built
-  * of first the left hand's layout, followed by the right hand's layout.
-  *
-  * Keymaps typically consist mostly of `Key_` definitions. There are many, many keys
-  * defined as part of the USB HID Keyboard specification. You can find the names
-  * (if not yet the explanations) for all the standard `Key_` defintions offered by
-  * Kaleidoscope in these files:
-  *    https://github.com/keyboardio/Kaleidoscope/blob/master/src/kaleidoscope/key_defs_keyboard.h
-  *    https://github.com/keyboardio/Kaleidoscope/blob/master/src/kaleidoscope/key_defs_consumerctl.h
-  *    https://github.com/keyboardio/Kaleidoscope/blob/master/src/kaleidoscope/key_defs_sysctl.h
-  *    https://github.com/keyboardio/Kaleidoscope/blob/master/src/kaleidoscope/key_defs_keymaps.h
-  *
-  * Additional things that should be documented here include
-  *   using ___ to let keypresses fall through to the previously active layer
-  *   using XXX to mark a keyswitch as 'blocked' on this layer
-  *   using ShiftToLayer() and LockLayer() keys to change the active keymap.
-  *   keeping NUM and FN consistent and accessible on all layers
-  *
-  * The PROG key is special, since it is how you indicate to the board that you
-  * want to flash the firmware. However, it can be remapped to a regular key.
-  * When the keyboard boots, it first looks to see whether the PROG key is held
-  * down; if it is, it simply awaits further flashing instructions. If it is
-  * not, it continues loading the rest of the firmware and the keyboard
-  * functions normally, with whatever binding you have set to PROG. More detail
-  * here: https://community.keyboard.io/t/how-the-prog-key-gets-you-into-the-bootloader/506/8
-  *
-  * The "keymaps" data structure is a list of the keymaps compiled into the firmware.
-  * The order of keymaps in the list is important, as the ShiftToLayer(#) and LockLayer(#)
-  * macros switch to key layers based on this list.
-  *
-  *
-
-  * A key defined as 'ShiftToLayer(FUNCTION)' will switch to FUNCTION while held.
-  * Similarly, a key defined as 'LockLayer(NUMPAD)' will switch to NUMPAD when tapped.
-  */
-
-/**
-  * Layers are "0-indexed" -- That is the first one is layer 0. The second one is layer 1.
-  * The third one is layer 2.
-  * This 'enum' lets us use names like QWERTY, FUNCTION, and NUMPAD in place of
-  * the numbers 0, 1 and 2.
-  *
-  */
-
-enum { PRIMARY,
-       NUMPAD,
-       FUNCTION };  // layers
-
-
-/**
-  * To change your keyboard's layout from QWERTY to DVORAK or COLEMAK, comment out the line
-  *
-  * #define PRIMARY_KEYMAP_QWERTY
-  *
-  * by changing it to
-  *
-  * // #define PRIMARY_KEYMAP_QWERTY
-  *
-  * Then uncomment the line corresponding to the layout you want to use.
-  *
-  */
-
-#define PRIMARY_KEYMAP_QWERTY
-// #define PRIMARY_KEYMAP_DVORAK
-// #define PRIMARY_KEYMAP_COLEMAK
-// #define PRIMARY_KEYMAP_CUSTOM
-
-
-/* This comment temporarily turns off astyle's indent enforcement
- *   so we can make the keymaps actually resemble the physical key layout better
- */
-// *INDENT-OFF*
 
 KEYMAPS(
-
+  QWERTY,
-#if defined(PRIMARY_KEYMAP_QWERTY)
+  GENERIC_FN2,
-  [PRIMARY] = KEYMAP_STACKED(___, Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext, Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab, Key_PageUp, Key_A, Key_S, Key_D, Key_F, Key_G, Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape, Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift, ShiftToLayer(FUNCTION),
+  NUMPAD
-
+)
-                             M(MACRO_ANY),
+// clang-format on
-                             Key_6,
+
-                             Key_7,
+static kaleidoscope::plugin::LEDSolidColor solidRed(60, 0, 0);
-                             Key_8,
+static kaleidoscope::plugin::LEDSolidColor solidOrange(60, 20, 0);
-                             Key_9,
+static kaleidoscope::plugin::LEDSolidColor solidYellow(40, 35, 0);
-                             Key_0,
+static kaleidoscope::plugin::LEDSolidColor solidGreen(0, 100, 0);
-                             LockLayer(NUMPAD),
+static kaleidoscope::plugin::LEDSolidColor solidBlue(0, 15, 100);
-                             Key_Enter,
+static kaleidoscope::plugin::LEDSolidColor solidIndigo(0, 0, 100);
-                             Key_Y,
+static kaleidoscope::plugin::LEDSolidColor solidViolet(70, 0, 60);
-                             Key_U,
-                             Key_I,
-                             Key_O,
-                             Key_P,
-                             Key_Equals,
-                             Key_H,
-                             Key_J,
-                             Key_K,
-                             Key_L,
-                             Key_Semicolon,
-                             Key_Quote,
-                             Key_RightAlt,
-                             Key_N,
-                             Key_M,
-                             Key_Comma,
-                             Key_Period,
-                             Key_Slash,
-                             Key_Minus,
-                             Key_RightShift,
-                             Key_LeftAlt,
-                             Key_Spacebar,
-                             Key_RightControl,
-                             ShiftToLayer(FUNCTION)),
-
-#elif defined(PRIMARY_KEYMAP_DVORAK)
-
-  [PRIMARY] = KEYMAP_STACKED(___, Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext, Key_Backtick, Key_Quote, Key_Comma, Key_Period, Key_P, Key_Y, Key_Tab, Key_PageUp, Key_A, Key_O, Key_E, Key_U, Key_I, Key_PageDown, Key_Semicolon, Key_Q, Key_J, Key_K, Key_X, Key_Escape, Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift, ShiftToLayer(FUNCTION),
-
-                             M(MACRO_ANY),
-                             Key_6,
-                             Key_7,
-                             Key_8,
-                             Key_9,
-                             Key_0,
-                             LockLayer(NUMPAD),
-                             Key_Enter,
-                             Key_F,
-                             Key_G,
-                             Key_C,
-                             Key_R,
-                             Key_L,
-                             Key_Slash,
-                             Key_D,
-                             Key_H,
-                             Key_T,
-                             Key_N,
-                             Key_S,
-                             Key_Minus,
-                             Key_RightAlt,
-                             Key_B,
-                             Key_M,
-                             Key_W,
-                             Key_V,
-                             Key_Z,
-                             Key_Equals,
-                             Key_RightShift,
-                             Key_LeftAlt,
-                             Key_Spacebar,
-                             Key_RightControl,
-                             ShiftToLayer(FUNCTION)),
-
-#elif defined(PRIMARY_KEYMAP_COLEMAK)
-
-  [PRIMARY] = KEYMAP_STACKED(___, Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext, Key_Backtick, Key_Q, Key_W, Key_F, Key_P, Key_G, Key_Tab, Key_PageUp, Key_A, Key_R, Key_S, Key_T, Key_D, Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape, Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift, ShiftToLayer(FUNCTION),
-
-                             M(MACRO_ANY),
-                             Key_6,
-                             Key_7,
-                             Key_8,
-                             Key_9,
-                             Key_0,
-                             LockLayer(NUMPAD),
-                             Key_Enter,
-                             Key_J,
-                             Key_L,
-                             Key_U,
-                             Key_Y,
-                             Key_Semicolon,
-                             Key_Equals,
-                             Key_H,
-                             Key_N,
-                             Key_E,
-                             Key_I,
-                             Key_O,
-                             Key_Quote,
-                             Key_RightAlt,
-                             Key_K,
-                             Key_M,
-                             Key_Comma,
-                             Key_Period,
-                             Key_Slash,
-                             Key_Minus,
-                             Key_RightShift,
-                             Key_LeftAlt,
-                             Key_Spacebar,
-                             Key_RightControl,
-                             ShiftToLayer(FUNCTION)),
-
-#elif defined(PRIMARY_KEYMAP_CUSTOM)
-  // Edit this keymap to make a custom layout
-  [PRIMARY] = KEYMAP_STACKED(___, Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext, Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab, Key_PageUp, Key_A, Key_S, Key_D, Key_F, Key_G, Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape, Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift, ShiftToLayer(FUNCTION),
-
-                             M(MACRO_ANY),
-                             Key_6,
-                             Key_7,
-                             Key_8,
-                             Key_9,
-                             Key_0,
-                             LockLayer(NUMPAD),
-                             Key_Enter,
-                             Key_Y,
-                             Key_U,
-                             Key_I,
-                             Key_O,
-                             Key_P,
-                             Key_Equals,
-                             Key_H,
-                             Key_J,
-                             Key_K,
-                             Key_L,
-                             Key_Semicolon,
-                             Key_Quote,
-                             Key_RightAlt,
-                             Key_N,
-                             Key_M,
-                             Key_Comma,
-                             Key_Period,
-                             Key_Slash,
-                             Key_Minus,
-                             Key_RightShift,
-                             Key_LeftAlt,
-                             Key_Spacebar,
-                             Key_RightControl,
-                             ShiftToLayer(FUNCTION)),
-
-#else
-
-#error "No default keymap defined. You should make sure that you have a line like '#define PRIMARY_KEYMAP_QWERTY' in your sketch"
-
-#endif
-
-
-  [NUMPAD] = KEYMAP_STACKED(___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___,
-
-                            M(MACRO_VERSION_INFO),
-                            ___,
-                            Key_7,
-                            Key_8,
-                            Key_9,
-                            Key_KeypadSubtract,
-                            ___,
-                            ___,
-                            ___,
-                            Key_4,
-                            Key_5,
-                            Key_6,
-                            Key_KeypadAdd,
-                            ___,
-                            ___,
-                            Key_1,
-                            Key_2,
-                            Key_3,
-                            Key_Equals,
-                            ___,
-                            ___,
-                            ___,
-                            Key_0,
-                            Key_Period,
-                            Key_KeypadMultiply,
-                            Key_KeypadDivide,
-                            Key_Enter,
-                            ___,
-                            ___,
-                            ___,
-                            ___,
-                            ___),
-
-  [FUNCTION] = KEYMAP_STACKED(___, Key_F1, Key_F2, Key_F3, Key_F4, Key_F5, Key_CapsLock, Key_Tab, ___, Key_mouseUp, ___, Key_mouseBtnR, Key_mouseWarpEnd, Key_mouseWarpNE, Key_Home, Key_mouseL, Key_mouseDn, Key_mouseR, Key_mouseBtnL, Key_mouseWarpNW, Key_End, Key_PrintScreen, Key_Insert, ___, Key_mouseBtnM, Key_mouseWarpSW, Key_mouseWarpSE, ___, Key_Delete, ___, ___, ___,
-
-                              Consumer_ScanPreviousTrack,
-                              Key_F6,
-                              Key_F7,
-                              Key_F8,
-                              Key_F9,
-                              Key_F10,
-                              Key_F11,
-                              Consumer_PlaySlashPause,
-                              Consumer_ScanNextTrack,
-                              Key_LeftCurlyBracket,
-                              Key_RightCurlyBracket,
-                              Key_LeftBracket,
-                              Key_RightBracket,
-                              Key_F12,
-                              Key_LeftArrow,
-                              Key_DownArrow,
-                              Key_UpArrow,
-                              Key_RightArrow,
-                              ___,
-                              ___,
-                              Key_PcApplication,
-                              Consumer_Mute,
-                              Consumer_VolumeDecrement,
-                              Consumer_VolumeIncrement,
-                              ___,
-                              Key_Backslash,
-                              Key_Pipe,
-                              ___,
-                              ___,
-                              Key_Enter,
-                              ___,
-                              ___))  // KEYMAPS(
-
-/* Re-enable astyle's indent enforcement */
-// *INDENT-ON*
-
-/** versionInfoMacro handles the 'firmware version info' macro
- *  When a key bound to the macro is pressed, this macro
- *  prints out the firmware build information as virtual keystrokes
- */
-
-static void versionInfoMacro(uint8_t key_state) {
-  if (keyToggledOn(key_state)) {
-    Macros.type(PSTR("Keyboardio Model 01 - Kaleidoscope "));
-    Macros.type(PSTR(BUILD_INFORMATION));
-  }
-}
-
-/** anyKeyMacro is used to provide the functionality of the 'Any' key.
- *
- * When the 'any key' macro is toggled on, a random alphanumeric key is
- * selected. While the key is held, the function generates a synthetic
- * keypress event repeating that randomly selected key.
- *
- */
-
-static void anyKeyMacro(KeyEvent &event) {
-  if (keyToggledOn(event.state)) {
-    event.key.setKeyCode(Key_A.getKeyCode() + (uint8_t)(millis() % 36));
-    event.key.setFlags(0);
-  }
-}
-
-
-/** macroAction dispatches keymap events that are tied to a macro
-    to that macro. It takes two uint8_t parameters.
-
-    The first is the macro being called (the entry in the 'enum' earlier in this file).
-    The second is the state of the keyswitch. You can use the keyswitch state to figure out
-    if the key has just been toggled on, is currently pressed or if it's just been released.
-
-    The 'switch' statement should have a 'case' for each entry of the macro enum.
-    Each 'case' statement should call out to a function to handle the macro in question.
-
- */
 
 const macro_t *macroAction(uint8_t macro_id, KeyEvent &event) {
-  switch (macro_id) {
+  if (macro_id == 1 && keyToggledOn(event.state)) {
-
+    Kaleidoscope.serialPort().print("Keyboard.IO keyboard driver v0.00");
-  case MACRO_VERSION_INFO:
+    return MACRO(I(25),
-    versionInfoMacro(event.state);
+                 D(LeftShift),
-    break;
+                 T(M),
-
+                 U(LeftShift),
-  case MACRO_ANY:
+                 T(O),
-    anyKeyMacro(event);
+                 T(D),
-    break;
+                 T(E),
+                 T(L),
+                 T(Spacebar),
+                 W(100),
+                 T(0),
+                 T(1));
   }
   return MACRO_NONE;
 }
 
-
-// These 'solid' color effect definitions define a rainbow of
-// LED color modes calibrated to draw 500mA or less on the
-// Keyboardio Model 01.
-
-
-static kaleidoscope::plugin::LEDSolidColor solidRed(160, 0, 0);
-static kaleidoscope::plugin::LEDSolidColor solidOrange(140, 70, 0);
-static kaleidoscope::plugin::LEDSolidColor solidYellow(130, 100, 0);
-static kaleidoscope::plugin::LEDSolidColor solidGreen(0, 160, 0);
-static kaleidoscope::plugin::LEDSolidColor solidBlue(0, 70, 130);
-static kaleidoscope::plugin::LEDSolidColor solidIndigo(0, 0, 170);
-static kaleidoscope::plugin::LEDSolidColor solidViolet(130, 0, 120);
-
-/** toggleLedsOnSuspendResume toggles the LEDs off when the host goes to sleep,
- * and turns them back on when it wakes up.
- */
-void toggleLedsOnSuspendResume(kaleidoscope::plugin::HostPowerManagement::Event event) {
-  switch (event) {
-  case kaleidoscope::plugin::HostPowerManagement::Suspend:
-    LEDControl.disable();
-    break;
-  case kaleidoscope::plugin::HostPowerManagement::Resume:
-    LEDControl.enable();
-    break;
-  case kaleidoscope::plugin::HostPowerManagement::Sleep:
-    break;
-  }
-}
-
-/** hostPowerManagementEventHandler dispatches power management events (suspend,
- * resume, and sleep) to other functions that perform action based on these
- * events.
- */
-void hostPowerManagementEventHandler(kaleidoscope::plugin::HostPowerManagement::Event event) {
-  toggleLedsOnSuspendResume(event);
-}
-
-/** This 'enum' is a list of all the magic combos used by the Model 01's
- * firmware The names aren't particularly important. What is important is that
- * each is unique.
- *
- * These are the names of your magic combos. They will be used by the
- * `USE_MAGIC_COMBOS` call below.
- */
-enum {
-  // Toggle between Boot (6-key rollover; for BIOSes and early boot) and NKRO
-  // mode.
-  COMBO_TOGGLE_NKRO_MODE,
-  // Enter test mode
-  COMBO_ENTER_TEST_MODE
-};
-
-/** Wrappers, to be used by MagicCombo. **/
-
-/**
- * This simply toggles the keyboard protocol via USBQuirks, and wraps it within
- * a function with an unused argument, to match what MagicCombo expects.
- */
-static void toggleKeyboardProtocol(uint8_t combo_index) {
-  USBQuirks.toggleKeyboardProtocol();
-}
-
 /**
  *  This enters the hardware test mode
  */
@@ -528,168 +112,35 @@ static void enterHardwareTestMode(uint8_t combo_index) {
 /** Magic combo list, a list of key combo and action pairs the firmware should
  * recognise.
  */
-USE_MAGIC_COMBOS({.action = toggleKeyboardProtocol,
+USE_MAGIC_COMBOS({.action = enterHardwareTestMode,
-                  // Left Fn + Esc + Shift
-                  .keys = {R3C6, R2C6, R3C7}},
-                 {.action = enterHardwareTestMode,
                   // Left Fn + Prog + LED
                   .keys = {R3C6, R0C0, R0C6}});
 
-// First, tell Kaleidoscope which plugins you want to use.
+KALEIDOSCOPE_INIT_PLUGINS(HardwareTestMode,
-// The order can be important. For example, LED effects are
+                          LEDControl,
-// added in the order they're listed here.
+                          LEDOff,
-KALEIDOSCOPE_INIT_PLUGINS(
+                          solidRed,
-  // The EEPROMSettings & EEPROMKeymap plugins make it possible to have an
+                          solidOrange,
-  // editable keymap in EEPROM.
+                          solidYellow,
-  EEPROMSettings,
+                          solidGreen,
-  EEPROMKeymap,
+                          solidBlue,
-
+                          solidIndigo,
-  // Focus allows bi-directional communication with the host, and is the
+                          solidViolet,
-  // interface through which the keymap in EEPROM can be edited.
+                          LEDBreatheEffect,
-  Focus,
+                          LEDRainbowEffect,
-
+                          LEDChaseEffect,
-  // FocusSettingsCommand adds a few Focus commands, intended to aid in
+                          NumPad,
-  // changing some settings of the keyboard, such as the default layer (via the
+                          Macros,
-  // `settings.defaultLayer` command)
+                          MouseKeys,
-  FocusSettingsCommand,
+                          MagicCombo);
-
-  // FocusEEPROMCommand adds a set of Focus commands, which are very helpful in
-  // both debugging, and in backing up one's EEPROM contents.
-  FocusEEPROMCommand,
-
-  // The boot greeting effect pulses the LED button for 10 seconds after the
-  // keyboard is first connected
-  BootGreetingEffect,
-
-  // The hardware test mode, which can be invoked by tapping Prog, LED and the
-  // left Fn button at the same time.
-  HardwareTestMode,
-
-  // LEDControl provides support for other LED modes
-  LEDControl,
-
-  // We start with the LED effect that turns off all the LEDs.
-  LEDOff,
-
-  // The rainbow effect changes the color of all of the keyboard's keys at the same time
-  // running through all the colors of the rainbow.
-  LEDRainbowEffect,
-
-  // The rainbow wave effect lights up your keyboard with all the colors of a rainbow
-  // and slowly moves the rainbow across your keyboard
-  LEDRainbowWaveEffect,
-
-  // The chase effect follows the adventure of a blue pixel which chases a red pixel across
-  // your keyboard. Spoiler: the blue pixel never catches the red pixel
-  LEDChaseEffect,
-
-  // These static effects turn your keyboard's LEDs a variety of colors
-  solidRed,
-  solidOrange,
-  solidYellow,
-  solidGreen,
-  solidBlue,
-  solidIndigo,
-  solidViolet,
-
-  // The breathe effect slowly pulses all of the LEDs on your keyboard
-  LEDBreatheEffect,
-
-  // The LED Palette Theme plugin provides a shared palette for other plugins,
-  // like Colormap below
-  LEDPaletteTheme,
-
-  // The Colormap effect makes it possible to set up per-layer colormaps
-  ColormapEffect,
 
-  // The numpad plugin is responsible for lighting up the 'numpad' mode
-  // with a custom LED effect
-  NumPad,
-
-  // The macros plugin adds support for macros, DynamicMacros does the same for
-  // Chrysalis-editable, dynamic ones.
-  Macros,
-  DynamicMacros,
-
-  // The MouseKeys plugin lets you add keys to your keymap which move the mouse.
-  MouseKeys,
-
-  // Qukeys lets you add secondary actions to keys, such that they do their
-  // original action on tap, but another action (usually a modifier or a layer
-  // shift action) when held.
-  Qukeys,
-
-  // The HostPowerManagement plugin allows us to turn LEDs off when then host
-  // goes to sleep, and resume them when it wakes up.
-  HostPowerManagement,
-
-  // The MagicCombo plugin lets you use key combinations to trigger custom
-  // actions - a bit like Macros, but triggered by pressing multiple keys at the
-  // same time.
-  MagicCombo,
-
-  // The USBQuirks plugin lets you do some things with USB that we aren't
-  // comfortable - or able - to do automatically, but can be useful
-  // nevertheless. Such as toggling the key report protocol between Boot (used
-  // by BIOSes) and Report (NKRO).
-  USBQuirks,
-
-  // The FirmwareVersion plugin lets Chrysalis query the version of the firmware
-  // programmatically.
-  FirmwareVersion);
-
-/** The 'setup' function is one of the two standard Arduino sketch functions.
- * It's called when your keyboard first powers up. This is where you set up
- * Kaleidoscope and any plugins.
- */
 void setup() {
-  // First, call Kaleidoscope's internal setup function
   Kaleidoscope.setup();
 
-  // While we hope to improve this in the future, the NumPad plugin
+  NumPad.numPadLayer = NUMPAD_KEYMAP;
-  // needs to be explicitly told which keymap layer is your numpad layer
-  NumPad.numPadLayer = NUMPAD;
-
-  // We set the brightness of the rainbow effects to 150 (on a scale of 0-255)
-  // This draws more than 500mA, but looks much nicer than a dimmer effect
-  LEDRainbowEffect.brightness(150);
-  LEDRainbowWaveEffect.brightness(150);
-
-  // Set the action key the test mode should listen for to Left Fn
-  HardwareTestMode.setActionKey(R3C6);
-
-  // We want to make sure that the firmware starts with LED effects off
-  // This avoids over-taxing devices that don't have a lot of power to share
-  // with USB devices
   LEDOff.activate();
-
-  // To make the keymap editable without flashing new firmware, we store
-  // additional layers in EEPROM. For now, we reserve space for five layers. If
-  // one wants to use these layers, just set the default layer to one in EEPROM,
-  // by using the `settings.defaultLayer` Focus command, or by using the
-  // `keymap.onlyCustom` command to use EEPROM layers only.
-  EEPROMKeymap.setup(5);
-
-  // We need to tell the Colormap plugin how many layers we want to have custom
-  // maps for. To make things simple, we set it to five layers, which is how
-  // many editable layers we have (see above).
-  ColormapEffect.max_layers(5);
-
-  // For Dynamic Macros, we need to reserve storage space for the editable
-  // macros.
-  DynamicMacros.reserve_storage(128);
-
-  // If there's a default layer set in EEPROM, we should set that as the default
-  // here.
-  Layer.move(EEPROMSettings.default_layer());
 }
 
-/** loop is the second of the standard Arduino sketch functions.
-  * As you might expect, it runs in a loop, never exiting.
-  *
-  * For Kaleidoscope-based keyboard firmware, you usually just want to
-  * call Kaleidoscope.loop(); and not do anything custom here.
-  */
 
 void loop() {
   Kaleidoscope.loop();

examples/Devices/Keyboardio/Model01/sketch.json

@@ -3,4 +3,4 @@
     "fqbn": "keyboardio:avr:model01",
     "port": ""
   }
-}
+}

examples/Devices/Keyboardio/Model100/Model100.ino

@@ -2,11 +2,17 @@
 // Copyright 2016-2022 Keyboardio, inc. <jesse@keyboard.io>
 // See "LICENSE" for license details
 
+#ifndef BUILD_INFORMATION
+#define BUILD_INFORMATION "locally built on " __DATE__ " at " __TIME__
+#endif
+
+
 /**
  * These #include directives pull in the Kaleidoscope firmware core,
  * as well as the Kaleidoscope plugins we use in the Model 100's firmware
  */
 
+
 // The Kaleidoscope core
 #include "Kaleidoscope.h"
 
@@ -17,11 +23,8 @@
 // Support for communicating with the host via a simple Serial protocol
 #include "Kaleidoscope-FocusSerial.h"
 
-// Support for querying the firmware version via Focus
-#include "Kaleidoscope-FirmwareVersion.h"
-
 // Support for keys that move the mouse
-// #include "Kaleidoscope-MouseKeys.h"
+#include "Kaleidoscope-MouseKeys.h"
 
 // Support for macros
 #include "Kaleidoscope-Macros.h"
@@ -30,7 +33,7 @@
 #include "Kaleidoscope-LEDControl.h"
 
 // Support for "Numpad" mode, which is mostly just the Numpad specific LED mode
-// #include "Kaleidoscope-NumPad.h"
+#include "Kaleidoscope-NumPad.h"
 
 // Support for the "Boot greeting" effect, which pulses the 'LED' button for 10s
 // when the keyboard is connected to a computer (or that computer is powered on)
@@ -63,9 +66,6 @@
 // Support for turning the LEDs off after a certain amount of time
 #include "Kaleidoscope-IdleLEDs.h"
 
-// Support for setting and saving the default LED mode
-#include "Kaleidoscope-DefaultLEDModeConfig.h"
-
 // Support for Keyboardio's internal keyboard testing mode
 #include "Kaleidoscope-HardwareTestMode.h"
 
@@ -88,15 +88,6 @@
 // Support for dynamic, Chrysalis-editable macros
 #include "Kaleidoscope-DynamicMacros.h"
 
-// Support for SpaceCadet keys
-#include "Kaleidoscope-SpaceCadet.h"
-
-// Support for editable layer names
-#include "Kaleidoscope-LayerNames.h"
-
-// Support for the GeminiPR Stenography protocol
-// #include "Kaleidoscope-Steno.h"
-
 /** This 'enum' is a list of all the macros used by the Model 100's firmware
   * The names aren't particularly important. What is important is that each
   * is unique.
@@ -166,9 +157,8 @@ enum {
 
 enum {
   PRIMARY,
-  // NUMPAD,
+  NUMPAD,
   FUNCTION,
-  ETC,
 };  // layers
 
 
@@ -185,10 +175,10 @@ enum {
   *
   */
 
-// #define PRIMARY_KEYMAP_QWERTY
+#define PRIMARY_KEYMAP_QWERTY
 // #define PRIMARY_KEYMAP_DVORAK
 // #define PRIMARY_KEYMAP_COLEMAK
-#define PRIMARY_KEYMAP_CUSTOM
+// #define PRIMARY_KEYMAP_CUSTOM
 
 
 /* This comment temporarily turns off astyle's indent enforcement
@@ -198,37 +188,82 @@ enum {
 
 KEYMAPS(
 
+#if defined (PRIMARY_KEYMAP_QWERTY)
   [PRIMARY] = KEYMAP_STACKED
-  (___,          ___,        ___,   ___,   ___,   ___,   Key_LEDEffectNext,
+  (___,          Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext,
-   ___,          Key_Q,      Key_W, Key_D, Key_F, Key_K, Key_Tab,
+   Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab,
-   ___,          Key_A,      Key_S, Key_E, Key_T, Key_G,
+   Key_PageUp,   Key_A, Key_S, Key_D, Key_F, Key_G,
-   Key_Backtick, Key_Z,      Key_X, Key_C, Key_V, Key_B, LCTRL(LALT(Key_LeftGui)),
+   Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape,
-   GUI_T(Tab), ALT_T(Backspace), CTL_T(Escape), Key_LeftShift,
+   Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,
    ShiftToLayer(FUNCTION),
 
-   M(MACRO_ANY),              ___,  Key_LeftArrow, Key_DownArrow, Key_UpArrow, Key_RightArrow, ___,
+   M(MACRO_ANY),  Key_6, Key_7, Key_8,     Key_9,         Key_0,         LockLayer(NUMPAD),
-   Consumer_VolumeIncrement, Key_J, Key_U,         Key_R,         Key_L,       Key_Semicolon,  Key_Backslash,
+   Key_Enter,     Key_Y, Key_U, Key_I,     Key_O,         Key_P,         Key_Equals,
-                             Key_Y, Key_N,         Key_I,         Key_O,       Key_H,          Key_Quote,
+                  Key_H, Key_J, Key_K,     Key_L,         Key_Semicolon, Key_Quote,
-   Consumer_VolumeDecrement, Key_P, Key_M,         Key_Comma,     Key_Period,  Key_Slash,      ___,
+   Key_RightAlt,  Key_N, Key_M, Key_Comma, Key_Period,    Key_Slash,     Key_Minus,
-   Key_RightShift, ALT_T(Enter), Key_Spacebar, GUI_T(Tab),
+   Key_RightShift, Key_LeftAlt, Key_Spacebar, Key_RightControl,
    ShiftToLayer(FUNCTION)),
 
-  [FUNCTION] =  KEYMAP_STACKED
+#elif defined (PRIMARY_KEYMAP_DVORAK)
-  (___,                  Key_F1,        Key_F2,        Key_F3,                  Key_F4,                   Key_F5,                ___,
-   ___,                  LSHIFT(Key_1), LSHIFT(Key_2), LSHIFT(Key_LeftBracket), LSHIFT(Key_RightBracket), LSHIFT(Key_Backslash), ___,
-   LSHIFT(Key_7),        LSHIFT(Key_3), LSHIFT(Key_4), LSHIFT(Key_9),           LSHIFT(Key_0),            Key_Backslash,
-   LSHIFT(Key_Backtick), LSHIFT(Key_5), LSHIFT(Key_6), Key_LeftBracket,         Key_RightBracket,         LSHIFT(Key_8),         ___,
-   ___, Key_Delete, ___, ___,
-   ___,
 
-   ___, Key_F6,            Key_F7, Key_F8, Key_F9, Key_F10,            Key_F11,
+  [PRIMARY] = KEYMAP_STACKED
-   ___, Key_Equals,        Key_7,  Key_8,  Key_9,  LSHIFT(Key_Equals), Key_F12,
+  (___,          Key_1,         Key_2,     Key_3,      Key_4, Key_5, Key_LEDEffectNext,
-        Key_Minus,         Key_4,  Key_5,  Key_6,  Key_Quote,          ___,
+   Key_Backtick, Key_Quote,     Key_Comma, Key_Period, Key_P, Key_Y, Key_Tab,
-   ___, LSHIFT(Key_Minus), Key_1,  Key_2,  Key_3,  LSHIFT(Key_Quote),  ___,
+   Key_PageUp,   Key_A,         Key_O,     Key_E,      Key_U, Key_I,
-   ___, ___, Key_Enter, Key_0,
+   Key_PageDown, Key_Semicolon, Key_Q,     Key_J,      Key_K, Key_X, Key_Escape,
-   ___),
+   Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,
+   ShiftToLayer(FUNCTION),
+
+   M(MACRO_ANY),   Key_6, Key_7, Key_8, Key_9, Key_0, LockLayer(NUMPAD),
+   Key_Enter,      Key_F, Key_G, Key_C, Key_R, Key_L, Key_Slash,
+                   Key_D, Key_H, Key_T, Key_N, Key_S, Key_Minus,
+   Key_RightAlt,   Key_B, Key_M, Key_W, Key_V, Key_Z, Key_Equals,
+   Key_RightShift, Key_LeftAlt, Key_Spacebar, Key_RightControl,
+   ShiftToLayer(FUNCTION)),
+
+#elif defined (PRIMARY_KEYMAP_COLEMAK)
+
+  [PRIMARY] = KEYMAP_STACKED
+  (___,          Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext,
+   Key_Backtick, Key_Q, Key_W, Key_F, Key_P, Key_G, Key_Tab,
+   Key_PageUp,   Key_A, Key_R, Key_S, Key_T, Key_D,
+   Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape,
+   Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,
+   ShiftToLayer(FUNCTION),
 
-  [ETC] =  KEYMAP_STACKED
+   M(MACRO_ANY),  Key_6, Key_7, Key_8,     Key_9,         Key_0,         LockLayer(NUMPAD),
+   Key_Enter,     Key_J, Key_L, Key_U,     Key_Y,         Key_Semicolon, Key_Equals,
+                  Key_H, Key_N, Key_E,     Key_I,         Key_O,         Key_Quote,
+   Key_RightAlt,  Key_K, Key_M, Key_Comma, Key_Period,    Key_Slash,     Key_Minus,
+   Key_RightShift, Key_LeftAlt, Key_Spacebar, Key_RightControl,
+   ShiftToLayer(FUNCTION)),
+
+#elif defined (PRIMARY_KEYMAP_CUSTOM)
+  // Edit this keymap to make a custom layout
+  [PRIMARY] = KEYMAP_STACKED
+  (___,          Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext,
+   Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab,
+   Key_PageUp,   Key_A, Key_S, Key_D, Key_F, Key_G,
+   Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape,
+   Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,
+   ShiftToLayer(FUNCTION),
+
+   M(MACRO_ANY),  Key_6, Key_7, Key_8,     Key_9,         Key_0,         LockLayer(NUMPAD),
+   Key_Enter,     Key_Y, Key_U, Key_I,     Key_O,         Key_P,         Key_Equals,
+                  Key_H, Key_J, Key_K,     Key_L,         Key_Semicolon, Key_Quote,
+   Key_RightAlt,  Key_N, Key_M, Key_Comma, Key_Period,    Key_Slash,     Key_Minus,
+   Key_RightShift, Key_LeftAlt, Key_Spacebar, Key_RightControl,
+   ShiftToLayer(FUNCTION)),
+
+#else
+
+#error "No default keymap defined. You should make sure that you have a line like '#define PRIMARY_KEYMAP_QWERTY' in your sketch"
+
+#endif
+
+
+
+  [NUMPAD] =  KEYMAP_STACKED
   (___, ___, ___, ___, ___, ___, ___,
    ___, ___, ___, ___, ___, ___, ___,
    ___, ___, ___, ___, ___, ___,
@@ -236,13 +271,27 @@ KEYMAPS(
    ___, ___, ___, ___,
    ___,
 
-   ___, ___, ___,    ___,    ___,    ___,        ___,
+   M(MACRO_VERSION_INFO),  ___, Key_7, Key_8,      Key_9,              Key_KeypadSubtract, ___,
-   ___, ___, Key_F7, Key_F8, Key_F9, Key_Home,   ___,
+   ___,                    ___, Key_4, Key_5,      Key_6,              Key_KeypadAdd,      ___,
-        ___, Key_F4, Key_F5, Key_F6, Key_End,    ___,
+                           ___, Key_1, Key_2,      Key_3,              Key_Equals,         ___,
-   ___, ___, Key_F1, Key_F2, Key_F3, Key_Insert, ___,
+   ___,                    ___, Key_0, Key_Period, Key_KeypadMultiply, Key_KeypadDivide,   Key_Enter,
    ___, ___, ___, ___,
-   ___)
+   ___),
+
+  [FUNCTION] =  KEYMAP_STACKED
+  (___,      Key_F1,           Key_F2,      Key_F3,     Key_F4,        Key_F5,           Key_CapsLock,
+   Key_Tab,  ___,              Key_mouseUp, ___,        Key_mouseBtnR, Key_mouseWarpEnd, Key_mouseWarpNE,
+   Key_Home, Key_mouseL,       Key_mouseDn, Key_mouseR, Key_mouseBtnL, Key_mouseWarpNW,
+   Key_End,  Key_PrintScreen,  Key_Insert,  ___,        Key_mouseBtnM, Key_mouseWarpSW,  Key_mouseWarpSE,
+   ___, Key_Delete, ___, ___,
+   ___,
 
+   Consumer_ScanPreviousTrack, Key_F6,                 Key_F7,                   Key_F8,                   Key_F9,          Key_F10,          Key_F11,
+   Consumer_PlaySlashPause,    Consumer_ScanNextTrack, Key_LeftCurlyBracket,     Key_RightCurlyBracket,    Key_LeftBracket, Key_RightBracket, Key_F12,
+                               Key_LeftArrow,          Key_DownArrow,            Key_UpArrow,              Key_RightArrow,  ___,              ___,
+   Key_PcApplication,          Consumer_Mute,          Consumer_VolumeDecrement, Consumer_VolumeIncrement, ___,             Key_Backslash,    Key_Pipe,
+   ___, ___, Key_Enter, ___,
+   ___)
 ) // KEYMAPS(
 
 /* Re-enable astyle's indent enforcement */
@@ -255,8 +304,8 @@ KEYMAPS(
 
 static void versionInfoMacro(uint8_t key_state) {
   if (keyToggledOn(key_state)) {
-    Macros.type(PSTR("Keyboardio Model 100 - Firmware version "));
+    Macros.type(PSTR("Keyboardio Model 100 - Kaleidoscope "));
-    Macros.type(PSTR(KALEIDOSCOPE_FIRMWARE_VERSION));
+    Macros.type(PSTR(BUILD_INFORMATION));
   }
 }
 
@@ -365,17 +414,6 @@ static void toggleKeyboardProtocol(uint8_t combo_index) {
   USBQuirks.toggleKeyboardProtocol();
 }
 
-/**
- * Toggles between using the built-in keymap, and the EEPROM-stored one.
- */
-static void toggleKeymapSource(uint8_t combo_index) {
-  if (Layer.getKey == Layer.getKeyFromPROGMEM) {
-    Layer.getKey = EEPROMKeymap.getKey;
-  } else {
-    Layer.getKey = Layer.getKeyFromPROGMEM;
-  }
-}
-
 /**
  *  This enters the hardware test mode
  */
@@ -392,10 +430,7 @@ USE_MAGIC_COMBOS({.action = toggleKeyboardProtocol,
                   .keys = {R3C6, R2C6, R3C7}},
                  {.action = enterHardwareTestMode,
                   // Left Fn + Prog + LED
-                  .keys = {R3C6, R0C0, R0C6}},
+                  .keys = {R3C6, R0C0, R0C6}});
-                 {.action = toggleKeymapSource,
-                  // Left Fn + Prog + Shift
-                  .keys = {R3C6, R0C0, R3C7}});
 
 // First, tell Kaleidoscope which plugins you want to use.
 // The order can be important. For example, LED effects are
@@ -406,12 +441,6 @@ KALEIDOSCOPE_INIT_PLUGINS(
   EEPROMSettings,
   EEPROMKeymap,
 
-  // SpaceCadet can turn your shifts into parens on tap, while keeping them as
-  // Shifts when held. SpaceCadetConfig lets Chrysalis configure some aspects of
-  // the plugin.
-  // SpaceCadet,
-  // SpaceCadetConfig,
-
   // Focus allows bi-directional communication with the host, and is the
   // interface through which the keymap in EEPROM can be edited.
   Focus,
@@ -479,13 +508,13 @@ KALEIDOSCOPE_INIT_PLUGINS(
 
   // The numpad plugin is responsible for lighting up the 'numpad' mode
   // with a custom LED effect
-  // NumPad,
+  NumPad,
 
   // The macros plugin adds support for macros
   Macros,
 
   // The MouseKeys plugin lets you add keys to your keymap which move the mouse.
-  // MouseKeys,
+  MouseKeys,
 
   // The HostPowerManagement plugin allows us to turn LEDs off when then host
   // goes to sleep, and resume them when it wakes up.
@@ -518,24 +547,7 @@ KALEIDOSCOPE_INIT_PLUGINS(
   PersistentIdleLEDs,
 
   // Enables dynamic, Chrysalis-editable macros.
-  DynamicMacros,
+  DynamicMacros);
-
-  // The FirmwareVersion plugin lets Chrysalis query the version of the firmware
-  // programmatically.
-  FirmwareVersion,
-
-  // The LayerNames plugin allows Chrysalis to display - and edit - custom layer
-  // names, to be shown instead of the default indexes.
-  LayerNames,
-
-  // Enables setting, saving (via Chrysalis), and restoring (on boot) the
-  // default LED mode.
-  DefaultLEDModeConfig
-
-  // Enables the GeminiPR Stenography protocol. Unused by default, but with the
-  // plugin enabled, it becomes configurable - and then usable - via Chrysalis.
-  //GeminiPR
-  );
 
 /** The 'setup' function is one of the two standard Arduino sketch functions.
  * It's called when your keyboard first powers up. This is where you set up
@@ -551,7 +563,7 @@ void setup() {
 
   // While we hope to improve this in the future, the NumPad plugin
   // needs to be explicitly told which keymap layer is your numpad layer
-  // NumPad.numPadLayer = NUMPAD;
+  NumPad.numPadLayer = NUMPAD;
 
   // We configure the AlphaSquare effect to use RED letters
   AlphaSquare.color = CRGB(255, 0, 0);
@@ -569,6 +581,11 @@ void setup() {
   // https://github.com/keyboardio/Kaleidoscope/blob/master/docs/plugins/LED-Stalker.md
   StalkerEffect.variant = STALKER(BlazingTrail);
 
+  // We want to make sure that the firmware starts with LED effects off
+  // This avoids over-taxing devices that don't have a lot of power to share
+  // with USB devices
+  LEDOff.activate();
+
   // To make the keymap editable without flashing new firmware, we store
   // additional layers in EEPROM. For now, we reserve space for eight layers. If
   // one wants to use these layers, just set the default layer to one in EEPROM,
@@ -584,26 +601,6 @@ void setup() {
   // For Dynamic Macros, we need to reserve storage space for the editable
   // macros. A kilobyte is a reasonable default.
   DynamicMacros.reserve_storage(1024);
-
-  // If there's a default layer set in EEPROM, we should set that as the default
-  // here.
-  Layer.move(EEPROMSettings.default_layer());
-
-  // To avoid any surprises, SpaceCadet is turned off by default. However, it
-  // can be permanently enabled via Chrysalis, so we should only disable it if
-  // no configuration exists.
-  // SpaceCadetConfig.disableSpaceCadetIfUnconfigured();
-  // SpaceCadet.disable();
-
-  // Editable layer names are stored in EEPROM too, and we reserve 16 bytes per
-  // layer for them. We need one extra byte per layer for bookkeeping, so we
-  // reserve 17 / layer in total.
-  LayerNames.reserve_storage(17 * 8);
-
-  // Unless configured otherwise with Chrysalis, we want to make sure that the
-  // firmware starts with LED effects off. This avoids over-taxing devices that
-  // don't have a lot of power to share with USB devices
-  DefaultLEDModeConfig.activateLEDModeIfUnconfigured(&LEDOff);
 }
 
 /** loop is the second of the standard Arduino sketch functions.

examples/Features/FocusSerial/FocusSerial.ino

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

examples/LEDs/LED-Palette-Theme/LED-Palette-Theme.ino

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

plugins/Kaleidoscope-AutoShift/src/kaleidoscope/plugin/AutoShift.h

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

plugins/Kaleidoscope-AutoShift/src/kaleidoscope/plugin/AutoShiftConfig.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/AutoShift.h"  // IWYU pragma: associated
 
-#include <Arduino.h>                       // for PSTR
+#include <Arduino.h>                       // for PSTR, strcmp_P, strncmp_P
 #include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 #include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
 #include <stdint.h>                        // for uint8_t, uint16_t
@@ -47,25 +47,25 @@ EventHandlerResult AutoShiftConfig::onSetup() {
   return EventHandlerResult::OK;
 }
 
-EventHandlerResult AutoShiftConfig::onFocusEvent(const char *input) {
+EventHandlerResult AutoShiftConfig::onFocusEvent(const char *command) {
   enum {
     ENABLED,
     TIMEOUT,
     CATEGORIES,
   } subCommand;
 
-  const char *cmd_enabled    = PSTR("autoshift.enabled");
+  if (::Focus.handleHelp(command, PSTR("autoshift.enabled\r\n"
-  const char *cmd_timeout    = PSTR("autoshift.timeout");
+                                       "autoshift.timeout\r\n"
-  const char *cmd_categories = PSTR("autoshift.categories");
+                                       "autoshift.categories")))
-
+    return EventHandlerResult::OK;
-  if (::Focus.inputMatchesHelp(input))
-    return ::Focus.printHelp(cmd_enabled, cmd_timeout, cmd_categories);
 
-  if (::Focus.inputMatchesCommand(input, cmd_enabled))
+  if (strncmp_P(command, PSTR("autoshift."), 10) != 0)
+    return EventHandlerResult::OK;
+  if (strcmp_P(command + 10, PSTR("enabled")) == 0)
     subCommand = ENABLED;
-  else if (::Focus.inputMatchesCommand(input, cmd_timeout))
+  else if (strcmp_P(command + 10, PSTR("timeout")) == 0)
     subCommand = TIMEOUT;
-  else if (::Focus.inputMatchesCommand(input, cmd_categories))
+  else if (strcmp_P(command + 10, PSTR("categories")) == 0)
     subCommand = CATEGORIES;
   else
     return EventHandlerResult::OK;

plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/Colormap.cpp

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

plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/Colormap.h

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

plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/DefaultColormap.cpp

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

plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/DefaultColormap.h

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

plugins/Kaleidoscope-DefaultLEDModeConfig/README.md

@@ -31,7 +31,7 @@ KALEIDOSCOPE_INIT_PLUGINS(EEPROMSettings,
 void setup() {
   Kaleidoscope.setup();
 
-  DefaultLEDModeConfig.activateLEDModeIfUnconfigured(
+  DefaultLEDModeConfig.activeLEDModeIfUnconfigured(
     &LEDRainbowWaveEffect
   );
 }

plugins/Kaleidoscope-DefaultLEDModeConfig/src/kaleidoscope/plugin/DefaultLEDModeConfig.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/DefaultLEDModeConfig.h"
 
-#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper
+#include <Arduino.h>                       // for PSTR, strcmp_P, F, __FlashStringHelper
 #include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 #include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
 #include <stdint.h>                        // for uint8_t, uint16_t
@@ -48,13 +48,13 @@ EventHandlerResult DefaultLEDModeConfig::onSetup() {
   return EventHandlerResult::OK;
 }
 
-EventHandlerResult DefaultLEDModeConfig::onFocusEvent(const char *input) {
+EventHandlerResult DefaultLEDModeConfig::onFocusEvent(const char *command) {
   const char *cmd = PSTR("led_mode.default");
 
-  if (::Focus.inputMatchesHelp(input))
+  if (::Focus.handleHelp(command, cmd))
-    return ::Focus.printHelp(cmd);
+    return EventHandlerResult::OK;
 
-  if (!::Focus.inputMatchesCommand(input, cmd))
+  if (strcmp_P(command, cmd) != 0)
     return EventHandlerResult::OK;
 
   if (::Focus.isEOL()) {

plugins/Kaleidoscope-DefaultLEDModeConfig/src/kaleidoscope/plugin/DefaultLEDModeConfig.h

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

plugins/Kaleidoscope-DynamicMacros/src/kaleidoscope/plugin/DynamicMacros.cpp

@@ -16,7 +16,7 @@
 
 #include "kaleidoscope/plugin/DynamicMacros.h"
 
-#include <Arduino.h>                   // for delay, PSTR, F, __FlashStri...
+#include <Arduino.h>                   // for delay, PSTR, strcmp_P, F, __FlashStri...
 #include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
 #include <Kaleidoscope-Ranges.h>       // for DYNAMIC_MACRO_FIRST, DYNAMIC_MACRO_LAST
 
@@ -214,14 +214,14 @@ EventHandlerResult DynamicMacros::onNameQuery() {
   return ::Focus.sendName(F("DynamicMacros"));
 }
 
-EventHandlerResult DynamicMacros::onFocusEvent(const char *input) {
+EventHandlerResult DynamicMacros::onFocusEvent(const char *command) {
-  const char *cmd_map     = PSTR("macros.map");
+  if (::Focus.handleHelp(command, PSTR("macros.map\r\nmacros.trigger")))
-  const char *cmd_trigger = PSTR("macros.trigger");
+    return EventHandlerResult::OK;
 
-  if (::Focus.inputMatchesHelp(input))
+  if (strncmp_P(command, PSTR("macros."), 7) != 0)
-    return ::Focus.printHelp(cmd_map, cmd_trigger);
+    return EventHandlerResult::OK;
 
-  if (::Focus.inputMatchesCommand(input, cmd_map)) {
+  if (strcmp_P(command + 7, PSTR("map")) == 0) {
     if (::Focus.isEOL()) {
       for (uint16_t i = 0; i < storage_size_; i++) {
         uint8_t b;
@@ -240,16 +240,15 @@ EventHandlerResult DynamicMacros::onFocusEvent(const char *input) {
       Runtime.storage().commit();
       macro_count_ = updateDynamicMacroCache();
     }
-    return EventHandlerResult::EVENT_CONSUMED;
+  }
-  } else if (::Focus.inputMatchesCommand(input, cmd_trigger)) {
+
+  if (strcmp_P(command + 7, PSTR("trigger")) == 0) {
     uint8_t id = 0;
     ::Focus.read(id);
     play(id);
-
-    return EventHandlerResult::EVENT_CONSUMED;
   }
 
-  return EventHandlerResult::OK;
+  return EventHandlerResult::EVENT_CONSUMED;
 }
 
 // public

plugins/Kaleidoscope-DynamicMacros/src/kaleidoscope/plugin/DynamicMacros.h

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

plugins/Kaleidoscope-DynamicTapDance/src/kaleidoscope/plugin/DynamicTapDance.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/DynamicTapDance.h"
 
-#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper
+#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper, strcmp_P
 #include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 #include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
 #include <stdint.h>                        // for uint16_t, uint8_t
@@ -93,33 +93,33 @@ EventHandlerResult DynamicTapDance::onNameQuery() {
   return ::Focus.sendName(F("DynamicTapDance"));
 }
 
-EventHandlerResult DynamicTapDance::onFocusEvent(const char *input) {
+EventHandlerResult DynamicTapDance::onFocusEvent(const char *command) {
-  const char *cmd_map = PSTR("tapdance.map");
+  if (::Focus.handleHelp(command, PSTR("tapdance.map")))
-
+    return EventHandlerResult::OK;
-  if (::Focus.inputMatchesHelp(input))
-    return ::Focus.printHelp(cmd_map);
 
-  if (!::Focus.inputMatchesCommand(input, cmd_map))
+  if (strncmp_P(command, PSTR("tapdance."), 9) != 0)
     return EventHandlerResult::OK;
 
-  if (::Focus.isEOL()) {
+  if (strcmp_P(command + 9, PSTR("map")) == 0) {
-    for (uint16_t i = 0; i < storage_size_; i += 2) {
+    if (::Focus.isEOL()) {
-      Key k;
+      for (uint16_t i = 0; i < storage_size_; i += 2) {
-      Runtime.storage().get(storage_base_ + i, k);
+        Key k;
-      ::Focus.send(k);
+        Runtime.storage().get(storage_base_ + i, k);
-    }
+        ::Focus.send(k);
-  } else {
+      }
-    uint16_t pos = 0;
+    } else {
+      uint16_t pos = 0;
 
-    while (!::Focus.isEOL()) {
+      while (!::Focus.isEOL()) {
-      Key k;
+        Key k;
-      ::Focus.read(k);
+        ::Focus.read(k);
 
-      Runtime.storage().put(storage_base_ + pos, k);
+        Runtime.storage().put(storage_base_ + pos, k);
-      pos += 2;
+        pos += 2;
+      }
+      Runtime.storage().commit();
+      updateDynamicTapDanceCache();
     }
-    Runtime.storage().commit();
-    updateDynamicTapDanceCache();
   }
 
   return EventHandlerResult::EVENT_CONSUMED;

plugins/Kaleidoscope-DynamicTapDance/src/kaleidoscope/plugin/DynamicTapDance.h

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

plugins/Kaleidoscope-EEPROM-Keymap-Programmer/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/EEPROM-Keymap-Programmer.h"
 
-#include <Arduino.h>                     // for PSTR
+#include <Arduino.h>                     // for PSTR, strcmp_P
 #include <Kaleidoscope-EEPROM-Keymap.h>  // for EEPROMKeymap
 #include <Kaleidoscope-FocusSerial.h>    // for Focus, FocusSerial
 #include <stdint.h>                      // for uint16_t, uint8_t
@@ -106,13 +106,13 @@ EventHandlerResult EEPROMKeymapProgrammer::onKeyEvent(KeyEvent &event) {
   return EventHandlerResult::EVENT_CONSUMED;
 }
 
-EventHandlerResult EEPROMKeymapProgrammer::onFocusEvent(const char *input) {
+EventHandlerResult EEPROMKeymapProgrammer::onFocusEvent(const char *command) {
   const char *cmd = PSTR("keymap.toggleProgrammer");
 
-  if (::Focus.inputMatchesHelp(input))
+  if (::Focus.handleHelp(command, cmd))
-    return ::Focus.printHelp(cmd);
+    return EventHandlerResult::OK;
 
-  if (!::Focus.inputMatchesCommand(input, cmd))
+  if (strcmp_P(command, cmd) != 0)
     return EventHandlerResult::OK;
 
   if (state_ == INACTIVE)

plugins/Kaleidoscope-EEPROM-Keymap-Programmer/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.h

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

plugins/Kaleidoscope-EEPROM-Keymap/src/kaleidoscope/plugin/EEPROM-Keymap.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/EEPROM-Keymap.h"
 
-#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper
+#include <Arduino.h>                       // for PSTR, strcmp_P, F, __FlashStringHelper
 #include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 #include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
 #include <stdint.h>                        // for uint8_t, uint16_t
@@ -38,6 +38,7 @@ uint8_t EEPROMKeymap::progmem_layers_;
 EventHandlerResult EEPROMKeymap::onSetup() {
   ::EEPROMSettings.onSetup();
   progmem_layers_ = layer_count;
+
   return EventHandlerResult::OK;
 }
 
@@ -45,6 +46,7 @@ EventHandlerResult EEPROMKeymap::onNameQuery() {
   return ::Focus.sendName(F("EEPROMKeymap"));
 }
 
+
 void EEPROMKeymap::setup(uint8_t max) {
   layer_count = max;
   if (::EEPROMSettings.ignoreHardcodedLayers()) {
@@ -101,15 +103,22 @@ void EEPROMKeymap::dumpKeymap(uint8_t layers, Key (*getkey)(uint8_t, KeyAddr)) {
   }
 }
 
+
 EventHandlerResult EEPROMKeymap::onFocusEvent(const char *input) {
-  const char *cmd_custom     = PSTR("keymap.custom");
+  const char *primary_focus_command_  = PSTR("keymap.");
-  const char *cmd_default    = PSTR("keymap.default");
+  const char *custom_subcommand_      = PSTR("custom");
-  const char *cmd_onlyCustom = PSTR("keymap.onlyCustom");
+  const char *default_subcommand_     = PSTR("default");
+  const char *only_custom_subcommand_ = PSTR("onlyCustom");
+
+
+  if (::Focus.handleHelp(input, 8, primary_focus_command_, custom_subcommand_, Focus.CRLF, primary_focus_command_, default_subcommand_, Focus.CRLF, primary_focus_command_, only_custom_subcommand_))
+    return EventHandlerResult::OK;
+
+  if (!::Focus.inputMatchesCommand(input, primary_focus_command_))
+    return EventHandlerResult::OK;
 
-  if (::Focus.inputMatchesHelp(input))
-    return ::Focus.printHelp(cmd_custom, cmd_default, cmd_onlyCustom);
 
-  if (::Focus.inputMatchesCommand(input, cmd_onlyCustom)) {
+  if (::Focus.inputMatchesSubcommand(input, primary_focus_command_, only_custom_subcommand_)) {
     if (::Focus.isEOL()) {
       ::Focus.send((uint8_t)::EEPROMSettings.ignoreHardcodedLayers());
     } else {
@@ -129,7 +138,7 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *input) {
     return EventHandlerResult::EVENT_CONSUMED;
   }
 
-  if (::Focus.inputMatchesCommand(input, cmd_default)) {
+  if (::Focus.inputMatchesSubcommand(input, primary_focus_command_, default_subcommand_)) {
     // By using a cast to the appropriate function type,
     // tell the compiler which overload of getKeyFromPROGMEM
     // we actully want.
@@ -139,9 +148,9 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *input) {
     return EventHandlerResult::EVENT_CONSUMED;
   }
 
-  if (!::Focus.inputMatchesCommand(input, cmd_custom))
+  if (!::Focus.inputMatchesSubcommand(input, primary_focus_command_, custom_subcommand_)) {
     return EventHandlerResult::OK;
-
+  }
   if (::Focus.isEOL()) {
     // By using a cast to the appropriate function type,
     // tell the compiler which overload of getKey

plugins/Kaleidoscope-EEPROM-Keymap/src/kaleidoscope/plugin/EEPROM-Keymap.h

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

plugins/Kaleidoscope-EEPROM-Settings/src/kaleidoscope/plugin/EEPROM-Settings.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/EEPROM-Settings.h"
 
-#include <Arduino.h>                   // for PSTR, F, __FlashStringHelper
+#include <Arduino.h>                   // for PSTR, strcmp_P, F, __FlashStringHelper
 #include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
 #include <stdint.h>                    // for uint16_t, uint8_t
 
@@ -156,7 +156,7 @@ void EEPROMSettings::update() {
 }
 
 /** Focus **/
-EventHandlerResult FocusSettingsCommand::onFocusEvent(const char *input) {
+EventHandlerResult FocusSettingsCommand::onFocusEvent(const char *command) {
   enum {
     DEFAULT_LAYER,
     IS_VALID,
@@ -164,21 +164,27 @@ EventHandlerResult FocusSettingsCommand::onFocusEvent(const char *input) {
     GET_CRC,
   } sub_command;
 
-  const char *cmd_defaultLayer = PSTR("settings.defaultLayer");
-  const char *cmd_isValid      = PSTR("settings.valid?");
-  const char *cmd_version      = PSTR("settings.version");
-  const char *cmd_crc          = PSTR("settings.crc");
 
-  if (::Focus.inputMatchesHelp(input))
+  const char *focus_command_settings_      = PSTR("settings");
-    return ::Focus.printHelp(cmd_defaultLayer, cmd_isValid, cmd_version, cmd_crc);
+  const char *focus_command_default_layer_ = PSTR("defaultLayer");
+  const char *focus_command_is_valid_      = PSTR("valid?");
+  const char *focus_command_version_       = PSTR("version");
+  const char *focus_command_crc_           = PSTR("crc");
 
-  if (::Focus.inputMatchesCommand(input, cmd_defaultLayer))
+  if (::Focus.handleHelp(command, 11, focus_command_settings_, focus_command_default_layer_, Focus.CRLF, focus_command_settings_, focus_command_is_valid_, Focus.CRLF, focus_command_settings_, focus_command_version_, Focus.CRLF, focus_command_settings_, focus_command_crc_))
+    return EventHandlerResult::OK;
+
+
+  if (strncmp_P(command, PSTR("settings."), 9) != 0)
+    return EventHandlerResult::OK;
+
+  if (strcmp_P(command + 9, PSTR("defaultLayer")) == 0)
     sub_command = DEFAULT_LAYER;
-  else if (::Focus.inputMatchesCommand(input, cmd_isValid))
+  else if (strcmp_P(command + 9, PSTR("valid?")) == 0)
     sub_command = IS_VALID;
-  else if (::Focus.inputMatchesCommand(input, cmd_version))
+  else if (strcmp_P(command + 9, PSTR("version")) == 0)
     sub_command = GET_VERSION;
-  else if (::Focus.inputMatchesCommand(input, cmd_crc))
+  else if (strcmp_P(command + 9, PSTR("crc")) == 0)
     sub_command = GET_CRC;
   else
     return EventHandlerResult::OK;
@@ -208,25 +214,21 @@ EventHandlerResult FocusSettingsCommand::onFocusEvent(const char *input) {
   return EventHandlerResult::EVENT_CONSUMED;
 }
 
-EventHandlerResult FocusEEPROMCommand::onFocusEvent(const char *input) {
+EventHandlerResult FocusEEPROMCommand::onFocusEvent(const char *command) {
   enum {
     CONTENTS,
     FREE,
     ERASE,
   } sub_command;
 
-  const char *cmd_contents = PSTR("eeprom.contents");
+  if (::Focus.handleHelp(command, PSTR("eeprom.contents\r\neeprom.free\r\neeprom.erase")))
-  const char *cmd_free     = PSTR("eeprom.free");
+    return EventHandlerResult::OK;
-  const char *cmd_erase    = PSTR("eeprom.erase");
-
-  if (::Focus.inputMatchesHelp(input))
-    return ::Focus.printHelp(cmd_contents, cmd_free, cmd_erase);
 
-  if (::Focus.inputMatchesCommand(input, cmd_contents))
+  if (strcmp_P(command, PSTR("eeprom.contents")) == 0)
     sub_command = CONTENTS;
-  else if (::Focus.inputMatchesCommand(input, cmd_free))
+  else if (strcmp_P(command, PSTR("eeprom.free")) == 0)
     sub_command = FREE;
-  else if (::Focus.inputMatchesCommand(input, cmd_erase))
+  else if (strcmp_P(command, PSTR("eeprom.erase")) == 0)
     sub_command = ERASE;
   else
     return EventHandlerResult::OK;

plugins/Kaleidoscope-EEPROM-Settings/src/kaleidoscope/plugin/EEPROM-Settings.h

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

plugins/Kaleidoscope-Escape-OneShot/src/kaleidoscope/plugin/Escape-OneShot-Config.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/Escape-OneShot.h"  // IWYU pragma: associated
 
-#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper
+#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper, strcmp_P
 #include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 #include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
 
@@ -48,12 +48,11 @@ EventHandlerResult EscapeOneShotConfig::onNameQuery() {
   return ::Focus.sendName(F("EscapeOneShot"));
 }
 
-EventHandlerResult EscapeOneShotConfig::onFocusEvent(const char *input) {
+EventHandlerResult EscapeOneShotConfig::onFocusEvent(const char *command) {
-  const char *cmd_cancel_key = PSTR("escape_oneshot.cancel_key");
+  if (::Focus.handleHelp(command, PSTR("escape_oneshot.cancel_key")))
-  if (::Focus.inputMatchesHelp(input))
+    return EventHandlerResult::OK;
-    return ::Focus.printHelp(cmd_cancel_key);
 
-  if (!::Focus.inputMatchesCommand(input, cmd_cancel_key))
+  if (strcmp_P(command, PSTR("escape_oneshot.cancel_key")) != 0)
     return EventHandlerResult::OK;
 
   if (::Focus.isEOL()) {

plugins/Kaleidoscope-Escape-OneShot/src/kaleidoscope/plugin/Escape-OneShot.h

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

plugins/Kaleidoscope-FingerPainter/src/kaleidoscope/plugin/FingerPainter.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/FingerPainter.h"
 
-#include <Arduino.h>                         // for PSTR, F, __FlashStringHelper
+#include <Arduino.h>                         // for PSTR, strcmp_P, F, __FlashStringHelper
 #include <Kaleidoscope-FocusSerial.h>        // for Focus, FocusSerial
 #include <Kaleidoscope-LED-Palette-Theme.h>  // for LEDPaletteTheme
 #include <stdint.h>                          // for uint16_t, uint8_t
@@ -94,21 +94,21 @@ EventHandlerResult FingerPainter::onKeyEvent(KeyEvent &event) {
   return EventHandlerResult::EVENT_CONSUMED;
 }
 
-EventHandlerResult FingerPainter::onFocusEvent(const char *input) {
+EventHandlerResult FingerPainter::onFocusEvent(const char *command) {
   enum {
     TOGGLE,
     CLEAR,
   } sub_command;
 
-  const char *cmd_toggle = PSTR("fingerpainter.toggle");
+  if (::Focus.handleHelp(command, PSTR("fingerpainter.toggle\r\nfingerpainter.clear")))
-  const char *cmd_clear  = PSTR("fingerpainter.clear");
+    return EventHandlerResult::OK;
 
-  if (::Focus.inputMatchesHelp(input))
+  if (strncmp_P(command, PSTR("fingerpainter."), 14) != 0)
-    return ::Focus.printHelp(cmd_toggle, cmd_clear);
+    return EventHandlerResult::OK;
 
-  if (::Focus.inputMatchesCommand(input, cmd_toggle))
+  if (strcmp_P(command + 14, PSTR("toggle")) == 0)
     sub_command = TOGGLE;
-  else if (::Focus.inputMatchesCommand(input, cmd_clear))
+  else if (strcmp_P(command + 14, PSTR("clear")) == 0)
     sub_command = CLEAR;
   else
     return EventHandlerResult::OK;

plugins/Kaleidoscope-FingerPainter/src/kaleidoscope/plugin/FingerPainter.h

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

plugins/Kaleidoscope-FirmwareDump/src/kaleidoscope/plugin/FirmwareDump.cpp

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

plugins/Kaleidoscope-FirmwareDump/src/kaleidoscope/plugin/FirmwareDump.h

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

plugins/Kaleidoscope-FirmwareVersion/src/kaleidoscope/plugin/FirmwareVersion.h

@@ -21,7 +21,7 @@
 #define KALEIDOSCOPE_FIRMWARE_VERSION "0.0.0"
 #endif
 
-#include <Arduino.h>                            // for PSTR, F, __FlashStringHelper
+#include <Arduino.h>                            // for PSTR, F, __FlashStringHelper, strcmp_P
 #include "Kaleidoscope-FocusSerial.h"           // for Focus, FocusSerial
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
 #include "kaleidoscope/plugin.h"                // for Plugin
@@ -31,24 +31,23 @@ namespace plugin {
 
 class FirmwareVersion : public Plugin {
  public:
-  EventHandlerResult onFocusEvent(const char *input) {
+  EventHandlerResult onFocusEvent(const char *command) {
-    const char *cmd_version = PSTR("version");
+    const char *focus_command_version_ = PSTR("version");
-
+    if (::Focus.handleHelp(command, focus_command_version_))
-    if (::Focus.inputMatchesHelp(input))
+      return EventHandlerResult::OK;
-      return ::Focus.printHelp(cmd_version);
 
-    if (!::Focus.inputMatchesCommand(input, cmd_version))
+    if (::Focus.inputMatchesCommand(command, focus_command_version_)) {
       return EventHandlerResult::OK;
 
 #ifdef KALEIDOSCOPE_FIRMWARE_VERSION
-    ::Focus.send(F(KALEIDOSCOPE_FIRMWARE_VERSION));
+      ::Focus.send(F(KALEIDOSCOPE_FIRMWARE_VERSION));
 #else
-    ::Focus.send(F("0.0.0"));
+      ::Focus.send(F("0.0.0"));
 #endif
 
-    return EventHandlerResult::OK;
+      return EventHandlerResult::OK;
-  }
+    }
-};
+  };
 
 }  // namespace plugin
 }  // namespace kaleidoscope

plugins/Kaleidoscope-FocusSerial/README.md

@@ -24,13 +24,8 @@ class FocusTestCommand : public Plugin {
     return ::Focus.sendName(F("FocusTestCommand"));
   }
 
-  EventHandlerResult onFocusEvent(const char *input) {
+  EventHandlerResult onFocusEvent(const char *command) {
-    const char *cmd = PSTR("test");
+    if (strcmp_P(command, PSTR("test")) != 0)
-
-    if (::Focus.inputMatchesHelp(input))
-      return ::Focus.printHelp(cmd);
-
-    if (!::Focus.inputMatchesCommand(input, cmd))
       return EventHandlerResult::OK;
 
     ::Focus.send(F("Congratulations, the test command works!"));
@@ -52,18 +47,6 @@ void setup () {
 
 The plugin provides the `Focus` object, with a couple of helper methods aimed at developers. Terminating the response with a dot on its own line is handled implicitly by `FocusSerial`, one does not need to do that explicitly.
 
-### `.inputMatchesHelp(input)`
-
-Returns `true` if the given `input` matches the `help` command. To be used at the top of `onFocusEvent()`, followed by `.printHelp(...)`.
-
-### `.printHelp(...)`
-
-Given a series of strings (stored in `PROGMEM`, via `PSTR()`), prints them one per line. Assumes it is run as part of handling the `help` command. Returns `EventHandlerResult::OK`.
-
-### `.inputMatchesCommand(input, command)`
-
-Returns `true` if the `input` matches the expected `command`, false otherwise. A convenience function over `strcmp_P()`.
-
 ### `.send(...)`
 ### `.sendRaw(...)`
 

plugins/Kaleidoscope-FocusSerial/src/kaleidoscope/plugin/FocusSerial.cpp

@@ -32,6 +32,11 @@
 namespace kaleidoscope {
 namespace plugin {
 
+EventHandlerResult FocusSerial::onSetup() {
+  const char *focus_command_help_ = PSTR("help");
+  return EventHandlerResult::OK;
+}
+
 EventHandlerResult FocusSerial::afterEachCycle() {
   int c;
   // GD32 doesn't currently autoflush the very last packet. So manually flush here
@@ -51,17 +56,17 @@ EventHandlerResult FocusSerial::afterEachCycle() {
     if (c == SEPARATOR) {
       break;
     }
-    input_[buf_cursor_++] = c;
+    command_[buf_cursor_++] = c;
-  } while (buf_cursor_ < (sizeof(input_) - 1) && Runtime.serialPort().available());
+  } while (buf_cursor_ < (sizeof(command_) - 1) && Runtime.serialPort().available());
 
-  if ((c != SEPARATOR) && (Runtime.serialPort().peek() != NEWLINE) && buf_cursor_ < (sizeof(input_) - 1)) {
+  if ((c != SEPARATOR) && (Runtime.serialPort().peek() != NEWLINE) && buf_cursor_ < (sizeof(command_) - 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(input_);
+  Runtime.onFocusEvent(command_);
   while (Runtime.serialPort().available()) {
     c = Runtime.serialPort().read();
     if (c == NEWLINE) {
@@ -73,23 +78,67 @@ 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(input_, 0, sizeof(input_));
+  memset(command_, 0, sizeof(command_));
   return EventHandlerResult::OK;
 }
 
-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(input))
+bool FocusSerial::inputMatchesCommand(const char *input, const char *to_match) {
-    return printHelp(cmd_help, cmd_reset, cmd_plugins);
+  if (strncmp_P(input, to_match, strlen_P(to_match)) == 0) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool FocusSerial::inputMatchesSubcommand(const char *input, const char *command_to_match, const char *subcommand_to_match) {
+  if (strcmp_P(input + strlen_P(command_to_match), subcommand_to_match) == 0) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool FocusSerial::handleHelp(const char *command,
+                             const char *help_message) {
+  if (!inputMatchesCommand(command, focus_command_help_))
+    return false;
+
+  Runtime.serialPort().println((const __FlashStringHelper *)help_message);
+  return true;
+}
+
+
+bool FocusSerial::handleHelp(const char *command,
+                             uint8_t help_message_count,
+                             ...) {
+
+  if (!inputMatchesCommand(command, focus_command_help_))
+    return false;
+
+  va_list messages;
+  va_start(messages, help_message_count);
 
-  if (inputMatchesCommand(input, cmd_reset)) {
+  for (int i = 0; i < help_message_count; ++i) {
+    char *message = va_arg(messages, char *);
+    Runtime.serialPort().print((const __FlashStringHelper *)message);
+  }
+  Runtime.serialPort().println();
+  va_end(messages);
+  return true;
+}
+
+EventHandlerResult FocusSerial::onFocusEvent(const char *command) {
+  const char *focus_command_device_reset_ = PSTR("device.reset");
+  const char *focus_command_plugins_      = PSTR("plugins");
+  if (handleHelp(command, 5, focus_command_help_, Focus.CRLF, focus_command_device_reset_, Focus.CRLF, focus_command_plugins_))
+    return EventHandlerResult::OK;
+
+  if (inputMatchesCommand(command, focus_command_device_reset_)) {
     Runtime.device().rebootBootloader();
     return EventHandlerResult::EVENT_CONSUMED;
   }
-  if (inputMatchesCommand(input, cmd_plugins)) {
+  if (inputMatchesCommand(command, focus_command_plugins_)) {
     kaleidoscope::Hooks::onNameQuery();
     return EventHandlerResult::EVENT_CONSUMED;
   }
@@ -97,27 +146,10 @@ EventHandlerResult FocusSerial::onFocusEvent(const char *input) {
   return EventHandlerResult::OK;
 }
 
-#ifndef NDEPRECATED
-bool FocusSerial::handleHelp(const char *input, const char *help_message) {
-  if (!inputMatchesHelp(input)) return false;
-
-  printHelp(help_message);
-  return true;
-}
-#endif
-
 void FocusSerial::printBool(bool b) {
   Runtime.serialPort().print((b) ? F("true") : F("false"));
 }
 
-bool FocusSerial::inputMatchesHelp(const char *input) {
-  return inputMatchesCommand(input, PSTR("help"));
-}
-
-bool FocusSerial::inputMatchesCommand(const char *input, const char *expected) {
-  return strcmp_P(input, expected) == 0;
-}
-
 }  // namespace plugin
 }  // namespace kaleidoscope
 

plugins/Kaleidoscope-FocusSerial/src/kaleidoscope/plugin/FocusSerial.h

@@ -26,15 +26,6 @@
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult, EventHandlerResult::OK
 #include "kaleidoscope/key_defs.h"              // for Key
 #include "kaleidoscope/plugin.h"                // for Plugin
-// -----------------------------------------------------------------------------
-// Deprecation warning messages
-#include "kaleidoscope_internal/deprecations.h"  // for DEPRECATED
-
-#define _DEPRECATED_MESSAGE_FOCUS_HANDLEHELP                      \
-  "The `Focus.handleHelp()` method is deprecated. Please use\n"   \
-  "`Focus.inputMatchesHelp()` and `Focus.printHelp()` instead.\n" \
-  "This method will be removed after 2022-12-26."
-// -----------------------------------------------------------------------------
 
 // IWYU pragma: no_include "WString.h"
 
@@ -45,25 +36,20 @@ class FocusSerial : public kaleidoscope::Plugin {
   static constexpr char COMMENT   = '#';
   static constexpr char SEPARATOR = ' ';
   static constexpr char NEWLINE   = '\n';
+  static constexpr char CR        = '\r';
+  static constexpr char *CRLF     = "\r\n";
 
-#ifndef NDEPRECATED
+  bool handleHelp(const char *command,
-  DEPRECATED(FOCUS_HANDLEHELP)
+                  const char *help_message);
-  bool handleHelp(const char *input, const char *help_message);
+  bool handleHelp(const char *command,
-#endif
+                  uint8_t help_message_count,
+                  ...);
 
-  bool inputMatchesHelp(const char *input);
+  bool inputMatchesCommand(const char *input, const char *to_match);
-  bool inputMatchesCommand(const char *input, const char *expected);
+  bool inputMatchesSubcommand(const char *input, const char *command_to_match, const char *subcommand_to_match);
 
-  EventHandlerResult printHelp() {
-    return EventHandlerResult::OK;
-  }
-  template<typename... Vars>
-  EventHandlerResult printHelp(const char *h1, Vars... vars) {
-    Runtime.serialPort().println((const __FlashStringHelper *)h1);
-    delayAfterPrint();
-    return printHelp(vars...);
-  }
 
+  EventHandlerResult onSetup(void);
   EventHandlerResult sendName(const __FlashStringHelper *name) {
     Runtime.serialPort().print(name);
     delayAfterPrint();
@@ -119,7 +105,7 @@ class FocusSerial : public kaleidoscope::Plugin {
     color.b = Runtime.serialPort().parseInt();
   }
   void read(char &c) {
-    Runtime.serialPort().readBytes(&c, 1);
+    c = static_cast<char>(Runtime.serialPort().read());
   }
   void read(uint8_t &u8) {
     u8 = Runtime.serialPort().parseInt();
@@ -137,18 +123,21 @@ class FocusSerial : public kaleidoscope::Plugin {
 
   /* Hooks */
   EventHandlerResult afterEachCycle();
-  EventHandlerResult onFocusEvent(const char *input);
+  EventHandlerResult onFocusEvent(const char *command);
 
  private:
-  char input_[32];
+  char command_[32];
   uint8_t buf_cursor_ = 0;
+  const char *focus_command_help_;
   void printBool(bool b);
 
   // This is a hacky workaround for the host seemingly dropping characters
   // when a client spams its serial port too quickly
   // Verified on GD32 and macOS 12.3 2022-03-29
   static constexpr uint8_t focus_delay_us_after_character_ = 100;
-  void delayAfterPrint() { delayMicroseconds(focus_delay_us_after_character_); }
+  void delayAfterPrint() {
+    delayMicroseconds(focus_delay_us_after_character_);
+  }
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/Focus.cpp

@@ -33,37 +33,24 @@ namespace raise {
 #define RAISE_FIRMWARE_VERSION "<unknown>"
 #endif
 
-EventHandlerResult Focus::onFocusEvent(const char *input) {
+EventHandlerResult Focus::onFocusEvent(const char *command) {
-  const char *cmd_version      = PSTR("hardware.version");
+  if (::Focus.handleHelp(command, PSTR("hardware.version\r\nhardware.side_power\r\nhardware.side_ver\r\nhardware.sled_ver\r\nhardware.sled_current\r\nhardware.layout\r\nhardware.joint\r\nhardware.keyscan\r\nhardware.crc_errors\r\nhardware.firmware")))
-  const char *cmd_side_power   = PSTR("hardware.side_power");
+    return EventHandlerResult::OK;
-  const char *cmd_side_ver     = PSTR("hardware.side_ver");
+
-  const char *cmd_sled_ver     = PSTR("hardware.sled_ver");
+  if (strncmp_P(command, PSTR("hardware."), 9) != 0)
-  const char *cmd_sled_current = PSTR("hardware.sled_current");
+    return EventHandlerResult::OK;
-  const char *cmd_layout       = PSTR("hardware.layout");
+
-  const char *cmd_joint        = PSTR("hardware.joint");
+  if (strcmp_P(command + 9, PSTR("version")) == 0) {
-  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(input))
-    return ::Focus.printHelp(cmd_version,
-                             cmd_side_power,
-                             cmd_side_ver,
-                             cmd_sled_ver,
-                             cmd_sled_current,
-                             cmd_layout,
-                             cmd_joint,
-                             cmd_keyscan,
-                             cmd_crc_errors,
-                             cmd_firmware);
-
-  if (::Focus.inputMatchesCommand(input, cmd_version)) {
     ::Focus.send("Dygma Raise");
     return EventHandlerResult::EVENT_CONSUMED;
-  } else if (::Focus.inputMatchesCommand(input, cmd_firmware)) {
+  }
+
+  if (strcmp_P(command + 9, PSTR("firmware")) == 0) {
     ::Focus.send(RAISE_FIRMWARE_VERSION);
     return EventHandlerResult::EVENT_CONSUMED;
-  } else if (::Focus.inputMatchesCommand(input, cmd_side_power)) {
+  }
+
+  if (strcmp_P(command + 9, PSTR("side_power")) == 0) {
     if (::Focus.isEOL()) {
       ::Focus.send(Runtime.device().side.getPower());
       return EventHandlerResult::EVENT_CONSUMED;
@@ -73,25 +60,33 @@ EventHandlerResult Focus::onFocusEvent(const char *input) {
       Runtime.device().side.setPower(power);
       return EventHandlerResult::EVENT_CONSUMED;
     }
-  } else if (::Focus.inputMatchesCommand(input, cmd_side_ver)) {
+  }
+
+  if (strcmp_P(command + 9, PSTR("side_ver")) == 0) {
     ::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(input, cmd_crc_errors)) {
+  }
+
+  if (strcmp_P(command + 9, PSTR("crc_errors")) == 0) {
     ::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(input, cmd_sled_ver)) {
+  }
+
+  if (strcmp_P(command + 9, PSTR("sled_ver")) == 0) {
     ::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(input, cmd_sled_current)) {
+  }
+
+  if (strcmp_P(command + 9, PSTR("sled_current")) == 0) {
     if (::Focus.isEOL()) {
       ::Focus.send("left:");
       ::Focus.send(Runtime.device().side.leftSLEDCurrent());
@@ -104,14 +99,20 @@ EventHandlerResult Focus::onFocusEvent(const char *input) {
       Runtime.device().side.setSLEDCurrent(current);
       return EventHandlerResult::EVENT_CONSUMED;
     }
-  } else if (::Focus.inputMatchesCommand(input, cmd_layout)) {
+  }
+
+  if (strcmp_P(command + 9, PSTR("layout")) == 0) {
     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(input, cmd_joint)) {
+  }
+
+  if (strcmp_P(command + 9, PSTR("joint")) == 0) {
     ::Focus.send(Runtime.device().settings.joint());
     return EventHandlerResult::EVENT_CONSUMED;
-  } else if (::Focus.inputMatchesCommand(input, cmd_keyscan)) {
+  }
+
+  if (strcmp_P(command + 9, PSTR("keyscan")) == 0) {
     if (::Focus.isEOL()) {
       ::Focus.send(Runtime.device().settings.keyscanInterval());
       return EventHandlerResult::EVENT_CONSUMED;

plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/Focus.h

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

plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/SideFlash.h

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

plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/Model100Side.cpp

@@ -214,7 +214,6 @@ void Model100Side::sendLEDData() {
   }
 }
 
-auto constexpr gamma8 = kaleidoscope::driver::color::gamma_correction;
 
 void Model100Side::sendLEDBank(uint8_t bank) {
   uint8_t data[LED_BYTES_PER_BANK + 1];
@@ -230,25 +229,25 @@ void Model100Side::sendLEDBank(uint8_t bank) {
     else
       c = 0;
 
-    data[i + 1] = pgm_read_byte(&gamma8[c]);
+    data[i + 1] = c;
   }
   uint8_t result = writeData(data, ELEMENTS(data));
 }
 
 void Model100Side::setAllLEDsTo(cRGB color) {
   uint8_t data[] = {TWI_CMD_LED_SET_ALL_TO,
-                    pgm_read_byte(&gamma8[color.b]),
+                    color.b,
-                    pgm_read_byte(&gamma8[color.g]),
+                    color.g,
-                    pgm_read_byte(&gamma8[color.r])};
+                    color.r};
   uint8_t result = writeData(data, ELEMENTS(data));
 }
 
 void Model100Side::setOneLEDTo(uint8_t led, cRGB color) {
   uint8_t data[] = {TWI_CMD_LED_SET_ONE_TO,
                     led,
-                    pgm_read_byte(&gamma8[color.b]),
+                    color.b,
-                    pgm_read_byte(&gamma8[color.g]),
+                    color.g,
-                    pgm_read_byte(&gamma8[color.r])};
+                    color.r};
   uint8_t result = writeData(data, ELEMENTS(data));
 }
 

plugins/Kaleidoscope-HostOS/src/kaleidoscope/plugin/HostOS-Focus.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/HostOS-Focus.h"
 
-#include <Arduino.h>                   // for PSTR
+#include <Arduino.h>                   // for PSTR, strcmp_P
 #include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
 #include <stdint.h>                    // for uint8_t
 
@@ -27,13 +27,12 @@
 namespace kaleidoscope {
 namespace plugin {
 
-EventHandlerResult FocusHostOSCommand::onFocusEvent(const char *input) {
+EventHandlerResult FocusHostOSCommand::onFocusEvent(const char *command) {
   const char *cmd = PSTR("hostos.type");
 
-  if (::Focus.inputMatchesHelp(input))
+  if (::Focus.handleHelp(command, cmd))
-    return ::Focus.printHelp(cmd);
+    return EventHandlerResult::OK;
-
+  if (strcmp_P(command, cmd) != 0)
-  if (!::Focus.inputMatchesCommand(input, cmd))
     return EventHandlerResult::OK;
 
   if (::Focus.isEOL()) {

plugins/Kaleidoscope-HostOS/src/kaleidoscope/plugin/HostOS-Focus.h

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

plugins/Kaleidoscope-HostPowerManagement/src/kaleidoscope/plugin/HostPowerManagement.cpp

@@ -20,41 +20,39 @@
 #include <Arduino.h>  // IWYU pragma: keep
 #include <stdint.h>   // for uint8_t
 
-#ifdef ARDUINO_ARCH_GD32
-#include "USBCore.h"
-#endif
-
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult, EventHandlerResult::OK
 
+// This is a terrible hack until Arduino#6964 gets implemented.
+// It makes the `_usbSuspendState` symbol available to us.
+extern uint8_t _usbSuspendState;
+
 namespace kaleidoscope {
 namespace plugin {
 
-bool HostPowerManagement::was_suspended_ = false;
+bool HostPowerManagement::was_suspended_   = false;
-
+bool HostPowerManagement::initial_suspend_ = true;
-bool HostPowerManagement::isSuspended() {
-#if defined(__AVR__)
-  return USBDevice.isSuspended();
-#elif defined(ARDUINO_ARCH_GD32)
-  return USBCore().isSuspended();
-#else
-  return false;
-#endif
-}
 
 EventHandlerResult HostPowerManagement::beforeEachCycle() {
-  if (isSuspended()) {
+
-    if (!was_suspended_) {
+#ifdef __AVR__
-      was_suspended_ = true;
+  if ((_usbSuspendState & (1 << SUSPI))) {
-      hostPowerManagementEventHandler(Suspend);
+    if (!initial_suspend_) {
-    } else {
+      if (!was_suspended_) {
-      hostPowerManagementEventHandler(Sleep);
+        was_suspended_ = true;
+        hostPowerManagementEventHandler(Suspend);
+      } else {
+        hostPowerManagementEventHandler(Sleep);
+      }
     }
   } else {
+    if (initial_suspend_)
+      initial_suspend_ = false;
     if (was_suspended_) {
       was_suspended_ = false;
       hostPowerManagementEventHandler(Resume);
     }
   }
+#endif
 
   return EventHandlerResult::OK;
 }

plugins/Kaleidoscope-HostPowerManagement/src/kaleidoscope/plugin/HostPowerManagement.h

@@ -34,8 +34,7 @@ class HostPowerManagement : public kaleidoscope::Plugin {
 
  private:
   static bool was_suspended_;
-
+  static bool initial_suspend_;
-  bool isSuspended();
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-IdleLEDs/src/kaleidoscope/plugin/IdleLEDs.cpp

@@ -18,7 +18,7 @@
 
 #include "kaleidoscope/plugin/IdleLEDs.h"
 
-#include <Arduino.h>                       // for F, PSTR, __FlashStringHelper
+#include <Arduino.h>                       // for F, PSTR, __FlashStringHelper, strcmp_P
 #include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 #include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
 #include <stdint.h>                        // for uint32_t, uint16_t
@@ -97,13 +97,13 @@ void PersistentIdleLEDs::setIdleTimeoutSeconds(uint32_t new_limit) {
   Runtime.storage().commit();
 }
 
-EventHandlerResult PersistentIdleLEDs::onFocusEvent(const char *input) {
+EventHandlerResult PersistentIdleLEDs::onFocusEvent(const char *command) {
   const char *cmd = PSTR("idleleds.time_limit");
 
-  if (::Focus.inputMatchesHelp(input))
+  if (::Focus.handleHelp(command, cmd))
-    return ::Focus.printHelp(cmd);
+    return EventHandlerResult::OK;
 
-  if (!::Focus.inputMatchesCommand(input, cmd))
+  if (strcmp_P(command, cmd) != 0)
     return EventHandlerResult::OK;
 
   if (::Focus.isEOL()) {

plugins/Kaleidoscope-IdleLEDs/src/kaleidoscope/plugin/IdleLEDs.h

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

plugins/Kaleidoscope-LED-Palette-Theme/README.md

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

plugins/Kaleidoscope-LED-Palette-Theme/src/kaleidoscope/plugin/LED-Palette-Theme.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/LED-Palette-Theme.h"
 
-#include <Arduino.h>                       // for PSTR
+#include <Arduino.h>                       // for strcmp_P, PSTR
 #include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 #include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
 #include <stdint.h>                        // for uint8_t, uint16_t
@@ -122,16 +122,16 @@ bool LEDPaletteTheme::isThemeUninitialized(uint16_t theme_base, uint8_t max_them
   return paletteEmpty && themeEmpty;
 }
 
-EventHandlerResult LEDPaletteTheme::onFocusEvent(const char *input) {
+EventHandlerResult LEDPaletteTheme::onFocusEvent(const char *command) {
   if (!Runtime.has_leds)
     return EventHandlerResult::OK;
 
   const char *cmd = PSTR("palette");
 
-  if (::Focus.inputMatchesHelp(input))
+  if (::Focus.handleHelp(command, cmd))
-    return ::Focus.printHelp(cmd);
+    return EventHandlerResult::OK;
 
-  if (!::Focus.inputMatchesCommand(input, cmd))
+  if (strcmp_P(command, cmd) != 0)
     return EventHandlerResult::OK;
 
   if (::Focus.isEOL()) {
@@ -159,17 +159,17 @@ EventHandlerResult LEDPaletteTheme::onFocusEvent(const char *input) {
   return EventHandlerResult::EVENT_CONSUMED;
 }
 
-EventHandlerResult LEDPaletteTheme::themeFocusEvent(const char *input,
+EventHandlerResult LEDPaletteTheme::themeFocusEvent(const char *command,
-                                                    const char *expected_input,
+                                                    const char *expected_command,
                                                     uint16_t theme_base,
                                                     uint8_t max_themes) {
   if (!Runtime.has_leds)
     return EventHandlerResult::OK;
 
-  if (::Focus.inputMatchesHelp(input))
+  if (::Focus.handleHelp(command, expected_command))
-    return ::Focus.printHelp(expected_input);
+    return EventHandlerResult::OK;
 
-  if (!::Focus.inputMatchesCommand(input, expected_input))
+  if (strcmp_P(command, expected_command) != 0)
     return EventHandlerResult::OK;
 
   uint16_t max_index = (max_themes * Runtime.device().led_count) / 2;

plugins/Kaleidoscope-LED-Palette-Theme/src/kaleidoscope/plugin/LED-Palette-Theme.h

@@ -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 *input);
+  EventHandlerResult onFocusEvent(const char *command);
-  EventHandlerResult themeFocusEvent(const char *input,
+  EventHandlerResult themeFocusEvent(const char *command,
-                                     const char *expected_input,
+                                     const char *expected_command,
                                      uint16_t theme_base,
                                      uint8_t max_themes);
   static bool isThemeUninitialized(uint16_t theme_base, uint8_t max_themes);

plugins/Kaleidoscope-LayerFocus/src/kaleidoscope/plugin/LayerFocus.cpp

@@ -18,7 +18,7 @@
 
 #include "kaleidoscope/plugin/LayerFocus.h"
 
-#include <Arduino.h>                   // for PSTR, F, __FlashStringHelper
+#include <Arduino.h>                   // for PSTR, strcmp_P, F, __FlashStringHelper
 #include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
 #include <stdint.h>                    // for uint8_t
 
@@ -32,45 +32,39 @@ EventHandlerResult LayerFocus::onNameQuery() {
   return ::Focus.sendName(F("LayerFocus"));
 }
 
-EventHandlerResult LayerFocus::onFocusEvent(const char *input) {
+EventHandlerResult LayerFocus::onFocusEvent(const char *command) {
-  const char *cmd_activate   = PSTR("layer.activate");
+  if (::Focus.handleHelp(command, PSTR("layer.activate\r\nlayer.deactivate\r\nlayer.isActive"
-  const char *cmd_deactivate = PSTR("layer.deactivate");
+                                       "\r\nlayer.moveTo\r\nlayer.state")))
-  const char *cmd_isActive   = PSTR("layer.isActive");
+    return EventHandlerResult::OK;
-  const char *cmd_moveTo     = PSTR("layer.moveTo");
-  const char *cmd_state      = PSTR("layer.state");
 
-  if (::Focus.inputMatchesHelp(input))
+  if (strncmp_P(command, PSTR("layer."), 6) != 0)
-    return ::Focus.printHelp(cmd_activate,
+    return EventHandlerResult::OK;
-                             cmd_deactivate,
-                             cmd_isActive,
-                             cmd_moveTo,
-                             cmd_state);
 
-  if (::Focus.inputMatchesCommand(input, cmd_activate)) {
+  if (strcmp_P(command + 6, PSTR("activate")) == 0) {
     if (!::Focus.isEOL()) {
       uint8_t layer;
       ::Focus.read(layer);
       ::Layer.activate(layer);
     }
-  } else if (::Focus.inputMatchesCommand(input, cmd_deactivate)) {
+  } else if (strcmp_P(command + 6, PSTR("deactivate")) == 0) {
     if (!::Focus.isEOL()) {
       uint8_t layer;
       ::Focus.read(layer);
       ::Layer.deactivate(layer);
     }
-  } else if (::Focus.inputMatchesCommand(input, cmd_isActive)) {
+  } else if (strcmp_P(command + 6, PSTR("isActive")) == 0) {
     if (!::Focus.isEOL()) {
       uint8_t layer;
       ::Focus.read(layer);
       ::Focus.send(::Layer.isActive(layer));
     }
-  } else if (::Focus.inputMatchesCommand(input, cmd_moveTo)) {
+  } else if (strcmp_P(command + 6, PSTR("moveTo")) == 0) {
     if (!::Focus.isEOL()) {
       uint8_t layer;
       ::Focus.read(layer);
       ::Layer.move(layer);
     }
-  } else if (::Focus.inputMatchesCommand(input, cmd_state)) {
+  } else if (strcmp_P(command + 6, PSTR("state")) == 0) {
     if (::Focus.isEOL()) {
       for (uint8_t i = 0; i < 32; i++) {
         ::Focus.send(::Layer.isActive(i) ? 1 : 0);
@@ -86,8 +80,6 @@ EventHandlerResult LayerFocus::onFocusEvent(const char *input) {
           ::Layer.activate(i);
       }
     }
-  } else {
-    return EventHandlerResult::OK;
   }
 
   return EventHandlerResult::EVENT_CONSUMED;

plugins/Kaleidoscope-LayerFocus/src/kaleidoscope/plugin/LayerFocus.h

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

plugins/Kaleidoscope-LayerNames/src/kaleidoscope/plugin/LayerNames.cpp

@@ -16,7 +16,7 @@
 
 #include "kaleidoscope/plugin/LayerNames.h"
 
-#include <Arduino.h>                   // for delay, PSTR, F, __FlashStri...
+#include <Arduino.h>                   // for delay, PSTR, strcmp_P, F, __FlashStri...
 #include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
 
 #include "kaleidoscope/Runtime.h"                 // for Runtime, Runtime_
@@ -31,13 +31,12 @@ EventHandlerResult LayerNames::onNameQuery() {
   return ::Focus.sendName(F("LayerNames"));
 }
 
-EventHandlerResult LayerNames::onFocusEvent(const char *input) {
+EventHandlerResult LayerNames::onFocusEvent(const char *command) {
-  const char *cmd_layerNames = PSTR("keymap.layerNames");
+  const char *focus_command_layer_names_ = PSTR("layer_names");
-
+  if (::Focus.handleHelp(command, focus_command_layer_names_))
-  if (::Focus.inputMatchesHelp(input))
+    return EventHandlerResult::OK;
-    return ::Focus.printHelp(cmd_layerNames);
 
-  if (!::Focus.inputMatchesCommand(input, cmd_layerNames))
+  if (!::Focus.inputMatchesCommand(command, focus_command_layer_names_))
     return EventHandlerResult::OK;
 
   if (::Focus.isEOL()) {

plugins/Kaleidoscope-LayerNames/src/kaleidoscope/plugin/LayerNames.h

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

plugins/Kaleidoscope-MouseKeys/README.md

@@ -37,23 +37,21 @@ void setup() {
 The plugin provides a number of keys one can put on the keymap, that allow
 control of the mouse. They can be divided into a few groups:
 
-### Mouse buttons
-
-Mouse button keys are straightforward; pressing one is the same as pressing the
-corresponding button on a physical mouse.  You can hold a mouse button key to
-perform drag gestures, as you might expect.  MouseKeys supports five mouse
-buttons: left, right, middle, previous, and next.
-
-* `Key_mouseBtnL`, `Key_mouseBtnM`, `Key_mouseBtnR`, `Key_mouseBtnP`,
-  `Key_mouseBtnN`: The left, middle, right, previous, and next mouse buttons,
-  respectively.
-
-
 ### Cursor movement
 
-When a cursor movement key is pressed, the mouse cursor will begin to move
+The simplest set of keys are the mouse cursor movement keys. These move the
-slowly, then accelerate to full speed.  Both the full speed and the time it
+cursor one direction or the other, with speed and acceleration factored in. When
-takes to reach full speed are configurable.
+a mouse cursor movement key is held down, it will move `.speed` pixels each
+`.speedDelay` milliseconds without acceleration. But when `.accelSpeed` is
+non-zero (and it is not zero by default,
+see [below](#accelspeed-and-acceldelay)), the speed will increase by
+`.accelSpeed` every `.accelDelay` milliseconds. Thus, unless configured
+otherwise, holding a direction will move that way at increasing speed.
+
+One can hold more than one key down at the same time, and the cursor will move
+towards a direction that is the combination of the keys held. For example,
+holding the "mouse up" and "mouse right" keys together will move the cursor
+diagonally up and right.
 
 The cursor movement keys are as follows:
 
@@ -62,18 +60,26 @@ The cursor movement keys are as follows:
 * `Key_mouseUpL`, `Key_mouseUpR`, `Key_mouseDnL`, `Key_mouseDnR`: Move the
   cursor up-left, up-right, down-left, down-right, respectively.
 
-### Scroll wheels
+### Scroll wheel
 
-Controlling the scroll wheel is similarly simple.  It does not have
+Controlling the scroll wheel is similarly simple. It does not have acceleration,
-acceleration, but one can control the speed with the
+but one can control the speed with the `.wheelSpeed` and `.wheelDelay`
-`MouseKeys.setScrollInterval()` function, which controls the length of time
+properties (see below).
-between scroll events.
 
 * `Key_mouseScrollUp`, `Key_mouseScrollDn`: Scroll the mouse wheel up or down,
   respectively.
 * `Key_mouseScrollL`, `Key_mouseScrollR`: Scroll the mouse wheel left or right,
   respectively.
 
+### Buttons
+
+Buttons are even simpler than movement: there is no movement speed, nor
+acceleration involved. One just presses them.
+
+* `Key_mouseBtnL`, `Key_mouseBtnM`, `Key_mouseBtnR`, `Key_mouseBtnP`,
+  `Key_mouseBtnN`: The left, middle, right, previous, and next mouse buttons,
+  respectively.
+
 ## Warping
 
 Warping is one of the most interesting features of the plugin, and is a feature
@@ -204,32 +210,37 @@ the following additions:
 The plugin provides a `MouseKeys` object, with the following methods and
 properties available:
 
-### `.setCursorInitSpeed(speed)`/`.getCursorInitSpeed()`
+### `.speed` and `.speedDelay`
 
-> Controls (or returns) the current starting speed value for mouse cursor
+> These two control the speed of the mouse cursor, when a movement key is held.
-> movement.  When a mouse movement key is pressed, the cursor starts moving at
+> The former, `.speed`, controls the amount of pixels the cursor moves, when it
-> this speed, then accelerates.  The number is abstract, but linear, with higher
+> has to move, and defaults to 1. The latter, `.speedDelay` is the amount of
-> numbers representing faster speeds.  Default starting speed is `1`.
+> time - in milliseconds - to wait between two movements, and defaults to 0, no
+> delay.
 
-### `.setCursorBaseSpeed(speed)`/`.getCursorBaseSpeed()`
+### `.accelSpeed` and `.accelDelay`
 
-> Controls (or returns) the current top speed value for mouse cursor movement.
+> These two properties control the speed of acceleration. The former,
-> When a mouse movement key is pressed, the cursor accelerates until it reaches
+> `.accelSpeed`, controls how much the speed shall be increased at each step,
-> this speed.  The number is abstract, but linear, with higher numbers
+> while the second, `.accelDelay`, controls how often (in milliseconds)
-> representing faster speeds.  Default full-speed value is `50`.
+> acceleration should be applied.
+>
+> They default to 1 pixel and 50 milliseconds, respectively.
 
-### `.setCursorAccelDuration(duration)`/`.getCursorAccelDuration()`
+### `.wheelSpeed` and `.wheelDelay`
 
-> Controls (or returns) the current time it takes for the mouse cursor to reach
+> The last two properties supported by the plugin control the mouse wheel
-> full speed (in milliseconds), starting from when the first movement key is
+> scrolling speed. The former, `.wheelSpeed`, controls the amount of ticks the
-> pressed.  Default value is `800` ms.
+> wheel shall scroll, and defaults to 1. The second, `.wheelDelay`, controls the
+> delay between two scroll events, and defaults to 50 milliseconds.
 
-### `.setScrollInterval(interval)`/`.getScrollInterval()`
+### `.setSpeedLimit`
 
-> Controls (or returns) the current scrolling speed, by setting the time between
+> This method sets the maximum speed after which acceleration stops.
-> mouse scroll reports (in milliseconds).  Default value is `50` ms.
+> The default is 127, and the minimum value is 16 (things will not work
+> properly below 16).
 
-### `.setWarpGridSize(size)`
+### `.setWarpGridSize`
 
 > This method changes the size of the grid used for [warping](#warping). The
 > following are valid sizes: `MOUSE_WARP_GRID_2X2`, `MOUSE_WARP_GRID_3X3`

plugins/Kaleidoscope-MouseKeys/src/kaleidoscope/plugin/MouseKeys.cpp

@@ -1,5 +1,5 @@
 /* Kaleidoscope-MouseKeys - Mouse keys for Kaleidoscope.
- * Copyright (C) 2017-2022  Keyboard.io, Inc.
+ * Copyright (C) 2017-2021  Keyboard.io, Inc.
  *
  * This program is free software: you can redistribute it and/or modify it under
  * the terms of the GNU General Public License as published by the Free Software
@@ -29,14 +29,11 @@
 #include "kaleidoscope/key_defs.h"                             // for Key, SYNTHETIC
 #include "kaleidoscope/keyswitch_state.h"                      // for keyToggledOn
 #include "kaleidoscope/plugin/mousekeys/MouseKeyDefs.h"        // for KEY_MOUSE_BUTTON, KEY_MOUS...
-#include "kaleidoscope/plugin/mousekeys/MouseWrapper.h"        // for MouseWrapper, WARP_DOWN
+#include "kaleidoscope/plugin/mousekeys/MouseWrapper.h"        // for MouseWrapper, wrapper, WAR...
 
 namespace kaleidoscope {
 namespace plugin {
 
-#ifndef NDEPRECATED
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 uint8_t MouseKeys::speed       = 1;
 uint16_t MouseKeys::speedDelay = 1;
 
@@ -45,14 +42,16 @@ uint16_t MouseKeys::accelDelay = 64;
 
 uint8_t MouseKeys::wheelSpeed  = 1;
 uint16_t MouseKeys::wheelDelay = 50;
-#pragma GCC diagnostic pop
-#endif
 
 // =============================================================================
 // Configuration functions
 
 void MouseKeys::setWarpGridSize(uint8_t grid_size) {
-  MouseWrapper.warp_grid_size = grid_size;
+  mousekeys::wrapper.warp_grid_size = grid_size;
+}
+
+void MouseKeys::setSpeedLimit(uint8_t speed_limit) {
+  mousekeys::wrapper.speed_limit = speed_limit;
 }
 
 // =============================================================================
@@ -93,6 +92,7 @@ EventHandlerResult MouseKeys::onNameQuery() {
 
 // -----------------------------------------------------------------------------
 EventHandlerResult MouseKeys::onSetup() {
+  kaleidoscope::Runtime.hid().mouse().setup();
   kaleidoscope::Runtime.hid().absoluteMouse().setup();
 
   return EventHandlerResult::OK;
@@ -100,20 +100,23 @@ EventHandlerResult MouseKeys::onSetup() {
 
 // -----------------------------------------------------------------------------
 EventHandlerResult MouseKeys::afterEachCycle() {
-  if (directions_ == 0)
+  // Check timeout for accel update interval.
-    return EventHandlerResult::OK;
+  if (Runtime.hasTimeExpired(accel_start_time_, accelDelay)) {
+    accel_start_time_ = Runtime.millisAtCycleStart();
+    // `accel_step` determines the movement speed of the mouse pointer, and gets
+    // reset to zero when no mouse movement keys is pressed (see below).
+    if (mousekeys::wrapper.accel_step < 255 - accelSpeed) {
+      mousekeys::wrapper.accel_step += accelSpeed;
+    }
+  }
 
   // Check timeout for position update interval.
-  if (Runtime.hasTimeExpired(last_cursor_update_time_, cursor_update_interval_)) {
+  if (Runtime.hasTimeExpired(move_start_time_, speedDelay))
     sendMouseMoveReport();
-    last_cursor_update_time_ += cursor_update_interval_;
-  }
 
   // Check timeout for scroll report interval.
-  if (Runtime.hasTimeExpired(last_wheel_update_time_, settings_.wheel_update_interval)) {
+  if (Runtime.hasTimeExpired(wheel_start_time_, wheelDelay))
     sendMouseWheelReport();
-    last_wheel_update_time_ += settings_.wheel_update_interval;
-  }
 
   return EventHandlerResult::OK;
 }
@@ -129,15 +132,10 @@ EventHandlerResult MouseKeys::onKeyEvent(KeyEvent &event) {
     // Clear button state; it will be repopulated by `onAddToReport()`, and the
     // report will be sent by `afterReportingState()`.
     buttons_ = 0;
-  }
 
-  if (keyToggledOn(event.state)) {
+  } else if (isMouseWarpKey(event.key)) {
-    if (isMouseWarpKey(event.key)) {
+    if (keyToggledOn(event.state)) {
-      // If a mouse warp key toggles on, we immediately send the warp report.
       sendMouseWarpReport(event);
-    } else {
-      // If any non-warp mouse key toggles on, we cancel warping.
-      MouseWrapper.endWarping();
     }
   }
 
@@ -159,27 +157,20 @@ EventHandlerResult MouseKeys::afterReportingState(const KeyEvent &event) {
     sendMouseButtonReport();
   }
 
-  // If no mouse move keys were active before this event, and a mouse movement
-  // key toggled on, we need to set the move start time so that acceleration can
-  // begin correctly.
-  if ((directions_ & cursor_mask_) == 0) {
-    cursor_start_time_ = Runtime.millisAtCycleStart();
-  }
-
   // A mouse key event has been successfully registered, and we have now
   // gathered all the information on held mouse movement and wheel keys, so it's
   // safe to update the direction information.
   directions_         = pending_directions_;
   pending_directions_ = 0;
 
-  if (keyToggledOn(event.state)) {
+  if (isMouseMoveKey(event.key)) {
-    if (isMouseMoveKey(event.key)) {
+    // When a cursor movement key toggles on, set the acceleration start time in
-      sendMouseMoveReport();
+    // order to get consistent behavior.
-      last_cursor_update_time_ = Runtime.millisAtCycleStart();
+    accel_start_time_ = Runtime.millisAtCycleStart();
-    } else if (isMouseWheelKey(event.key)) {
+    sendMouseMoveReport();
-      sendMouseWheelReport();
+
-      last_wheel_update_time_ = Runtime.millisAtCycleStart();
+  } else if (isMouseWheelKey(event.key)) {
-    }
+    sendMouseWheelReport();
   }
 
   return EventHandlerResult::OK;
@@ -219,7 +210,7 @@ void MouseKeys::sendMouseButtonReport() const {
 
 // -----------------------------------------------------------------------------
 void MouseKeys::sendMouseWarpReport(const KeyEvent &event) const {
-  MouseWrapper.warp(
+  mousekeys::wrapper.warp(
     ((event.key.getKeyCode() & KEY_MOUSE_WARP_END) ? WARP_END : 0x00) |
     ((event.key.getKeyCode() & KEY_MOUSE_UP) ? WARP_UP : 0x00) |
     ((event.key.getKeyCode() & KEY_MOUSE_DOWN) ? WARP_DOWN : 0x00) |
@@ -228,148 +219,57 @@ void MouseKeys::sendMouseWarpReport(const KeyEvent &event) const {
 }
 
 // -----------------------------------------------------------------------------
-void MouseKeys::sendMouseMoveReport() const {
+void MouseKeys::sendMouseMoveReport() {
-  int8_t dx = 0;
+  move_start_time_ = Runtime.millisAtCycleStart();
-  int8_t dy = 0;
 
-  uint8_t direction = directions_ & cursor_mask_;
+  int8_t vx         = 0;
+  int8_t vy         = 0;
+  uint8_t direction = directions_ & move_mask_;
 
-  if (direction != 0) {
+  if (direction == 0) {
-    // Calculate
+    // If there are no mouse movement keys held, reset speed to zero.
-    uint8_t delta = cursorDelta();
+    mousekeys::wrapper.accel_step = 0;
-    // For each active direction, add the move update interval value to
+  } else {
-    // normalize speed of motion regardless of the frequency of updates.
+    // For each active direction, add the mouse movement speed.
     if (direction & KEY_MOUSE_LEFT)
-      dx -= delta;
+      vx -= speed;
     if (direction & KEY_MOUSE_RIGHT)
-      dx += delta;
+      vx += speed;
     if (direction & KEY_MOUSE_UP)
-      dy -= delta;
+      vy -= speed;
     if (direction & KEY_MOUSE_DOWN)
-      dy += delta;
+      vy += speed;
 
+    // Prepare the mouse report.
+    mousekeys::wrapper.move(vx, vy);
     // Send the report.
-    Runtime.hid().mouse().move(dx, dy, 0, 0);
     Runtime.hid().mouse().sendReport();
   }
 }
 
 // -----------------------------------------------------------------------------
-// Get the current point on the acceleration curve's x axis, translating time
+void MouseKeys::sendMouseWheelReport() {
-// elapsed since mouse movement started to a value between 0 and 255.
+  wheel_start_time_ = Runtime.millisAtCycleStart();
-uint8_t MouseKeys::accelStep() const {
-  uint16_t elapsed_time   = Runtime.millisAtCycleStart() - cursor_start_time_;
-  uint16_t accel_duration = settings_.cursor_accel_duration;
-  if (elapsed_time > accel_duration)
-    return 255;
-  uint16_t accel_step = (uint32_t(elapsed_time) * 256) / accel_duration;
-  return uint8_t(accel_step);
-}
-
-// -----------------------------------------------------------------------------
-// Compute the acceleration factor for mouse movement.  When a movement key is
-// first pressed, the cursor starts out slow then accelerates to full speed.
-// The speed during acceleration follows an approximation of a sigmoid function,
-// using two parabolas for simplicity.
-uint8_t accelFactor(uint8_t accel_step) {
-  if (accel_step < 128) {
-    uint16_t y = accel_step * accel_step;
-    return 1 + (y >> 7);
-  } else {
-    uint16_t remaining_steps = 256 - accel_step;
-
-    uint16_t y = remaining_steps * remaining_steps;
-    return 255 - (y >> 7);
-  }
-}
-
-// -----------------------------------------------------------------------------
-// Compute the distance the mouse cursor should move in subpixels, return the
-// number of pixels the mouse should move (in active directions), and store the
-// remaining subpixels for the next move.
-uint8_t MouseKeys::cursorDelta() const {
-  // When the cursor speed is slow, it can be moving less than one pixel per
-  // update, so we need to calculate movement in "subpixels" and store the
-  // remaining subpixels to add to the next update's movement.
-  static uint8_t subpixel_remainder{0};
-
-  // First, we calculate where we are on the "time" axis of the acceleration
-  // curve, based on the time passed since the first cursor movement key was
-  // pressed.
-  uint8_t accel_step = accelStep();
-
-  // Next, we translate that into a speed scaling factor (from 1-255).  If we
-  // had an FPU, we would do this in floating point, with a scale between 0 and
-  // 1, so this is how we emulate that using only integer (i.e. fixed-point)
-  // arithmetic.
-  uint8_t accel_factor = accelFactor(accel_step);
-
-  // We want the cursor to start out with some minimum speed, otherwise the user
-  // presses a movement key and then waits for a while before the cursor moves
-  // even one pixel.  We need to multiply our speed-scaling factor by the
-  // difference between the starting speed and the full speed, then add the
-  // starting speed (multiplied by the full value of the scaling factor) to get
-  // the current speed.
-  uint8_t max_speed       = settings_.cursor_base_speed;
-  uint8_t min_speed       = settings_.cursor_init_speed;
-  uint8_t speed_range     = max_speed - min_speed;
-  uint16_t subpixel_speed = (speed_range * accel_factor);
-  subpixel_speed += (min_speed * 256);
-
-  // We want to end up with small numbers of pixels, otherwise the speed will be
-  // too fast to be useful.  But we also want to be able to make fine
-  // adjustments to the speed, so `settings_.cursor_base_speed` should be
-  // allowed to have a reasonbly high value, using all eight bits.  This means
-  // that "decimal point" needs to be somewhere in the high byte of this 16-bit
-  // value.  In order to store only eight bits of subpixel remainder, we need to
-  // do a shift first.  This amount is arbitrary, but seems like a reasonable
-  // compromise.
-  subpixel_speed >>= 4;
-
-  // `max_speed` and `accel_factor` can both be up to 255.  So we can't
-  // just multiply by `cursor_update_interval_ without risk of overflow.  The
-  // update interval should be some low number, anyway (8 or less, I think), and
-  // should probably be fixed as a constexpr, so we could just leave it out.
-  subpixel_speed *= cursor_update_interval_;
-
-  // There's no risk of overflow here: (255 * 255) + 255 = 65535
-  subpixel_speed += subpixel_remainder;
-
-  // Set minimum speed
-  subpixel_speed += 64;
-
-  // This shift should be more than eight pixels; a single update of 100 pixels
-  // is a huge jump.  See above.
-  uint8_t pixel_speed = subpixel_speed >> 8;
-  // Truncate to get only lower 8 bits.
-  subpixel_remainder = subpixel_speed;
-  //subpixel_remainder = subpixel_speed - (uint16_t(pixel_speed) << 8);
-  return pixel_speed;
-}
-
-// -----------------------------------------------------------------------------
-// Wheel speed should be controlled by changing the update interval, not by
-// setting `wheel_speed_`.
-void MouseKeys::sendMouseWheelReport() const {
-  int8_t dh = 0;
-  int8_t dv = 0;
 
+  int8_t vx         = 0;
+  int8_t vy         = 0;
   uint8_t direction = directions_ >> wheel_offset_;
 
   if (direction != 0) {
     // Horizontal scroll wheel:
     if (direction & KEY_MOUSE_LEFT)
-      dh -= 1;
+      vx -= wheelSpeed;
     if (direction & KEY_MOUSE_RIGHT)
-      dh += 1;
+      vx += wheelSpeed;
     // Vertical scroll wheel (note coordinates are opposite movement):
     if (direction & KEY_MOUSE_UP)
-      dv += 1;
+      vy += wheelSpeed;
     if (direction & KEY_MOUSE_DOWN)
-      dv -= 1;
+      vy -= wheelSpeed;
 
+    // Add scroll wheel changes to HID report.
+    Runtime.hid().mouse().move(0, 0, vy, vx);
     // Send the report.
-    Runtime.hid().mouse().move(0, 0, dv, dh);
     Runtime.hid().mouse().sendReport();
   }
 }

plugins/Kaleidoscope-MouseKeys/src/kaleidoscope/plugin/MouseKeys.h

@@ -1,5 +1,5 @@
 /* Kaleidoscope-MouseKeys - Mouse keys for Kaleidoscope.
- * Copyright (C) 2017-2022  Keyboard.io, Inc.
+ * Copyright (C) 2017-2021  Keyboard.io, Inc.
  *
  * This program is free software: you can redistribute it and/or modify it under
  * the terms of the GNU General Public License as published by the Free Software
@@ -22,113 +22,20 @@
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
 #include "kaleidoscope/key_defs.h"              // for Key
 #include "kaleidoscope/plugin.h"                // for Plugin
-// =============================================================================
-// Deprecated MousKeys code
-#include "kaleidoscope_internal/deprecations.h"  // for DEPRECATED
-
-#define _DEPRECATED_MESSAGE_MOUSEKEYS_SET_SPEED_LIMIT                           \
-  "The `MouseKeys.setSpeedLimit()` function is deprecated.  It no longer has\n" \
-  "any function, and can be safely removed."
-
-#define _DEPRECATED_MESSAGE_MOUSEKEYS_SPEED                                  \
-  "Direct access to the `MouseKeys.speed` variable has been deprecated.\n"   \
-  "Please refer to the MouseKeys documentation for instructions on how to\n" \
-  "configure the plugin.\n"
-
-#define _DEPRECATED_MESSAGE_MOUSEKEYS_SPEED_DELAY                               \
-  "Direct access to the `MouseKeys.speedDelay` variable has been deprecated.\n" \
-  "Please refer to the MouseKeys documentation for instructions on how to\n"    \
-  "configure the plugin.\n"
-
-#define _DEPRECATED_MESSAGE_MOUSEKEYS_ACCEL_SPEED                               \
-  "Direct access to the `MouseKeys.accelSpeed` variable has been deprecated.\n" \
-  "Please refer to the MouseKeys documentation for instructions on how to\n"    \
-  "configure the plugin.\n"
-
-#define _DEPRECATED_MESSAGE_MOUSEKEYS_ACCEL_DELAY                               \
-  "Direct access to the `MouseKeys.accelDelay` variable has been deprecated.\n" \
-  "Please refer to the MouseKeys documentation for instructions on how to\n"    \
-  "configure the plugin.\n"
-
-#define _DEPRECATED_MESSAGE_MOUSEKEYS_WHEEL_SPEED                               \
-  "Direct access to the `MouseKeys.wheelSpeed` variable has been deprecated.\n" \
-  "Please refer to the MouseKeys documentation for instructions on how to\n"    \
-  "configure the plugin.\n"
-
-#define _DEPRECATED_MESSAGE_MOUSEKEYS_WHEEL_DELAY                               \
-  "Direct access to the `MouseKeys.wheelDelay` variable has been deprecated.\n" \
-  "Please refer to the MouseKeys documentation for instructions on how to\n"    \
-  "configure the plugin.\n"
-
 
 namespace kaleidoscope {
 namespace plugin {
 class MouseKeys : public kaleidoscope::Plugin {
  public:
-#ifndef NDEPRECATED
-  DEPRECATED(MOUSEKEYS_SPEED)
   static uint8_t speed;
-  DEPRECATED(MOUSEKEYS_SPEED_DELAY)
   static uint16_t speedDelay;
-  DEPRECATED(MOUSEKEYS_ACCEL_SPEED)
   static uint8_t accelSpeed;
-  DEPRECATED(MOUSEKEYS_ACCEL_DELAY)
   static uint16_t accelDelay;
-  DEPRECATED(MOUSEKEYS_WHEEL_SPEED)
   static uint8_t wheelSpeed;
-  DEPRECATED(MOUSEKEYS_WHEEL_DELAY)
   static uint16_t wheelDelay;
 
-  DEPRECATED(MOUSEKEYS_SET_SPEED_LIMIT)
+  static void setWarpGridSize(uint8_t grid_size);
-  static void setSpeedLimit(uint8_t speed_limit) {}
+  static void setSpeedLimit(uint8_t speed_limit);
-#endif
-
-  void setWarpGridSize(uint8_t grid_size);
-
-  /// Get the current mouse (full) speed setting
-  ///
-  /// This returns the value for full-speed mouse movement (after the initial
-  /// acceleration period), not the current speed of the mouse cursor on screen.
-  /// The value does not have straightforward units, but it is linear.
-  uint8_t getCursorBaseSpeed() const {
-    return settings_.cursor_base_speed;
-  }
-  /// Set the full-speed mouse movement value
-  void setCursorBaseSpeed(uint8_t speed) {
-    settings_.cursor_base_speed = speed;
-  }
-
-  /// Get the initial mouse cursor movement speed setting
-  uint8_t getCursorInitSpeed() const {
-    return settings_.cursor_init_speed;
-  }
-  /// Set the initial mouse cursor movement speed
-  void setCursorInitSpeed(uint8_t speed) {
-    settings_.cursor_init_speed = speed;
-  }
-
-  /// Get the current acceleration window duration
-  uint16_t getCursorAccelDuration() const {
-    return settings_.cursor_accel_duration;
-  }
-  /// Set the acceleration window duration
-  void setCursorAccelDuration(uint16_t duration) {
-    settings_.cursor_accel_duration = duration;
-  }
-
-  /// Get the current mouse wheel update interval
-  ///
-  /// Returns the interval (in milliseconds) between mouse wheel updates while a
-  /// mouse wheel key is active (held).
-  uint8_t getScrollInterval() const {
-    return settings_.wheel_update_interval;
-  }
-  /// Set the current mouse wheel update interval
-  ///
-  /// Sets the wheel update interval to the specified number of milliseconds.
-  void setScrollInterval(uint8_t interval) {
-    settings_.wheel_update_interval = interval;
-  }
 
   EventHandlerResult onSetup();
   EventHandlerResult onNameQuery();
@@ -137,39 +44,20 @@ class MouseKeys : public kaleidoscope::Plugin {
   EventHandlerResult onAddToReport(Key key);
   EventHandlerResult afterReportingState(const KeyEvent &event);
 
-  // ---------------------------------------------------------------------------
-  // Structure for storing all user-configurable settings.
-  struct Settings {
-    uint8_t wheel_update_interval  = 50;
-    uint8_t cursor_init_speed      = 1;
-    uint8_t cursor_base_speed      = 50;
-    uint16_t cursor_accel_duration = 1000;
-  };
-
-  // ---------------------------------------------------------------------------
-  // This lets the MouseKeysConfig plugin access the internal config variables
-  // directly. Mainly useful for calls to `Runtime.storage.get()`/`.put()`.
-  friend class MouseKeysConfig;
-
  private:
-  static constexpr uint8_t cursor_update_interval_ = 4;
+  uint16_t move_start_time_  = 0;
-
+  uint16_t accel_start_time_ = 0;
-  Settings settings_;
+  uint16_t wheel_start_time_ = 0;
-
-  uint16_t cursor_start_time_      = 0;
-  uint8_t last_cursor_update_time_ = 0;
-  uint8_t last_wheel_update_time_  = 0;
 
   // Mouse cursor and wheel movement directions are stored in a single bitfield
   // to save space.  The low four bits are for cursor movement, and the high
   // four are for wheel movement.
   static constexpr uint8_t wheel_offset_ = 4;
   static constexpr uint8_t wheel_mask_   = 0b11110000;
-  static constexpr uint8_t cursor_mask_  = 0b00001111;
+  static constexpr uint8_t move_mask_    = 0b00001111;
-
+  uint8_t directions_                    = 0;
-  uint8_t directions_         = 0;
+  uint8_t pending_directions_            = 0;
-  uint8_t pending_directions_ = 0;
+  uint8_t buttons_                       = 0;
-  uint8_t buttons_            = 0;
 
   bool isMouseKey(const Key &key) const;
   bool isMouseButtonKey(const Key &key) const;
@@ -179,28 +67,11 @@ class MouseKeys : public kaleidoscope::Plugin {
 
   void sendMouseButtonReport() const;
   void sendMouseWarpReport(const KeyEvent &event) const;
-  void sendMouseMoveReport() const;
+  void sendMouseMoveReport();
-  void sendMouseWheelReport() const;
+  void sendMouseWheelReport();
-
-  uint8_t accelStep() const;
-  uint8_t cursorDelta() const;
-};
-
-// =============================================================================
-// Plugin for configuration of MouseKeys via Focus and persistent storage of
-// settins in EEPROM (i.e. Chrysalis).
-class MouseKeysConfig : public Plugin {
- public:
-  EventHandlerResult onSetup();
-  EventHandlerResult onFocusEvent(const char *command);
-
- private:
-  // The base address in persistent storage for configuration data:
-  uint16_t settings_addr_;
 };
 
 }  // namespace plugin
 }  // namespace kaleidoscope
 
 extern kaleidoscope::plugin::MouseKeys MouseKeys;
-extern kaleidoscope::plugin::MouseKeysConfig MouseKeysConfig;

plugins/Kaleidoscope-MouseKeys/src/kaleidoscope/plugin/MouseKeysConfig.cpp

@@ -1,144 +0,0 @@
-/* -*- mode: c++ -*-
- * Kaleidoscope-MouseKeys -- Mouse keys for Kaleidoscope.
- * Copyright (C) 2022  Keyboard.io, Inc
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU General Public License as published by the Free Software
- * Foundation, version 3.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
- * details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "kaleidoscope/plugin/MouseKeys.h"  // IWYU pragma: associated
-
-#include <Arduino.h>                       // for PSTR, strcmp_P, strncmp_P
-#include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
-#include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
-#include <stdint.h>                        // for uint16_t, uint32_t, uint8_t
-
-#include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
-#include "kaleidoscope/device/device.h"         // for VirtualProps::Storage, Base<>::Storage
-#include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult, EventHandlerResult::OK
-
-namespace kaleidoscope {
-namespace plugin {
-
-// =============================================================================
-// MouseKeys configurator
-
-EventHandlerResult MouseKeysConfig::onSetup() {
-  settings_addr_ = ::EEPROMSettings.requestSlice(sizeof(MouseKeys::Settings));
-  uint32_t checker;
-
-  Runtime.storage().get(settings_addr_, checker);
-
-  // If the EEPROM is empty, storre the default settings.
-  if (checker == 0xffffffff) {
-    Runtime.storage().put(settings_addr_, ::MouseKeys.settings_);
-    Runtime.storage().commit();
-  }
-
-  Runtime.storage().get(settings_addr_, ::MouseKeys.settings_);
-  return EventHandlerResult::OK;
-}
-
-// -----------------------------------------------------------------------------
-EventHandlerResult MouseKeysConfig::onFocusEvent(const char *command) {
-  // If the focus command is a request for help, provide the list of valid
-  // commands.
-  if (::Focus.handleHelp(command, PSTR("mousekeys.scroll_interval\n"
-                                       "mousekeys.init_speed\n"
-                                       "mousekeys.base_speed\n"
-                                       "mousekeys.accel_duration")))
-    return EventHandlerResult::OK;
-
-  // The length of the string `mousekeys.`:
-  constexpr uint8_t base_cmd_len = 10;
-
-  // If this is not a MouseKeys command, do nothing.
-  if (strncmp_P(command, PSTR("mousekeys."), base_cmd_len) != 0)
-    return EventHandlerResult::OK;
-  // Otherwise, advance the pointer to the subcommand.
-  command += base_cmd_len;
-
-  enum Command : uint8_t {
-    SCROLL_INTERVAL,
-    INIT_SPEED,
-    BASE_SPEED,
-    ACCEL_DURATION,
-  };
-  Command cmd;
-
-  // Parse the (sub)command.  If it's not a valid command, abort.
-  if (strcmp_P(command, PSTR("scroll_interval")) == 0)
-    cmd = Command::SCROLL_INTERVAL;
-  else if (strcmp_P(command, PSTR("init_speed")) == 0)
-    cmd = Command::INIT_SPEED;
-  else if (strcmp_P(command, PSTR("base_speed")) == 0)
-    cmd = Command::BASE_SPEED;
-  else if (strcmp_P(command, PSTR("accel_duration")) == 0)
-    cmd = Command::ACCEL_DURATION;
-  else
-    return EventHandlerResult::ABORT;
-
-  if (::Focus.isEOL()) {
-    // If there is no argument given, we send back the current value of the
-    // setting that was requested.
-    uint16_t val;
-    switch (cmd) {
-    case Command::SCROLL_INTERVAL:
-      val = ::MouseKeys.getScrollInterval();
-      break;
-    case Command::INIT_SPEED:
-      val = ::MouseKeys.getCursorInitSpeed();
-      break;
-    case Command::BASE_SPEED:
-      val = ::MouseKeys.getCursorBaseSpeed();
-      break;
-    case Command::ACCEL_DURATION:
-      val = ::MouseKeys.getCursorAccelDuration();
-      break;
-    default:
-      return EventHandlerResult::ABORT;
-    }
-    ::Focus.send(val);
-    return EventHandlerResult::EVENT_CONSUMED;
-  } else {
-    // If there is an argument, we read it, then pass it to the corresponding
-    // setter method of MouseKeys.
-    uint16_t arg;
-    ::Focus.read(arg);
-
-    switch (cmd) {
-    case Command::SCROLL_INTERVAL:
-      ::MouseKeys.setScrollInterval(arg);
-      break;
-    case Command::INIT_SPEED:
-      ::MouseKeys.setCursorInitSpeed(arg);
-      break;
-    case Command::BASE_SPEED:
-      ::MouseKeys.setCursorBaseSpeed(arg);
-      break;
-    case Command::ACCEL_DURATION:
-      ::MouseKeys.setCursorAccelDuration(arg);
-      break;
-    }
-  }
-
-  // Update settings stored in EEPROM, and indicate that this Focus event has
-  // been handled successfully.
-  Runtime.storage().put(settings_addr_, ::MouseKeys.settings_);
-  Runtime.storage().commit();
-  return EventHandlerResult::EVENT_CONSUMED;
-}
-
-}  // namespace plugin
-}  // namespace kaleidoscope
-
-kaleidoscope::plugin::MouseKeysConfig MouseKeysConfig;

plugins/Kaleidoscope-MouseKeys/src/kaleidoscope/plugin/mousekeys/MouseWrapper.cpp

@@ -1,5 +1,5 @@
 /* Kaleidoscope-MouseKeys - Mouse keys for Kaleidoscope.
- * Copyright (C) 2017-2022  Keyboard.io, Inc.
+ * Copyright (C) 2017-2018  Keyboard.io, Inc.
  *
  * This program is free software: you can redistribute it and/or modify it under
  * the terms of the GNU General Public License as published by the Free Software
@@ -16,22 +16,27 @@
 
 #include "kaleidoscope/plugin/mousekeys/MouseWrapper.h"
 
-#include <stdint.h>  // for uint16_t, uint8_t
+#include <stdint.h>  // for uint16_t, uint8_t, int8_t
 
 #include "kaleidoscope/Runtime.h"                              // for Runtime, Runtime_
 #include "kaleidoscope/device/device.h"                        // for Base<>::HID, VirtualProps:...
 #include "kaleidoscope/driver/hid/keyboardio/AbsoluteMouse.h"  // for AbsoluteMouse
+#include "kaleidoscope/driver/hid/keyboardio/Mouse.h"          // for Mouse
+#include "kaleidoscope/plugin/mousekeys/MouseWarpModes.h"      // for MOUSE_WARP_GRID_2X2
 
 namespace kaleidoscope {
 namespace plugin {
 namespace mousekeys {
 
-// uint8_t MouseWrapper::warp_grid_size = MOUSE_WARP_GRID_2X2;
+uint8_t MouseWrapper::warp_grid_size = MOUSE_WARP_GRID_2X2;
-// uint16_t MouseWrapper::next_width;
+uint16_t MouseWrapper::next_width;
-// uint16_t MouseWrapper::next_height;
+uint16_t MouseWrapper::next_height;
-// uint16_t MouseWrapper::section_top;
+uint16_t MouseWrapper::section_top;
-// uint16_t MouseWrapper::section_left;
+uint16_t MouseWrapper::section_left;
-// bool MouseWrapper::is_warping;
+bool MouseWrapper::is_warping;
+
+uint8_t MouseWrapper::accel_step;
+uint8_t MouseWrapper::speed_limit = 127;
 
 void MouseWrapper::warpJump(uint16_t left, uint16_t top, uint16_t height, uint16_t width) {
   uint16_t x_center = left + width / 2;
@@ -95,9 +100,52 @@ void MouseWrapper::warp(uint8_t warp_cmd) {
   warpJump(section_left, section_top, next_height, next_width);
 }
 
-}  // namespace mousekeys
+// To approximate a sine wave, this uses two parabolas. Acceleration begins
+// slowly, grows rapidly in the middle, and slows again near the top.
+uint8_t MouseWrapper::acceleration(uint8_t cycles) {
+  if (cycles < 128) {
+    uint16_t c2 = cycles * cycles;
+    return 1 + (c2 >> 7);
+  } else {
+    uint16_t remaining_cycles = 256 - cycles;
+    uint16_t c2               = remaining_cycles * remaining_cycles;
+    return 255 - (c2 >> 7);
+  }
+}
 
-mousekeys::MouseWrapper MouseWrapper;
+void MouseWrapper::move(int8_t x, int8_t y) {
+  int16_t moveX               = 0;
+  int16_t moveY               = 0;
+  static int8_t remainderX    = 0;
+  static int8_t remainderY    = 0;
+  int16_t effectiveSpeedLimit = speed_limit;
+
+  if (x != 0) {
+    moveX = remainderX + (x * acceleration(accel_step));
+    if (moveX > effectiveSpeedLimit)
+      moveX = effectiveSpeedLimit;
+    else if (moveX < -effectiveSpeedLimit)
+      moveX = -effectiveSpeedLimit;
+  }
 
+  if (y != 0) {
+    moveY = remainderY + (y * acceleration(accel_step));
+    if (moveY > effectiveSpeedLimit)
+      moveY = effectiveSpeedLimit;
+    else if (moveY < -effectiveSpeedLimit)
+      moveY = -effectiveSpeedLimit;
+  }
+
+  endWarping();
+  // move by whole pixels, not subpixels
+  Runtime.hid().mouse().move(moveX / subpixels_per_pixel, moveY / subpixels_per_pixel);
+  // save leftover subpixel movements for later
+  remainderX = moveX - moveX / subpixels_per_pixel * subpixels_per_pixel;
+  remainderY = moveY - moveY / subpixels_per_pixel * subpixels_per_pixel;
+}
+
+MouseWrapper wrapper;
+
+}  // namespace mousekeys
 }  // namespace plugin
 }  // namespace kaleidoscope

plugins/Kaleidoscope-MouseKeys/src/kaleidoscope/plugin/mousekeys/MouseWrapper.h

@@ -1,5 +1,5 @@
 /* Kaleidoscope-MouseKeys - Mouse keys for Kaleidoscope.
- * Copyright (C) 2017-2022  Keyboard.io, Inc.
+ * Copyright (C) 2017-2018  Keyboard.io, Inc.
  *
  * This program is free software: you can redistribute it and/or modify it under
  * the terms of the GNU General Public License as published by the Free Software
@@ -16,56 +16,58 @@
 
 #pragma once
 
-#include <stdint.h>  // for uint16_t, uint8_t
+#include <stdint.h>  // for uint16_t, uint8_t, int8_t
-
-#include "kaleidoscope/plugin/mousekeys/MouseWarpModes.h"  // for MOUSE_WARP_GRID_2X2
-
-// Mouse acceleration
-
-namespace kaleidoscope {
-namespace plugin {
 
 // Warping commands
 
-constexpr uint8_t WARP_END   = 1 << 0;
+#define WARP_END   1
-constexpr uint8_t WARP_UP    = 1 << 1;
+#define WARP_UP    2
-constexpr uint8_t WARP_DOWN  = 1 << 2;
+#define WARP_DOWN  4
-constexpr uint8_t WARP_LEFT  = 1 << 3;
+#define WARP_LEFT  8
-constexpr uint8_t WARP_RIGHT = 1 << 4;
+#define WARP_RIGHT 16
 
 // apparently, the mac discards 15% of the value space for mouse movement.
 // need to test this on other platforms
 
-constexpr uint16_t MAX_WARP_WIDTH  = 32767;
+#define MAX_WARP_WIDTH  32767
-constexpr uint16_t MAX_WARP_HEIGHT = 32767;
+#define MAX_WARP_HEIGHT 32767
 
-constexpr uint8_t WARP_ABS_TOP  = 0;
+#define WARP_ABS_TOP    0
-constexpr uint8_t WARP_ABS_LEFT = 0;
+#define WARP_ABS_LEFT   0
 
+// Mouse acceleration
+
+namespace kaleidoscope {
+namespace plugin {
 namespace mousekeys {
 
 class MouseWrapper {
  public:
-  void warp(uint8_t warp_cmd);
+  static void move(int8_t x, int8_t y);
-  void endWarping();
+  static void warp(uint8_t warp_cmd);
 
-  uint8_t warp_grid_size = MOUSE_WARP_GRID_2X2;
+  static uint8_t accel_step;
+  static uint8_t speed_limit;
+  static constexpr uint8_t subpixels_per_pixel = 16;
+  static uint8_t warp_grid_size;
 
  private:
-  uint16_t next_width;
+  static uint16_t next_width;
-  uint16_t next_height;
+  static uint16_t next_height;
-  uint16_t section_top;
+  static uint16_t section_top;
-  uint16_t section_left;
+  static uint16_t section_left;
-  bool is_warping = false;
+  static bool is_warping;
-
+
-  void beginWarping();
+  static uint8_t acceleration(uint8_t cycles);
-  void resetWarping();
+
-  void warpJump(uint16_t left, uint16_t top, uint16_t height, uint16_t width);
+  static void beginWarping();
+  static void endWarping();
+  static void resetWarping();
+  static void warpJump(uint16_t left, uint16_t top, uint16_t height, uint16_t width);
 };
 
-}  // namespace mousekeys
+extern MouseWrapper wrapper;
-
-extern mousekeys::MouseWrapper MouseWrapper;
 
+}  // namespace mousekeys
 }  // namespace plugin
 }  // namespace kaleidoscope

plugins/Kaleidoscope-PersistentLEDMode/src/kaleidoscope/plugin/PersistentLEDMode.cpp

@@ -18,7 +18,7 @@
 
 #include "kaleidoscope/plugin/PersistentLEDMode.h"
 
-#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper
+#include <Arduino.h>                       // for PSTR, strcmp_P, F, __FlashStringHelper
 #include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 #include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
 #include <stdint.h>                        // for uint8_t, uint16_t

plugins/Kaleidoscope-SpaceCadet/README.md

@@ -81,11 +81,7 @@ void setup() {
 
 ##   Plugin methods
 
-The plugin provides two objects, `SpaceCadet` and `SpaceCadetConfig`. The latter
+The plugin provides the `SpaceCadet` object, with the following methods:
-requires the first, and allows configuring some aspects of `SpaceCadet` through
-[Focus][focus].
-
-The `SpaceCadet` object provides the following methods:
 
 ### `.setMap(map)`
 
@@ -114,14 +110,7 @@ The `SpaceCadet` object provides the following methods:
 > timeout setting can be overridden by an individual key in the keymap, but if
 > it is omitted or set to `0` in the key map, the global timeout will be used.
 >
-> Defaults to 200.
+> Defaults to 1000.
-
-### `.getTimeout()`
-
-> Returns the number of milliseconds SpaceCadet will wait before considering a
-> key held in isolation as its secondary role. This returns the *global*
-> setting, as set by `.setTimeout()`. If any key in the mapping set by
-> `.setMap()` has a different timeout, that is not considered here.
 
 ### `.enable()`
 
@@ -131,13 +120,6 @@ The `SpaceCadet` object provides the following methods:
 >
 > The default behavior is `enabled`.
 
-### `.enableWithoutDelay()`
-
-> This method enables the SpaceCadet plugin in "no-delay" mode. In this mode,
-> SpaceCadet immediately sends the primary (modifier) value of the SpaceCadet
-> key when it is pressed. If it is then released before timing out, it sends the
-> alternate "tap" value, replacing the modifier.
-
 ### `.disable()`
 
 > This method disables the SpaceCadet behavior. This is useful for interfacing
@@ -150,11 +132,12 @@ The `SpaceCadet` object provides the following methods:
 > is disabled. This is useful for interfacing with other plugins or macros,
 > especially where SpaceCadet functionality isn't always desired.
 
+### `.enableWithoutDelay()`
 
-### `.activeWithoutDelay()`
+> This method enables the SpaceCadet plugin in "no-delay" mode. In this mode,
-
+> SpaceCadet immediately sends the primary (modifier) value of the SpaceCadet
-> This method returns `true` if SpaceCadet is enabled, and is in "no-delay"
+> key when it is pressed. If it is then released before timing out, it sends the
-> mode, as set by `.enableWithoutDelay()`.
+> alternate "tap" value, replacing the modifier.
 
 ### `Key_SpaceCadetEnable`
 
@@ -168,38 +151,10 @@ The `SpaceCadet` object provides the following methods:
 > behavior. This is only triggered on initial press, and does not
 > trigger again if held down or when the key is released.
 
-## Focus commands
-
-When using the `SpaceCadetConfig` plugin, the following Focus commands become
-available:
-
-### `spacecadet.mode`
-
-> Without arguments, returns the mode SpaceCadet is currently in, as a number.
-> When `SpaceCadet` is enabled in normal mode, this returns 0. When it is turned
-> off, it returns 1. When it is active in no-delay mode, it returns 2.
->
-> When an argument is supplied, it must be one of the above, and will set the
-> SpaceCadet mode appropriately. Giving a numeric argument other than the
-> allowed ones will disable SpaceCadet.
-
-### `spacecadet.timeout`
-
-> Without arguments, prints the global timeout used by SpaceCadet.
->
-> When an argument is given, it sets the global timeout.
-
 ## Dependencies
 
 * [Kaleidoscope-Ranges](Kaleidoscope-Ranges.md)
 
-### Optional dependencies, if using the `SpaceCadetConfig` object
-
-* [Kaleidoscope-EEPROM-Settings](Kaleidoscope-EEPROM-Settings.md)
-* [Kaleidoscope-FocusSerial][focus]
-
- [focus]: Kaleidoscope-FocusSerial.md
-
 ## Further reading
 
 Starting from the [example][plugin:example] is the recommended way of getting

plugins/Kaleidoscope-SpaceCadet/src/kaleidoscope/plugin/SpaceCadet.cpp

@@ -42,6 +42,17 @@ SpaceCadet::KeyBinding::KeyBinding(Key input, Key output)
 SpaceCadet::KeyBinding::KeyBinding(Key input, Key output, uint16_t timeout)
   : input(input), output(output), timeout(timeout) {}
 
+// =============================================================================
+// Space Cadet class variables
+
+// -----------------------------------------------------------------------------
+// Plugin configuration variables
+
+#ifndef NDEPRECATED
+SpaceCadet::KeyBinding *SpaceCadet::map;
+uint16_t SpaceCadet::time_out = 200;
+#endif
+
 // =============================================================================
 // SpaceCadet functions
 
@@ -102,7 +113,7 @@ EventHandlerResult SpaceCadet::onKeyswitchEvent(KeyEvent &event) {
   }
 
   // Do nothing if disabled, but keep the event tracker current.
-  if (settings_.mode == Mode::OFF)
+  if (mode_ == Mode::OFF)
     return EventHandlerResult::OK;
 
   if (!event_queue_.isEmpty()) {
@@ -133,7 +144,7 @@ EventHandlerResult SpaceCadet::onKeyswitchEvent(KeyEvent &event) {
       // A SpaceCadet key has just toggled on. First, if we're in no-delay mode,
       // we need to send the event unchanged (with the primary `Key` value),
       // bypassing other `onKeyswitchEvent()` handlers.
-      if (settings_.mode == Mode::NO_DELAY)
+      if (mode_ == Mode::NO_DELAY)
         Runtime.handleKeyEvent(event);
       // Queue the press event and abort; this press event will be resolved
       // later.
@@ -151,10 +162,17 @@ EventHandlerResult SpaceCadet::afterEachCycle() {
   if (event_queue_.isEmpty())
     return EventHandlerResult::OK;
 
-  // Get timeout value for the pending key.
+    // Get timeout value for the pending key.
-  uint16_t pending_timeout = settings_.timeout;
+#ifndef NDEPRECATED
-  if (map_[pending_map_index_].timeout != 0)
+#pragma GCC diagnostic push
-    pending_timeout = map_[pending_map_index_].timeout;
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+  uint16_t pending_timeout = time_out;
+#pragma GCC diagnostic pop
+#else
+  uint16_t pending_timeout = timeout_;
+#endif
+  if (map[pending_map_index_].timeout != 0)
+    pending_timeout = map[pending_map_index_].timeout;
   uint16_t start_time = event_queue_.timestamp(0);
 
   if (Runtime.hasTimeExpired(start_time, pending_timeout)) {
@@ -168,8 +186,8 @@ EventHandlerResult SpaceCadet::afterEachCycle() {
 // Private helper function(s)
 
 int8_t SpaceCadet::getSpaceCadetKeyIndex(Key key) const {
-  for (uint8_t i = 0; !map_[i].isEmpty(); ++i) {
+  for (uint8_t i = 0; !map[i].isEmpty(); ++i) {
-    if (map_[i].input == key) {
+    if (map[i].input == key) {
       return i;
     }
   }
@@ -187,13 +205,13 @@ void SpaceCadet::flushEvent(bool is_tap) {
   if (is_tap && pending_map_index_ >= 0) {
     // If we're in no-delay mode, we should first send the release of the
     // modifier key as a courtesy before sending the tap event.
-    if (settings_.mode == Mode::NO_DELAY) {
+    if (mode_ == Mode::NO_DELAY) {
       Runtime.handleKeyEvent(KeyEvent(event.addr, WAS_PRESSED));
     }
-    event.key = map_[pending_map_index_].output;
+    event.key = map[pending_map_index_].output;
   }
   event_queue_.shift();
-  Runtime.handleKeyEvent(event);
+  Runtime.handleKeyswitchEvent(event);
 }
 
 }  // namespace plugin

plugins/Kaleidoscope-SpaceCadet/src/kaleidoscope/plugin/SpaceCadet.h

@@ -1,7 +1,7 @@
 /* -*- mode: c++ -*-
  * Kaleidoscope-SpaceCadet -- Space Cadet Shift Extended
  * Copyright (C) 2016, 2017, 2018  Keyboard.io, Inc, Ben Gemperline
- * Copyright (C) 2019-2022  Keyboard.io, Inc
+ * Copyright (C) 2019-2021  Keyboard.io, Inc
  *
  * This program is free software: you can redistribute it and/or modify it under
  * the terms of the GNU General Public License as published by the Free Software
@@ -27,6 +27,15 @@
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
 #include "kaleidoscope/key_defs.h"              // for Key, Key_NoKey
 #include "kaleidoscope/plugin.h"                // for Plugin
+// -----------------------------------------------------------------------------
+// Deprecation warning messages
+#include "kaleidoscope_internal/deprecations.h"  // for DEPRECATED
+
+#define _DEPRECATED_MESSAGE_SPACECADET_TIME_OUT                        \
+  "The `SpaceCadet.time_out` variable is deprecated. Please use the\n" \
+  "`SpaceCadet.setTimeout()` function instead.\n"                      \
+  "This variable will be removed after 2022-09-01."
+// -----------------------------------------------------------------------------
 
 #ifndef SPACECADET_MAP_END
 #define SPACECADET_MAP_END \
@@ -39,11 +48,7 @@ constexpr Key Key_SpaceCadetDisable = Key(kaleidoscope::ranges::SC_LAST);
 namespace kaleidoscope {
 namespace plugin {
 
-class SpaceCadetConfig;
-
 class SpaceCadet : public kaleidoscope::Plugin {
-  friend class SpaceCadetConfig;
-
  public:
   // Internal Class
   // Declarations for the modifier key mapping
@@ -71,53 +76,61 @@ class SpaceCadet : public kaleidoscope::Plugin {
 
   // Methods
   void enable() {
-    settings_.mode = Mode::ON;
+    mode_ = Mode::ON;
   }
   void disable() {
-    settings_.mode = Mode::OFF;
+    mode_ = Mode::OFF;
   }
   void enableWithoutDelay() {
-    settings_.mode = Mode::NO_DELAY;
+    mode_ = Mode::NO_DELAY;
   }
   bool active() {
-    return (settings_.mode == Mode::ON || settings_.mode == Mode::NO_DELAY);
+    return (mode_ == Mode::ON || mode_ == Mode::NO_DELAY);
-  }
-  bool activeWithoutDelay() {
-    return settings_.mode == Mode::NO_DELAY;
   }
 
-  void setTimeout(uint16_t timeout) {
+#ifndef NDEPRECATED
-    settings_.timeout = timeout;
+  // Publically accessible variables
-  }
+  DEPRECATED(SPACECADET_TIME_OUT)
+  static uint16_t time_out;            //  The global timeout in milliseconds
+  static SpaceCadet::KeyBinding *map;  // The map of key bindings
+#endif
 
-  uint16_t getTimeout() {
+  void setTimeout(uint16_t timeout) {
-    return settings_.timeout;
+#ifndef NDEPRECATED
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+    time_out = timeout;
+#pragma GCC diagnostic pop
+#else
+    timeout_ = timeout;
+#endif
   }
 
   void setMap(KeyBinding *bindings) {
-    map_ = bindings;
+    map = bindings;
   }
 
   EventHandlerResult onNameQuery();
   EventHandlerResult onKeyswitchEvent(KeyEvent &event);
   EventHandlerResult afterEachCycle();
 
- protected:
+ private:
   enum Mode : uint8_t {
     ON,
     OFF,
     NO_DELAY,
   };
-  struct {
+  uint8_t mode_;
-    Mode mode;
 
-    // Global timeout in milliseconds
+#ifdef NDEPRECATED
-    uint16_t timeout = 200;
+  // Global timeout in milliseconds
-  } settings_;
+  uint16_t timeout_ = 200;
 
- private:
   // The map of keybindings
-  KeyBinding *map_ = nullptr;
+  KeyBinding *map = nullptr;
+  // When DEPRECATED public `map[]` variable is removed, this variable name
+  // should be given a trailing underscore to conform to code style guide.
+#endif
 
   KeyEventTracker event_tracker_;
 
@@ -139,23 +152,7 @@ class SpaceCadet : public kaleidoscope::Plugin {
   void flushQueue();
 };
 
-class SpaceCadetConfig : public kaleidoscope::Plugin {
- public:
-  EventHandlerResult onSetup();
-  EventHandlerResult onFocusEvent(const char *input);
-
-  void disableSpaceCadetIfUnconfigured();
-
- private:
-  struct Settings {
-    SpaceCadet::Mode mode;
-    uint16_t timeout;
-  };
-  uint16_t settings_base_;
-};
-
 }  // namespace plugin
 }  // namespace kaleidoscope
 
 extern kaleidoscope::plugin::SpaceCadet SpaceCadet;
-extern kaleidoscope::plugin::SpaceCadetConfig SpaceCadetConfig;

plugins/Kaleidoscope-SpaceCadet/src/kaleidoscope/plugin/SpaceCadetConfig.cpp

@@ -1,98 +0,0 @@
-/* -*- mode: c++ -*-
- * Kaleidoscope-SpaceCadet -- Space Cadet Shift Extended
- * Copyright (C) 2016, 2017, 2018  Keyboard.io, Inc, Ben Gemperline
- * Copyright (C) 2019-2021  Keyboard.io, Inc.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU General Public License as published by the Free Software
- * Foundation, version 3.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
- * details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "SpaceCadet.h"
-#include "kaleidoscope/plugin/SpaceCadet.h"
-
-#include <Arduino.h>                       // for PSTR
-#include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
-#include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
-#include <stdint.h>                        // for uint16_t, int8_t, uint8_t
-
-#include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
-#include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult, EventHandlerResult::OK
-
-namespace kaleidoscope {
-namespace plugin {
-
-EventHandlerResult SpaceCadetConfig::onSetup() {
-  settings_base_ = ::EEPROMSettings.requestSlice(sizeof(SpaceCadet::settings_));
-
-  // If our slice is uninitialized, then return early.
-  if (Runtime.storage().isSliceUninitialized(settings_base_, sizeof(SpaceCadet::settings_)))
-    return EventHandlerResult::OK;
-
-  Runtime.storage().get(settings_base_, ::SpaceCadet.settings_);
-
-  return EventHandlerResult::OK;
-}
-
-void SpaceCadetConfig::disableSpaceCadetIfUnconfigured() {
-  if (Runtime.storage().isSliceUninitialized(settings_base_, sizeof(SpaceCadet::settings_)))
-    ::SpaceCadet.disable();
-}
-
-EventHandlerResult SpaceCadetConfig::onFocusEvent(const char *input) {
-  const char *cmd_mode    = PSTR("spacecadet.mode");
-  const char *cmd_timeout = PSTR("spacecadet.timeout");
-
-  if (::Focus.inputMatchesHelp(input))
-    return ::Focus.printHelp(cmd_mode, cmd_timeout);
-
-  if (::Focus.inputMatchesCommand(input, cmd_mode)) {
-    if (::Focus.isEOL()) {
-      ::Focus.send(::SpaceCadet.settings_.mode);
-    } else {
-      uint8_t mode;
-      ::Focus.read(mode);
-      switch (mode) {
-      case SpaceCadet::Mode::ON:
-        ::SpaceCadet.settings_.mode = SpaceCadet::Mode::ON;
-        break;
-      case SpaceCadet::Mode::NO_DELAY:
-        ::SpaceCadet.settings_.mode = SpaceCadet::Mode::NO_DELAY;
-        break;
-      case SpaceCadet::Mode::OFF:
-      default:
-        ::SpaceCadet.settings_.mode = SpaceCadet::Mode::OFF;
-        break;
-      }
-
-      Runtime.storage().put(settings_base_, ::SpaceCadet.settings_);
-      Runtime.storage().commit();
-    }
-  } else if (::Focus.inputMatchesCommand(input, cmd_timeout)) {
-    if (::Focus.isEOL()) {
-      ::Focus.send(::SpaceCadet.settings_.timeout);
-    } else {
-      ::Focus.read(::SpaceCadet.settings_.timeout);
-
-      Runtime.storage().put(settings_base_, ::SpaceCadet.settings_);
-      Runtime.storage().commit();
-    }
-  } else {
-    return EventHandlerResult::OK;
-  }
-
-  return EventHandlerResult::EVENT_CONSUMED;
-}
-
-}  // namespace plugin
-}  // namespace kaleidoscope
-
-kaleidoscope::plugin::SpaceCadetConfig SpaceCadetConfig;

plugins/Kaleidoscope-TypingBreaks/README.md

@@ -96,18 +96,6 @@ properties. All times are in seconds.
 
 > Get or set the `.settings.right_hand_max_keys` property.
 
-### `typingbreaks.leftKeys`
-
-> Get the current counter of keys pressed on the left half of the keyboard.
-
-### `typingbreaks.rightKeys`
-
-> Get the current counter of keys pressed on the right half of the keyboard.
-
-### `typingbreaks.lockSecsRemaining`
-
-> Get the duration the keyboard remains locked in seconds.
-
 ## Dependencies
 
 * [Kaleidoscope-EEPROM-Settings](Kaleidoscope-EEPROM-Settings.md)

plugins/Kaleidoscope-TypingBreaks/src/kaleidoscope/plugin/TypingBreaks.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/TypingBreaks.h"
 
-#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper
+#include <Arduino.h>                       // for PSTR, strcmp_P, F, __FlashStringHelper
 #include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 #include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
 #include <stdint.h>                        // for uint32_t, uint16_t
@@ -103,7 +103,7 @@ EventHandlerResult TypingBreaks::onKeyEvent(KeyEvent &event) {
 
   // So it seems we did not need to lock up. In this case, lets increase key
   // counters if need be.
-  if (event.addr.col() < Runtime.device().matrix_columns / 2)
+  if (event.addr.col() <= Runtime.device().matrix_columns / 2)
     left_hand_keys_++;
   else
     right_hand_keys_++;
@@ -132,52 +132,41 @@ EventHandlerResult TypingBreaks::onSetup() {
   return EventHandlerResult::OK;
 }
 
-EventHandlerResult TypingBreaks::onFocusEvent(const char *input) {
+#define FOCUS_HOOK_TYPINGBREAKS FOCUS_HOOK(TypingBreaks.focusHook,          \
+                                           "typingbreaks.idleTimeLimit\r\n" \
+                                           "typingbreaks.lockTimeOut\r\n"   \
+                                           "typingbreaks.lockLength\r\n"    \
+                                           "typingbreaks.leftMaxKeys\r\n"   \
+                                           "typingbreaks.rightMaxKeys")
+
+EventHandlerResult TypingBreaks::onFocusEvent(const char *command) {
   enum {
     IDLE_TIME_LIMIT,
     LOCK_TIMEOUT,
     LOCK_LENGTH,
     LEFT_MAX,
     RIGHT_MAX,
-    LEFT_COUNT,
-    RIGHT_COUNT,
-    LOCK_SECS_REMAINING,
   } subCommand;
 
-  const char *cmd_idleTimeLimit = PSTR("typingbreaks.idleTimeLimit");
+  if (::Focus.handleHelp(command, PSTR("typingbreaks.idleTimeLimit\r\n"
-  const char *cmd_lockTimeOut   = PSTR("typingbreaks.lockTimeOut");
+                                       "typingbreaks.lockTimeOut\r\n"
-  const char *cmd_lockLength    = PSTR("typingbreaks.lockLength");
+                                       "typingbreaks.lockLength\r\n"
-  const char *cmd_leftMaxKeys   = PSTR("typingbreaks.leftMaxKeys");
+                                       "typingbreaks.leftMaxKeys\r\n"
-  const char *cmd_rightMaxKeys  = PSTR("typingbreaks.rightMaxKeys");
+                                       "typingbreaks.rightMaxKeys")))
-  const char *cmd_leftKeys      = PSTR("typingbreaks.leftKeys");
+    return EventHandlerResult::OK;
-  const char *cmd_rightKeys     = PSTR("typingbreaks.rightKeys");
+
-  const char *cmd_lockSecsRem   = PSTR("typingbreaks.lockSecsRemaining");
+  if (strncmp_P(command, PSTR("typingbreaks."), 13) != 0)
-  if (::Focus.inputMatchesHelp(input))
+    return EventHandlerResult::OK;
-    return ::Focus.printHelp(cmd_idleTimeLimit,
+  if (strcmp_P(command + 13, PSTR("idleTimeLimit")) == 0)
-                             cmd_lockTimeOut,
-                             cmd_lockLength,
-                             cmd_leftMaxKeys,
-                             cmd_rightMaxKeys,
-                             cmd_leftKeys,
-                             cmd_rightKeys,
-                             cmd_lockSecsRem);
-
-  if (::Focus.inputMatchesCommand(input, cmd_idleTimeLimit))
     subCommand = IDLE_TIME_LIMIT;
-  else if (::Focus.inputMatchesCommand(input, cmd_lockTimeOut))
+  else if (strcmp_P(command + 13, PSTR("lockTimeOut")) == 0)
     subCommand = LOCK_TIMEOUT;
-  else if (::Focus.inputMatchesCommand(input, cmd_lockLength))
+  else if (strcmp_P(command + 13, PSTR("lockLength")) == 0)
     subCommand = LOCK_LENGTH;
-  else if (::Focus.inputMatchesCommand(input, cmd_leftMaxKeys))
+  else if (strcmp_P(command + 13, PSTR("leftMaxKeys")) == 0)
     subCommand = LEFT_MAX;
-  else if (::Focus.inputMatchesCommand(input, cmd_rightMaxKeys))
+  else if (strcmp_P(command + 13, PSTR("rightMaxKeys")) == 0)
     subCommand = RIGHT_MAX;
-  else if (::Focus.inputMatchesCommand(input, cmd_leftKeys))
-    subCommand = LEFT_COUNT;
-  else if (::Focus.inputMatchesCommand(input, cmd_rightKeys))
-    subCommand = RIGHT_COUNT;
-  else if (::Focus.inputMatchesCommand(input, cmd_lockSecsRem))
-    subCommand = LOCK_SECS_REMAINING;
   else
     return EventHandlerResult::OK;
 
@@ -217,21 +206,6 @@ EventHandlerResult TypingBreaks::onFocusEvent(const char *input) {
       ::Focus.read(settings.right_hand_max_keys);
     }
     break;
-  case LEFT_COUNT:
-    ::Focus.send(left_hand_keys_);
-    return EventHandlerResult::EVENT_CONSUMED;
-  case RIGHT_COUNT:
-    ::Focus.send(right_hand_keys_);
-    return EventHandlerResult::EVENT_CONSUMED;
-  case LOCK_SECS_REMAINING:
-    if (keyboard_locked_) {
-      uint16_t elapsed   = Runtime.millisAtCycleStart() / 1000 - lock_start_time_ / 1000;
-      uint16_t remaining = settings.lock_length - elapsed;
-      ::Focus.send(remaining);
-    } else {
-      ::Focus.send(0);
-    }
-    return EventHandlerResult::EVENT_CONSUMED;
   }
 
   Runtime.storage().put(settings_base_, settings);

plugins/Kaleidoscope-TypingBreaks/src/kaleidoscope/plugin/TypingBreaks.h

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

src/kaleidoscope/Runtime.h

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

src/kaleidoscope/event_handlers.h

@@ -199,8 +199,8 @@ class SignatureCheckDummy {};
              _CURRENT_IMPLEMENTATION,                                     __NL__ \
                 _ABORTABLE,                                               __NL__ \
                 (),(),(), /* non template */                              __NL__ \
-                (const char *input),                                      __NL__ \
+                (const char *command),                                    __NL__ \
-                (input), ##__VA_ARGS__)                                   __NL__ \
+                (command), ##__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__ \

src/kaleidoscope/plugin/LEDControl.cpp

@@ -16,7 +16,7 @@
 
 #include "kaleidoscope/plugin/LEDControl.h"
 
-#include <Arduino.h>                   // for PSTR, strncmp_P
+#include <Arduino.h>                   // for PSTR, strcmp_P, strncmp_P
 #include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
 
 #include "kaleidoscope/KeyAddrMap.h"               // for KeyAddrMap<>::Iterator, KeyAddrMap
@@ -212,7 +212,7 @@ EventHandlerResult LEDControl::afterEachCycle() {
   return EventHandlerResult::OK;
 }
 
-EventHandlerResult FocusLEDCommand::onFocusEvent(const char *input) {
+EventHandlerResult FocusLEDCommand::onFocusEvent(const char *command) {
   enum {
     SETALL,
     MODE,
@@ -224,28 +224,24 @@ EventHandlerResult FocusLEDCommand::onFocusEvent(const char *input) {
   if (!Runtime.has_leds)
     return EventHandlerResult::OK;
 
-  const char *cmd_at         = PSTR("led.at");
+  if (::Focus.handleHelp(command, PSTR("led.at\r\n"
-  const char *cmd_setAll     = PSTR("led.setAll");
+                                       "led.setAll\r\n"
-  const char *cmd_mode       = PSTR("led.mode");
+                                       "led.mode\r\n"
-  const char *cmd_brightness = PSTR("led.brightness");
+                                       "led.brightness\r\n"
-  const char *cmd_theme      = PSTR("led.theme");
+                                       "led.theme")))
-
+    return EventHandlerResult::OK;
-  if (::Focus.inputMatchesHelp(input))
-    return ::Focus.printHelp(cmd_at,
-                             cmd_setAll,
-                             cmd_mode,
-                             cmd_brightness,
-                             cmd_theme);
 
-  if (::Focus.inputMatchesCommand(input, cmd_at))
+  if (strncmp_P(command, PSTR("led."), 4) != 0)
+    return EventHandlerResult::OK;
+  if (strcmp_P(command + 4, PSTR("at")) == 0)
     subCommand = AT;
-  else if (::Focus.inputMatchesCommand(input, cmd_setAll))
+  else if (strcmp_P(command + 4, PSTR("setAll")) == 0)
     subCommand = SETALL;
-  else if (::Focus.inputMatchesCommand(input, cmd_mode))
+  else if (strcmp_P(command + 4, PSTR("mode")) == 0)
     subCommand = MODE;
-  else if (::Focus.inputMatchesCommand(input, cmd_theme))
+  else if (strcmp_P(command + 4, PSTR("theme")) == 0)
     subCommand = THEME;
-  else if (::Focus.inputMatchesCommand(input, cmd_brightness))
+  else if (strcmp_P(command + 4, PSTR("brightness")) == 0)
     subCommand = BRIGHTNESS;
   else
     return EventHandlerResult::OK;

src/kaleidoscope/plugin/LEDControl.h

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

tests/plugins/MouseKeys/basic/basic.ino

@@ -42,8 +42,6 @@ KALEIDOSCOPE_INIT_PLUGINS(MouseKeys);
 
 void setup() {
   Kaleidoscope.setup();
-
-  MouseKeys.setCursorAccelDuration(200);
 }
 
 void loop() {

tests/plugins/MouseKeys/basic/test.ktest

@@ -21,33 +21,15 @@ RUN 3 ms
 PRESS MOVE_UP
 RUN 1 cycle
 
-RUN 4 ms
+RUN 15 ms
-EXPECT mouse-report y=-1
-RUN 8 ms
-EXPECT mouse-report y=-1
-RUN 8 ms
-EXPECT mouse-report y=-1
-RUN 4 ms
 EXPECT mouse-report y=-1
-RUN 4 ms
+RUN 1 cycle
-EXPECT mouse-report y=-1
+
-RUN 4 ms
+RUN 15 ms
-EXPECT mouse-report y=-1
-RUN 4 ms
 EXPECT mouse-report y=-1
-RUN 4 ms
+RUN 1 cycle
-EXPECT mouse-report y=-2
-RUN 4 ms
-EXPECT mouse-report y=-2
-RUN 4 ms
-EXPECT mouse-report y=-2
-RUN 4 ms
-EXPECT mouse-report y=-2
-RUN 4 ms
-EXPECT mouse-report y=-2
-RUN 4 ms
-EXPECT mouse-report y=-3
 
+RUN 5 ms
 RELEASE MOVE_UP
 RUN 1 cycle
 EXPECT no mouse-report

tests/plugins/SpaceCadet/basic/basic.ino

@@ -59,8 +59,8 @@ void setup() {
     SPACECADET_MAP_END
   };
   //Set the map.
-  SpaceCadet.setMap(spacecadetmap);
+  SpaceCadet.map = spacecadetmap;
-  SpaceCadet.setTimeout(20);
+  SpaceCadet.time_out = 20;
 }
 
 void loop() {

tests/plugins/SpaceCadet/no-delay/no-delay.ino

@@ -57,8 +57,8 @@ void setup() {
     SPACECADET_MAP_END
   };
   //Set the map.
-  SpaceCadet.setMap(spacecadetmap);
+  SpaceCadet.map = spacecadetmap;
-  SpaceCadet.setTimeout(20);
+  SpaceCadet.time_out = 20;
 
   SpaceCadet.enableWithoutDelay();
 }