Format codebase with `clang-format`

Signed-off-by: Michael Richters <gedankenexperimenter@gmail.com>

examples/Features/AppSwitcher/AppSwitcher.cpp

@@ -64,16 +64,16 @@ EventHandlerResult AppSwitcher::onKeyEvent(KeyEvent &event) {
     // have any effect. Then we turn the event for that key's press into an
     // event for the release of the AppSwitcher's modifier key.
     live_keys.mask(event.addr);
-    event.addr = active_addr_;
+    event.addr  = active_addr_;
     event.state = WAS_PRESSED | INJECTED;
-    event.key = live_keys[event.addr];
+    event.key   = live_keys[event.addr];
     // Turn off AppSwitcher:
     active_addr_.clear();
   }
   return EventHandlerResult::OK;
 }
 
-} // namespace plugin
+}  // namespace plugin
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 kaleidoscope::plugin::AppSwitcher AppSwitcher;

examples/Features/AppSwitcher/AppSwitcher.h

@@ -34,10 +34,9 @@ class AppSwitcher : public kaleidoscope::Plugin {
 
  private:
   KeyAddr active_addr_ = KeyAddr::none();
-
 };
 
-} // namespace plugin
+}  // namespace plugin
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 extern kaleidoscope::plugin::AppSwitcher AppSwitcher;

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

@@ -34,8 +34,8 @@ namespace plugin {
 
 // Configuration settings that can be saved to persistent storage.
 AutoShift::Settings AutoShift::settings_ = {
-  .enabled = true,
+  .enabled            = true,
-  .timeout = 175,
+  .timeout            = 175,
   .enabled_categories = AutoShift::Categories::printableKeys(),
 };
 
@@ -62,8 +62,7 @@ void AutoShift::disable() {
 // -----------------------------------------------------------------------------
 // Test for whether or not to apply AutoShift to a given `Key`.  This function
 // can be overridden from the user sketch.
-__attribute__((weak))
+__attribute__((weak)) bool AutoShift::isAutoShiftable(Key key) {
-bool AutoShift::isAutoShiftable(Key key) {
   return enabledForKey(key);
 }
 
@@ -207,7 +206,7 @@ void AutoShift::flushEvent(bool is_long_press) {
     return;
   KeyEvent event = queue_.event(0);
   if (is_long_press) {
-    event.key = Runtime.lookupKey(event.addr);
+    event.key     = Runtime.lookupKey(event.addr);
     uint8_t flags = event.key.getFlags();
     flags ^= SHIFT_HELD;
     event.key.setFlags(flags);
@@ -216,7 +215,7 @@ void AutoShift::flushEvent(bool is_long_press) {
   Runtime.handleKeyswitchEvent(event);
 }
 
-} // namespace plugin
+}  // namespace plugin
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 kaleidoscope::plugin::AutoShift AutoShift;

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <stdint.h>                             // for uint8_t, uint16_t
+#include <stdint.h>  // for uint8_t, uint16_t
 
 #include "kaleidoscope/KeyAddrEventQueue.h"     // for KeyAddrEventQueue
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
@@ -63,16 +63,17 @@ class AutoShift : public Plugin {
     uint8_t raw_bits_{0};
 
     // constants for bits in the `raw_bits_` bitfield
-    static constexpr uint8_t LETTERS    = 1 << 0;
+    static constexpr uint8_t LETTERS   = 1 << 0;
-    static constexpr uint8_t NUMBERS    = 1 << 1;
+    static constexpr uint8_t NUMBERS   = 1 << 1;
-    static constexpr uint8_t SYMBOLS    = 1 << 2;
+    static constexpr uint8_t SYMBOLS   = 1 << 2;
-    static constexpr uint8_t ARROWS     = 1 << 3;
+    static constexpr uint8_t ARROWS    = 1 << 3;
-    static constexpr uint8_t FUNCTIONS  = 1 << 4;
+    static constexpr uint8_t FUNCTIONS = 1 << 4;
-    static constexpr uint8_t ALL        = 1 << 7;
+    static constexpr uint8_t ALL       = 1 << 7;
 
    public:
     // Basic un-checked constructor
-    constexpr Categories(uint8_t raw_bits) : raw_bits_(raw_bits) {}
+    constexpr Categories(uint8_t raw_bits)
+      : raw_bits_(raw_bits) {}
 
     static constexpr Categories letterKeys() {
       return Categories(LETTERS);
@@ -276,8 +277,8 @@ class AutoShiftConfig : public Plugin {
   static uint16_t settings_base_;
 };
 
-} // namespace plugin
+}  // namespace plugin
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 extern kaleidoscope::plugin::AutoShift AutoShift;
 extern kaleidoscope::plugin::AutoShiftConfig AutoShiftConfig;

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

@@ -17,10 +17,10 @@
 
 #include "kaleidoscope/plugin/AutoShift.h"  // IWYU pragma: associated
 
-#include <Arduino.h>                              // for PSTR, strcmp_P, str...
+#include <Arduino.h>                       // for PSTR, strcmp_P, str...
-#include <Kaleidoscope-EEPROM-Settings.h>         // for EEPROMSettings
+#include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
-#include <Kaleidoscope-FocusSerial.h>             // for Focus, FocusSerial
+#include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
-#include <stdint.h>                               // for uint16_t, uint8_t
+#include <stdint.h>                        // for uint16_t, uint8_t
 
 #include "kaleidoscope/Runtime.h"                 // for Runtime, Runtime_
 #include "kaleidoscope/device/Base.h"             // for Base<>::Storage
@@ -118,7 +118,7 @@ EventHandlerResult AutoShiftConfig::onFocusEvent(const char *command) {
   return EventHandlerResult::EVENT_CONSUMED;
 }
 
-} // namespace plugin
+}  // namespace plugin
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 kaleidoscope::plugin::AutoShiftConfig AutoShiftConfig;

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

@@ -17,9 +17,9 @@
 
 #include "kaleidoscope/plugin/CharShift.h"
 
-#include <Arduino.h>                                      // for F, __FlashS...
+#include <Arduino.h>                   // for F, __FlashS...
-#include <Kaleidoscope-FocusSerial.h>                     // for Focus, Focu...
+#include <Kaleidoscope-FocusSerial.h>  // for Focus, Focu...
-#include <Kaleidoscope-Ranges.h>                          // for CS_FIRST
+#include <Kaleidoscope-Ranges.h>       // for CS_FIRST
 
 #include "kaleidoscope/KeyAddrMap.h"                      // for KeyAddrMap<...
 #include "kaleidoscope/KeyEvent.h"                        // for KeyEvent
@@ -38,7 +38,7 @@ namespace plugin {
 
 // =============================================================================
 // CharShift class variables
-CharShift::KeyPair const * CharShift::progmem_keypairs_{nullptr};
+CharShift::KeyPair const *CharShift::progmem_keypairs_{nullptr};
 uint8_t CharShift::num_keypairs_{0};
 
 bool CharShift::reverse_shift_state_{false};
@@ -131,13 +131,15 @@ CharShift::KeyPair CharShift::decodeCharShiftKey(Key key) {
 
 // This should be overridden if the KeyPairs array is stored in EEPROM
 __attribute__((weak))
-uint8_t CharShift::numKeyPairs() {
+uint8_t
+CharShift::numKeyPairs() {
   return numProgmemKeyPairs();
 }
 
 // This should be overridden if the KeyPairs array is stored in EEPROM
 __attribute__((weak))
-CharShift::KeyPair CharShift::readKeyPair(uint8_t n) {
+CharShift::KeyPair
+CharShift::readKeyPair(uint8_t n) {
   return readKeyPairFromProgmem(n);
 }
 
@@ -149,7 +151,7 @@ CharShift::KeyPair CharShift::readKeyPairFromProgmem(uint8_t n) {
   return cloneFromProgmem(progmem_keypairs_[n]);
 }
 
-} // namespace plugin
+}  // namespace plugin
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 kaleidoscope::plugin::CharShift CharShift;

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

@@ -17,8 +17,8 @@
 
 #pragma once
 
-#include <Kaleidoscope-Ranges.h>                // for CS_FIRST
+#include <Kaleidoscope-Ranges.h>  // for CS_FIRST
-#include <stdint.h>                             // for uint8_t
+#include <stdint.h>               // for uint8_t
 
 #include "Arduino.h"                            // for PROGMEM
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
@@ -59,7 +59,8 @@ class CharShift : public Plugin {
     ///
     /// This constructor is used when defining an array of `KeyPair` objects in
     /// PROGMEM (though it can also be used elsewhere).
-    constexpr KeyPair(Key lower, Key upper) : lower(lower), upper(upper) {}
+    constexpr KeyPair(Key lower, Key upper)
+      : lower(lower), upper(upper) {}
 
     /// Constructor for reading from PROGMEM
     ///
@@ -75,15 +76,15 @@ class CharShift : public Plugin {
   /// `keypairs` array given, which must be a fixed-sized array, not a pointer.
   /// Generally, it will be called via the `KEYPAIRS()` preprocessor macro, not
   /// directly by user code.
-  template <uint8_t _num_keypairs>
+  template<uint8_t _num_keypairs>
-  static void setProgmemKeyPairs(KeyPair const(&keypairs)[_num_keypairs]) {
+  static void setProgmemKeyPairs(KeyPair const (&keypairs)[_num_keypairs]) {
     progmem_keypairs_ = keypairs;
-    num_keypairs_ = _num_keypairs;
+    num_keypairs_     = _num_keypairs;
   }
 
  private:
   // A pointer to an array of `KeyPair` objects in PROGMEM
-  static KeyPair const * progmem_keypairs_;
+  static KeyPair const *progmem_keypairs_;
   // The size of the PROGMEM array of `KeyPair` objects
   static uint8_t num_keypairs_;
 
@@ -114,8 +115,8 @@ class CharShift : public Plugin {
   static KeyPair readKeyPairFromProgmem(uint8_t n);
 };
 
-} // namespace plugin
+}  // namespace plugin
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 extern kaleidoscope::plugin::CharShift CharShift;
 
@@ -125,12 +126,12 @@ extern kaleidoscope::plugin::CharShift CharShift;
 /// defines them as an array in PROGMEM, and configures `CharShift` to use that
 /// array, automatically setting the count correctly to prevent out-of-bounds
 /// lookups.
-#define CS_KEYS(keypairs...) {                                          \
+#define CS_KEYS(keypairs...)                                                     \
+  {                                                                              \
     static kaleidoscope::plugin::CharShift::KeyPair const kp_table[] PROGMEM = { \
-      keypairs                                                          \
+      keypairs};                                                                 \
-    };                                                                  \
+    CharShift.setProgmemKeyPairs(kp_table);                                      \
-    CharShift.setProgmemKeyPairs(kp_table);                             \
+  }
-}
 
 /// Define an `KeyPair` entry in a keymap
 ///

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

@@ -17,10 +17,10 @@
 
 #include "kaleidoscope/plugin/Colormap.h"
 
-#include <Arduino.h>                            // for F, PSTR, __FlashStrin...
+#include <Arduino.h>                         // for F, PSTR, __FlashStrin...
-#include <Kaleidoscope-FocusSerial.h>           // for Focus, FocusSerial
+#include <Kaleidoscope-FocusSerial.h>        // for Focus, FocusSerial
-#include <Kaleidoscope-LED-Palette-Theme.h>     // for LEDPaletteTheme
+#include <Kaleidoscope-LED-Palette-Theme.h>  // for LEDPaletteTheme
-#include <stdint.h>                             // for uint8_t, uint16_t
+#include <stdint.h>                          // for uint8_t, uint16_t
 
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr
 #include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
@@ -40,7 +40,7 @@ void ColormapEffect::max_layers(uint8_t max_) {
     return;
 
   max_layers_ = max_;
-  map_base_ = ::LEDPaletteTheme.reserveThemes(max_layers_);
+  map_base_   = ::LEDPaletteTheme.reserveThemes(max_layers_);
 }
 
 EventHandlerResult ColormapEffect::onNameQuery() {
@@ -68,8 +68,7 @@ EventHandlerResult ColormapEffect::onLayerChange() {
 }
 
 EventHandlerResult ColormapEffect::onFocusEvent(const char *command) {
-  return ::LEDPaletteTheme.themeFocusEvent(command, PSTR("colormap.map"),
+  return ::LEDPaletteTheme.themeFocusEvent(command, PSTR("colormap.map"), map_base_, max_layers_);
-                                           map_base_, max_layers_);
 }
 
 }  // namespace plugin

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <stdint.h>                                      // for uint8_t, uin...
+#include <stdint.h>  // for uint8_t, uin...
 
 #include "kaleidoscope/KeyAddr.h"                        // for KeyAddr
 #include "kaleidoscope/event_handler_result.h"           // for EventHandler...
@@ -29,8 +29,8 @@
 namespace kaleidoscope {
 namespace plugin {
 class ColormapEffect : public Plugin,
-  public LEDModeInterface,
+                       public LEDModeInterface,
-  public AccessTransientLEDMode {
+                       public AccessTransientLEDMode {
  public:
   ColormapEffect(void) {}
 
@@ -44,21 +44,20 @@ class ColormapEffect : public Plugin,
   //
   class TransientLEDMode : public LEDMode {
    public:
-
     // Please note that storing the parent ptr is only required
     // for those LED modes that require access to
     // members of their parent class. Most LED modes can do without.
     //
-    explicit TransientLEDMode(const ColormapEffect *parent) : parent_(parent) {}
+    explicit TransientLEDMode(const ColormapEffect *parent)
+      : parent_(parent) {}
 
    protected:
-
     friend class ColormapEffect;
 
     void onActivate(void) final;
     void refreshAt(KeyAddr key_addr) final;
-   private:
 
+   private:
     const ColormapEffect *parent_;
   };
 

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

@@ -17,10 +17,10 @@
 
 #include "kaleidoscope/plugin/Cycle.h"
 
-#include <Arduino.h>                            // for F, __FlashStringHelper
+#include <Arduino.h>                   // for F, __FlashStringHelper
-#include <Kaleidoscope-FocusSerial.h>           // for Focus, FocusSerial
+#include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
-#include <Kaleidoscope-Ranges.h>                // for CYCLE
+#include <Kaleidoscope-Ranges.h>       // for CYCLE
-#include <stdint.h>                             // for uint8_t
+#include <stdint.h>                    // for uint8_t
 
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr, MatrixAddr
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
@@ -113,8 +113,7 @@ uint8_t Cycle::toModFlag(uint8_t keyCode) {
 }  // namespace plugin
 }  // namespace kaleidoscope
 
-__attribute__((weak))
+__attribute__((weak)) void cycleAction(Key previous_key, uint8_t cycle_count) {
-void cycleAction(Key previous_key, uint8_t cycle_count) {
 }
 
 kaleidoscope::plugin::Cycle Cycle;

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

@@ -17,8 +17,8 @@
 
 #pragma once
 
-#include <Kaleidoscope-Ranges.h>                // for CYCLE
+#include <Kaleidoscope-Ranges.h>  // for CYCLE
-#include <stdint.h>                             // for uint8_t
+#include <stdint.h>               // for uint8_t
 
 #include "Arduino.h"                            // for PROGMEM
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr
@@ -29,10 +29,10 @@
 
 constexpr Key Key_Cycle = Key(kaleidoscope::ranges::CYCLE);
 
-#define cycleThrough(...) ({                                \
+#define cycleThrough(...) ({                         \
-      static const Key __k[] PROGMEM = { __VA_ARGS__ };     \
+  static const Key __k[] PROGMEM = {__VA_ARGS__};    \
-      Cycle.replace(sizeof(__k) / sizeof(Key), &__k[0]); \
+  Cycle.replace(sizeof(__k) / sizeof(Key), &__k[0]); \
-    })
+})
 
 namespace kaleidoscope {
 namespace plugin {

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

@@ -17,9 +17,9 @@
 
 #include "kaleidoscope/plugin/CycleTimeReport.h"
 
-#include <Arduino.h>                            // for micros, F, __FlashStr...
+#include <Arduino.h>                   // for micros, F, __FlashStr...
-#include <Kaleidoscope-FocusSerial.h>           // for Focus, FocusSerial
+#include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
-#include <stdint.h>                             // for uint16_t, uint32_t
+#include <stdint.h>                    // for uint16_t, uint32_t
 
 #include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
@@ -62,8 +62,7 @@ EventHandlerResult CycleTimeReport::afterEachCycle() {
 }  // namespace kaleidoscope
 
 __attribute__((weak)) void cycleTimeReport(void) {
-  Focus.send(Focus.COMMENT, F("average loop time:"), CycleTimeReport.average_loop_time,
+  Focus.send(Focus.COMMENT, F("average loop time:"), CycleTimeReport.average_loop_time, Focus.NEWLINE);
-             Focus.NEWLINE);
 }
 
 kaleidoscope::plugin::CycleTimeReport CycleTimeReport;

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <stdint.h>                             // for uint32_t, uint16_t
+#include <stdint.h>  // for uint32_t, uint16_t
 
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
 #include "kaleidoscope/plugin.h"                // for Plugin

plugins/Kaleidoscope-Devel-ArduinoTrace/src/ArduinoTrace.h

@@ -57,7 +57,7 @@ constexpr size_t strlen(const char *str) {
   return str[0] ? strlen(str + 1) + 1 : 0;
 }
 
-template <char... chars>
+template<char... chars>
 struct string {
 #if ARDUINOTRACE_ENABLE_PROGMEM
   const __FlashStringHelper *data() {
@@ -72,52 +72,47 @@ struct string {
 #endif
 };
 
-template <typename TSourceString, size_t remainingLength,
+template<typename TSourceString, size_t remainingLength, char... collectedChars>
-          char... collectedChars>
 struct string_maker {
   using result =
-    typename string_maker < TSourceString, remainingLength - 1,
+    typename string_maker<TSourceString, remainingLength - 1, TSourceString::data()[remainingLength - 1], collectedChars...>::result;
-    TSourceString::data()[remainingLength - 1],
-    collectedChars... >::result;
 };
 
 #if ARDUINOTRACE_ENABLE_FULLPATH == 0
-template <typename TSourceString, size_t remainingLength,
+template<typename TSourceString, size_t remainingLength, char... collectedChars>
-          char... collectedChars>
 struct string_maker<TSourceString, remainingLength, '/', collectedChars...> {
   using result = string<collectedChars..., '\0'>;
 };
 
-template <typename TSourceString, size_t remainingLength,
+template<typename TSourceString, size_t remainingLength, char... collectedChars>
-          char... collectedChars>
 struct string_maker<TSourceString, remainingLength, '\\', collectedChars...> {
   using result = string<collectedChars..., '\0'>;
 };
 #endif
 
-template <typename TSourceString, char... collectedChars>
+template<typename TSourceString, char... collectedChars>
 struct string_maker<TSourceString, 0, collectedChars...> {
   using result = string<collectedChars..., '\0'>;
 };
 
-template <typename TStringSource>
+template<typename TStringSource>
 using make_string =
   typename string_maker<TStringSource, strlen(TStringSource::data())>::result;
 
 struct Initializer {
-  template <typename TSerial>
+  template<typename TSerial>
   Initializer(TSerial &serial, int bauds) {
     serial.begin(bauds);
     while (!serial) continue;
   }
 };
 
-template <typename TFilename, typename TPrefix>
+template<typename TFilename, typename TPrefix>
 struct Printer {
-  template <typename TSerial, typename TValue>
+  template<typename TSerial, typename TValue>
   Printer(TSerial &serial, const TValue &content) {
-    serial.print(make_string<TFilename> {}.data());
+    serial.print(make_string<TFilename>{}.data());
-    serial.print(make_string<TPrefix> {}.data());
+    serial.print(make_string<TPrefix>{}.data());
     serial.println(content);
     serial.flush();
   }
@@ -154,7 +149,7 @@ struct Printer {
 
 #define ARDUINOTRACE_INITIALIZE(id, bauds)                          \
   ArduinoTrace::Initializer ARDUINOTRACE_CONCAT(__initializer, id)( \
-      ARDUINOTRACE_SERIAL, bauds);
+    ARDUINOTRACE_SERIAL, bauds);
 
 #define ARDUINOTRACE_TRACE_PREFIX(line) ":" ARDUINOTRACE_STRINGIFY(line) ": "
 
@@ -172,19 +167,16 @@ struct Printer {
 // Call this macro anywhere, including at global scope.
 // However, if you use it at global scope, you need to call ARDUINOTRACE_INIT()
 // first, otherwise, the Serial port will not be ready.
-#define TRACE()                                           \
+#define TRACE() \
-  ARDUINOTRACE_PRINT(__COUNTER__, __FILE__,               \
+  ARDUINOTRACE_PRINT(__COUNTER__, __FILE__, ARDUINOTRACE_TRACE_PREFIX(__LINE__), ARDUINOTRACE_FUNCTION_NAME)
-                     ARDUINOTRACE_TRACE_PREFIX(__LINE__), \
-                     ARDUINOTRACE_FUNCTION_NAME)
 
 // Prints the value of a variable.
 //
 // This function will print the name and the value of the variable to the
 // Serial. If you use it at global scope, you need to call ARDUINOTRACE_INIT()
 // first, otherwise, the Serial port will not be ready.
-#define DUMP(variable)                      \
+#define DUMP(variable) \
-  ARDUINOTRACE_PRINT(__COUNTER__, __FILE__, \
+  ARDUINOTRACE_PRINT(__COUNTER__, __FILE__, ARDUINOTRACE_DUMP_PREFIX(__LINE__, variable), variable)
-                     ARDUINOTRACE_DUMP_PREFIX(__LINE__, variable), variable)
 
 #else  // ie ARDUINOTRACE_ENABLE == 0
 

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

@@ -16,6 +16,6 @@
 
 #pragma once
 
-#include <Kaleidoscope-Macros.h> // IWYU pragma: keep
+#include <Kaleidoscope-Macros.h>  // IWYU pragma: keep
 
 #include "kaleidoscope/plugin/DynamicMacros.h"  // IWYU pragma: export

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

@@ -16,16 +16,16 @@
 
 #include "kaleidoscope/plugin/DynamicMacros.h"
 
-#include <Arduino.h>                                // for delay, PSTR, strc...
+#include <Arduino.h>                   // for delay, PSTR, strc...
-#include <Kaleidoscope-FocusSerial.h>               // for Focus, FocusSerial
+#include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
-#include <Kaleidoscope-Ranges.h>                    // for DYNAMIC_MACRO_FIRST
+#include <Kaleidoscope-Ranges.h>       // for DYNAMIC_MACRO_FIRST
 
-#include "kaleidoscope/KeyAddr.h"                   // for KeyAddr
+#include "kaleidoscope/KeyAddr.h"                 // for KeyAddr
-#include "kaleidoscope/KeyEvent.h"                  // for KeyEvent
+#include "kaleidoscope/KeyEvent.h"                // for KeyEvent
-#include "kaleidoscope/Runtime.h"                   // for Runtime, Runtime_
+#include "kaleidoscope/Runtime.h"                 // for Runtime, Runtime_
-#include "kaleidoscope/device/device.h"             // for VirtualProps::Sto...
+#include "kaleidoscope/device/device.h"           // for VirtualProps::Sto...
-#include "kaleidoscope/keyswitch_state.h"           // for INJECTED, IS_PRESSED
+#include "kaleidoscope/keyswitch_state.h"         // for INJECTED, IS_PRESSED
-#include "kaleidoscope/plugin/EEPROM-Settings.h"    // for EEPROMSettings
+#include "kaleidoscope/plugin/EEPROM-Settings.h"  // for EEPROMSettings
 
 // This is a special exception to the rule of only including a plugin's
 // top-level header file, because DynamicMacros doesn't depend on the Macros
@@ -67,9 +67,9 @@ void DynamicMacros::tap(Key key) {
 }
 
 void DynamicMacros::updateDynamicMacroCache() {
-  uint16_t pos = storage_base_;
+  uint16_t pos              = storage_base_;
-  uint8_t current_id = 0;
+  uint8_t current_id        = 0;
-  macro_t macro = MACRO_ACTION_END;
+  macro_t macro             = MACRO_ACTION_END;
   bool previous_macro_ended = false;
 
   map_[0] = 0;
@@ -103,7 +103,7 @@ void DynamicMacros::updateDynamicMacroCache() {
       previous_macro_ended = false;
       uint8_t keyCode, flags;
       do {
-        flags = Runtime.storage().read(pos++);
+        flags   = Runtime.storage().read(pos++);
         keyCode = Runtime.storage().read(pos++);
       } while (!(flags == 0 && keyCode == 0));
       break;
@@ -132,7 +132,7 @@ void DynamicMacros::updateDynamicMacroCache() {
 
 // public
 void DynamicMacros::play(uint8_t macro_id) {
-  macro_t macro = MACRO_ACTION_END;
+  macro_t macro    = MACRO_ACTION_END;
   uint8_t interval = 0;
   uint16_t pos;
   Key key;
@@ -289,7 +289,7 @@ void DynamicMacros::reserve_storage(uint16_t size) {
   updateDynamicMacroCache();
 }
 
-} // namespace plugin
+}  // namespace plugin
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 kaleidoscope::plugin::DynamicMacros DynamicMacros;

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

@@ -16,15 +16,15 @@
 
 #pragma once
 
-#include <Kaleidoscope-Ranges.h>                // for DYNAMIC_MACRO_FIRST
+#include <Kaleidoscope-Ranges.h>  // for DYNAMIC_MACRO_FIRST
-#include <stdint.h>                             // for uint16_t, uint8_t
+#include <stdint.h>               // for uint16_t, uint8_t
 
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
 #include "kaleidoscope/key_defs.h"              // for Key
 #include "kaleidoscope/plugin.h"                // for Plugin
 
-#define DM(n) ::kaleidoscope::plugin::DynamicMacrosKey(n)
+#define DM(n)                             ::kaleidoscope::plugin::DynamicMacrosKey(n)
 
 #define MAX_CONCURRENT_DYNAMIC_MACRO_KEYS 8
 
@@ -56,7 +56,7 @@ class DynamicMacros : public kaleidoscope::Plugin {
   static void tap(Key key);
 };
 
-} // namespace plugin
+}  // namespace plugin
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 extern kaleidoscope::plugin::DynamicMacros DynamicMacros;

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

@@ -17,10 +17,10 @@
 
 #include "kaleidoscope/plugin/DynamicTapDance.h"
 
-#include <Arduino.h>                            // for PSTR, F, __FlashStrin...
+#include <Arduino.h>                       // for PSTR, F, __FlashStrin...
-#include <Kaleidoscope-EEPROM-Settings.h>       // for EEPROMSettings
+#include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
-#include <Kaleidoscope-FocusSerial.h>           // for Focus, FocusSerial
+#include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
-#include <stdint.h>                             // for uint16_t, uint8_t
+#include <stdint.h>                        // for uint16_t, uint8_t
 
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
@@ -42,12 +42,12 @@ uint8_t DynamicTapDance::dance_count_;
 constexpr uint8_t DynamicTapDance::reserved_tap_dance_key_count_;
 
 void DynamicTapDance::updateDynamicTapDanceCache() {
-  uint16_t pos = storage_base_;
+  uint16_t pos              = storage_base_;
-  uint8_t current_id = 0;
+  uint8_t current_id        = 0;
   bool previous_dance_ended = false;
 
   dance_count_ = 0;
-  map_[0] = 0;
+  map_[0]      = 0;
 
   while (pos < storage_base_ + storage_size_) {
     uint16_t raw_key = Runtime.storage().read(pos);
@@ -68,9 +68,8 @@ void DynamicTapDance::updateDynamicTapDanceCache() {
   }
 }
 
-bool DynamicTapDance::dance(uint8_t tap_dance_index, KeyAddr key_addr,
+bool DynamicTapDance::dance(uint8_t tap_dance_index, KeyAddr key_addr, uint8_t tap_count, TapDance::ActionType tap_dance_action) {
-                            uint8_t tap_count, TapDance::ActionType tap_dance_action) {
+  uint16_t pos      = map_[tap_dance_index - offset_] + ((tap_count - 1) * 2);
-  uint16_t pos = map_[tap_dance_index - offset_] + ((tap_count - 1) * 2);
   uint16_t next_pos = map_[tap_dance_index - offset_ + 1];
   if (next_pos <= pos || (tap_dance_index > offset_ + dance_count_))
     return false;
@@ -136,7 +135,7 @@ EventHandlerResult DynamicTapDance::onFocusEvent(const char *command) {
 void DynamicTapDance::setup(uint8_t dynamic_offset, uint16_t size) {
   storage_base_ = ::EEPROMSettings.requestSlice(size);
   storage_size_ = size;
-  offset_ = dynamic_offset;
+  offset_       = dynamic_offset;
   updateDynamicTapDanceCache();
 }
 

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

@@ -17,9 +17,9 @@
 
 #pragma once
 
-#include <Kaleidoscope-Ranges.h>                // for TD_FIRST, TD_LAST
+#include <Kaleidoscope-Ranges.h>    // for TD_FIRST, TD_LAST
-#include <Kaleidoscope-TapDance.h>              // for TapDance, TapDance::A...
+#include <Kaleidoscope-TapDance.h>  // for TapDance, TapDance::A...
-#include <stdint.h>                             // for uint8_t, uint16_t
+#include <stdint.h>                 // for uint8_t, uint16_t
 
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
@@ -28,7 +28,7 @@
 namespace kaleidoscope {
 namespace plugin {
 
-class DynamicTapDance: public kaleidoscope::Plugin {
+class DynamicTapDance : public kaleidoscope::Plugin {
  public:
   DynamicTapDance() {}
 
@@ -37,8 +37,7 @@ class DynamicTapDance: public kaleidoscope::Plugin {
 
   static void setup(uint8_t dynamic_offset, uint16_t size);
 
-  static bool dance(uint8_t tap_dance_index, KeyAddr key_addr, uint8_t tap_count,
+  static bool dance(uint8_t tap_dance_index, KeyAddr key_addr, uint8_t tap_count, TapDance::ActionType tap_dance_action);
-                    TapDance::ActionType tap_dance_action);
 
  private:
   static uint16_t storage_base_;

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

@@ -17,10 +17,10 @@
 
 #include "kaleidoscope/plugin/EEPROM-Keymap-Programmer.h"
 
-#include <Arduino.h>                            // for PSTR, strcmp_P
+#include <Arduino.h>                     // for PSTR, strcmp_P
-#include <Kaleidoscope-EEPROM-Keymap.h>         // for EEPROMKeymap
+#include <Kaleidoscope-EEPROM-Keymap.h>  // for EEPROMKeymap
-#include <Kaleidoscope-FocusSerial.h>           // for Focus, FocusSerial
+#include <Kaleidoscope-FocusSerial.h>    // for Focus, FocusSerial
-#include <stdint.h>                             // for uint16_t, uint8_t
+#include <stdint.h>                      // for uint16_t, uint8_t
 
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
@@ -60,8 +60,8 @@ void EEPROMKeymapProgrammer::nextState(void) {
 
 void EEPROMKeymapProgrammer::cancel(void) {
   update_position_ = 0;
-  new_key_ = Key_NoKey;
+  new_key_         = Key_NoKey;
-  state_ = INACTIVE;
+  state_           = INACTIVE;
 }
 
 EventHandlerResult EEPROMKeymapProgrammer::onKeyEvent(KeyEvent &event) {

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <stdint.h>                             // for uint16_t
+#include <stdint.h>  // for uint16_t
 
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult

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

@@ -17,10 +17,10 @@
 
 #include "kaleidoscope/plugin/EEPROM-Keymap.h"
 
-#include <Arduino.h>                            // for PSTR, strcmp_P, F
+#include <Arduino.h>                       // for PSTR, strcmp_P, F
-#include <Kaleidoscope-EEPROM-Settings.h>       // for EEPROMSettings
+#include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
-#include <Kaleidoscope-FocusSerial.h>           // for Focus, FocusSerial
+#include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
-#include <stdint.h>                             // for uint8_t, uint16_t
+#include <stdint.h>                        // for uint8_t, uint16_t
 
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr, MatrixAddr
 #include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
@@ -57,7 +57,7 @@ void EEPROMKeymap::setup(uint8_t max) {
 }
 
 void EEPROMKeymap::max_layers(uint8_t max) {
-  max_layers_ = max;
+  max_layers_  = max;
   keymap_base_ = ::EEPROMSettings.requestSlice(max_layers_ * Runtime.device().numKeys() * 2);
 }
 
@@ -67,8 +67,8 @@ Key EEPROMKeymap::getKey(uint8_t layer, KeyAddr key_addr) {
 
   uint16_t pos = ((layer * Runtime.device().numKeys()) + key_addr.toInt()) * 2;
 
-  return Key(Runtime.storage().read(keymap_base_ + pos + 1), // key_code
+  return Key(Runtime.storage().read(keymap_base_ + pos + 1),  // key_code
-             Runtime.storage().read(keymap_base_ + pos));    // flags
+             Runtime.storage().read(keymap_base_ + pos));     // flags
 }
 
 Key EEPROMKeymap::getKeyExtended(uint8_t layer, KeyAddr key_addr) {
@@ -91,7 +91,7 @@ void EEPROMKeymap::updateKey(uint16_t base_pos, Key key) {
   Runtime.storage().update(keymap_base_ + base_pos * 2 + 1, key.getKeyCode());
 }
 
-void EEPROMKeymap::dumpKeymap(uint8_t layers, Key(*getkey)(uint8_t, KeyAddr)) {
+void EEPROMKeymap::dumpKeymap(uint8_t layers, Key (*getkey)(uint8_t, KeyAddr)) {
   for (uint8_t layer = 0; layer < layers; layer++) {
     for (auto key_addr : KeyAddr::all()) {
       Key k = (*getkey)(layer, key_addr);
@@ -134,7 +134,7 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) {
     // we actully want.
     //
     dumpKeymap(progmem_layers_,
-               static_cast<Key(*)(uint8_t, KeyAddr)>(Layer_::getKeyFromPROGMEM));
+               static_cast<Key (*)(uint8_t, KeyAddr)>(Layer_::getKeyFromPROGMEM));
     return EventHandlerResult::EVENT_CONSUMED;
   }
 
@@ -146,7 +146,7 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) {
     // tell the compiler which overload of getKey
     // we actually want.
     //
-    dumpKeymap(max_layers_, static_cast<Key(*)(uint8_t, KeyAddr)>(getKey));
+    dumpKeymap(max_layers_, static_cast<Key (*)(uint8_t, KeyAddr)>(getKey));
   } else {
     uint16_t i = 0;
 

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <stdint.h>                             // for uint8_t, uint16_t
+#include <stdint.h>  // for uint8_t, uint16_t
 
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
@@ -57,7 +57,7 @@ class EEPROMKeymap : public kaleidoscope::Plugin {
 
   static Key parseKey(void);
   static void printKey(Key key);
-  static void dumpKeymap(uint8_t layers, Key(*getkey)(uint8_t, KeyAddr));
+  static void dumpKeymap(uint8_t layers, Key (*getkey)(uint8_t, KeyAddr));
 };
 
 }  // namespace plugin

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

@@ -17,9 +17,9 @@
 
 #include "kaleidoscope/plugin/EEPROM-Settings.h"
 
-#include <Arduino.h>                                  // for PSTR, strcmp_P, F
+#include <Arduino.h>                   // for PSTR, strcmp_P, F
-#include <Kaleidoscope-FocusSerial.h>                 // for Focus, FocusSerial
+#include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
-#include <stdint.h>                                   // for uint16_t, uint8_t
+#include <stdint.h>                    // for uint16_t, uint8_t
 
 #include "kaleidoscope/Runtime.h"                     // for Runtime, Runtime_
 #include "kaleidoscope/device/device.h"               // for VirtualProps::S...
@@ -47,7 +47,7 @@ EventHandlerResult EEPROMSettings::onSetup() {
          uninitialized state, we do not override them, to avoid overwriting user
          settings. */
       settings_.ignore_hardcoded_layers = false;
-      settings_.default_layer = 0;
+      settings_.default_layer           = 0;
     }
 
     /* If the version is undefined, we'll set it to our current one. */

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <stdint.h>                             // for uint8_t, uint16_t
+#include <stdint.h>  // for uint8_t, uint16_t
 
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
 #include "kaleidoscope/plugin.h"                // for Plugin
@@ -74,8 +74,8 @@ class EEPROMSettings : public kaleidoscope::Plugin {
   static bool sealed_;
 
   static struct settings {
-    uint8_t default_layer: 7;
+    uint8_t default_layer : 7;
-    bool ignore_hardcoded_layers: 1;
+    bool ignore_hardcoded_layers : 1;
     uint8_t version;
     uint16_t crc;
   } settings_;

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

@@ -28,8 +28,7 @@
 
 #include "crc.h"
 
-void
+void CRC_::reflect(uint8_t len) {
-CRC_::reflect(uint8_t len) {
   uint8_t i;
   uint16_t newCRC;
 
@@ -42,8 +41,7 @@ CRC_::reflect(uint8_t len) {
   crc = newCRC;
 }
 
-void
+void CRC_::update(const void *data, uint8_t len) {
-CRC_::update(const void *data, uint8_t len) {
   const uint8_t *d = (const uint8_t *)data;
   uint8_t i;
   bool bit;

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

@@ -34,7 +34,7 @@ class CRC_ {
  public:
   uint16_t crc = 0;
 
-  CRC_(void) {};
+  CRC_(void){};
 
   void update(const void *data, uint8_t len);
   void finalize(void) {

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

@@ -17,10 +17,10 @@
 
 #include "kaleidoscope/plugin/Escape-OneShot.h"  // IWYU pragma: associated
 
-#include <Arduino.h>                            // for PSTR, F, __FlashStrin...
+#include <Arduino.h>                       // for PSTR, F, __FlashStrin...
-#include <Kaleidoscope-EEPROM-Settings.h>       // for EEPROMSettings
+#include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
-#include <Kaleidoscope-FocusSerial.h>           // for Focus, FocusSerial
+#include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
-#include <stdint.h>                             // for uint16_t
+#include <stdint.h>                        // for uint16_t
 
 #include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
 #include "kaleidoscope/device/device.h"         // for VirtualProps::Storage
@@ -71,7 +71,7 @@ EventHandlerResult EscapeOneShotConfig::onFocusEvent(const char *command) {
   return EventHandlerResult::EVENT_CONSUMED;
 }
 
-} // namespace plugin
+}  // namespace plugin
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 kaleidoscope::plugin::EscapeOneShotConfig EscapeOneShotConfig;

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

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/Escape-OneShot.h"
 
-#include <Kaleidoscope-OneShot.h>               // for OneShot
+#include <Kaleidoscope-OneShot.h>  // for OneShot
 
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
@@ -28,8 +28,7 @@ namespace kaleidoscope {
 namespace plugin {
 
 EscapeOneShot::Settings EscapeOneShot::settings_ = {
-  .cancel_oneshot_key = Key_Escape
+  .cancel_oneshot_key = Key_Escape};
-};
 
 EventHandlerResult EscapeOneShot::onKeyEvent(KeyEvent &event) {
   // We only act on an escape key (or `cancel_oneshot_key_`, if that has been

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

@@ -17,8 +17,8 @@
 
 #pragma once
 
-#include <Kaleidoscope-Ranges.h>                // for OS_CANCEL
+#include <Kaleidoscope-Ranges.h>  // for OS_CANCEL
-#include <stdint.h>                             // for uint16_t
+#include <stdint.h>               // for uint16_t
 
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
@@ -27,8 +27,8 @@
 
 // DEPRECATED: `OneShotCancelKey` doesn't match our normal naming, and should
 // eventually be removed.
-constexpr Key OneShotCancelKey {kaleidoscope::ranges::OS_CANCEL};
+constexpr Key OneShotCancelKey{kaleidoscope::ranges::OS_CANCEL};
-constexpr Key Key_OneShotCancel {kaleidoscope::ranges::OS_CANCEL};
+constexpr Key Key_OneShotCancel{kaleidoscope::ranges::OS_CANCEL};
 
 namespace kaleidoscope {
 namespace plugin {

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

@@ -17,11 +17,11 @@
 
 #include "kaleidoscope/plugin/FingerPainter.h"
 
-#include <Arduino.h>                            // for PSTR, strcmp_P, F
+#include <Arduino.h>                         // for PSTR, strcmp_P, F
-#include <Kaleidoscope-FocusSerial.h>           // for Focus, FocusSerial
+#include <Kaleidoscope-FocusSerial.h>        // for Focus, FocusSerial
-#include <Kaleidoscope-LED-Palette-Theme.h>     // for LEDPaletteTheme
+#include <Kaleidoscope-LED-Palette-Theme.h>  // for LEDPaletteTheme
-#include <stdint.h>                             // for uint16_t, uint8_t
+#include <stdint.h>                          // for uint16_t, uint8_t
-#include <string.h>                             // for memcmp
+#include <string.h>                          // for memcmp
 
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
@@ -71,8 +71,8 @@ EventHandlerResult FingerPainter::onKeyEvent(KeyEvent &event) {
   // TODO(anyone): The following works only for keyboards with LEDs for each key.
 
   uint8_t color_index = ::LEDPaletteTheme
-                        .lookupColorIndexAtPosition(color_base_,
+                          .lookupColorIndexAtPosition(color_base_,
-                                                    Runtime.device().getLedIndex(event.addr));
+                                                      Runtime.device().getLedIndex(event.addr));
 
   // Find the next color in the palette that is different.
   // But do not loop forever!

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <stdint.h>                             // for uint16_t
+#include <stdint.h>  // for uint16_t
 
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent

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

@@ -23,7 +23,7 @@
 
 #ifdef __AVR__
 
-#include <stdint.h>                             // for uint16_t
+#include <stdint.h>  // for uint16_t
 
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
 #include "kaleidoscope/plugin.h"                // for Plugin
@@ -37,6 +37,7 @@ class FirmwareDump : public kaleidoscope::Plugin {
 
   EventHandlerResult onSetup();
   EventHandlerResult onFocusEvent(const char *command);
+
  private:
   uint16_t bootloader_size_;
 };

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

@@ -17,10 +17,10 @@
 
 #include "kaleidoscope/plugin/FocusSerial.h"
 
-#include <Arduino.h>                            // for __FlashStringHelper, F
+#include <Arduino.h>         // for __FlashStringHelper, F
-#include <HardwareSerial.h>                     // for HardwareSerial
+#include <HardwareSerial.h>  // for HardwareSerial
-#include <stdint.h>                             // for uint8_t
+#include <stdint.h>          // for uint8_t
-#include <string.h>                             // for memset
+#include <string.h>          // for memset
 
 #include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
@@ -44,10 +44,7 @@ EventHandlerResult FocusSerial::afterEachCycle() {
 
   do {
     command_[buf_cursor_++] = Runtime.serialPort().read();
-  } while (command_[buf_cursor_ - 1] != SEPARATOR
+  } while (command_[buf_cursor_ - 1] != SEPARATOR && buf_cursor_ < sizeof(command_) && Runtime.serialPort().available() && (Runtime.serialPort().peek() != NEWLINE));
-           && buf_cursor_ < sizeof(command_)
-           && Runtime.serialPort().available()
-           && (Runtime.serialPort().peek() != NEWLINE));
 
 
   // If there was no command, there's nothing to do
@@ -57,9 +54,7 @@ EventHandlerResult FocusSerial::afterEachCycle() {
     return EventHandlerResult::OK;
   }
 
-  if ((command_[buf_cursor_ - 1] != SEPARATOR)  && (Runtime.serialPort().peek() != NEWLINE)
+  if ((command_[buf_cursor_ - 1] != SEPARATOR) && (Runtime.serialPort().peek() != NEWLINE) && buf_cursor_ < sizeof(command_)) {
-      && buf_cursor_ < sizeof(command_)
-     ) {
     // We don't have enough command to work with yet.
     // Let's leave the buffer around for another cycle
     return EventHandlerResult::OK;
@@ -74,7 +69,7 @@ EventHandlerResult FocusSerial::afterEachCycle() {
   // Then process the command
   Runtime.onFocusEvent(command_);
   while (Runtime.serialPort().available()) {
-    char c =  Runtime.serialPort().read();
+    char c = Runtime.serialPort().read();
     if (c == NEWLINE) {
       // newline serves as an end-of-command marker
       // don't drain the buffer past there
@@ -86,7 +81,6 @@ EventHandlerResult FocusSerial::afterEachCycle() {
   buf_cursor_ = 0;
   memset(command_, 0, sizeof(command_));
   return EventHandlerResult::OK;
-
 }
 
 bool FocusSerial::handleHelp(const char *command,

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

@@ -17,9 +17,9 @@
 
 #pragma once
 
-#include <Arduino.h>                            // for __FlashStringHelper
+#include <Arduino.h>         // for __FlashStringHelper
-#include <HardwareSerial.h>                     // for HardwareSerial
+#include <HardwareSerial.h>  // for HardwareSerial
-#include <stdint.h>                             // for uint8_t, uint16_t
+#include <stdint.h>          // for uint8_t, uint16_t
 
 #include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
 #include "kaleidoscope/device/device.h"         // for cRGB
@@ -33,9 +33,9 @@ class FocusSerial : public kaleidoscope::Plugin {
  public:
   FocusSerial(void) {}
 
-  static constexpr char COMMENT = '#';
+  static constexpr char COMMENT   = '#';
   static constexpr char SEPARATOR = ' ';
-  static constexpr char NEWLINE = '\n';
+  static constexpr char NEWLINE   = '\n';
 
   bool handleHelp(const char *command,
                   const char *help_message);
@@ -57,19 +57,19 @@ class FocusSerial : public kaleidoscope::Plugin {
     printBool(b);
     Runtime.serialPort().print(SEPARATOR);
   }
-  template <typename V>
+  template<typename V>
   void send(V v) {
     Runtime.serialPort().print(v);
     Runtime.serialPort().print(SEPARATOR);
   }
-  template <typename Var, typename... Vars>
+  template<typename Var, typename... Vars>
   void send(Var v, Vars... vars) {
     send(v);
     send(vars...);
   }
 
   void sendRaw() {}
-  template <typename Var, typename... Vars>
+  template<typename Var, typename... Vars>
   void sendRaw(Var v, Vars... vars) {
     Runtime.serialPort().print(v);
     sendRaw(vars...);

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

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/GhostInTheFirmware.h"
 
-#include <stdint.h>                             // for uint16_t
+#include <stdint.h>  // for uint16_t
 
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
@@ -29,7 +29,7 @@
 namespace kaleidoscope {
 namespace plugin {
 const GhostInTheFirmware::GhostKey *GhostInTheFirmware::ghost_keys;
-bool GhostInTheFirmware::is_active_ = false;
+bool GhostInTheFirmware::is_active_       = false;
 uint16_t GhostInTheFirmware::current_pos_ = 0;
 uint16_t GhostInTheFirmware::start_time_;
 
@@ -53,9 +53,9 @@ EventHandlerResult GhostInTheFirmware::afterEachCycle() {
     // value (i.e. KeyAddr::none()). If we read this sentinel value, reset and
     // deactivate.
     if (!ghost_key.addr.isValid()) {
-      current_pos_ = 0;
+      current_pos_    = 0;
       ghost_key.delay = 0;
-      is_active_ = false;
+      is_active_      = false;
       return EventHandlerResult::OK;
     }
     // If we're not at the end of the sequence, send the first keypress event,

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <stdint.h>                             // for uint16_t
+#include <stdint.h>  // for uint16_t
 
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult

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

@@ -28,13 +28,13 @@
 #include "kaleidoscope/driver/keyscanner/Base_Impl.h"
 #include "kaleidoscope/util/crc16.h"
 
-#define I2C_CLOCK_KHZ 100
+#define I2C_CLOCK_KHZ       100
-#define I2C_FLASH_CLOCK_KHZ 100 // flashing doesn't work reliably at higher clock speeds
+#define I2C_FLASH_CLOCK_KHZ 100  // flashing doesn't work reliably at higher clock speeds
 
-#define SIDE_POWER 1 // side power switch pa10
+#define SIDE_POWER          1  // side power switch pa10
 
-#define LAYOUT_ISO 0
+#define LAYOUT_ISO          0
-#define LAYOUT_ANSI 1
+#define LAYOUT_ANSI         1
 
 namespace kaleidoscope {
 namespace device {
@@ -148,7 +148,7 @@ void RaiseLEDDriver::setBrightness(uint8_t brightness) {
   RaiseHands::leftHand.setBrightness(brightness);
   RaiseHands::rightHand.setBrightness(brightness);
   for (uint8_t i = 0; i < LED_BANKS; i++) {
-    isLEDChangedLeft[i] = true;
+    isLEDChangedLeft[i]  = true;
     isLEDChangedRight[i] = true;
   }
 }
@@ -159,7 +159,7 @@ uint8_t RaiseLEDDriver::getBrightness() {
 
 void RaiseLEDDriver::syncLeds() {
   // left and right sides
-  for (uint8_t i = 0; i < LED_BANKS; i ++) {
+  for (uint8_t i = 0; i < LED_BANKS; i++) {
     // only send the banks that have changed - try to improve jitter performance
     if (isLEDChangedLeft[i]) {
       RaiseHands::leftHand.sendLEDBank(i);
@@ -180,7 +180,7 @@ void RaiseLEDDriver::syncLeds() {
 void RaiseLEDDriver::updateNeuronLED() {
   static constexpr struct {
     uint8_t r, g, b;
-  } pins = { 3, 5, 4 };
+  } pins                = {3, 5, 4};
   auto constexpr gamma8 = kaleidoscope::driver::color::gamma_correction;
 
   // invert as these are common anode, and make sure we reach 65535 to be able
@@ -207,13 +207,13 @@ void RaiseLEDDriver::setCrgbAt(uint8_t i, cRGB crgb) {
   // get the SLED index
   uint8_t sled_num = led_map[RaiseHands::layout][i];
   if (sled_num < LEDS_PER_HAND) {
-    cRGB oldColor = RaiseHands::leftHand.led_data.leds[sled_num];
+    cRGB oldColor                                = RaiseHands::leftHand.led_data.leds[sled_num];
     RaiseHands::leftHand.led_data.leds[sled_num] = crgb;
     isLEDChangedLeft[uint8_t(sled_num / 8)] |= !(oldColor.r == crgb.r &&
                                                  oldColor.g == crgb.g &&
                                                  oldColor.b == crgb.b);
   } else if (sled_num < 2 * LEDS_PER_HAND) {
-    cRGB oldColor = RaiseHands::rightHand.led_data.leds[sled_num - LEDS_PER_HAND];
+    cRGB oldColor                                                 = RaiseHands::rightHand.led_data.leds[sled_num - LEDS_PER_HAND];
     RaiseHands::rightHand.led_data.leds[sled_num - LEDS_PER_HAND] = crgb;
     isLEDChangedRight[uint8_t((sled_num - LEDS_PER_HAND) / 8)] |=
       !(oldColor.r == crgb.r &&
@@ -253,7 +253,7 @@ void RaiseLEDDriver::setup() {
 
   delay(10);
   RaiseHands::setSidePower(true);
-  delay(500); // wait for sides to power up and finish bootloader
+  delay(500);  // wait for sides to power up and finish bootloader
 }
 
 /********* Key scanner *********/
@@ -266,7 +266,7 @@ bool RaiseKeyScanner::lastLeftOnline;
 bool RaiseKeyScanner::lastRightOnline;
 
 void RaiseKeyScanner::readMatrix() {
-  previousLeftHandState = leftHandState;
+  previousLeftHandState  = leftHandState;
   previousRightHandState = rightHandState;
 
   if (RaiseHands::leftHand.readKeys()) {
@@ -275,8 +275,8 @@ void RaiseKeyScanner::readMatrix() {
     if (RaiseHands::layout == LAYOUT_ANSI) {
       // only swap if bits are different
       if ((leftHandState.rows[3] & (1 << 0)) ^ leftHandState.rows[3] & (1 << 1)) {
-        leftHandState.rows[3] ^= (1 << 0); // flip the bit
+        leftHandState.rows[3] ^= (1 << 0);  // flip the bit
-        leftHandState.rows[3] ^= (1 << 1); // flip the bit
+        leftHandState.rows[3] ^= (1 << 1);  // flip the bit
       }
     }
   }
@@ -305,7 +305,7 @@ void RaiseKeyScanner::readMatrix() {
     rightHandState.all = 0;
 
   // store previous state of whether the sides are plugged in
-  lastLeftOnline = RaiseHands::leftHand.online;
+  lastLeftOnline  = RaiseHands::leftHand.online;
   lastRightOnline = RaiseHands::rightHand.online;
 }
 
@@ -383,7 +383,7 @@ void RaiseKeyScanner::setup() {
 }
 
 void RaiseKeyScanner::reset() {
-  leftHandState.all = 0;
+  leftHandState.all  = 0;
   rightHandState.all = 0;
   Runtime.hid().keyboard().releaseAllKeys();
   Runtime.hid().keyboard().sendReport();

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

@@ -23,7 +23,8 @@
 
 #include "kaleidoscope/device/dygma/raise/RaiseSide.h"
 
-#define CRGB(r,g,b) (cRGB){b, g, r}
+#define CRGB(r, g, b) \
+  (cRGB) { b, g, r }
 
 #include "kaleidoscope/device/Base.h"
 #include "kaleidoscope/driver/bootloader/samd/Bossac.h"
@@ -67,6 +68,7 @@ class RaiseLEDDriver : public kaleidoscope::driver::led::Base<RaiseLEDDriverProp
   static uint8_t getBrightness();
 
   static void updateNeuronLED();
+
  private:
   static bool isLEDChangedNeuron;
   static uint8_t isLEDChangedLeft[LED_BANKS];
@@ -114,11 +116,11 @@ class RaiseLEDDriver : public kaleidoscope::driver::led::Base<RaiseLEDDriverProp
 };
 
 struct RaiseKeyScannerProps : public kaleidoscope::driver::keyscanner::BaseProps {
-  static constexpr uint8_t matrix_rows = 5;
+  static constexpr uint8_t matrix_rows    = 5;
   static constexpr uint8_t matrix_columns = 16;
   typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
 
-  static constexpr uint8_t left_columns = 8;
+  static constexpr uint8_t left_columns  = 8;
   static constexpr uint8_t right_columns = matrix_columns - left_columns;
 };
 
@@ -126,6 +128,7 @@ class RaiseKeyScanner : public kaleidoscope::driver::keyscanner::Base<RaiseKeySc
  private:
   typedef RaiseKeyScanner ThisType;
   typedef RaiseKeyScannerProps Props_;
+
  public:
   static void setup();
   static void scanMatrix();
@@ -161,7 +164,7 @@ struct RaiseSideFlasherProps : public kaleidoscope::util::flasher::BaseProps {};
 struct RaiseProps : kaleidoscope::device::BaseProps {
   typedef kaleidoscope::driver::hid::KeyboardioProps HIDProps;
   typedef kaleidoscope::driver::hid::Keyboardio<HIDProps> HID;
-  typedef RaiseLEDDriverProps  LEDDriverProps;
+  typedef RaiseLEDDriverProps LEDDriverProps;
   typedef RaiseLEDDriver LEDDriver;
   typedef RaiseKeyScannerProps KeyScannerProps;
   typedef RaiseKeyScanner KeyScanner;
@@ -174,9 +177,10 @@ struct RaiseProps : kaleidoscope::device::BaseProps {
   static constexpr const char *short_name = "raise";
 };
 
-class Raise: public kaleidoscope::device::Base<RaiseProps> {
+class Raise : public kaleidoscope::device::Base<RaiseProps> {
  private:
   static RaiseProps::SideFlasher SideFlasher;
+
  public:
   static void setup();
 
@@ -208,7 +212,7 @@ class Raise: public kaleidoscope::device::Base<RaiseProps> {
     void prepareForFlash();
 
     // Side bootloader addresses
-    static constexpr uint8_t left_boot_address = 0x50;
+    static constexpr uint8_t left_boot_address  = 0x50;
     static constexpr uint8_t right_boot_address = 0x51;
   } side;
 

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

@@ -29,42 +29,42 @@ namespace device {
 namespace dygma {
 namespace raise {
 
-#define TWI_CMD_NONE 0x00
+#define TWI_CMD_NONE                  0x00
-#define TWI_CMD_VERSION 0x01
+#define TWI_CMD_VERSION               0x01
-#define TWI_CMD_KEYSCAN_INTERVAL 0x02
+#define TWI_CMD_KEYSCAN_INTERVAL      0x02
-#define TWI_CMD_LED_SET_ALL_TO 0x03
+#define TWI_CMD_LED_SET_ALL_TO        0x03
-#define TWI_CMD_LED_SET_ONE_TO 0x04
+#define TWI_CMD_LED_SET_ONE_TO        0x04
-#define TWI_CMD_COLS_USE_PULLUPS 0x05
+#define TWI_CMD_COLS_USE_PULLUPS      0x05
-#define TWI_CMD_LED_SPI_FREQUENCY 0x06
+#define TWI_CMD_LED_SPI_FREQUENCY     0x06
 #define TWI_CMD_LED_GLOBAL_BRIGHTNESS 0x07
 
-#define TWI_CMD_SLED_STATUS 0x08
+#define TWI_CMD_SLED_STATUS           0x08
-#define TWI_CMD_LED_OPEN 0x09
+#define TWI_CMD_LED_OPEN              0x09
-#define TWI_CMD_LED_SHORT 0x0A
+#define TWI_CMD_LED_SHORT             0x0A
-#define TWI_CMD_JOINED 0x0B
+#define TWI_CMD_JOINED                0x0B
-#define TWI_CMD_LAYOUT 0x0C
+#define TWI_CMD_LAYOUT                0x0C
-#define TWI_CMD_SLED_CURRENT 0x0D
+#define TWI_CMD_SLED_CURRENT          0x0D
-#define TWI_CMD_SLED_SELF_TEST 0x0E
+#define TWI_CMD_SLED_SELF_TEST        0x0E
-
+
-#define LED_SPI_FREQUENCY_4MHZ      0x07
+#define LED_SPI_FREQUENCY_4MHZ        0x07
-#define LED_SPI_FREQUENCY_2MHZ      0x06
+#define LED_SPI_FREQUENCY_2MHZ        0x06
-#define LED_SPI_FREQUENCY_1MHZ      0x05
+#define LED_SPI_FREQUENCY_1MHZ        0x05
-#define LED_SPI_FREQUENCY_512KHZ    0x04
+#define LED_SPI_FREQUENCY_512KHZ      0x04
-#define LED_SPI_FREQUENCY_256KHZ    0x03
+#define LED_SPI_FREQUENCY_256KHZ      0x03
-#define LED_SPI_FREQUENCY_128KHZ    0x02
+#define LED_SPI_FREQUENCY_128KHZ      0x02
-#define LED_SPI_FREQUENCY_64KHZ     0x01
+#define LED_SPI_FREQUENCY_64KHZ       0x01
-#define LED_SPI_OFF                 0x00
+#define LED_SPI_OFF                   0x00
 
 // 512KHZ seems to be the sweet spot in early testing
 // so make it the default
 #define LED_SPI_FREQUENCY_DEFAULT LED_SPI_FREQUENCY_512KHZ
 
-#define TWI_CMD_LED_BASE 0x80
+#define TWI_CMD_LED_BASE          0x80
 
-#define TWI_REPLY_NONE 0x00
+#define TWI_REPLY_NONE            0x00
-#define TWI_REPLY_KEYDATA 0x01
+#define TWI_REPLY_KEYDATA         0x01
 
-#define ELEMENTS(arr)  (sizeof(arr) / sizeof((arr)[0]))
+#define ELEMENTS(arr)             (sizeof(arr) / sizeof((arr)[0]))
 
 // Returns the relative controller addresss. The expected range is 0-3
 uint8_t RaiseSide::controllerAddress() {
@@ -221,9 +221,9 @@ void RaiseSide::sendLEDData() {
 auto constexpr gamma8 = kaleidoscope::driver::color::gamma_correction;
 
 void RaiseSide::sendLEDBank(uint8_t bank) {
-  uint8_t data[LED_BYTES_PER_BANK + 1]; // + 1 for the update LED command itself
+  uint8_t data[LED_BYTES_PER_BANK + 1];  // + 1 for the update LED command itself
-  data[0]  = TWI_CMD_LED_BASE + bank;
+  data[0] = TWI_CMD_LED_BASE + bank;
-  for (uint8_t i = 0 ; i < LED_BYTES_PER_BANK; i++) {
+  for (uint8_t i = 0; i < LED_BYTES_PER_BANK; i++) {
     uint8_t c = led_data.bytes[bank][i];
     if (c > brightness_adjustment_)
       c -= brightness_adjustment_;

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

@@ -35,11 +35,11 @@ namespace device {
 namespace dygma {
 namespace raise {
 
-#define LED_BANKS 9
+#define LED_BANKS          9
 
-#define LEDS_PER_HAND 72
+#define LEDS_PER_HAND      72
-#define LPH LEDS_PER_HAND
+#define LPH                LEDS_PER_HAND
-#define LEDS_PER_BANK 8
+#define LEDS_PER_BANK      8
 #define LED_BYTES_PER_BANK (sizeof(cRGB) * LEDS_PER_BANK)
 
 typedef union {
@@ -57,7 +57,8 @@ typedef union {
 
 class RaiseSide {
  public:
-  explicit RaiseSide(uint8_t ad01) : ad01_(ad01), twi_(i2c_addr_base_ | ad01) {}
+  explicit RaiseSide(uint8_t ad01)
+    : ad01_(ad01), twi_(i2c_addr_base_ | ad01) {}
 
   int readVersion();
   int readSLEDVersion();

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

@@ -28,10 +28,11 @@ namespace device {
 namespace dygma {
 namespace raise {
 
-template <typename _Firmware>
+template<typename _Firmware>
 class SideFlash : public kaleidoscope::Plugin {
  private:
   _Firmware firmware;
+
  public:
   EventHandlerResult onFocusEvent(const char *command) {
     if (::Focus.handleHelp(command, PSTR("hardware.flash_left_side\nhardware.flash_right_side\nhardware.verify_left_side\nhardware.verify_right_side")))
@@ -40,8 +41,8 @@ class SideFlash : public kaleidoscope::Plugin {
     if (strncmp_P(command, PSTR("hardware."), 9) != 0)
       return EventHandlerResult::OK;
 
-    auto sideFlasher = Runtime.device().sideFlasher();
+    auto sideFlasher           = Runtime.device().sideFlasher();
-    uint8_t left_boot_address = Runtime.device().side.left_boot_address;
+    uint8_t left_boot_address  = Runtime.device().side.left_boot_address;
     uint8_t right_boot_address = Runtime.device().side.right_boot_address;
     enum {
       FLASH,
@@ -51,16 +52,16 @@ class SideFlash : public kaleidoscope::Plugin {
 
     if (strcmp_P(command + 9, PSTR("flash_left_side")) == 0) {
       sub_command = FLASH;
-      address = left_boot_address;
+      address     = left_boot_address;
     } else if (strcmp_P(command + 9, PSTR("flash_right_side")) == 0) {
       sub_command = FLASH;
-      address = right_boot_address;
+      address     = right_boot_address;
     } else if (strcmp_P(command + 9, PSTR("verify_left_side")) == 0) {
       sub_command = VERIFY;
-      address = left_boot_address;
+      address     = left_boot_address;
     } else if (strcmp_P(command + 9, PSTR("verify_right_side")) == 0) {
       sub_command = VERIFY;
-      address = right_boot_address;
+      address     = right_boot_address;
     } else {
       return EventHandlerResult::OK;
     }

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

@@ -32,7 +32,7 @@ uint8_t TWI::writeTo(uint8_t *data, size_t length) {
   Wire.beginTransmission(addr_);
 
   // calc cksum
-  uint16_t crc16 = 0xffff;
+  uint16_t crc16  = 0xffff;
   uint8_t *buffer = data;
   for (uint8_t i = 0; i < length; i++) {
     crc16 = _crc_ccitt_update(crc16, *buffer);
@@ -50,12 +50,12 @@ uint8_t TWI::writeTo(uint8_t *data, size_t length) {
   return 0;
 }
 
-uint8_t TWI::readFrom(uint8_t* data, size_t length) {
+uint8_t TWI::readFrom(uint8_t *data, size_t length) {
   uint8_t counter = 0;
   uint32_t timeout;
   uint8_t *buffer = data;
 
-  if (!Wire.requestFrom(addr_, length + 2, true)) { // + 2 for the cksum
+  if (!Wire.requestFrom(addr_, length + 2, true)) {  // + 2 for the cksum
     // in case slave is not responding - return 0 (0 length of received data).
     return 0;
   }
@@ -65,7 +65,7 @@ uint8_t TWI::readFrom(uint8_t* data, size_t length) {
     counter++;
   }
 
-  uint16_t crc16 = 0xffff;
+  uint16_t crc16    = 0xffff;
   uint16_t rx_cksum = (Wire.read() << 8) + Wire.read();
   for (uint8_t i = 0; i < length; i++) {
     crc16 = _crc_ccitt_update(crc16, *buffer);

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

@@ -29,10 +29,11 @@ namespace raise {
 
 class TWI {
  public:
-  explicit TWI(int addr) : addr_(addr), crc_errors_(0) {}
+  explicit TWI(int addr)
+    : addr_(addr), crc_errors_(0) {}
 
   uint8_t writeTo(uint8_t *data, size_t length);
-  uint8_t readFrom(uint8_t* data, size_t length);
+  uint8_t readFrom(uint8_t *data, size_t length);
   void disable();
   void init(uint16_t clock_khz);
   uint8_t crc_errors() {

plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox.cpp

@@ -53,12 +53,12 @@ void ErgoDox::setup(void) {
   TCCR1A = 0b10101001;
   TCCR1B = 0b00001001;
 
-  DDRB  &= ~(1 << 4);
+  DDRB &= ~(1 << 4);
   PORTB &= ~(1 << 4);
 
-  DDRC  &= ~(1 << 7);
+  DDRC &= ~(1 << 7);
-  DDRD  &= ~(1 << 5 | 1 << 4);
+  DDRD &= ~(1 << 5 | 1 << 4);
-  DDRE  &= ~(1 << 6);
+  DDRE &= ~(1 << 6);
   PORTC |= (1 << 7);
   PORTD |= (1 << 5 | 1 << 4);
   PORTE |= (1 << 6);
@@ -75,7 +75,7 @@ void ErgoDox::setup(void) {
 
   const uint32_t cycles = (F_CPU / 2000000) * 1700;
 
-  ICR1 = cycles;
+  ICR1   = cycles;
   TCCR1B = _BV(WGM13) | _BV(CS10);
   TIMSK1 = _BV(TOIE1);
 
@@ -148,9 +148,8 @@ void ErgoDox::setStatusLED(uint8_t led, bool state) {
 }
 
 void ErgoDox::setStatusLEDBrightness(uint8_t led, uint8_t brightness) {
-  (led == 1) ? (OCR1A = brightness) :
+  (led == 1) ? (OCR1A = brightness) : (led == 2) ? (OCR1B = brightness)
-  (led == 2) ? (OCR1B = brightness) :
+                                                 : (OCR1C = brightness);
-  (OCR1C = brightness);
 }
 
 uint8_t ErgoDox::debounceMaskForRow(uint8_t row) {
@@ -215,4 +214,4 @@ uint8_t ErgoDox::pressedKeyswitchCount() {
 }  // namespace kaleidoscope
 
 #endif
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox.h

@@ -33,14 +33,15 @@ struct cRGB {
   uint8_t r, g, b;
 };
 
-#define CRGB(r,g,b) (cRGB){b, g, r}
+#define CRGB(r, g, b) \
+  (cRGB) { b, g, r }
 
 #include "kaleidoscope/device/ATmega32U4Keyboard.h"
 #include "kaleidoscope/driver/bootloader/avr/HalfKay.h"
 #include "kaleidoscope/driver/keyscanner/Base.h"
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 #include "kaleidoscope/device/ez/ErgoDox/ErgoDoxScanner.h"
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 namespace kaleidoscope {
 namespace device {
@@ -48,10 +49,9 @@ namespace ez {
 
 struct ErgoDoxProps : public kaleidoscope::device::ATmega32U4KeyboardProps {
   struct KeyScannerProps : kaleidoscope::driver::keyscanner::BaseProps {
-    static constexpr uint8_t matrix_rows = 14;
+    static constexpr uint8_t matrix_rows    = 14;
     static constexpr uint8_t matrix_columns = 6;
     typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
-
   };
   typedef kaleidoscope::driver::bootloader::avr::HalfKay Bootloader;
   static constexpr const char *short_name = "ErgoDox-EZ";
@@ -92,9 +92,9 @@ class ErgoDox : public kaleidoscope::device::ATmega32U4Keyboard<ErgoDoxProps> {
   static void debounceRow(uint8_t change, uint8_t row);
   static void readMatrixRow(uint8_t row);
 };
-#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#else   // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 class ErgoDox;
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 // clang-format off
 

plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox/ErgoDoxScanner.cpp

@@ -34,17 +34,17 @@
 #include "kaleidoscope/device/avr/pins_and_ports.h"
 #include "kaleidoscope/device/ez/ErgoDox/i2cmaster.h"
 
-#define I2C_ADDR        0b0100000
+#define I2C_ADDR       0b0100000
-#define I2C_ADDR_WRITE  ( (I2C_ADDR<<1) | I2C_WRITE )
+#define I2C_ADDR_WRITE ((I2C_ADDR << 1) | I2C_WRITE)
-#define I2C_ADDR_READ   ( (I2C_ADDR<<1) | I2C_READ  )
+#define I2C_ADDR_READ  ((I2C_ADDR << 1) | I2C_READ)
-#define IODIRA          0x00
+#define IODIRA         0x00
-#define IODIRB          0x01
+#define IODIRB         0x01
-#define GPPUA           0x0C
+#define GPPUA          0x0C
-#define GPPUB           0x0D
+#define GPPUB          0x0D
-#define GPIOA           0x12
+#define GPIOA          0x12
-#define GPIOB           0x13
+#define GPIOB          0x13
-#define OLATA           0x14
+#define OLATA          0x14
-#define OLATB           0x15
+#define OLATB          0x15
 
 namespace kaleidoscope {
 namespace device {
@@ -90,20 +90,19 @@ out:
   return status;
 }
 
-void
+void ErgoDoxScanner::begin() {
-ErgoDoxScanner::begin() {
   expander_error_ = initExpander();
 
   // Init columns
-  DDRF  &= ~(1 << 7 | 1 << 6 | 1 << 5 | 1 << 4 | 1 << 1 | 1 << 0);
+  DDRF &= ~(1 << 7 | 1 << 6 | 1 << 5 | 1 << 4 | 1 << 1 | 1 << 0);
   PORTF |= (1 << 7 | 1 << 6 | 1 << 5 | 1 << 4 | 1 << 1 | 1 << 0);
 
   // Init rows
-  DDRB  |= (1 << 0 | 1 << 1 | 1 << 2 | 1 << 3);
+  DDRB |= (1 << 0 | 1 << 1 | 1 << 2 | 1 << 3);
   PORTB |= (1 << 0 | 1 << 1 | 1 << 2 | 1 << 3);
-  DDRD  |= (1 << 2 | 1 << 3);
+  DDRD |= (1 << 2 | 1 << 3);
   PORTD |= (1 << 2 | 1 << 3);
-  DDRC  |= (1 << 6);
+  DDRC |= (1 << 6);
   PORTC |= (1 << 6);
 }
 
@@ -118,13 +117,13 @@ void __attribute__((optimize(3))) ErgoDoxScanner::selectExtenderRow(int row) {
     expander_error_ = i2c_write(0xFF & ~(1 << row));
     if (expander_error_)
       goto out;
-out:
+  out:
     i2c_stop();
   }
 }
 
 void __attribute__((optimize(3))) ErgoDoxScanner::toggleATMegaRow(int row) {
-  static uint8_t row_pins[] = { PIN_B0, PIN_B1, PIN_B2, PIN_B3, PIN_D2, PIN_D3, PIN_C6 };
+  static uint8_t row_pins[] = {PIN_B0, PIN_B1, PIN_B2, PIN_B3, PIN_D2, PIN_D3, PIN_C6};
   OUTPUT_TOGGLE(row_pins[row]);
 }
 
@@ -148,7 +147,7 @@ ErgoDoxScanner::readCols(int row) {
 
     data = i2c_readNak();
     data = ~data;
-out:
+  out:
     i2c_stop();
     return data;
   } else {
@@ -156,8 +155,7 @@ out:
   }
 }
 
-void
+void ErgoDoxScanner::reattachExpanderOnError() {
-ErgoDoxScanner::reattachExpanderOnError() {
   static uint32_t start_time = millis();
 
   if (!expander_error_)
@@ -167,7 +165,7 @@ ErgoDoxScanner::reattachExpanderOnError() {
     return;
 
   expander_error_ = initExpander();
-  start_time = millis();
+  start_time      = millis();
 }
 
 }  // namespace ez
@@ -175,4 +173,4 @@ ErgoDoxScanner::reattachExpanderOnError() {
 }  // namespace kaleidoscope
 
 #endif
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox/i2cmaster.cpp

@@ -21,7 +21,7 @@
 #endif
 
 /* I2C clock in Hz */
-#define SCL_CLOCK  400000L
+#define SCL_CLOCK 400000L
 
 
 /*************************************************************************
@@ -36,10 +36,10 @@ void i2c_init(void) {
    * for more details, see 20.5.2 in ATmega16/32 secification
    */
 
-  TWSR = 0;     /* no prescaler */
+  TWSR = 0;  /* no prescaler */
-  TWBR = 10;    /* must be >= 10 for stable operation */
+  TWBR = 10; /* must be >= 10 for stable operation */
 
-}/* i2c_init */
+} /* i2c_init */
 
 
 /*************************************************************************
@@ -47,13 +47,14 @@ void i2c_init(void) {
   return 0 = device accessible, 1= failed to access device
 *************************************************************************/
 unsigned char i2c_start(unsigned char address) {
-  uint8_t   twst;
+  uint8_t twst;
 
   // send START condition
   TWCR = (1 << TWINT) | (1 << TWSTA) | (1 << TWEN);
 
   // wait until transmission completed
-  while (!(TWCR & (1 << TWINT)));
+  while (!(TWCR & (1 << TWINT)))
+    ;
 
   // check value of TWI Status Register. Mask prescaler bits.
   twst = TW_STATUS & 0xF8;
@@ -64,7 +65,8 @@ unsigned char i2c_start(unsigned char address) {
   TWCR = (1 << TWINT) | (1 << TWEN);
 
   // wail until transmission completed and ACK/NACK has been received
-  while (!(TWCR & (1 << TWINT)));
+  while (!(TWCR & (1 << TWINT)))
+    ;
 
   // check value of TWI Status Register. Mask prescaler bits.
   twst = TW_STATUS & 0xF8;
@@ -72,7 +74,7 @@ unsigned char i2c_start(unsigned char address) {
 
   return 0;
 
-}/* i2c_start */
+} /* i2c_start */
 
 
 /*************************************************************************
@@ -82,7 +84,7 @@ unsigned char i2c_start(unsigned char address) {
  Input:   address and transfer direction of I2C device
 *************************************************************************/
 void i2c_start_wait(unsigned char address) {
-  uint8_t   twst;
+  uint8_t twst;
 
 
   while (1) {
@@ -90,7 +92,8 @@ void i2c_start_wait(unsigned char address) {
     TWCR = (1 << TWINT) | (1 << TWSTA) | (1 << TWEN);
 
     // wait until transmission completed
-    while (!(TWCR & (1 << TWINT)));
+    while (!(TWCR & (1 << TWINT)))
+      ;
 
     // check value of TWI Status Register. Mask prescaler bits.
     twst = TW_STATUS & 0xF8;
@@ -101,7 +104,8 @@ void i2c_start_wait(unsigned char address) {
     TWCR = (1 << TWINT) | (1 << TWEN);
 
     // wail until transmission completed
-    while (!(TWCR & (1 << TWINT)));
+    while (!(TWCR & (1 << TWINT)))
+      ;
 
     // check value of TWI Status Register. Mask prescaler bits.
     twst = TW_STATUS & 0xF8;
@@ -110,7 +114,8 @@ void i2c_start_wait(unsigned char address) {
       TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO);
 
       // wait until stop condition is executed and bus released
-      while (TWCR & (1 << TWSTO));
+      while (TWCR & (1 << TWSTO))
+        ;
 
       continue;
     }
@@ -118,7 +123,7 @@ void i2c_start_wait(unsigned char address) {
     break;
   }
 
-}/* i2c_start_wait */
+} /* i2c_start_wait */
 
 
 /*************************************************************************
@@ -132,7 +137,7 @@ void i2c_start_wait(unsigned char address) {
 unsigned char i2c_rep_start(unsigned char address) {
   return i2c_start(address);
 
-}/* i2c_rep_start */
+} /* i2c_rep_start */
 
 
 /*************************************************************************
@@ -143,9 +148,10 @@ void i2c_stop(void) {
   TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO);
 
   // wait until stop condition is executed and bus released
-  while (TWCR & (1 << TWSTO));
+  while (TWCR & (1 << TWSTO))
+    ;
 
-}/* i2c_stop */
+} /* i2c_stop */
 
 
 /*************************************************************************
@@ -156,21 +162,22 @@ void i2c_stop(void) {
             1 write failed
 *************************************************************************/
 unsigned char i2c_write(unsigned char data) {
-  uint8_t   twst;
+  uint8_t twst;
 
   // send data to the previously addressed device
   TWDR = data;
   TWCR = (1 << TWINT) | (1 << TWEN);
 
   // wait until transmission completed
-  while (!(TWCR & (1 << TWINT)));
+  while (!(TWCR & (1 << TWINT)))
+    ;
 
   // check value of TWI Status Register. Mask prescaler bits
   twst = TW_STATUS & 0xF8;
   if (twst != TW_MT_DATA_ACK) return 1;
   return 0;
 
-}/* i2c_write */
+} /* i2c_write */
 
 
 /*************************************************************************
@@ -180,11 +187,12 @@ unsigned char i2c_write(unsigned char data) {
 *************************************************************************/
 unsigned char i2c_readAck(void) {
   TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWEA);
-  while (!(TWCR & (1 << TWINT)));
+  while (!(TWCR & (1 << TWINT)))
+    ;
 
   return TWDR;
 
-}/* i2c_readAck */
+} /* i2c_readAck */
 
 
 /*************************************************************************
@@ -194,11 +202,12 @@ unsigned char i2c_readAck(void) {
 *************************************************************************/
 unsigned char i2c_readNak(void) {
   TWCR = (1 << TWINT) | (1 << TWEN);
-  while (!(TWCR & (1 << TWINT)));
+  while (!(TWCR & (1 << TWINT)))
+    ;
 
   return TWDR;
 
-}/* i2c_readNak */
+} /* i2c_readNak */
 
 #endif
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox/i2cmaster.h

@@ -89,10 +89,10 @@
 #include <avr/io.h>
 
 /** defines the data direction (reading from I2C device) in i2c_start(),i2c_rep_start() */
-#define I2C_READ    1
+#define I2C_READ 1
 
 /** defines the data direction (writing to I2C device) in i2c_start(),i2c_rep_start() */
-#define I2C_WRITE   0
+#define I2C_WRITE 0
 
 
 /**
@@ -172,7 +172,7 @@ extern unsigned char i2c_readNak(void);
  @return   byte read from I2C device
  */
 extern unsigned char i2c_read(unsigned char ack);
-#define i2c_read(ack)  (ack) ? i2c_readAck() : i2c_readNak();
+#define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak();
 
 
 /**@}*/

plugins/Kaleidoscope-Hardware-GD32-Eval/src/kaleidoscope/device/gd32/Eval.cpp

@@ -24,8 +24,8 @@ namespace kaleidoscope {
 namespace device {
 namespace gd32 {
 
-} // namespace gd32
+}  // namespace gd32
-} // namespace device
+}  // namespace device
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
-#endif // ifdef ARDUINO_GD32F303ZE_EVAL
+#endif  // ifdef ARDUINO_GD32F303ZE_EVAL

plugins/Kaleidoscope-Hardware-GD32-Eval/src/kaleidoscope/device/gd32/Eval.h

@@ -30,9 +30,9 @@ namespace kaleidoscope {
 namespace device {
 namespace gd32 {
 
-struct EvalStorageProps: kaleidoscope::driver::storage::GD32FlashProps {};
+struct EvalStorageProps : kaleidoscope::driver::storage::GD32FlashProps {};
 
-struct EvalProps: kaleidoscope::device::BaseProps {
+struct EvalProps : kaleidoscope::device::BaseProps {
   typedef kaleidoscope::driver::bootloader::gd32::Base BootLoader;
   typedef eval::KeyScannerProps KeyScannerProps;
   typedef eval::KeyScanner KeyScanner;
@@ -41,7 +41,7 @@ struct EvalProps: kaleidoscope::device::BaseProps {
   static constexpr const char *short_name = "GD32Eval";
 };
 
-class Eval: public kaleidoscope::device::Base<EvalProps> {};
+class Eval : public kaleidoscope::device::Base<EvalProps> {};
 
 // clang-format off
 #define PER_KEY_DATA(dflt,                                           \
@@ -50,11 +50,11 @@ class Eval: public kaleidoscope::device::Base<EvalProps> {};
          R0C0, R0C1
 // clang-format on
 
-} // namespace gd32
+}  // namespace gd32
-} // namespace device
+}  // namespace device
 
 EXPORT_DEVICE(kaleidoscope::device::gd32::Eval)
 
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 #endif

plugins/Kaleidoscope-Hardware-GD32-Eval/src/kaleidoscope/device/gd32/eval/KeyScanner.cpp

@@ -160,9 +160,9 @@ uint8_t KeyScanner::previousPressedKeyswitchCount() {
   return count;
 }
 
-} // namespace eval
+}  // namespace eval
-} // namespace gd32
+}  // namespace gd32
-} // namespace device
+}  // namespace device
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 #endif

plugins/Kaleidoscope-Hardware-GD32-Eval/src/kaleidoscope/device/gd32/eval/KeyScanner.h

@@ -29,19 +29,20 @@ namespace gd32 {
 namespace eval {
 
 struct KeyScannerProps : public kaleidoscope::driver::keyscanner::BaseProps {
-  static constexpr uint8_t matrix_rows = 1;
+  static constexpr uint8_t matrix_rows    = 1;
   static constexpr uint8_t matrix_columns = 2;
 
-  static constexpr uint8_t matrix_row_pins[] = { PA3  };
+  static constexpr uint8_t matrix_row_pins[] = {PA3};
-  static constexpr uint8_t matrix_col_pins[] = { PE4, PD12 };
+  static constexpr uint8_t matrix_col_pins[] = {PE4, PD12};
 
   typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
 };
 
-class KeyScanner: public kaleidoscope::driver::keyscanner::Base<KeyScannerProps> {
+class KeyScanner : public kaleidoscope::driver::keyscanner::Base<KeyScannerProps> {
  private:
   typedef KeyScanner ThisType;
   typedef KeyScannerProps Props_;
+
  public:
   static bool do_scan;
 
@@ -55,6 +56,7 @@ class KeyScanner: public kaleidoscope::driver::keyscanner::Base<KeyScannerProps>
 
   static bool wasKeyswitchPressed(KeyAddr key_addr);
   static uint8_t previousPressedKeyswitchCount();
+
  private:
   /*
     each of these variables are storing the state for a row of keys
@@ -63,8 +65,8 @@ class KeyScanner: public kaleidoscope::driver::keyscanner::Base<KeyScannerProps>
     and the state in debounced_state[0].
   */
   struct debounce_t {
-    uint16_t db0;    // counter bit 0
+    uint16_t db0;              // counter bit 0
-    uint16_t db1;    // counter bit 1
+    uint16_t db1;              // counter bit 1
     uint16_t debounced_state;  // debounced state
   };
 
@@ -79,9 +81,9 @@ class KeyScanner: public kaleidoscope::driver::keyscanner::Base<KeyScannerProps>
   static uint16_t readRows();
 };
 
-} // namespace eval
+}  // namespace eval
-} // namespace gd32
+}  // namespace gd32
-} // namespace device
+}  // namespace device
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 #endif

plugins/Kaleidoscope-Hardware-KBDFans-KBD4x/src/kaleidoscope/device/kbdfans/KBD4x.cpp

@@ -26,7 +26,7 @@
 // in the global namespace within the scope of this file. We'll use these
 // aliases to simplify some template initialization code below.
 using KeyScannerProps = typename kaleidoscope::device::kbdfans::KBD4xProps::KeyScannerProps;
-using KeyScanner = typename kaleidoscope::device::kbdfans::KBD4xProps::KeyScanner;
+using KeyScanner      = typename kaleidoscope::device::kbdfans::KBD4xProps::KeyScanner;
 
 namespace kaleidoscope {
 namespace device {
@@ -44,7 +44,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
 
 // `KeyScanner` here refers to the alias set up above, just like in the
 // `KeyScannerProps` case above.
-template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
+template<>
+KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
 
 // We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
 // cannot be in a header-only driver, and must be placed here.
@@ -58,9 +59,9 @@ ISR(TIMER1_OVF_vect) {
   Runtime.device().keyScanner().do_scan_ = true;
 }
 
-} // namespace kbdfans
+}  // namespace kbdfans
-} // namespace device
+}  // namespace device
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 #endif
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

plugins/Kaleidoscope-Hardware-KBDFans-KBD4x/src/kaleidoscope/device/kbdfans/KBD4x.h

@@ -32,19 +32,19 @@ namespace device {
 namespace kbdfans {
 
 struct KBD4xProps : kaleidoscope::device::ATmega32U4KeyboardProps {
-  struct MCUProps: public kaleidoscope::driver::mcu::ATmega32U4Props {
+  struct MCUProps : public kaleidoscope::driver::mcu::ATmega32U4Props {
-    static constexpr bool disable_jtag = true;
+    static constexpr bool disable_jtag           = true;
     static constexpr bool disable_clock_division = true;
   };
   typedef kaleidoscope::driver::mcu::ATmega32U4<MCUProps> MCU;
   struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
-    static constexpr uint8_t matrix_rows = 4;
+    static constexpr uint8_t matrix_rows    = 4;
     static constexpr uint8_t matrix_columns = 12;
     typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-    static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D2, PIN_D3};
+    static constexpr uint8_t matrix_row_pins[matrix_rows]    = {PIN_D0, PIN_D1, PIN_D2, PIN_D3};
-    static constexpr uint8_t matrix_col_pins[matrix_columns] = { PIN_F0, PIN_F1, PIN_F4, PIN_F5, PIN_F6, PIN_F7, PIN_B3, PIN_B1, PIN_B0, PIN_D5, PIN_B7, PIN_C7 };
+    static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_F0, PIN_F1, PIN_F4, PIN_F5, PIN_F6, PIN_F7, PIN_B3, PIN_B1, PIN_B0, PIN_D5, PIN_B7, PIN_C7};
-#endif // KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // KALEIDOSCOPE_VIRTUAL_BUILD
   };
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
   typedef kaleidoscope::driver::bootloader::avr::FLIP Bootloader;
@@ -52,8 +52,8 @@ struct KBD4xProps : kaleidoscope::device::ATmega32U4KeyboardProps {
 };
 
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-class KBD4x: public kaleidoscope::device::ATmega32U4Keyboard<KBD4xProps> {};
+class KBD4x : public kaleidoscope::device::ATmega32U4Keyboard<KBD4xProps> {};
-#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#else  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are
  * some legacy extern references to boards whose definition
@@ -61,7 +61,7 @@ class KBD4x: public kaleidoscope::device::ATmega32U4Keyboard<KBD4xProps> {};
  */
 class KBD4x;
 
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 // clang-format off
 #define PER_KEY_DATA(dflt,                                                       \

plugins/Kaleidoscope-Hardware-Keyboardio-Atreus/src/kaleidoscope/device/keyboardio/Atreus2.cpp

@@ -27,7 +27,7 @@
 // in the global namespace within the scope of this file. We'll use these
 // aliases to simplify some template initialization code below.
 using KeyScannerProps = typename kaleidoscope::device::keyboardio::AtreusProps::KeyScannerProps;
-using KeyScanner = typename kaleidoscope::device::keyboardio::AtreusProps::KeyScanner;
+using KeyScanner      = typename kaleidoscope::device::keyboardio::AtreusProps::KeyScanner;
 
 namespace kaleidoscope {
 namespace device {
@@ -45,7 +45,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
 
 // `KeyScanner` here refers to the alias set up above, just like in the
 // `KeyScannerProps` case above.
-template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
+template<>
+KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
 
 // We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
 // cannot be in a header-only driver, and must be placed here.
@@ -64,4 +65,4 @@ ISR(TIMER1_OVF_vect) {
 }  // namespace kaleidoscope
 
 #endif
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

plugins/Kaleidoscope-Hardware-Keyboardio-Atreus/src/kaleidoscope/device/keyboardio/Atreus2.h

@@ -35,13 +35,13 @@ struct AtreusProps : kaleidoscope::device::ATmega32U4KeyboardProps {
   struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
 
 
-    static constexpr uint8_t matrix_rows = 4;
+    static constexpr uint8_t matrix_rows    = 4;
     static constexpr uint8_t matrix_columns = 12;
     typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-    static constexpr uint8_t matrix_row_pins[matrix_rows] =  {PIN_F6, PIN_F5, PIN_F4, PIN_F1};
+    static constexpr uint8_t matrix_row_pins[matrix_rows]    = {PIN_F6, PIN_F5, PIN_F4, PIN_F1};
     static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_F7, PIN_E2, PIN_C7, PIN_C6, PIN_B6, PIN_B5, PIN_D7, PIN_D6, PIN_D4, PIN_D5, PIN_D3, PIN_D2};
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
   };
 
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
@@ -50,8 +50,8 @@ struct AtreusProps : kaleidoscope::device::ATmega32U4KeyboardProps {
 };
 
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-class Atreus: public kaleidoscope::device::ATmega32U4Keyboard<AtreusProps> {};
+class Atreus : public kaleidoscope::device::ATmega32U4Keyboard<AtreusProps> {};
-#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#else  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are
  * some legacy extern references to boards whose definition
@@ -59,7 +59,7 @@ class Atreus: public kaleidoscope::device::ATmega32U4Keyboard<AtreusProps> {};
  */
 class Atreus;
 
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 // clang-format off
 

plugins/Kaleidoscope-Hardware-Keyboardio-Imago/src/kaleidoscope/device/keyboardio/Imago.cpp

@@ -24,7 +24,7 @@ extern "C" {
 #include "twi.h"
 }
 
-#define ELEMENTS(arr)  (sizeof(arr) / sizeof((arr)[0]))
+#define ELEMENTS(arr)   (sizeof(arr) / sizeof((arr)[0]))
 
 #define LED_DRIVER_ADDR 0x30
 
@@ -32,7 +32,7 @@ extern "C" {
 // in the global namespace within the scope of this file. We'll use these
 // aliases to simplify some template initialization code below.
 using KeyScannerProps = typename kaleidoscope::device::keyboardio::ImagoProps::KeyScannerProps;
-using KeyScanner = typename kaleidoscope::device::keyboardio::ImagoProps::KeyScanner;
+using KeyScanner      = typename kaleidoscope::device::keyboardio::ImagoProps::KeyScanner;
 
 namespace kaleidoscope {
 namespace device {
@@ -42,18 +42,18 @@ constexpr uint8_t ImagoLEDDriverProps::key_led_map[] PROGMEM;
 
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
-static constexpr uint8_t CMD_SET_REGISTER = 0xFD;
+static constexpr uint8_t CMD_SET_REGISTER  = 0xFD;
-static constexpr uint8_t CMD_WRITE_ENABLE = 0xFE;
+static constexpr uint8_t CMD_WRITE_ENABLE  = 0xFE;
 static constexpr uint8_t WRITE_ENABLE_ONCE = 0b11000101;
 
-static constexpr uint8_t LED_REGISTER_PWM0 = 0x00;
+static constexpr uint8_t LED_REGISTER_PWM0    = 0x00;
-static constexpr uint8_t LED_REGISTER_PWM1 = 0x01;
+static constexpr uint8_t LED_REGISTER_PWM1    = 0x01;
-static constexpr uint8_t LED_REGISTER_DATA0 = 0x02;
+static constexpr uint8_t LED_REGISTER_DATA0   = 0x02;
-static constexpr uint8_t LED_REGISTER_DATA1 = 0x03;
+static constexpr uint8_t LED_REGISTER_DATA1   = 0x03;
 static constexpr uint8_t LED_REGISTER_CONTROL = 0x04;
 
-static constexpr uint8_t LED_REGISTER_PWM0_SIZE = 0xB4;
+static constexpr uint8_t LED_REGISTER_PWM0_SIZE  = 0xB4;
-static constexpr uint8_t LED_REGISTER_PWM1_SIZE = 0xAB;
+static constexpr uint8_t LED_REGISTER_PWM1_SIZE  = 0xAB;
 static constexpr uint8_t LED_REGISTER_DATA0_SIZE = 0xB4;
 static constexpr uint8_t LED_REGISTER_DATA1_SIZE = 0xAB;
 
@@ -71,7 +71,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
 
 // `KeyScanner` here refers to the alias set up above, just like in the
 // `KeyScannerProps` case above.
-template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
+template<>
+KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
 
 // We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
 // cannot be in a header-only driver, and must be placed here.
@@ -92,17 +93,17 @@ uint8_t ImagoLEDDriver::brightness_adjustment_;
 void ImagoLEDDriver::setup() {
   setAllPwmTo(0xFF);
   selectRegister(LED_REGISTER_CONTROL);
-  twiSend(LED_DRIVER_ADDR, 0x01, 0xFF); //global current
+  twiSend(LED_DRIVER_ADDR, 0x01, 0xFF);  //global current
-  twiSend(LED_DRIVER_ADDR, 0x00, 0x01); //normal operation
+  twiSend(LED_DRIVER_ADDR, 0x00, 0x01);  //normal operation
 }
 
 void ImagoLEDDriver::twiSend(uint8_t addr, uint8_t Reg_Add, uint8_t Reg_Dat) {
-  uint8_t data[] = {Reg_Add, Reg_Dat };
+  uint8_t data[] = {Reg_Add, Reg_Dat};
   uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0);
 }
 
 void ImagoLEDDriver::unlockRegister(void) {
-  twiSend(LED_DRIVER_ADDR, CMD_WRITE_ENABLE, WRITE_ENABLE_ONCE); //unlock
+  twiSend(LED_DRIVER_ADDR, CMD_WRITE_ENABLE, WRITE_ENABLE_ONCE);  //unlock
 }
 
 void ImagoLEDDriver::selectRegister(uint8_t page) {
@@ -139,18 +140,18 @@ uint8_t ImagoLEDDriver::adjustBrightness(uint8_t value) {
 }
 
 void ImagoLEDDriver::syncLeds() {
-//  if (!isLEDChanged)
+  //  if (!isLEDChanged)
-//   return;
+  //   return;
 
   uint8_t data[LED_REGISTER_DATA_LARGEST + 1];
-  data[0] = 0;// the address of the first byte to copy in
+  data[0]          = 0;  // the address of the first byte to copy in
   uint8_t last_led = 0;
 
   // Write the first LED bank
   selectRegister(LED_REGISTER_DATA0);
 
   for (auto i = 1; i < LED_REGISTER_DATA0_SIZE; i += 3) {
-    data[i] = adjustBrightness(led_data[last_led].b);
+    data[i]     = adjustBrightness(led_data[last_led].b);
     data[i + 1] = adjustBrightness(led_data[last_led].g);
     data[i + 2] = adjustBrightness(led_data[last_led].r);
     last_led++;
@@ -170,7 +171,7 @@ void ImagoLEDDriver::syncLeds() {
   selectRegister(LED_REGISTER_DATA1);
 
   for (auto i = 1; i < LED_REGISTER_DATA1_SIZE; i += 3) {
-    data[i] = adjustBrightness(led_data[last_led].b);
+    data[i]     = adjustBrightness(led_data[last_led].b);
     data[i + 1] = adjustBrightness(led_data[last_led].g);
     data[i + 2] = adjustBrightness(led_data[last_led].r);
     last_led++;
@@ -186,11 +187,10 @@ void ImagoLEDDriver::setAllPwmTo(uint8_t step) {
   selectRegister(LED_REGISTER_PWM0);
 
   uint8_t data[0xB5] = {};
-  data[0] = 0;
+  data[0]            = 0;
   // PWM Register 0 is 0x00 to 0xB3
   for (auto i = 1; i <= 0xB4; i++) {
     data[i] = step;
-
   }
   twi_writeTo(LED_DRIVER_ADDR, data, 0xB5, 1, 0);
 
@@ -198,7 +198,6 @@ void ImagoLEDDriver::setAllPwmTo(uint8_t step) {
   // PWM Register 1 is 0x00 to 0xAA
   for (auto i = 1; i <= LED_REGISTER_PWM1_SIZE; i++) {
     data[i] = step;
-
   }
   twi_writeTo(LED_DRIVER_ADDR, data, 0xAC, 1, 0);
 }
@@ -215,7 +214,7 @@ void Imago::setup() {
   kaleidoscope::device::ATmega32U4Keyboard<ImagoProps>::setup();
 }
 
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 }  // namespace keyboardio
 }  // namespace device

plugins/Kaleidoscope-Hardware-Keyboardio-Imago/src/kaleidoscope/device/keyboardio/Imago.h

@@ -27,7 +27,8 @@ struct cRGB {
   uint8_t r;
 };
 
-#define CRGB(r,g,b) (cRGB){b, g, r}
+#define CRGB(r, g, b) \
+  (cRGB) { b, g, r }
 
 #include "kaleidoscope/device/ATmega32U4Keyboard.h"
 #include "kaleidoscope/driver/bootloader/avr/Caterina.h"
@@ -40,8 +41,8 @@ namespace keyboardio {
 
 using kaleidoscope::driver::led::no_led;
 
-struct ImagoLEDDriverProps: public kaleidoscope::driver::led::BaseProps {
+struct ImagoLEDDriverProps : public kaleidoscope::driver::led::BaseProps {
-  static constexpr uint8_t led_count = 78;
+  static constexpr uint8_t led_count                       = 78;
   static constexpr uint8_t key_led_map[/* 5*16 */] PROGMEM = {
     // clang-format off
     104,   0,     1,     2,     3,    4,    5,     6,    7,     8,    9,   10,   11,   115,   12,   116,
@@ -62,14 +63,14 @@ class ImagoLEDDriver : public kaleidoscope::driver::led::Base<ImagoLEDDriverProp
   static cRGB getCrgbAt(uint8_t i);
   static void setBrightness(uint8_t brightness) {
     brightness_adjustment_ = 255 - brightness;
-    isLEDChanged = true;
+    isLEDChanged           = true;
   }
   static uint8_t getBrightness() {
     return 255 - brightness_adjustment_;
   }
 
-  static cRGB led_data[117]; // 117 is the number of LEDs the chip drives
+  static cRGB led_data[117];  // 117 is the number of LEDs the chip drives
-  // until we clean stuff up a bit, it's easiest to just have the whole struct around
+                              // until we clean stuff up a bit, it's easiest to just have the whole struct around
 
  private:
   static uint8_t brightness_adjustment_;
@@ -81,19 +82,19 @@ class ImagoLEDDriver : public kaleidoscope::driver::led::Base<ImagoLEDDriverProp
   static void setAllPwmTo(uint8_t);
   static void twiSend(uint8_t addr, uint8_t Reg_Add, uint8_t Reg_Dat);
 };
-#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#else   // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 class ImagoLEDDriver;
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 struct ImagoProps : kaleidoscope::device::ATmega32U4KeyboardProps {
   struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
-    static constexpr uint8_t matrix_rows = 5;
+    static constexpr uint8_t matrix_rows    = 5;
     static constexpr uint8_t matrix_columns = 16;
     typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-    static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_F6, PIN_F5, PIN_F4, PIN_F1, PIN_F0};
+    static constexpr uint8_t matrix_row_pins[matrix_rows]    = {PIN_F6, PIN_F5, PIN_F4, PIN_F1, PIN_F0};
-    static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_B2, PIN_B7, PIN_E2, PIN_C7, PIN_C6, PIN_B6, PIN_B5, PIN_B4, PIN_D7, PIN_D6,  PIN_D4, PIN_D5, PIN_D3, PIN_D2, PIN_E6, PIN_F7};
+    static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_B2, PIN_B7, PIN_E2, PIN_C7, PIN_C6, PIN_B6, PIN_B5, PIN_B4, PIN_D7, PIN_D6, PIN_D4, PIN_D5, PIN_D3, PIN_D2, PIN_E6, PIN_F7};
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
   };
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
   typedef ImagoLEDDriverProps LEDDriverProps;
@@ -103,11 +104,11 @@ struct ImagoProps : kaleidoscope::device::ATmega32U4KeyboardProps {
 };
 
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-class Imago: public kaleidoscope::device::ATmega32U4Keyboard<ImagoProps> {
+class Imago : public kaleidoscope::device::ATmega32U4Keyboard<ImagoProps> {
  public:
   void setup();
 };
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 // clang-format off
 #define PER_KEY_DATA(dflt,                                              \

plugins/Kaleidoscope-Hardware-Keyboardio-Imago/src/kaleidoscope/device/keyboardio/twi.h

@@ -44,14 +44,14 @@ void twi_init(void);
 void twi_disable(void);
 void twi_setAddress(uint8_t);
 void twi_setFrequency(uint32_t);
-uint8_t twi_readFrom(uint8_t, uint8_t*, uint8_t, uint8_t);
+uint8_t twi_readFrom(uint8_t, uint8_t *, uint8_t, uint8_t);
-uint8_t twi_writeTo(uint8_t, uint8_t*, uint8_t, uint8_t, uint8_t);
+uint8_t twi_writeTo(uint8_t, uint8_t *, uint8_t, uint8_t, uint8_t);
-uint8_t twi_transmit(const uint8_t*, uint8_t);
+uint8_t twi_transmit(const uint8_t *, uint8_t);
-void twi_attachSlaveRxEvent(void (*)(uint8_t*, int));
+void twi_attachSlaveRxEvent(void (*)(uint8_t *, int));
 void twi_attachSlaveTxEvent(void (*)(void));
 void twi_reply(uint8_t);
 void twi_stop(void);
 void twi_releaseBus(void);
 
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 #endif

plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/device/keyboardio/Model01.cpp

@@ -20,15 +20,15 @@
 #include "kaleidoscope/device/keyboardio/Model01.h"
 
 // System headers
-#include <stdint.h>                                  // for uint8_t
+#include <stdint.h>  // for uint8_t
 
 // Arduino headers
-#include <Arduino.h>                                 // for PROGMEM
+#include <Arduino.h>  // for PROGMEM
 
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 #include <KeyboardioHID.h>
 #include <avr/wdt.h>
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 // Kaleidoscope headers
 #include "kaleidoscope/driver/keyscanner/Base_Impl.h"  // IWYU pragma: keep
@@ -63,8 +63,8 @@ void Model01Hands::setup(void) {
   PORTE &= ~_BV(6);
 
   // Set B4, the overcurrent check to an input with an internal pull-up
-  DDRB &= ~_BV(4);	// set bit, input
+  DDRB &= ~_BV(4);   // set bit, input
-  PORTB &= ~_BV(4);	// set bit, enable pull-up resistor
+  PORTB &= ~_BV(4);  // set bit, enable pull-up resistor
 }
 
 /********* LED Driver *********/
@@ -163,7 +163,7 @@ void Model01KeyScanner::setup() {
 
 void Model01KeyScanner::readMatrix() {
   //scan the Keyboard matrix looking for connections
-  previousLeftHandState = leftHandState;
+  previousLeftHandState  = leftHandState;
   previousRightHandState = rightHandState;
 
   if (Model01Hands::leftHand.readKeys()) {
@@ -180,12 +180,12 @@ void Model01KeyScanner::actOnHalfRow(uint8_t row, uint8_t colState, uint8_t colP
     for (uint8_t col = 0; col < 8; col++) {
       // Build up the key state for row, col
       uint8_t keyState = ((bitRead(colPrevState, 0) << 0) |
-                          (bitRead(colState,     0) << 1));
+                          (bitRead(colState, 0) << 1));
       if (keyState)
         ThisType::handleKeyswitchEvent(Key_NoKey, KeyAddr(row, startPos - col), keyState);
 
       // Throw away the data we've just used, so we can read the next column
-      colState = colState >> 1;
+      colState     = colState >> 1;
       colPrevState = colPrevState >> 1;
     }
   }
@@ -243,7 +243,7 @@ void Model01::setup() {
   Model01Hands::setup();
   kaleidoscope::device::Base<Model01Props>::setup();
 
-  TWBR = 12; // This is 400mhz, which is the fastest we can drive the ATTiny
+  TWBR = 12;  // This is 400mhz, which is the fastest we can drive the ATTiny
 }
 
 void Model01::enableHardwareTestMode() {

plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/device/keyboardio/Model01.h

@@ -22,15 +22,16 @@
 #ifdef ARDUINO_AVR_MODEL01
 
 // System headers
-#include <stdint.h>                                       // for uint8_t
+#include <stdint.h>  // for uint8_t
 // Arduino headers
-#include <Arduino.h>                                      // for PROGMEM
+#include <Arduino.h>  // for PROGMEM
 
 // Kaleidoscope headers
-#include "kaleidoscope/MatrixAddr.h"                      // for MatrixAddr
+#include "kaleidoscope/MatrixAddr.h"     // for MatrixAddr
-#include "kaleidoscope/macro_helpers.h"                   // for RESTRICT_AR...
+#include "kaleidoscope/macro_helpers.h"  // for RESTRICT_AR...
 
-#define CRGB(r,g,b) (cRGB){b, g, r}
+#define CRGB(r, g, b) \
+  (cRGB) { b, g, r }
 
 struct cRGB {
   uint8_t b;
@@ -44,14 +45,14 @@ struct cRGB {
 #include "kaleidoscope/driver/led/Base.h"                 // for BaseProps
 
 // Kaleidoscope-Hardware-Keyboardio-Model01 headers
-#include "kaleidoscope/driver/keyboardio/Model01Side.h"   // for keydata_t
+#include "kaleidoscope/driver/keyboardio/Model01Side.h"  // for keydata_t
 
 namespace kaleidoscope {
 namespace device {
 namespace keyboardio {
 
 struct Model01LEDDriverProps : public kaleidoscope::driver::led::BaseProps {
-  static constexpr uint8_t led_count = 64;
+  static constexpr uint8_t led_count             = 64;
   static constexpr uint8_t key_led_map[] PROGMEM = {
     // clang-format off
     3, 4, 11, 12, 19, 20, 26, 27,     36, 37, 43, 44, 51, 52, 59, 60,
@@ -77,12 +78,12 @@ class Model01LEDDriver : public kaleidoscope::driver::led::Base<Model01LEDDriver
  private:
   static bool isLEDChanged;
 };
-#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#else   // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 class Model01LEDDriver;
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 struct Model01KeyScannerProps : public kaleidoscope::driver::keyscanner::BaseProps {
-  static constexpr uint8_t matrix_rows = 4;
+  static constexpr uint8_t matrix_rows    = 4;
   static constexpr uint8_t matrix_columns = 16;
   typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
 };
@@ -91,6 +92,7 @@ struct Model01KeyScannerProps : public kaleidoscope::driver::keyscanner::BasePro
 class Model01KeyScanner : public kaleidoscope::driver::keyscanner::Base<Model01KeyScannerProps> {
  private:
   typedef Model01KeyScanner ThisType;
+
  public:
   static void setup();
   static void scanMatrix();
@@ -114,12 +116,12 @@ class Model01KeyScanner : public kaleidoscope::driver::keyscanner::Base<Model01K
   static void actOnHalfRow(byte row, byte colState, byte colPrevState, byte startPos);
   static void enableScannerPower();
 };
-#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#else   // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 class Model01KeyScanner;
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 struct Model01Props : public kaleidoscope::device::ATmega32U4KeyboardProps {
-  typedef Model01LEDDriverProps  LEDDriverProps;
+  typedef Model01LEDDriverProps LEDDriverProps;
   typedef Model01LEDDriver LEDDriver;
   typedef Model01KeyScannerProps KeyScannerProps;
   typedef Model01KeyScanner KeyScanner;
@@ -136,10 +138,10 @@ class Model01 : public kaleidoscope::device::ATmega32U4Keyboard<Model01Props> {
   static void enableHardwareTestMode();
 };
 
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
-} // namespace keyboardio
+}  // namespace keyboardio
-} // namespace device
+}  // namespace device
 
 EXPORT_DEVICE(kaleidoscope::device::keyboardio::Model01)
 

plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/device/keyboardio/twi.h

@@ -44,14 +44,14 @@ void twi_init(void);
 void twi_disable(void);
 void twi_setAddress(uint8_t);
 void twi_setFrequency(uint32_t);
-uint8_t twi_readFrom(uint8_t, uint8_t*, uint8_t, uint8_t);
+uint8_t twi_readFrom(uint8_t, uint8_t *, uint8_t, uint8_t);
-uint8_t twi_writeTo(uint8_t, uint8_t*, uint8_t, uint8_t, uint8_t);
+uint8_t twi_writeTo(uint8_t, uint8_t *, uint8_t, uint8_t, uint8_t);
-uint8_t twi_transmit(const uint8_t*, uint8_t);
+uint8_t twi_transmit(const uint8_t *, uint8_t);
-void twi_attachSlaveRxEvent(void (*)(uint8_t*, int));
+void twi_attachSlaveRxEvent(void (*)(uint8_t *, int));
 void twi_attachSlaveTxEvent(void (*)(void));
 void twi_reply(uint8_t);
 void twi_stop(void);
 void twi_releaseBus(void);
 
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 #endif

plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/driver/keyboardio/Model01Side.cpp

@@ -40,7 +40,7 @@ namespace driver {
 namespace keyboardio {
 
 #define SCANNER_I2C_ADDR_BASE 0x58
-#define ELEMENTS(arr)  (sizeof(arr) / sizeof((arr)[0]))
+#define ELEMENTS(arr)         (sizeof(arr) / sizeof((arr)[0]))
 
 uint8_t twi_uninitialized = 1;
 
@@ -82,8 +82,6 @@ uint8_t Model01Side::setKeyscanInterval(uint8_t delay) {
 }
 
 
-
-
 // returns -1 on error, otherwise returns the scanner version integer
 int Model01Side::readVersion() {
   return readRegister(TWI_CMD_VERSION);
@@ -113,7 +111,6 @@ uint8_t Model01Side::setLEDSPIFrequency(uint8_t frequency) {
 }
 
 
-
 int Model01Side::readRegister(uint8_t cmd) {
 
   uint8_t return_value = 0;
@@ -122,8 +119,7 @@ int Model01Side::readRegister(uint8_t cmd) {
   uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0);
 
 
-
+  delayMicroseconds(15);  // We may be able to drop this in the future
-  delayMicroseconds(15); // We may be able to drop this in the future
   // but will need to verify with correctly
   // sized pull-ups on both the left and right
   // hands' i2c SDA and SCL lines
@@ -137,7 +133,6 @@ int Model01Side::readRegister(uint8_t cmd) {
   } else {
     return -1;
   }
-
 }
 
 
@@ -174,8 +169,8 @@ auto constexpr gamma8 = kaleidoscope::driver::color::gamma_correction;
 
 void Model01Side::sendLEDBank(uint8_t bank) {
   uint8_t data[LED_BYTES_PER_BANK + 1];
-  data[0]  = TWI_CMD_LED_BASE + bank;
+  data[0] = TWI_CMD_LED_BASE + bank;
-  for (uint8_t i = 0 ; i < LED_BYTES_PER_BANK; i++) {
+  for (uint8_t i = 0; i < LED_BYTES_PER_BANK; i++) {
     /* While the ATTiny controller does have a global brightness command, it is
      * limited to 32 levels, and those aren't nicely spread out either. For this
      * reason, we're doing our own brightness adjustment on this side, because
@@ -195,8 +190,7 @@ void Model01Side::setAllLEDsTo(cRGB color) {
   uint8_t data[] = {TWI_CMD_LED_SET_ALL_TO,
                     pgm_read_byte(&gamma8[color.b]),
                     pgm_read_byte(&gamma8[color.g]),
-                    pgm_read_byte(&gamma8[color.r])
+                    pgm_read_byte(&gamma8[color.r])};
-                   };
   uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0);
 }
 
@@ -205,14 +199,12 @@ void Model01Side::setOneLEDTo(uint8_t led, cRGB color) {
                     led,
                     pgm_read_byte(&gamma8[color.b]),
                     pgm_read_byte(&gamma8[color.g]),
-                    pgm_read_byte(&gamma8[color.r])
+                    pgm_read_byte(&gamma8[color.r])};
-                   };
   uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0);
-
 }
 
-} // namespace keyboardio
+}  // namespace keyboardio
-} // namespace driver
+}  // namespace driver
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/driver/keyboardio/Model01Side.h

@@ -34,13 +34,14 @@ struct cRGB {
   uint8_t g;
   uint8_t r;
 };
-#define CRGB(r,g,b) (cRGB){b, g, r}
+#define CRGB(r, g, b) \
+  (cRGB) { b, g, r }
 #endif
 
-#define LED_BANKS 4
+#define LED_BANKS          4
 
-#define LEDS_PER_HAND 32
+#define LEDS_PER_HAND      32
-#define LED_BYTES_PER_BANK sizeof(cRGB)  * LEDS_PER_HAND/LED_BANKS
+#define LED_BYTES_PER_BANK sizeof(cRGB) * LEDS_PER_HAND / LED_BANKS
 
 namespace kaleidoscope {
 namespace driver {
@@ -97,8 +98,8 @@ class Model01Side {
   void sendLEDBank(uint8_t bank);
   int readRegister(uint8_t cmd);
 };
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
-} // namespace keyboardio
+}  // namespace keyboardio
-} // namespace driver
+}  // namespace driver
-} // namespace kaleidoscope
+}  // namespace kaleidoscope

plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/driver/keyboardio/wire-protocol-constants.h

@@ -22,22 +22,22 @@
 
 #pragma once
 
-#define TWI_CMD_NONE 0x00
+#define TWI_CMD_NONE              0x00
-#define TWI_CMD_VERSION 0x01
+#define TWI_CMD_VERSION           0x01
-#define TWI_CMD_KEYSCAN_INTERVAL 0x02
+#define TWI_CMD_KEYSCAN_INTERVAL  0x02
-#define TWI_CMD_LED_SET_ALL_TO 0x03
+#define TWI_CMD_LED_SET_ALL_TO    0x03
-#define TWI_CMD_LED_SET_ONE_TO 0x04
+#define TWI_CMD_LED_SET_ONE_TO    0x04
-#define TWI_CMD_COLS_USE_PULLUPS 0x05
+#define TWI_CMD_COLS_USE_PULLUPS  0x05
 #define TWI_CMD_LED_SPI_FREQUENCY 0x06
 
-#define LED_SPI_FREQUENCY_4MHZ      0x07
+#define LED_SPI_FREQUENCY_4MHZ    0x07
-#define LED_SPI_FREQUENCY_2MHZ      0x06
+#define LED_SPI_FREQUENCY_2MHZ    0x06
-#define LED_SPI_FREQUENCY_1MHZ      0x05
+#define LED_SPI_FREQUENCY_1MHZ    0x05
-#define LED_SPI_FREQUENCY_512KHZ    0x04
+#define LED_SPI_FREQUENCY_512KHZ  0x04
-#define LED_SPI_FREQUENCY_256KHZ    0x03
+#define LED_SPI_FREQUENCY_256KHZ  0x03
-#define LED_SPI_FREQUENCY_128KHZ    0x02
+#define LED_SPI_FREQUENCY_128KHZ  0x02
-#define LED_SPI_FREQUENCY_64KHZ     0x01
+#define LED_SPI_FREQUENCY_64KHZ   0x01
-#define LED_SPI_OFF                 0x00
+#define LED_SPI_OFF               0x00
 
 
 // 512KHZ seems to be the sweet spot in early testing
@@ -45,7 +45,7 @@
 #define LED_SPI_FREQUENCY_DEFAULT LED_SPI_FREQUENCY_512KHZ
 
 
-#define TWI_CMD_LED_BASE 0x80
+#define TWI_CMD_LED_BASE          0x80
 
-#define TWI_REPLY_NONE 0x00
+#define TWI_REPLY_NONE            0x00
-#define TWI_REPLY_KEYDATA 0x01
+#define TWI_REPLY_KEYDATA         0x01

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

@@ -19,8 +19,8 @@
 
 #include "kaleidoscope/device/keyboardio/Model100.h"
 
-#include <Arduino.h>                                   // for PROGMEM
+#include <Arduino.h>  // for PROGMEM
-#include <Wire.h>                                      // for Wire
+#include <Wire.h>     // for Wire
 
 #include "kaleidoscope/driver/keyscanner/Base_Impl.h"  // For Base<>
 
@@ -48,7 +48,6 @@ void Model100Hands::setup(void) {
   Model100KeyScanner::enableScannerPower();
   Wire.begin();
   Wire.setClock(400000);
-
 }
 
 /********* LED Driver *********/
@@ -125,9 +124,9 @@ driver::keyboardio::keydata_t Model100KeyScanner::previousLeftHandState;
 driver::keyboardio::keydata_t Model100KeyScanner::previousRightHandState;
 
 void Model100KeyScanner::enableScannerPower(void) {
-// Turn on the switched 5V network.
+  // Turn on the switched 5V network.
-//  make sure this happens at least 100ms after USB connect
+  //  make sure this happens at least 100ms after USB connect
-// to satisfy inrush limits
+  // to satisfy inrush limits
   //
   pinMode(PB9, OUTPUT_OPEN_DRAIN);
   digitalWrite(PB9, LOW);
@@ -141,7 +140,6 @@ void Model100KeyScanner::disableScannerPower(void) {
 }
 
 
-
 void Model100KeyScanner::setup() {
   enableScannerPower();
   delay(250);
@@ -149,7 +147,7 @@ void Model100KeyScanner::setup() {
 
 void Model100KeyScanner::readMatrix() {
   //scan the Keyboard matrix looking for connections
-  previousLeftHandState = leftHandState;
+  previousLeftHandState  = leftHandState;
   previousRightHandState = rightHandState;
 
   if (Model100Hands::leftHand.readKeys()) {
@@ -166,12 +164,12 @@ void Model100KeyScanner::actOnHalfRow(uint8_t row, uint8_t colState, uint8_t col
     for (uint8_t col = 0; col < 8; col++) {
       // Build up the key state for row, col
       uint8_t keyState = ((bitRead(colPrevState, 0) << 0) |
-                          (bitRead(colState,     0) << 1));
+                          (bitRead(colState, 0) << 1));
       if (keyState)
         ThisType::handleKeyswitchEvent(Key_NoKey, KeyAddr(row, startPos - col), keyState);
 
       // Throw away the data we've just used, so we can read the next column
-      colState = colState >> 1;
+      colState     = colState >> 1;
       colPrevState = colPrevState >> 1;
     }
   }

plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/Model100.h

@@ -25,7 +25,8 @@
 
 #include <Arduino.h>
 
-#define CRGB(r,g,b) (cRGB){b, g, r}
+#define CRGB(r, g, b) \
+  (cRGB) { b, g, r }
 
 struct cRGB {
   uint8_t b;
@@ -47,13 +48,13 @@ namespace kaleidoscope {
 namespace device {
 namespace keyboardio {
 
-struct Model100StorageProps: public kaleidoscope::driver::storage::GD32FlashProps {
+struct Model100StorageProps : public kaleidoscope::driver::storage::GD32FlashProps {
   static constexpr uint16_t length = EEPROM_EMULATION_SIZE;
 };
 
 
 struct Model100LEDDriverProps : public kaleidoscope::driver::led::BaseProps {
-  static constexpr uint8_t led_count = 64;
+  static constexpr uint8_t led_count             = 64;
   static constexpr uint8_t key_led_map[] PROGMEM = {
     // clang-format off
     3, 4, 11, 12, 19, 20, 26, 27,     36, 37, 43, 44, 51, 52, 59, 60,
@@ -78,12 +79,12 @@ class Model100LEDDriver : public kaleidoscope::driver::led::Base<Model100LEDDriv
  private:
   static bool isLEDChanged;
 };
-#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#else   // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 class Model100LEDDriver;
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 struct Model100KeyScannerProps : public kaleidoscope::driver::keyscanner::BaseProps {
-  static constexpr uint8_t matrix_rows = 4;
+  static constexpr uint8_t matrix_rows    = 4;
   static constexpr uint8_t matrix_columns = 16;
   typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
 };
@@ -92,6 +93,7 @@ struct Model100KeyScannerProps : public kaleidoscope::driver::keyscanner::BasePr
 class Model100KeyScanner : public kaleidoscope::driver::keyscanner::Base<Model100KeyScannerProps> {
  private:
   typedef Model100KeyScanner ThisType;
+
  public:
   static void setup();
   static void scanMatrix();
@@ -116,13 +118,13 @@ class Model100KeyScanner : public kaleidoscope::driver::keyscanner::Base<Model10
 
   static void actOnHalfRow(uint8_t row, uint8_t colState, uint8_t colPrevState, uint8_t startPos);
 };
-#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#else   // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 class Model100KeyScanner;
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 
 // If we need to override HID props:
-struct Model100HIDProps: public kaleidoscope::driver::hid::KeyboardioProps {
+struct Model100HIDProps : public kaleidoscope::driver::hid::KeyboardioProps {
   //typedef kaleidoscope::driver::hid::base::AbsoluteMouseProps AbsoluteMouseProps;
   //typedef kaleidoscope::driver::hid::base::AbsoluteMouse<AbsoluteMouseProps> AbsoluteMouse;
 };
@@ -132,7 +134,7 @@ struct Model100Props : public kaleidoscope::device::BaseProps {
   typedef Model100HIDProps HIDProps;
   typedef kaleidoscope::driver::hid::Keyboardio<HIDProps> HID;
 
-  typedef Model100LEDDriverProps  LEDDriverProps;
+  typedef Model100LEDDriverProps LEDDriverProps;
   typedef Model100LEDDriver LEDDriver;
 
   typedef Model100KeyScannerProps KeyScannerProps;
@@ -158,10 +160,10 @@ class Model100 : public kaleidoscope::device::Base<Model100Props> {
   static void enableHardwareTestMode();
 };
 
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
-} // namespace keyboardio
+}  // namespace keyboardio
-} // namespace device
+}  // namespace device
 
 EXPORT_DEVICE(kaleidoscope::device::keyboardio::Model100)
 

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

@@ -36,7 +36,7 @@ namespace driver {
 namespace keyboardio {
 
 #define SCANNER_I2C_ADDR_BASE 0x58
-#define ELEMENTS(arr)  (sizeof(arr) / sizeof((arr)[0]))
+#define ELEMENTS(arr)         (sizeof(arr) / sizeof((arr)[0]))
 
 uint8_t twi_uninitialized = 1;
 
@@ -75,8 +75,6 @@ uint8_t Model100Side::setKeyscanInterval(uint8_t delay) {
 }
 
 
-
-
 // returns -1 on error, otherwise returns the scanner version integer
 int Model100Side::readVersion() {
   return readRegister(TWI_CMD_VERSION);
@@ -100,7 +98,7 @@ int Model100Side::readLEDSPIFrequency() {
 // https://www.arduino.cc/en/Reference/WireEndTransmission
 uint8_t Model100Side::setLEDSPIFrequency(uint8_t frequency) {
   uint8_t data[] = {TWI_CMD_LED_SPI_FREQUENCY, frequency};
-  uint8_t result  = writeData(data, ELEMENTS(data));
+  uint8_t result = writeData(data, ELEMENTS(data));
 
   return result;
 }
@@ -134,11 +132,10 @@ bool Model100Side::isDeviceAvailable() {
     // we've decremented the counter, but it's not time to probe for the device yet.
     return false;
   }
-
 }
 
 void Model100Side::markDeviceUnavailable() {
-  unavailable_device_check_countdown_ = 1; // We think there was a comms problem. Check on the next cycle
+  unavailable_device_check_countdown_ = 1;  // We think there was a comms problem. Check on the next cycle
 }
 
 uint8_t Model100Side::writeData(uint8_t *data, uint8_t length) {
@@ -156,15 +153,15 @@ uint8_t Model100Side::writeData(uint8_t *data, uint8_t length) {
 
 int Model100Side::readRegister(uint8_t cmd) {
   uint8_t return_value = 0;
-  uint8_t data[] = {cmd};
+  uint8_t data[]       = {cmd};
-  uint8_t result  = writeData(data, ELEMENTS(data));
+  uint8_t result       = writeData(data, ELEMENTS(data));
 
   // If the setup failed, return. This means there was a problem asking for the register
   if (result) {
     return -1;
   }
 
-  delayMicroseconds(50); // TODO We may be able to drop this in the future
+  delayMicroseconds(50);  // TODO We may be able to drop this in the future
   // but will need to verify with correctly
   // sized pull-ups on both the left and right
   // hands' i2c SDA and SCL lines
@@ -173,14 +170,13 @@ int Model100Side::readRegister(uint8_t cmd) {
 
   // perform blocking read into buffer
 
-  Wire.requestFrom(addr, 1);    // request 1 byte from the keyscanner
+  Wire.requestFrom(addr, 1);  // request 1 byte from the keyscanner
   if (Wire.available()) {
     return Wire.read();
   } else {
     markDeviceUnavailable();
     return -1;
   }
-
 }
 
 
@@ -192,9 +188,9 @@ bool Model100Side::readKeys() {
 
   uint8_t row_counter = 0;
   // perform blocking read into buffer
-  uint8_t read = 0;
+  uint8_t read           = 0;
   uint8_t bytes_returned = 0;
-  bytes_returned = Wire.requestFrom(addr, 5);    // request 5 bytes from the keyscanner
+  bytes_returned         = Wire.requestFrom(addr, 5);  // request 5 bytes from the keyscanner
   if (bytes_returned < 5) {
     return false;
   }
@@ -224,8 +220,8 @@ void Model100Side::sendLEDData() {
 
 void Model100Side::sendLEDBank(uint8_t bank) {
   uint8_t data[LED_BYTES_PER_BANK + 1];
-  data[0]  = TWI_CMD_LED_BASE + bank;
+  data[0] = TWI_CMD_LED_BASE + bank;
-  for (uint8_t i = 0 ; i < LED_BYTES_PER_BANK; i++) {
+  for (uint8_t i = 0; i < LED_BYTES_PER_BANK; i++) {
     /* While the ATTiny controller does have a global brightness command, it is
      * limited to 32 levels, and those aren't nicely spread out either. For this
      * reason, we're doing our own brightness adjustment on this side, because
@@ -238,16 +234,15 @@ void Model100Side::sendLEDBank(uint8_t bank) {
 
     data[i + 1] = c;
   }
-  uint8_t result  = writeData(data, ELEMENTS(data));
+  uint8_t result = writeData(data, ELEMENTS(data));
 }
 
 void Model100Side::setAllLEDsTo(cRGB color) {
   uint8_t data[] = {TWI_CMD_LED_SET_ALL_TO,
                     color.b,
                     color.g,
-                    color.r
+                    color.r};
-                   };
+  uint8_t result = writeData(data, ELEMENTS(data));
-  uint8_t result  = writeData(data, ELEMENTS(data));
 }
 
 void Model100Side::setOneLEDTo(uint8_t led, cRGB color) {
@@ -255,14 +250,12 @@ void Model100Side::setOneLEDTo(uint8_t led, cRGB color) {
                     led,
                     color.b,
                     color.g,
-                    color.r
+                    color.r};
-                   };
+  uint8_t result = writeData(data, ELEMENTS(data));
-  uint8_t result  = writeData(data, ELEMENTS(data));
-
 }
 
-} // namespace keyboardio
+}  // namespace keyboardio
-} // namespace driver
+}  // namespace driver
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

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

@@ -34,13 +34,14 @@ struct cRGB {
   uint8_t g;
   uint8_t r;
 };
-#define CRGB(r,g,b) (cRGB){b, g, r}
+#define CRGB(r, g, b) \
+  (cRGB) { b, g, r }
 #endif
 
-#define LED_BANKS 4
+#define LED_BANKS          4
 
-#define LEDS_PER_HAND 32
+#define LEDS_PER_HAND      32
-#define LED_BYTES_PER_BANK sizeof(cRGB)  * LEDS_PER_HAND/LED_BANKS
+#define LED_BYTES_PER_BANK sizeof(cRGB) * LEDS_PER_HAND / LED_BANKS
 
 namespace kaleidoscope {
 namespace driver {
@@ -98,15 +99,15 @@ class Model100Side {
   keydata_t keyData;
   // a value of 0 is "device seen" - anything else is how many cycles before we should
   // check for the device
-  uint16_t unavailable_device_check_countdown_ = 0;
+  uint16_t unavailable_device_check_countdown_           = 0;
   static const uint16_t UNAVAILABLE_DEVICE_COUNTDOWN_MAX = 0x00FFU;
-  byte nextLEDBank = 0;
+  byte nextLEDBank                                       = 0;
   void sendLEDBank(byte bank);
   int readRegister(uint8_t cmd);
-  uint8_t writeData(uint8_t* data, uint8_t length);
+  uint8_t writeData(uint8_t *data, uint8_t length);
 };
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
-} // namespace keyboardio
+}  // namespace keyboardio
-} // namespace driver
+}  // namespace driver
-} // namespace kaleidoscope
+}  // namespace kaleidoscope

plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/wire-protocol-constants.h

@@ -22,22 +22,22 @@
 
 #pragma once
 
-#define TWI_CMD_NONE 0x00
+#define TWI_CMD_NONE              0x00
-#define TWI_CMD_VERSION 0x01
+#define TWI_CMD_VERSION           0x01
-#define TWI_CMD_KEYSCAN_INTERVAL 0x02
+#define TWI_CMD_KEYSCAN_INTERVAL  0x02
-#define TWI_CMD_LED_SET_ALL_TO 0x03
+#define TWI_CMD_LED_SET_ALL_TO    0x03
-#define TWI_CMD_LED_SET_ONE_TO 0x04
+#define TWI_CMD_LED_SET_ONE_TO    0x04
-#define TWI_CMD_COLS_USE_PULLUPS 0x05
+#define TWI_CMD_COLS_USE_PULLUPS  0x05
 #define TWI_CMD_LED_SPI_FREQUENCY 0x06
 
-#define LED_SPI_FREQUENCY_4MHZ      0x07
+#define LED_SPI_FREQUENCY_4MHZ    0x07
-#define LED_SPI_FREQUENCY_2MHZ      0x06
+#define LED_SPI_FREQUENCY_2MHZ    0x06
-#define LED_SPI_FREQUENCY_1MHZ      0x05
+#define LED_SPI_FREQUENCY_1MHZ    0x05
-#define LED_SPI_FREQUENCY_512KHZ    0x04
+#define LED_SPI_FREQUENCY_512KHZ  0x04
-#define LED_SPI_FREQUENCY_256KHZ    0x03
+#define LED_SPI_FREQUENCY_256KHZ  0x03
-#define LED_SPI_FREQUENCY_128KHZ    0x02
+#define LED_SPI_FREQUENCY_128KHZ  0x02
-#define LED_SPI_FREQUENCY_64KHZ     0x01
+#define LED_SPI_FREQUENCY_64KHZ   0x01
-#define LED_SPI_OFF                 0x00
+#define LED_SPI_OFF               0x00
 
 
 // 512KHZ seems to be the sweet spot in early testing
@@ -45,7 +45,7 @@
 #define LED_SPI_FREQUENCY_DEFAULT LED_SPI_FREQUENCY_512KHZ
 
 
-#define TWI_CMD_LED_BASE 0x80
+#define TWI_CMD_LED_BASE          0x80
 
-#define TWI_REPLY_NONE 0x00
+#define TWI_REPLY_NONE            0x00
-#define TWI_REPLY_KEYDATA 0x01
+#define TWI_REPLY_KEYDATA         0x01

plugins/Kaleidoscope-Hardware-OLKB-Planck/src/kaleidoscope/device/olkb/Planck.cpp

@@ -27,7 +27,7 @@
 // in the global namespace within the scope of this file. We'll use these
 // aliases to simplify some template initialization code below.
 using KeyScannerProps = typename kaleidoscope::device::olkb::PlanckProps::KeyScannerProps;
-using KeyScanner = typename kaleidoscope::device::olkb::PlanckProps::KeyScanner;
+using KeyScanner      = typename kaleidoscope::device::olkb::PlanckProps::KeyScanner;
 
 namespace kaleidoscope {
 namespace device {
@@ -45,7 +45,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
 
 // `KeyScanner` here refers to the alias set up above, just like in the
 // `KeyScannerProps` case above.
-template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
+template<>
+KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
 
 // We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
 // cannot be in a header-only driver, and must be placed here.
@@ -59,9 +60,9 @@ ISR(TIMER1_OVF_vect) {
   Runtime.device().keyScanner().do_scan_ = true;
 }
 
-} // namespace olkb
+}  // namespace olkb
-} // namespace device
+}  // namespace device
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 #endif
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

plugins/Kaleidoscope-Hardware-OLKB-Planck/src/kaleidoscope/device/olkb/Planck.h

@@ -31,13 +31,13 @@ namespace olkb {
 
 struct PlanckProps : kaleidoscope::device::ATmega32U4KeyboardProps {
   struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
-    static constexpr uint8_t matrix_rows = 4;
+    static constexpr uint8_t matrix_rows    = 4;
     static constexpr uint8_t matrix_columns = 12;
     typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-    static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D5, PIN_B5, PIN_B6};
+    static constexpr uint8_t matrix_row_pins[matrix_rows]    = {PIN_D0, PIN_D5, PIN_B5, PIN_B6};
     static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_F0, PIN_F1, PIN_F4, PIN_F5, PIN_F6, PIN_F7, PIN_B3, PIN_B1, PIN_B0, PIN_D5, PIN_B7, PIN_C7};
-#endif // KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // KALEIDOSCOPE_VIRTUAL_BUILD
   };
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
   typedef kaleidoscope::driver::bootloader::avr::HalfKay Bootloader;
@@ -45,8 +45,8 @@ struct PlanckProps : kaleidoscope::device::ATmega32U4KeyboardProps {
 };
 
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-class Planck: public kaleidoscope::device::ATmega32U4Keyboard<PlanckProps> {};
+class Planck : public kaleidoscope::device::ATmega32U4Keyboard<PlanckProps> {};
-#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#else  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are
  * some legacy extern references to boards whose definition
@@ -54,7 +54,7 @@ class Planck: public kaleidoscope::device::ATmega32U4Keyboard<PlanckProps> {};
  */
 class Planck;
 
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 // clang-format off
 #define PER_KEY_DATA(dflt,                                                       \

plugins/Kaleidoscope-Hardware-SOFTHRUF-Splitography/src/kaleidoscope/device/softhruf/Splitography.cpp

@@ -34,7 +34,7 @@
 // in the global namespace within the scope of this file. We'll use these
 // aliases to simplify some template initialization code below.
 using KeyScannerProps = typename kaleidoscope::device::softhruf::SplitographyProps::KeyScannerProps;
-using KeyScanner = typename kaleidoscope::device::softhruf::SplitographyProps::KeyScanner;
+using KeyScanner      = typename kaleidoscope::device::softhruf::SplitographyProps::KeyScanner;
 
 namespace kaleidoscope {
 namespace device {
@@ -52,7 +52,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
 
 // `KeyScanner` here refers to the alias set up above, just like in the
 // `KeyScannerProps` case above.
-template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
+template<>
+KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
 
 // We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
 // cannot be in a header-only driver, and must be placed here.
@@ -66,9 +67,9 @@ ISR(TIMER1_OVF_vect) {
   Runtime.device().keyScanner().do_scan_ = true;
 }
 
-} // namespace softhruf
+}  // namespace softhruf
-} // namespace device
+}  // namespace device
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 #endif
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

plugins/Kaleidoscope-Hardware-SOFTHRUF-Splitography/src/kaleidoscope/device/softhruf/Splitography.h

@@ -39,18 +39,18 @@ namespace device {
 namespace softhruf {
 
 struct SplitographyProps : kaleidoscope::device::ATmega32U4KeyboardProps {
-  struct MCUProps: kaleidoscope::driver::mcu::ATmega32U4Props {
+  struct MCUProps : kaleidoscope::driver::mcu::ATmega32U4Props {
     static constexpr bool disable_jtag = true;
   };
   typedef kaleidoscope::driver::mcu::ATmega32U4<MCUProps> MCU;
   struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
-    static constexpr uint8_t matrix_rows = 4;
+    static constexpr uint8_t matrix_rows    = 4;
     static constexpr uint8_t matrix_columns = 12;
     typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-    static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D2, PIN_D3};
+    static constexpr uint8_t matrix_row_pins[matrix_rows]    = {PIN_D0, PIN_D1, PIN_D2, PIN_D3};
-    static constexpr uint8_t matrix_col_pins[matrix_columns] = { PIN_F0, PIN_F1, PIN_F4, PIN_F5, PIN_F6, PIN_F7, PIN_C7, PIN_C6, PIN_B6, PIN_B5, PIN_B4, PIN_D7 };
+    static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_F0, PIN_F1, PIN_F4, PIN_F5, PIN_F6, PIN_F7, PIN_C7, PIN_C6, PIN_B6, PIN_B5, PIN_B4, PIN_D7};
-#endif // KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // KALEIDOSCOPE_VIRTUAL_BUILD
   };
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
   typedef kaleidoscope::driver::bootloader::avr::FLIP BootLoader;
@@ -58,15 +58,15 @@ struct SplitographyProps : kaleidoscope::device::ATmega32U4KeyboardProps {
 };
 
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-class Splitography: public kaleidoscope::device::ATmega32U4Keyboard<SplitographyProps> {};
+class Splitography : public kaleidoscope::device::ATmega32U4Keyboard<SplitographyProps> {};
-#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#else   // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are
  * some legacy extern references to boards whose definition
  * depends on this.
  */
 class Splitography;
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 // clang-format off
 

plugins/Kaleidoscope-Hardware-Technomancy-Atreus/src/Kaleidoscope-Hardware-Technomancy-Atreus.h

@@ -18,7 +18,7 @@
 
 #pragma once
 
-#if !defined(KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_ASTAR) && \
+#if !defined(KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_ASTAR) &&    \
   !defined(KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_ASTAR_DOWN) && \
   !defined(KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_LEGACY_TEENSY2)
 #define KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_ASTAR 1

plugins/Kaleidoscope-Hardware-Technomancy-Atreus/src/kaleidoscope/device/technomancy/Atreus.cpp

@@ -36,7 +36,7 @@
 // in the global namespace within the scope of this file. We'll use these
 // aliases to simplify some template initialization code below.
 using KeyScannerProps = typename kaleidoscope::device::technomancy::AtreusProps::KeyScannerProps;
-using KeyScanner = typename kaleidoscope::device::technomancy::AtreusProps::KeyScanner;
+using KeyScanner      = typename kaleidoscope::device::technomancy::AtreusProps::KeyScanner;
 
 
 namespace kaleidoscope {
@@ -55,7 +55,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
 
 // `KeyScanner` here refers to the alias set up above, just like in the
 // `KeyScannerProps` case above.
-template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
+template<>
+KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
 
 // We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
 // cannot be in a header-only driver, and must be placed here.
@@ -69,9 +70,9 @@ ISR(TIMER1_OVF_vect) {
   Runtime.device().keyScanner().do_scan_ = true;
 }
 
-} // namespace technomancy
+}  // namespace technomancy
-} // namespace device
+}  // namespace device
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 #endif
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

plugins/Kaleidoscope-Hardware-Technomancy-Atreus/src/kaleidoscope/device/technomancy/Atreus.h

@@ -40,28 +40,28 @@ namespace technomancy {
 struct AtreusProps : kaleidoscope::device::ATmega32U4KeyboardProps {
   struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
 
-    static constexpr uint8_t matrix_rows = 4;
+    static constexpr uint8_t matrix_rows    = 4;
     static constexpr uint8_t matrix_columns = 12;
     typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
 
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 #ifdef KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_ASTAR
-    static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D3, PIN_D2};
+    static constexpr uint8_t matrix_row_pins[matrix_rows]    = {PIN_D0, PIN_D1, PIN_D3, PIN_D2};
     static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_D7, PIN_C6, PIN_B5, PIN_B4, PIN_E6, PIN_D4, PIN_B6, PIN_F6, PIN_F7, PIN_D6, PIN_B7};
 #endif
 
 #ifdef KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_ASTAR_DOWN
-    static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D3, PIN_D2};
+    static constexpr uint8_t matrix_row_pins[matrix_rows]    = {PIN_D0, PIN_D1, PIN_D3, PIN_D2};
     static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_B7, PIN_D6, PIN_F7, PIN_F6, PIN_B6, PIN_D4, PIN_E6, PIN_B4, PIN_B5, PIN_C6, PIN_D7};
 #endif
 
 #ifdef KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_LEGACY_TEENSY2
-    static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D2, PIN_D3};
+    static constexpr uint8_t matrix_row_pins[matrix_rows]    = {PIN_D0, PIN_D1, PIN_D2, PIN_D3};
     static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_F6, PIN_F5, PIN_F4, PIN_B7, PIN_B6, PIN_B5, PIN_B4, PIN_B3, PIN_B2, PIN_B1, PIN_B0};
 #endif
 
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
   };
 
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
@@ -75,15 +75,15 @@ struct AtreusProps : kaleidoscope::device::ATmega32U4KeyboardProps {
 };
 
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-class Atreus: public kaleidoscope::device::ATmega32U4Keyboard<AtreusProps> {};
+class Atreus : public kaleidoscope::device::ATmega32U4Keyboard<AtreusProps> {};
-#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#else   // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are
  * some legacy extern references to boards whose definition
  * depends on this.
  */
 class Atreus;
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 // clang-format off
 

plugins/Kaleidoscope-Hardware-gHeavy-ButterStick/src/kaleidoscope/device/gheavy/ButterStick.cpp

@@ -27,7 +27,7 @@
 // in the global namespace within the scope of this file. We'll use these
 // aliases to simplify some template initialization code below.
 using KeyScannerProps = typename kaleidoscope::device::gheavy::ButterStickProps::KeyScannerProps;
-using KeyScanner = typename kaleidoscope::device::gheavy::ButterStickProps::KeyScanner;
+using KeyScanner      = typename kaleidoscope::device::gheavy::ButterStickProps::KeyScanner;
 
 namespace kaleidoscope {
 namespace device {
@@ -45,7 +45,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
 
 // `KeyScanner` here refers to the alias set up above, just like in the
 // `KeyScannerProps` case above.
-template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
+template<>
+KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
 
 // We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
 // cannot be in a header-only driver, and must be placed here.
@@ -59,9 +60,9 @@ ISR(TIMER1_OVF_vect) {
   Runtime.device().keyScanner().do_scan_ = true;
 }
 
-} // namespace gheavy
+}  // namespace gheavy
-} // namespace device
+}  // namespace device
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 #endif
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

plugins/Kaleidoscope-Hardware-gHeavy-ButterStick/src/kaleidoscope/device/gheavy/ButterStick.h

@@ -33,13 +33,13 @@ namespace gheavy {
 
 struct ButterStickProps : kaleidoscope::device::ATmega32U4KeyboardProps {
   struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
-    static constexpr uint8_t matrix_rows = 2;
+    static constexpr uint8_t matrix_rows    = 2;
     static constexpr uint8_t matrix_columns = 10;
     typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-    static constexpr uint8_t matrix_row_pins[matrix_rows] = { PIN_F4, PIN_F5 };
+    static constexpr uint8_t matrix_row_pins[matrix_rows]    = {PIN_F4, PIN_F5};
-    static constexpr uint8_t matrix_col_pins[matrix_columns] = { PIN_B0, PIN_B1, PIN_B2, PIN_B3, PIN_B4, PIN_B5, PIN_B6, PIN_B7, PIN_C6, PIN_C7 };
+    static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_B0, PIN_B1, PIN_B2, PIN_B3, PIN_B4, PIN_B5, PIN_B6, PIN_B7, PIN_C6, PIN_C7};
-#endif // KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // KALEIDOSCOPE_VIRTUAL_BUILD
   };
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
   typedef kaleidoscope::driver::bootloader::avr::FLIP Bootloader;
@@ -47,8 +47,8 @@ struct ButterStickProps : kaleidoscope::device::ATmega32U4KeyboardProps {
 };
 
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-class ButterStick: public kaleidoscope::device::ATmega32U4Keyboard<ButterStickProps> {};
+class ButterStick : public kaleidoscope::device::ATmega32U4Keyboard<ButterStickProps> {};
-#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#else  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are
  * some legacy extern references to boards whose definition
@@ -56,7 +56,7 @@ class ButterStick: public kaleidoscope::device::ATmega32U4Keyboard<ButterStickPr
  */
 class ButterStick;
 
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 // clang-format off
 #define PER_KEY_DATA(dflt,                                           \
@@ -67,11 +67,11 @@ class ButterStick;
          R1C9, R1C8, R1C7, R1C6, R1C5, R1C4, R1C3, R1C2, R1C1, R1C0
 // clang-format on
 
-} // namespace gheavy
+}  // namespace gheavy
-} // namespace device
+}  // namespace device
 
 EXPORT_DEVICE(kaleidoscope::device::gheavy::ButterStick)
 
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 #endif

plugins/Kaleidoscope-Hardware-gHeavy-FaunchPad/src/kaleidoscope/device/gheavy/FaunchPad.cpp

@@ -27,7 +27,7 @@
 // in the global namespace within the scope of this file. We'll use these
 // aliases to simplify some template initialization code below.
 using KeyScannerProps = typename kaleidoscope::device::gheavy::FaunchPadProps::KeyScannerProps;
-using KeyScanner = typename kaleidoscope::device::gheavy::FaunchPadProps::KeyScanner;
+using KeyScanner      = typename kaleidoscope::device::gheavy::FaunchPadProps::KeyScanner;
 
 namespace kaleidoscope {
 namespace device {
@@ -45,7 +45,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
 
 // `KeyScanner` here refers to the alias set up above, just like in the
 // `KeyScannerProps` case above.
-template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
+template<>
+KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
 
 // We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
 // cannot be in a header-only driver, and must be placed here.
@@ -59,9 +60,9 @@ ISR(TIMER1_OVF_vect) {
   Runtime.device().keyScanner().do_scan_ = true;
 }
 
-} // namespace gheavy
+}  // namespace gheavy
-} // namespace device
+}  // namespace device
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 #endif
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

plugins/Kaleidoscope-Hardware-gHeavy-FaunchPad/src/kaleidoscope/device/gheavy/FaunchPad.h

@@ -33,13 +33,13 @@ namespace gheavy {
 
 struct FaunchPadProps : kaleidoscope::device::ATmega32U4KeyboardProps {
   struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
-    static constexpr uint8_t matrix_rows = 2;
+    static constexpr uint8_t matrix_rows    = 2;
     static constexpr uint8_t matrix_columns = 4;
     typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-    static constexpr uint8_t matrix_row_pins[matrix_rows] = { PIN_F4, PIN_F5 };
+    static constexpr uint8_t matrix_row_pins[matrix_rows]    = {PIN_F4, PIN_F5};
-    static constexpr uint8_t matrix_col_pins[matrix_columns] = { PIN_B3, PIN_B2, PIN_B1, PIN_B0 };
+    static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_B3, PIN_B2, PIN_B1, PIN_B0};
-#endif // KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // KALEIDOSCOPE_VIRTUAL_BUILD
   };
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
   typedef kaleidoscope::driver::bootloader::avr::FLIP Bootloader;
@@ -47,8 +47,8 @@ struct FaunchPadProps : kaleidoscope::device::ATmega32U4KeyboardProps {
 };
 
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
-class FaunchPad: public kaleidoscope::device::ATmega32U4Keyboard<FaunchPadProps> {};
+class FaunchPad : public kaleidoscope::device::ATmega32U4Keyboard<FaunchPadProps> {};
-#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#else  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are
  * some legacy extern references to boards whose definition
@@ -56,7 +56,7 @@ class FaunchPad: public kaleidoscope::device::ATmega32U4Keyboard<FaunchPadProps>
  */
 class FaunchPad;
 
-#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
+#endif  // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 
 // clang-format off
 #define PER_KEY_DATA(dflt,                              \
@@ -66,11 +66,11 @@ class FaunchPad;
          R0C4, R0C5, R0C6, R0C7
 // clang-format on
 
-} // namespace gheavy
+}  // namespace gheavy
-} // namespace device
+}  // namespace device
 
 EXPORT_DEVICE(kaleidoscope::device::gheavy::FaunchPad)
 
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 #endif

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

@@ -16,7 +16,7 @@
 
 #include "kaleidoscope/plugin/HardwareTestMode.h"
 
-#include <stdint.h>                                       // for uint8_t
+#include <stdint.h>  // for uint8_t
 
 #include "kaleidoscope/KeyAddr.h"                         // for MatrixAddr
 #include "kaleidoscope/Runtime.h"                         // for Runtime
@@ -41,7 +41,7 @@ void HardwareTestMode::waitForKeypress() {
   while (1) {
     Runtime.device().readMatrix();
     if (Runtime.device().isKeyswitchPressed(actionKey) &&
-        ! Runtime.device().wasKeyswitchPressed(actionKey)) {
+        !Runtime.device().wasKeyswitchPressed(actionKey)) {
       break;
     }
   }
@@ -54,9 +54,9 @@ void HardwareTestMode::setLeds(cRGB color) {
 }
 
 void HardwareTestMode::testLeds(void) {
-  constexpr cRGB red = CRGB(255, 0, 0);
+  constexpr cRGB red         = CRGB(255, 0, 0);
-  constexpr cRGB blue = CRGB(0, 0, 255);
+  constexpr cRGB blue        = CRGB(0, 0, 255);
-  constexpr cRGB green = CRGB(0, 255, 0);
+  constexpr cRGB green       = CRGB(0, 255, 0);
   constexpr cRGB brightWhite = CRGB(160, 160, 160);
 
   // rainbow for 10 seconds
@@ -75,18 +75,16 @@ void HardwareTestMode::testLeds(void) {
   setLeds(blue);
   setLeds(green);
   setLeds(red);
-
 }
 
 
-
 void HardwareTestMode::testMatrix() {
   // Reset bad keys from previous tests.
   chatter_data state[Runtime.device().numKeys()] = {{0, 0, 0}};
 
-  constexpr cRGB red = CRGB(201, 0, 0);
+  constexpr cRGB red    = CRGB(201, 0, 0);
-  constexpr cRGB blue = CRGB(0, 0, 201);
+  constexpr cRGB blue   = CRGB(0, 0, 201);
-  constexpr cRGB green = CRGB(0, 201, 0);
+  constexpr cRGB green  = CRGB(0, 201, 0);
   constexpr cRGB yellow = CRGB(201, 100, 0);
 
   while (1) {
@@ -95,7 +93,7 @@ void HardwareTestMode::testMatrix() {
       uint8_t keynum = key_addr.toInt();
 
       // If the key is toggled on
-      if (Runtime.device().isKeyswitchPressed(key_addr) && ! Runtime.device().wasKeyswitchPressed(key_addr)) {
+      if (Runtime.device().isKeyswitchPressed(key_addr) && !Runtime.device().wasKeyswitchPressed(key_addr)) {
         // And it's too soon (in terms of cycles between changes)
         state[keynum].tested = 1;
         if (state[keynum].cyclesSinceStateChange < CHATTER_CYCLE_LIMIT) {
@@ -113,7 +111,7 @@ void HardwareTestMode::testMatrix() {
         Runtime.device().setCrgbAt(key_addr, red);
       } else if (state[keynum].tested == 0) {
         Runtime.device().setCrgbAt(key_addr, yellow);
-      } else if (! Runtime.device().isKeyswitchPressed(key_addr)) {
+      } else if (!Runtime.device().isKeyswitchPressed(key_addr)) {
         // If the key is not currently pressed and was not just released and is not marked bad
         Runtime.device().setCrgbAt(key_addr, blue);
       }

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

@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <stdint.h>                      // for uint8_t
+#include <stdint.h>  // for uint8_t
 
 #include "kaleidoscope/device/device.h"  // for cRGB
 #include "kaleidoscope/plugin.h"         // for Plugin
@@ -26,11 +26,10 @@ namespace plugin {
 
 class HardwareTestMode : public kaleidoscope::Plugin {
  public:
-
   typedef struct {
     uint8_t bad : 1,
-            tested : 1,
+      tested : 1,
-            cyclesSinceStateChange: 6;
+      cyclesSinceStateChange : 6;
   } chatter_data;
   static uint8_t actionKey;
 
@@ -38,6 +37,7 @@ class HardwareTestMode : public kaleidoscope::Plugin {
 
   static void runTests();
   static void setActionKey(uint8_t key);
+
  private:
   static void testLeds();
   static void testMatrix();

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

@@ -17,8 +17,8 @@
 
 #include "kaleidoscope/plugin/Heatmap.h"
 
-#include <Arduino.h>                            // for pgm_read_byte, PROGMEM
+#include <Arduino.h>  // for pgm_read_byte, PROGMEM
-#include <stdint.h>                             // for uint16_t, uint8_t
+#include <stdint.h>   // for uint16_t, uint8_t
 
 #include "kaleidoscope/KeyAddr.h"               // for MatrixAddr, MatrixAdd...
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
@@ -36,19 +36,18 @@ namespace plugin {
 static const cRGB heat_colors_default_[] PROGMEM = {{0, 0, 0}, {25, 255, 25}, {25, 255, 255}, {25, 25, 255}};
 
 // colors from cold to hot
-const cRGB *Heatmap::heat_colors = heat_colors_default_;
+const cRGB *Heatmap::heat_colors    = heat_colors_default_;
 uint8_t Heatmap::heat_colors_length = 4;
 // number of millisecond to wait between each heatmap computation
 uint16_t Heatmap::update_delay = 1000;
 
 Heatmap::TransientLEDMode::TransientLEDMode(const Heatmap *parent)
-  : // store the number of times each key has been strock
+  :  // store the number of times each key has been strock
     heatmap_{},
     // max of heatmap_ (we divide by it so we start at 1)
     highest_(1),
     // last heatmap computation time
-    last_heatmap_comp_time_(Runtime.millisAtCycleStart())
+    last_heatmap_comp_time_(Runtime.millisAtCycleStart()) {}
-{}
 
 cRGB Heatmap::TransientLEDMode::computeColor(float v) {
   // compute the color corresponding to a value between 0 and 1
@@ -98,7 +97,7 @@ cRGB Heatmap::TransientLEDMode::computeColor(float v) {
     // static_cast<int>(5.9) → 5
     idx1 = static_cast<int>(val);
     idx2 = idx1 + 1;
-    fb = val - static_cast<float>(idx1);
+    fb   = val - static_cast<float>(idx1);
   }
 
   uint8_t r = static_cast<uint8_t>((pgm_read_byte(&(heat_colors[idx2].r)) - pgm_read_byte(&(heat_colors[idx1].r))) * fb + pgm_read_byte(&(heat_colors[idx1].r)));

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <stdint.h>                                      // for uint16_t
+#include <stdint.h>  // for uint16_t
 
 #include "kaleidoscope/KeyEvent.h"                       // for KeyEvent
 #include "kaleidoscope/Runtime.h"                        // for Runtime, Run...
@@ -31,8 +31,8 @@
 namespace kaleidoscope {
 namespace plugin {
 class Heatmap : public Plugin,
-  public LEDModeInterface,
+                public LEDModeInterface,
-  public AccessTransientLEDMode {
+                public AccessTransientLEDMode {
  public:
   Heatmap(void) {}
 
@@ -48,7 +48,6 @@ class Heatmap : public Plugin,
   //
   class TransientLEDMode : public LEDMode {
    public:
-
     // Please note that storing the parent ptr is only required
     // for those LED modes that require access to
     // members of their parent class. Most LED modes can do without.
@@ -60,11 +59,9 @@ class Heatmap : public Plugin,
     EventHandlerResult beforeEachCycle();
 
    protected:
-
     void update() final;
 
    private:
-
     uint16_t heatmap_[Runtime.device().numKeys()];
     uint16_t highest_;
     uint16_t last_heatmap_comp_time_;

plugins/Kaleidoscope-HostOS/src/Kaleidoscope-HostOS.h

@@ -18,4 +18,4 @@
 #pragma once
 
 #include "kaleidoscope/plugin/HostOS-Focus.h"  // IWYU pragma: export
-#include "kaleidoscope/plugin/HostOS.h"  // IWYU pragma: export
+#include "kaleidoscope/plugin/HostOS.h"        // IWYU pragma: export

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

@@ -17,9 +17,9 @@
 
 #include "kaleidoscope/plugin/HostOS-Focus.h"
 
-#include <Arduino.h>                            // for PSTR, strcmp_P
+#include <Arduino.h>                   // for PSTR, strcmp_P
-#include <Kaleidoscope-FocusSerial.h>           // for Focus, FocusSerial
+#include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
-#include <stdint.h>                             // for uint8_t
+#include <stdint.h>                    // for uint8_t
 
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
 #include "kaleidoscope/plugin/HostOS.h"         // for HostOS, Type
@@ -40,7 +40,7 @@ EventHandlerResult FocusHostOSCommand::onFocusEvent(const char *command) {
   } else {
     uint8_t new_os;
     ::Focus.read(new_os);
-    ::HostOS.os((hostos::Type) new_os);
+    ::HostOS.os((hostos::Type)new_os);
   }
 
   return EventHandlerResult::EVENT_CONSUMED;

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

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/HostOS.h"
 
-#include <Kaleidoscope-EEPROM-Settings.h>       // for EEPROMSettings
+#include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 
 #include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
 #include "kaleidoscope/device/device.h"         // for VirtualProps::Storage

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <stdint.h>                             // for uint16_t
+#include <stdint.h>  // for uint16_t
 
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
 #include "kaleidoscope/plugin.h"                // for Plugin
@@ -34,7 +34,7 @@ typedef enum {
   OTHER,
 
   UNKNOWN = 0xff,
-  AUTO = UNKNOWN
+  AUTO    = UNKNOWN
 } Type;
 
 }

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

@@ -18,7 +18,7 @@
 #include "kaleidoscope/plugin/HostPowerManagement.h"
 
 #include <Arduino.h>  // IWYU pragma: keep
-#include <stdint.h>                             // for uint8_t
+#include <stdint.h>   // for uint8_t
 
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
 
@@ -29,7 +29,7 @@ extern uint8_t _usbSuspendState;
 namespace kaleidoscope {
 namespace plugin {
 
-bool HostPowerManagement::was_suspended_ = false;
+bool HostPowerManagement::was_suspended_   = false;
 bool HostPowerManagement::initial_suspend_ = true;
 
 EventHandlerResult HostPowerManagement::beforeEachCycle() {

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

@@ -18,10 +18,10 @@
 
 #include "kaleidoscope/plugin/IdleLEDs.h"
 
-#include <Arduino.h>                            // for F, PSTR, __FlashStrin...
+#include <Arduino.h>                       // for F, PSTR, __FlashStrin...
-#include <Kaleidoscope-EEPROM-Settings.h>       // for EEPROMSettings
+#include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
-#include <Kaleidoscope-FocusSerial.h>           // for Focus, FocusSerial
+#include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
-#include <stdint.h>                             // for uint32_t, uint16_t
+#include <stdint.h>                        // for uint32_t, uint16_t
 
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
 #include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
@@ -32,7 +32,7 @@
 namespace kaleidoscope {
 namespace plugin {
 
-uint32_t IdleLEDs::idle_time_limit = 600000; // 10 minutes
+uint32_t IdleLEDs::idle_time_limit = 600000;  // 10 minutes
 uint32_t IdleLEDs::start_time_     = 0;
 bool IdleLEDs::idle_;
 

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

@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include <stdint.h>                             // for uint32_t, uint16_t
+#include <stdint.h>  // for uint32_t, uint16_t
 
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
@@ -27,7 +27,7 @@
 namespace kaleidoscope {
 namespace plugin {
 
-class IdleLEDs: public kaleidoscope::Plugin {
+class IdleLEDs : public kaleidoscope::Plugin {
  public:
   IdleLEDs(void) {}
 
@@ -51,6 +51,7 @@ class PersistentIdleLEDs : public IdleLEDs {
   EventHandlerResult onFocusEvent(const char *command);
 
   static void setIdleTimeoutSeconds(uint32_t new_limit);
+
  private:
   static uint16_t settings_base_;
 };

plugins/Kaleidoscope-LED-ActiveLayerColor/src/kaleidoscope/plugin/LED-ActiveLayerColor.cpp

@@ -17,8 +17,8 @@
 
 #include "kaleidoscope/plugin/LED-ActiveLayerColor.h"
 
-#include <Arduino.h>                            // for pgm_read_byte
+#include <Arduino.h>  // for pgm_read_byte
-#include <stdint.h>                             // for uint8_t
+#include <stdint.h>   // for uint8_t
 
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr
 #include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
@@ -34,8 +34,7 @@ const cRGB *LEDActiveLayerColorEffect::colormap_;
 LEDActiveLayerColorEffect::TransientLEDMode::TransientLEDMode(
   const LEDActiveLayerColorEffect *parent)
   : parent_(parent),
-    active_color_{0, 0, 0}
+    active_color_{0, 0, 0} {}
-{}
 
 void LEDActiveLayerColorEffect::setColormap(const cRGB colormap[]) {
   colormap_ = colormap;

plugins/Kaleidoscope-LED-ActiveLayerColor/src/kaleidoscope/plugin/LED-ActiveLayerColor.h

@@ -28,8 +28,8 @@
 namespace kaleidoscope {
 namespace plugin {
 class LEDActiveLayerColorEffect : public Plugin,
-  public LEDModeInterface,
+                                  public LEDModeInterface,
-  public AccessTransientLEDMode {
+                                  public AccessTransientLEDMode {
  public:
   LEDActiveLayerColorEffect(void) {}
 
@@ -40,7 +40,6 @@ class LEDActiveLayerColorEffect : public Plugin,
   //
   class TransientLEDMode : public LEDMode {
    public:
-
     // Please note that storing the parent ptr is only required
     // for those LED modes that require access to
     // members of their parent class. Most LED modes can do without.
@@ -48,12 +47,10 @@ class LEDActiveLayerColorEffect : public Plugin,
     explicit TransientLEDMode(const LEDActiveLayerColorEffect *parent);
 
    protected:
-
     void onActivate(void) final;
     void refreshAt(KeyAddr key_addr) final;
 
    private:
-
     const LEDActiveLayerColorEffect *parent_;
 
     cRGB active_color_;
@@ -64,7 +61,6 @@ class LEDActiveLayerColorEffect : public Plugin,
   };
 
  private:
-
   static const cRGB *colormap_;
 };
 

plugins/Kaleidoscope-LED-ActiveModColor/src/kaleidoscope/plugin/LED-ActiveModColor.cpp

@@ -17,8 +17,8 @@
 
 #include "kaleidoscope/plugin/LED-ActiveModColor.h"
 
-#include <Kaleidoscope-OneShot.h>               // for OneShot
+#include <Kaleidoscope-OneShot.h>          // for OneShot
-#include <Kaleidoscope-OneShotMetaKeys.h>       // for OneShot_ActiveStickyKey
+#include <Kaleidoscope-OneShotMetaKeys.h>  // for OneShot_ActiveStickyKey
 
 #include "kaleidoscope/KeyAddr.h"               // for KeyAddr, MatrixAddr
 #include "kaleidoscope/KeyAddrBitfield.h"       // for KeyAddrBitfield, KeyA...
@@ -37,14 +37,14 @@ KeyAddrBitfield ActiveModColorEffect::mod_key_bits_;
 bool ActiveModColorEffect::highlight_normal_modifiers_ = true;
 
 cRGB ActiveModColorEffect::highlight_color_ = CRGB(160, 160, 160);
-cRGB ActiveModColorEffect::oneshot_color_ = CRGB(160, 160, 0);
+cRGB ActiveModColorEffect::oneshot_color_   = CRGB(160, 160, 0);
-cRGB ActiveModColorEffect::sticky_color_ = CRGB(160, 0, 0);
+cRGB ActiveModColorEffect::sticky_color_    = CRGB(160, 0, 0);
 
 // -----------------------------------------------------------------------------
 EventHandlerResult ActiveModColorEffect::onKeyEvent(KeyEvent &event) {
 
   // If `event.addr` is not a physical key address, ignore it:
-  if (! event.addr.isValid()) {
+  if (!event.addr.isValid()) {
     return EventHandlerResult::OK;
   }
 
@@ -70,7 +70,7 @@ EventHandlerResult ActiveModColorEffect::onKeyEvent(KeyEvent &event) {
         mod_key_bits_.set(entry_addr);
       }
     }
-  } else { // if (keyToggledOff(event.state))
+  } else {  // if (keyToggledOff(event.state))
     // Things get a bit ugly here because this plugin might come before OneShot
     // in the order, so we can't just count on OneShot stopping the suppressed
     // release event before we see it here.
@@ -104,7 +104,7 @@ EventHandlerResult ActiveModColorEffect::beforeSyncingLeds() {
   return EventHandlerResult::OK;
 }
 
-} // namespace plugin
+}  // namespace plugin
-} // namespace kaleidoscope
+}  // namespace kaleidoscope
 
 kaleidoscope::plugin::ActiveModColorEffect ActiveModColorEffect;

plugins/Kaleidoscope-LED-AlphaSquare/src/Kaleidoscope-LED-AlphaSquare.h

@@ -17,6 +17,6 @@
 
 #pragma once
 
-#include "kaleidoscope/plugin/LED-AlphaSquare.h"  // IWYU pragma: export
+#include "kaleidoscope/plugin/LED-AlphaSquare.h"          // IWYU pragma: export
-#include "kaleidoscope/plugin/LED-AlphaSquare/Effect.h"  // IWYU pragma: export
+#include "kaleidoscope/plugin/LED-AlphaSquare/Effect.h"   // IWYU pragma: export
 #include "kaleidoscope/plugin/LED-AlphaSquare/Symbols.h"  // IWYU pragma: export

plugins/Kaleidoscope-LED-AlphaSquare/src/kaleidoscope/plugin/LED-AlphaSquare.cpp

@@ -17,14 +17,14 @@
 
 #include "kaleidoscope/plugin/LED-AlphaSquare.h"
 
-#include <Arduino.h>                                       // for bitRead
+#include <Arduino.h>  // for bitRead
-#include <stdint.h>                                        // for uint16_t
+#include <stdint.h>   // for uint16_t
 
-#include "kaleidoscope/KeyAddr.h"                          // for KeyAddr
+#include "kaleidoscope/KeyAddr.h"            // for KeyAddr
-#include "kaleidoscope/Runtime.h"                          // for Runtime
+#include "kaleidoscope/Runtime.h"            // for Runtime
-#include "kaleidoscope/device/device.h"                    // for cRGB
+#include "kaleidoscope/device/device.h"      // for cRGB
-#include "kaleidoscope/key_defs.h"                         // for Key, Key_A
+#include "kaleidoscope/key_defs.h"           // for Key, Key_A
-#include "kaleidoscope/plugin/LEDControl.h"                // for LEDControl
+#include "kaleidoscope/plugin/LEDControl.h"  // for LEDControl
 
 #include "kaleidoscope/plugin/LED-AlphaSquare/Font-4x4.h"  // for ALPHASQUAR...
 
@@ -67,8 +67,7 @@ static const uint16_t alphabet[] PROGMEM = {
   ALPHASQUARE_SYMBOL_7,
   ALPHASQUARE_SYMBOL_8,
   ALPHASQUARE_SYMBOL_9,
-  ALPHASQUARE_SYMBOL_0
+  ALPHASQUARE_SYMBOL_0};
-};
 
 
 cRGB AlphaSquare::color = {0x80, 0x80, 0x80};
@@ -80,7 +79,7 @@ void AlphaSquare::display(Key key, KeyAddr key_addr, cRGB key_color) {
   if (key < Key_A || key > Key_0)
     return;
 
-  uint8_t index = key.getKeyCode() - Key_A.getKeyCode();
+  uint8_t index   = key.getKeyCode() - Key_A.getKeyCode();
   uint16_t symbol = pgm_read_word(&alphabet[index]);
 
   display(symbol, key_addr, key_color);
@@ -122,7 +121,7 @@ bool AlphaSquare::isSymbolPart(Key key,
   if (key < Key_A || key > Key_0)
     return false;
 
-  uint8_t index = key.getKeyCode() - Key_A.getKeyCode();
+  uint8_t index   = key.getKeyCode() - Key_A.getKeyCode();
   uint16_t symbol = pgm_read_word(&alphabet[index]);
 
   return isSymbolPart(symbol, displayLedAddr, key_addr);

plugins/Kaleidoscope-LED-AlphaSquare/src/kaleidoscope/plugin/LED-AlphaSquare.h

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <stdint.h>                 // for uint16_t, uint8_t
+#include <stdint.h>  // for uint16_t, uint8_t
 
 #include "kaleidoscope/KeyAddr.h"   // for KeyAddr
 #include "kaleidoscope/key_defs.h"  // for Key
@@ -42,7 +42,6 @@ namespace kaleidoscope {
 namespace plugin {
 class AlphaSquare : public kaleidoscope::Plugin {
  public:
-
   AlphaSquare(void) {}
 
   static void display(Key key, KeyAddr key_addr, cRGB key_color);

plugins/Kaleidoscope-LED-AlphaSquare/src/kaleidoscope/plugin/LED-AlphaSquare/Effect.cpp

@@ -17,16 +17,16 @@
 
 #include "kaleidoscope/plugin/LED-AlphaSquare/Effect.h"
 
-#include <stdint.h>                               // for uint16_t, uint8_t
+#include <stdint.h>  // for uint16_t, uint8_t
 
-#include "kaleidoscope/KeyAddr.h"                 // for KeyAddr
+#include "kaleidoscope/KeyAddr.h"               // for KeyAddr
-#include "kaleidoscope/KeyEvent.h"                // for KeyEvent
+#include "kaleidoscope/KeyEvent.h"              // for KeyEvent
-#include "kaleidoscope/Runtime.h"                 // for Runtime, Runtime_
+#include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
-#include "kaleidoscope/device/device.h"           // for Device, CRGB
+#include "kaleidoscope/device/device.h"         // for Device, CRGB
-#include "kaleidoscope/event_handler_result.h"    // for EventHandlerResult
+#include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
-#include "kaleidoscope/key_defs.h"                // for Key, Key_NoKey, Key_0
+#include "kaleidoscope/key_defs.h"              // for Key, Key_NoKey, Key_0
-#include "kaleidoscope/keyswitch_state.h"         // for keyIsInjected
+#include "kaleidoscope/keyswitch_state.h"       // for keyIsInjected
-#include "kaleidoscope/plugin/LEDControl.h"       // for LEDControl
+#include "kaleidoscope/plugin/LEDControl.h"     // for LEDControl
 
 #include "kaleidoscope/plugin/LED-AlphaSquare.h"  // for AlphaSquare
 
@@ -35,10 +35,9 @@ namespace plugin {
 
 uint16_t AlphaSquareEffect::length = 1000;
 
-AlphaSquareEffect::TransientLEDMode::TransientLEDMode(AlphaSquareEffect */*parent*/) // NOLINT(readability/casting)
+AlphaSquareEffect::TransientLEDMode::TransientLEDMode(AlphaSquareEffect * /*parent*/)  // NOLINT(readability/casting)
   : last_key_left_(Key_NoKey),
-    last_key_right_(Key_NoKey)
+    last_key_right_(Key_NoKey) {}
-{}
 
 void AlphaSquareEffect::TransientLEDMode::update(void) {
   if (!Runtime.has_leds)
@@ -59,14 +58,14 @@ void AlphaSquareEffect::TransientLEDMode::update(void) {
 void AlphaSquareEffect::TransientLEDMode::refreshAt(KeyAddr key_addr) {
   bool timed_out;
   uint8_t display_col = 2;
-  Key key = last_key_left_;
+  Key key             = last_key_left_;
 
   if (key_addr.col() < Runtime.device().matrix_columns / 2) {
     timed_out = Runtime.hasTimeExpired(start_time_left_, length);
   } else {
-    key = last_key_right_;
+    key         = last_key_right_;
     display_col = 10;
-    timed_out = Runtime.hasTimeExpired(start_time_right_, length);
+    timed_out   = Runtime.hasTimeExpired(start_time_right_, length);
   }
 
   if (!::AlphaSquare.isSymbolPart(key, KeyAddr(0, display_col), key_addr) || timed_out)
@@ -90,18 +89,18 @@ EventHandlerResult AlphaSquareEffect::onKeyEvent(KeyEvent &event) {
   //   return EventHandlerResult::OK;
 
   uint8_t display_col = 2;
-  auto this_led_mode = ::LEDControl.get_mode<TransientLEDMode>();
+  auto this_led_mode  = ::LEDControl.get_mode<TransientLEDMode>();
 
   Key prev_key = this_led_mode->last_key_left_;
 
   if (event.addr.col() < Runtime.device().matrix_columns / 2) {
-    this_led_mode->last_key_left_ = event.key;
+    this_led_mode->last_key_left_   = event.key;
     this_led_mode->start_time_left_ = Runtime.millisAtCycleStart();
   } else {
-    prev_key = this_led_mode->last_key_right_;
+    prev_key                         = this_led_mode->last_key_right_;
-    this_led_mode->last_key_right_ = event.key;
+    this_led_mode->last_key_right_   = event.key;
     this_led_mode->start_time_right_ = Runtime.millisAtCycleStart();
-    display_col = 10;
+    display_col                      = 10;
   }
 
   if (prev_key != event.key)