Format codebase with `clang-format`

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

examples/Features/AppSwitcher/AppSwitcher.h

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

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

@@ -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);
 }
 

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

@@ -72,7 +72,8 @@ class AutoShift : public Plugin {
 
    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);

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

@@ -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);
 }
 

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

@@ -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;
   }
 
  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_;
 
@@ -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);                                      \
-}
+  }
 
 /// Define an `KeyPair` entry in a keymap
 ///

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

@@ -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

@@ -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

@@ -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

@@ -30,9 +30,9 @@
 constexpr Key Key_Cycle = Key(kaleidoscope::ranges::CYCLE);
 
 #define cycleThrough(...) ({                         \
-      static const Key __k[] PROGMEM = { __VA_ARGS__ };     \
+  static const Key __k[] PROGMEM = {__VA_ARGS__};    \
   Cycle.replace(sizeof(__k) / sizeof(Key), &__k[0]); \
-    })
+})
 
 namespace kaleidoscope {
 namespace plugin {

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

@@ -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-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();
   }
@@ -173,9 +168,7 @@ struct Printer {
 // 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() \
-  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.
 //
@@ -183,8 +176,7 @@ struct Printer {
 // 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) \
-  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-DynamicTapDance/src/kaleidoscope/plugin/DynamicTapDance.cpp

@@ -68,8 +68,7 @@ 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 next_pos = map_[tap_dance_index - offset_ + 1];
   if (next_pos <= pos || (tap_dance_index > offset_ + dance_count_))

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

@@ -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/src/kaleidoscope/plugin/EEPROM-Keymap.cpp

@@ -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

@@ -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.h

@@ -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.cpp

@@ -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

@@ -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-FirmwareDump/src/kaleidoscope/plugin/FirmwareDump.h

@@ -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

@@ -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;
@@ -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

@@ -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-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/Raise.cpp

@@ -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

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];
@@ -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();
@@ -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();
 

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

@@ -223,7 +223,7 @@ 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
   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

@@ -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")))

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

@@ -50,7 +50,7 @@ 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;

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

@@ -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) {

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

@@ -33,7 +33,8 @@ 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"
@@ -51,7 +52,6 @@ struct ErgoDoxProps : public kaleidoscope::device::ATmega32U4KeyboardProps {
     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";

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

@@ -35,8 +35,8 @@
 #include "kaleidoscope/device/ez/ErgoDox/i2cmaster.h"
 
 #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 IODIRB         0x01
 #define GPPUA          0x0C
@@ -90,8 +90,7 @@ out:
   return status;
 }
 
-void
+void ErgoDoxScanner::begin() {
-ErgoDoxScanner::begin() {
   expander_error_ = initExpander();
 
   // Init columns
@@ -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_)

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

@@ -39,7 +39,7 @@ void i2c_init(void) {
   TWSR = 0;  /* no prescaler */
   TWBR = 10; /* must be >= 10 for stable operation */
 
-}/* i2c_init */
+} /* i2c_init */
 
 
 /*************************************************************************
@@ -53,7 +53,8 @@ unsigned char i2c_start(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;
@@ -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 */
 
 
 /*************************************************************************
@@ -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 */
 
 
 /*************************************************************************
@@ -163,14 +169,15 @@ unsigned char i2c_write(unsigned char 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

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,                                           \

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

@@ -32,16 +32,17 @@ struct KeyScannerProps : public kaleidoscope::driver::keyscanner::BaseProps {
   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

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

@@ -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.

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

@@ -32,7 +32,7 @@ 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_clock_division = true;
   };
@@ -43,7 +43,7 @@ struct KBD4xProps : kaleidoscope::device::ATmega32U4KeyboardProps {
     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_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
   };
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
@@ -52,7 +52,7 @@ 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
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are

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

@@ -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.

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

@@ -50,7 +50,7 @@ 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
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are

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

@@ -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.
@@ -97,7 +98,7 @@ void ImagoLEDDriver::setup() {
 }
 
 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);
 }
 
@@ -139,11 +140,11 @@ 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
@@ -190,7 +191,6 @@ void ImagoLEDDriver::setAllPwmTo(uint8_t step) {
   // 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);
 }

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,7 +41,7 @@ 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 key_led_map[/* 5*16 */] PROGMEM = {
     // clang-format off
@@ -103,7 +104,7 @@ 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();
 };

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

@@ -44,10 +44,10 @@ 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);

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

@@ -30,7 +30,8 @@
 #include "kaleidoscope/MatrixAddr.h"     // for MatrixAddr
 #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;
@@ -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();

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

@@ -44,10 +44,10 @@ 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);

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

@@ -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,7 +119,6 @@ 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
   // but will need to verify with correctly
   // sized pull-ups on both the left and right
@@ -137,7 +133,6 @@ int Model01Side::readRegister(uint8_t cmd) {
   } else {
     return -1;
   }
-
 }
 
 
@@ -175,7 +170,7 @@ 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;
-  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,10 +199,8 @@ 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

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 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 {

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

@@ -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);

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,7 +48,7 @@ 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;
 };
 
@@ -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();
@@ -122,7 +124,7 @@ class Model100KeyScanner;
 
 
 // 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;
 };

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

@@ -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);
@@ -134,7 +132,6 @@ bool Model100Side::isDeviceAvailable() {
     // we've decremented the counter, but it's not time to probe for the device yet.
     return false;
   }
-
 }
 
 void Model100Side::markDeviceUnavailable() {
@@ -180,7 +177,6 @@ int Model100Side::readRegister(uint8_t cmd) {
     markDeviceUnavailable();
     return -1;
   }
-
 }
 
 
@@ -225,7 +221,7 @@ void Model100Side::sendLEDData() {
 void Model100Side::sendLEDBank(uint8_t bank) {
   uint8_t data[LED_BYTES_PER_BANK + 1];
   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
@@ -245,8 +241,7 @@ 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));
 }
 
@@ -255,10 +250,8 @@ void Model100Side::setOneLEDTo(uint8_t led, cRGB color) {
                     led,
                     color.b,
                     color.g,
-                    color.r
+                    color.r};
-                   };
   uint8_t result = writeData(data, ELEMENTS(data));
-
 }
 
 }  // namespace keyboardio

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 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 {
@@ -103,7 +104,7 @@ class Model100Side {
   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
 

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

@@ -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.

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

@@ -45,7 +45,7 @@ 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
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are

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

@@ -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.

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

@@ -39,7 +39,7 @@ 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;
@@ -49,7 +49,7 @@ struct SplitographyProps : kaleidoscope::device::ATmega32U4KeyboardProps {
     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_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
   };
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
@@ -58,7 +58,7 @@ 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
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are

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

@@ -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.

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

@@ -75,7 +75,7 @@ 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
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are

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

@@ -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.

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

@@ -37,8 +37,8 @@ struct ButterStickProps : kaleidoscope::device::ATmega32U4KeyboardProps {
     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
   };
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
@@ -47,7 +47,7 @@ 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
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are

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

@@ -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.

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

@@ -37,8 +37,8 @@ struct FaunchPadProps : kaleidoscope::device::ATmega32U4KeyboardProps {
     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
   };
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
@@ -47,7 +47,7 @@ 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
 /* Device definition omitted for virtual device builds.
  * We need to forward declare the device name, though, as there are

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

@@ -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;
     }
   }
@@ -75,11 +75,9 @@ 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}};
@@ -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

@@ -26,11 +26,10 @@ namespace plugin {
 
 class HardwareTestMode : public kaleidoscope::Plugin {
  public:
-
   typedef struct {
     uint8_t bad : 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

@@ -47,8 +47,7 @@ Heatmap::TransientLEDMode::TransientLEDMode(const Heatmap *parent)
     // 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

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

@@ -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/plugin/HostOS-Focus.cpp

@@ -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-IdleLEDs/src/kaleidoscope/plugin/IdleLEDs.h

@@ -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

@@ -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

@@ -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

@@ -44,7 +44,7 @@ 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;
   }
 

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

@@ -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};

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

@@ -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

@@ -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)

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

@@ -44,7 +44,8 @@ class LEDPaletteTheme : public kaleidoscope::Plugin {
   EventHandlerResult onFocusEvent(const char *command);
   EventHandlerResult themeFocusEvent(const char *command,
                                      const char *expected_command,
-                                     uint16_t theme_base, uint8_t max_themes);
+                                     uint16_t theme_base,
+                                     uint8_t max_themes);
 
  private:
   static uint16_t palette_base_;

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

@@ -33,15 +33,13 @@ namespace plugin {
 
 StalkerEffect::ColorComputer *StalkerEffect::variant;
 uint16_t StalkerEffect::step_length = 50;
-cRGB StalkerEffect::inactive_color = (cRGB) {
+cRGB StalkerEffect::inactive_color  = (cRGB){
-  0, 0, 0
+  0, 0, 0};
-};
 
 StalkerEffect::TransientLEDMode::TransientLEDMode(const StalkerEffect *parent)
   : parent_(parent),
     step_start_time_(0),
-    map_{}
+    map_{} {}
-{}
 
 EventHandlerResult StalkerEffect::onKeyEvent(KeyEvent &event) {
   if (!Runtime.has_leds)
@@ -130,7 +128,7 @@ cRGB BlazingTrail::compute(uint8_t *step) {
   // Fade value from full following a 1-x^4 curve
   uint8_t val =
     0xff                                            // Maximum brightness
-    - ((uint32_t) pos255 * pos255 * pos255 * pos255 // Animation position to 4th power
+    - ((uint32_t)pos255 * pos255 * pos255 * pos255  // Animation position to 4th power
        >> 24)                                       // ...pulled down to 8-bit range (but this has a maximum of 0xfc rather than 0xff)
     - pos255 / (0x100 / 4);                         // Correction to bring the end result into a full 0 to 0xff range
 

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

@@ -28,7 +28,7 @@
 #include "kaleidoscope/plugin/LEDMode.h"                 // for LEDMode
 #include "kaleidoscope/plugin/LEDModeInterface.h"        // for LEDModeInter...
 
-#define STALKER(v, ...) ({static kaleidoscope::plugin::stalker::v _effect __VA_ARGS__; &_effect;})
+#define STALKER(v, ...) ({static kaleidoscope::plugin::stalker::v _effect __VA_ARGS__; &_effect; })
 
 namespace kaleidoscope {
 namespace plugin {
@@ -53,7 +53,6 @@ class StalkerEffect : 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.
@@ -61,11 +60,9 @@ class StalkerEffect : public Plugin,
     explicit TransientLEDMode(const StalkerEffect *parent);
 
    protected:
-
     void update() final;
 
    private:
-
     const StalkerEffect *parent_;
 
     uint16_t step_start_time_;
@@ -80,9 +77,11 @@ namespace stalker {
 class Haunt : public StalkerEffect::ColorComputer {
  public:
   explicit Haunt(const cRGB highlight_color);
-  Haunt(void) : Haunt(CRGB(0x40, 0x80, 0x80)) {}
+  Haunt(void)
+    : Haunt(CRGB(0x40, 0x80, 0x80)) {}
 
   cRGB compute(uint8_t *step) final;
+
  private:
   static cRGB highlight_color_;
 };

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

@@ -55,8 +55,7 @@ PROGMEM const uint8_t WavepoolEffect::TransientLEDMode::rc2pos[Runtime.device().
 WavepoolEffect::TransientLEDMode::TransientLEDMode(const WavepoolEffect *parent)
   : frames_since_event_(0),
     surface_{},
-    page_(0)
+    page_(0) {}
-{}
 
 EventHandlerResult WavepoolEffect::onKeyEvent(KeyEvent &event) {
   if (!event.addr.isValid())
@@ -112,9 +111,9 @@ void WavepoolEffect::TransientLEDMode::update(void) {
   // (side note: it's weird that this is a 16-bit int instead of 8-bit,
   //  but that's what the library function wants)
   static uint8_t current_hue = 0;
-  current_hue ++;
+  current_hue++;
 
-  frames_since_event_ ++;
+  frames_since_event_++;
 
   // needs two pages of height map to do the calculations
   int8_t *newpg = &surface_[page_ ^ 1][0];
@@ -137,9 +136,7 @@ void WavepoolEffect::TransientLEDMode::update(void) {
       raindrop(prev_x, prev_y, oldpg);
       prev_x = prev_y = -1;
     }
-    if (frames_since_event_
+    if (frames_since_event_ >= (frames_till_next_drop + (idle_timeout / MS_PER_FRAME))) {
-        >= (frames_till_next_drop
-            + (idle_timeout / MS_PER_FRAME))) {
       frames_till_next_drop = 4 + (wp_rand() % FRAMES_PER_DROP);
       frames_since_event_   = idle_timeout / MS_PER_FRAME;
 
@@ -239,7 +236,6 @@ void WavepoolEffect::TransientLEDMode::update(void) {
   // swap pages every frame
   page_ ^= 1;
 #endif
-
 }
 
 }  // namespace plugin

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

@@ -55,7 +55,6 @@ class WavepoolEffect : 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.
@@ -65,11 +64,9 @@ class WavepoolEffect : public Plugin,
     EventHandlerResult onKeyEvent(KeyEvent &event);
 
    protected:
-
     void update() final;
 
    private:
-
     uint8_t frames_since_event_;
     int8_t surface_[2][WP_WID * WP_HGT];
     uint8_t page_;

plugins/Kaleidoscope-LEDEffect-BootAnimation/src/kaleidoscope/plugin/LEDEffect-BootAnimation.cpp

@@ -47,8 +47,7 @@ const uint8_t BootAnimationEffect::greeting_[11] PROGMEM = {
   Key_D.getKeyCode(),
   Key_Period.getKeyCode(),
   Key_I.getKeyCode(),
-  Key_O.getKeyCode()
+  Key_O.getKeyCode()};
-};
 
 EventHandlerResult BootAnimationEffect::onSetup() {
   return EventHandlerResult::OK;

plugins/Kaleidoscope-LEDEffect-Breathe/src/kaleidoscope/plugin/LEDEffect-Breathe.h

@@ -36,7 +36,6 @@ class LEDBreatheEffect : 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,7 +47,6 @@ class LEDBreatheEffect : public Plugin,
     void update(void) final;
 
    private:
-
     const LEDBreatheEffect *parent_;
 
     static constexpr uint8_t update_interval_ = 50;

plugins/Kaleidoscope-LEDEffect-Chase/src/kaleidoscope/plugin/LEDEffect-Chase.h

@@ -47,7 +47,6 @@ class LEDChaseEffect : 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.
@@ -56,11 +55,9 @@ class LEDChaseEffect : public Plugin,
       : parent_(parent), last_update_(Runtime.millisAtCycleStart()) {}
 
    protected:
-
     void update() final;
 
    private:
-
     const LEDChaseEffect *parent_;
 
     uint8_t pos_      = uint8_t(0);

plugins/Kaleidoscope-LEDEffect-Rainbow/src/kaleidoscope/plugin/LEDEffect-Rainbow.h

@@ -42,7 +42,6 @@ class LEDRainbowEffect : 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.
@@ -53,7 +52,6 @@ class LEDRainbowEffect : public Plugin,
     void update() final;
 
    private:
-
     const LEDRainbowEffect *parent_;
 
     uint16_t rainbow_hue = 0;  //  stores 0 to 614
@@ -87,7 +85,6 @@ class LEDRainbowWaveEffect : public Plugin, public LEDModeInterface {
   //
   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.
@@ -98,7 +95,6 @@ class LEDRainbowWaveEffect : public Plugin, public LEDModeInterface {
     void update() final;
 
    private:
-
     const LEDRainbowWaveEffect *parent_;
 
     uint16_t rainbow_hue = 0;  //  stores 0 to 614

plugins/Kaleidoscope-LEDEffect-SolidColor/src/kaleidoscope/plugin/LEDEffect-SolidColor.h

@@ -28,16 +28,13 @@ namespace plugin {
 class LEDSolidColor : public Plugin,
                       public LEDModeInterface {
  public:
-
   LEDSolidColor(uint8_t r, uint8_t g, uint8_t b)
-    : r_(r), g_(g), b_(b)
+    : r_(r), g_(g), b_(b) {}
-  {}
 
   // This class' instance has dynamic lifetime
   //
   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.
@@ -50,12 +47,10 @@ class LEDSolidColor : public Plugin,
     void refreshAt(KeyAddr key_addr) final;
 
    private:
-
     const LEDSolidColor *parent_;
   };
 
  private:
-
   uint8_t r_, g_, b_;
 };
 

plugins/Kaleidoscope-LEDEffects/src/kaleidoscope/plugin/TriColor.cpp

@@ -45,12 +45,12 @@ void TriColor::TransientLEDMode::update(void) {
     cRGB color = parent_->mod_color_;
 
     switch (k.getKeyCode()) {
-    case Key_A.getKeyCode() ... Key_0.getKeyCode():
+    case Key_A.getKeyCode()... Key_0.getKeyCode():
     case Key_Spacebar.getKeyCode():
-    case Key_KeypadDivide.getKeyCode() ... Key_KeypadSubtract.getKeyCode():
+    case Key_KeypadDivide.getKeyCode()... Key_KeypadSubtract.getKeyCode():
-    case Key_Keypad1.getKeyCode() ... Key_KeypadDot.getKeyCode():
+    case Key_Keypad1.getKeyCode()... Key_KeypadDot.getKeyCode():
-    case Key_F1.getKeyCode() ... Key_F4.getKeyCode():
+    case Key_F1.getKeyCode()... Key_F4.getKeyCode():
-    case Key_F9.getKeyCode() ... Key_F12.getKeyCode():
+    case Key_F9.getKeyCode()... Key_F12.getKeyCode():
       color = parent_->base_color_;
       break;
     case Key_Escape.getKeyCode():

plugins/Kaleidoscope-LEDEffects/src/kaleidoscope/plugin/TriColor.h

@@ -28,13 +28,13 @@ class TriColor : public Plugin,
                  public LEDModeInterface {
  public:
   TriColor(cRGB base_color, cRGB mod_color, cRGB esc_color);
-  TriColor(cRGB base_color, cRGB mod_color) : TriColor(base_color, mod_color, mod_color) {}
+  TriColor(cRGB base_color, cRGB mod_color)
+    : TriColor(base_color, mod_color, mod_color) {}
 
   // This class' instance has dynamic lifetime
   //
   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.
@@ -43,11 +43,9 @@ class TriColor : public Plugin,
       : parent_(parent) {}
 
    protected:
-
     void update(void) final;
 
    private:
-
     const TriColor *parent_;
   };
 

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

@@ -24,7 +24,7 @@
 namespace kaleidoscope {
 namespace plugin {
 
-class LayerFocus: public kaleidoscope::Plugin {
+class LayerFocus : public kaleidoscope::Plugin {
  public:
   LayerFocus() {}
 

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

@@ -56,7 +56,7 @@ const Leader::dictionary_t *Leader::dictionary;
 int8_t Leader::lookup(void) {
   bool match;
 
-  for (uint8_t seq_index = 0; ; seq_index++) {
+  for (uint8_t seq_index = 0;; seq_index++) {
     match = true;
 
     if (dictionary[seq_index].sequence[0].readFromProgmem() == Key_NoKey)
@@ -75,8 +75,7 @@ int8_t Leader::lookup(void) {
     if (!match)
       continue;
 
-    seq_key
+    seq_key = dictionary[seq_index].sequence[sequence_pos_ + 1].readFromProgmem();
-      = dictionary[seq_index].sequence[sequence_pos_ + 1].readFromProgmem();
     if (seq_key == Key_NoKey) {
       return seq_index;
     } else {
@@ -143,7 +142,7 @@ EventHandlerResult Leader::onKeyswitchEvent(KeyEvent &event) {
     return EventHandlerResult::ABORT;
   }
 
-  action_t leaderAction = (action_t) pgm_read_ptr((void const **) & (dictionary[action_index].action));
+  action_t leaderAction = (action_t)pgm_read_ptr((void const **)&(dictionary[action_index].action));
   (*leaderAction)(action_index);
   reset();
 

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

@@ -46,8 +46,12 @@
 
 #define LEAD(n)                    kaleidoscope::plugin::LeaderKey(n)
 
-#define LEADER_SEQ(...) { __VA_ARGS__, Key_NoKey }
+#define LEADER_SEQ(...) \
-#define LEADER_DICT(...) { __VA_ARGS__, {{Key_NoKey}, NULL} }
+  { __VA_ARGS__, Key_NoKey }
+#define LEADER_DICT(...)               \
+  {                                    \
+    __VA_ARGS__, { {Key_NoKey}, NULL } \
+  }
 
 namespace kaleidoscope {
 namespace plugin {

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

@@ -32,7 +32,8 @@
 // =============================================================================
 // Default `macroAction()` function definitions
 __attribute__((weak))
-const macro_t *macroAction(uint8_t macro_id, KeyEvent &event) {
+const macro_t *
+macroAction(uint8_t macro_id, KeyEvent &event) {
   return MACRO_NONE;
 }
 
@@ -300,7 +301,7 @@ EventHandlerResult Macros::onKeyEvent(KeyEvent &event) {
   uint8_t macro_id = event.key.getRaw() - ranges::MACRO_FIRST;
 
   // Call the new `macroAction(event)` function.
-  const macro_t* macro_ptr = macroAction(macro_id, event);
+  const macro_t *macro_ptr = macroAction(macro_id, event);
 
   // Play back the macro pointed to by `macroAction()`
   play(macro_ptr);

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

@@ -27,7 +27,7 @@
 
 // =============================================================================
 // Define this function in a Kaleidoscope sketch in order to trigger Macros.
-const macro_t* macroAction(uint8_t macro_id, KeyEvent &event);
+const macro_t *macroAction(uint8_t macro_id, KeyEvent &event);
 
 // The number of simultaneously-active `Key` values that a macro can have
 // running during a call to `Macros.play()`. I don't know if it's actually
@@ -42,7 +42,6 @@ namespace plugin {
 
 class Macros : public kaleidoscope::Plugin {
  public:
-
   /// Send a key press event from a Macro
   ///
   /// Generates a new `KeyEvent` and calls `Runtime.handleKeyEvent()` with the
@@ -71,17 +70,17 @@ class Macros : public kaleidoscope::Plugin {
   void tap(Key key) const;
 
   /// Play a macro sequence of key events
-  void play(const macro_t* macro_ptr);
+  void play(const macro_t *macro_ptr);
 
   // Templates provide a `type()` function that takes a variable number of
   // `char*` (string) arguments, in the form of a list of strings stored in
   // PROGMEM, of the form `Macros.type(PSTR("Hello "), PSTR("world!"))`.
-  inline const macro_t* type() const {
+  inline const macro_t *type() const {
     return MACRO_NONE;
   }
-  const macro_t* type(const char* string) const;
+  const macro_t *type(const char *string) const;
-  template <typename... Strings>
+  template<typename... Strings>
-  const macro_t* type(const char* first, Strings&&... strings) const {
+  const macro_t *type(const char *first, Strings &&...strings) const {
     type(first);
     return type(strings...);
   }
@@ -105,7 +104,6 @@ class Macros : public kaleidoscope::Plugin {
       return true;
     return false;
   }
-
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-Macros/src/kaleidoscope/plugin/Macros/MacroSteps.h

@@ -49,8 +49,7 @@ typedef uint8_t macro_t;
   {                                        \
     static const macro_t __m[] PROGMEM = { \
       __VA_ARGS__,                         \
-        MACRO_ACTION_END                                                \
+      MACRO_ACTION_END};                   \
-      };                                                                \
     &__m[0];                               \
   })
 
@@ -58,15 +57,15 @@ typedef uint8_t macro_t;
 #define W(n)                 MACRO_ACTION_STEP_WAIT, n
 
 #define Kr(k)                (k).getFlags(), (k).getKeyCode()
-#define Kc(k) (Key_ ## k).getKeyCode()
+#define Kc(k)                (Key_##k).getKeyCode()
-#define K(k) Kr(Key_ ## k)
+#define K(k)                 Kr(Key_##k)
 
 #define Dr(k)                MACRO_ACTION_STEP_KEYDOWN, Kr(k)
-#define D(k)  Dr(Key_ ## k)
+#define D(k)                 Dr(Key_##k)
 #define Ur(k)                MACRO_ACTION_STEP_KEYUP, Kr(k)
-#define U(k)  Ur(Key_ ## k)
+#define U(k)                 Ur(Key_##k)
 #define Tr(k)                MACRO_ACTION_STEP_TAP, Kr(k)
-#define T(k)  Tr(Key_ ## k)
+#define T(k)                 Tr(Key_##k)
 
 #define Dc(k)                MACRO_ACTION_STEP_KEYCODEDOWN, Kc(k)
 #define Uc(k)                MACRO_ACTION_STEP_KEYCODEUP, Kc(k)

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

@@ -55,7 +55,7 @@ EventHandlerResult MagicCombo::afterEachCycle() {
       match = false;
 
     if (match && Runtime.hasTimeExpired(start_time_, min_interval)) {
-      ComboAction action = (ComboAction) pgm_read_ptr((void const **) & (magiccombo::combos[i].action));
+      ComboAction action = (ComboAction)pgm_read_ptr((void const **)&(magiccombo::combos[i].action));
 
       (*action)(i);
       start_time_ = Runtime.millisAtCycleStart();

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

@@ -57,26 +57,26 @@ void MouseKeys::setSpeedLimit(uint8_t speed_limit) {
 // =============================================================================
 // Key variant tests
 
-bool MouseKeys::isMouseKey(const Key& key) const {
+bool MouseKeys::isMouseKey(const Key &key) const {
   return (key.getFlags() == (SYNTHETIC | IS_MOUSE_KEY));
 }
 
-bool MouseKeys::isMouseButtonKey(const Key& key) const {
+bool MouseKeys::isMouseButtonKey(const Key &key) const {
   uint8_t variant = key.getKeyCode() & (KEY_MOUSE_BUTTON | KEY_MOUSE_WARP);
   return variant == KEY_MOUSE_BUTTON;
 }
 
-bool MouseKeys::isMouseMoveKey(const Key& key) const {
+bool MouseKeys::isMouseMoveKey(const Key &key) const {
   uint8_t mask    = (KEY_MOUSE_BUTTON | KEY_MOUSE_WARP | KEY_MOUSE_WHEEL);
   uint8_t variant = key.getKeyCode() & mask;
   return variant == 0;
 }
 
-bool MouseKeys::isMouseWarpKey(const Key& key) const {
+bool MouseKeys::isMouseWarpKey(const Key &key) const {
   return (key.getKeyCode() & KEY_MOUSE_WARP) != 0;
 }
 
-bool MouseKeys::isMouseWheelKey(const Key& key) const {
+bool MouseKeys::isMouseWheelKey(const Key &key) const {
   uint8_t mask    = (KEY_MOUSE_BUTTON | KEY_MOUSE_WARP | KEY_MOUSE_WHEEL);
   uint8_t variant = key.getKeyCode() & mask;
   return variant == KEY_MOUSE_WHEEL;

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

@@ -69,7 +69,6 @@ class MouseKeys : public kaleidoscope::Plugin {
   void sendMouseWarpReport(const KeyEvent &event) const;
   void sendMouseMoveReport();
   void sendMouseWheelReport();
-
 };
 
 }  // namespace plugin

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

@@ -31,30 +31,30 @@
 #define KEY_MOUSE_BUTTON  0b1000000
 
 
-#define Key_mouseWarpNW   Key(KEY_MOUSE_WARP| KEY_MOUSE_UP | KEY_MOUSE_LEFT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseWarpNW   Key(KEY_MOUSE_WARP | KEY_MOUSE_UP | KEY_MOUSE_LEFT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseWarpN    Key(KEY_MOUSE_WARP| KEY_MOUSE_UP, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseWarpN    Key(KEY_MOUSE_WARP | KEY_MOUSE_UP, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseWarpNE   Key(KEY_MOUSE_WARP| KEY_MOUSE_UP | KEY_MOUSE_RIGHT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseWarpNE   Key(KEY_MOUSE_WARP | KEY_MOUSE_UP | KEY_MOUSE_RIGHT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseWarpW    Key(KEY_MOUSE_WARP| KEY_MOUSE_LEFT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseWarpW    Key(KEY_MOUSE_WARP | KEY_MOUSE_LEFT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseWarpIn   Key(KEY_MOUSE_WARP| KEY_MOUSE_UP | KEY_MOUSE_DOWN, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseWarpIn   Key(KEY_MOUSE_WARP | KEY_MOUSE_UP | KEY_MOUSE_DOWN, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseWarpE    Key(KEY_MOUSE_WARP| KEY_MOUSE_RIGHT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseWarpE    Key(KEY_MOUSE_WARP | KEY_MOUSE_RIGHT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseWarpSW   Key(KEY_MOUSE_WARP| KEY_MOUSE_DOWN | KEY_MOUSE_LEFT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseWarpSW   Key(KEY_MOUSE_WARP | KEY_MOUSE_DOWN | KEY_MOUSE_LEFT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseWarpS    Key(KEY_MOUSE_WARP| KEY_MOUSE_DOWN, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseWarpS    Key(KEY_MOUSE_WARP | KEY_MOUSE_DOWN, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseWarpSE   Key(KEY_MOUSE_WARP| KEY_MOUSE_DOWN | KEY_MOUSE_RIGHT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseWarpSE   Key(KEY_MOUSE_WARP | KEY_MOUSE_DOWN | KEY_MOUSE_RIGHT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseWarpEnd  Key(KEY_MOUSE_WARP| KEY_MOUSE_WARP_END, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseWarpEnd  Key(KEY_MOUSE_WARP | KEY_MOUSE_WARP_END, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-
+
-
+
-#define Key_mouseUpL      Key(KEY_MOUSE_UP | KEY_MOUSE_LEFT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseUpL      Key(KEY_MOUSE_UP | KEY_MOUSE_LEFT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseUp       Key(KEY_MOUSE_UP, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseUp       Key(KEY_MOUSE_UP, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseUpR      Key(KEY_MOUSE_UP | KEY_MOUSE_RIGHT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseUpR      Key(KEY_MOUSE_UP | KEY_MOUSE_RIGHT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseL        Key(KEY_MOUSE_LEFT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseL        Key(KEY_MOUSE_LEFT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseR        Key(KEY_MOUSE_RIGHT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseR        Key(KEY_MOUSE_RIGHT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseDnL      Key(KEY_MOUSE_DOWN | KEY_MOUSE_LEFT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseDnL      Key(KEY_MOUSE_DOWN | KEY_MOUSE_LEFT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseDn       Key(KEY_MOUSE_DOWN, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseDn       Key(KEY_MOUSE_DOWN, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseDnR      Key(KEY_MOUSE_DOWN | KEY_MOUSE_RIGHT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseDnR      Key(KEY_MOUSE_DOWN | KEY_MOUSE_RIGHT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseScrollUp Key(KEY_MOUSE_WHEEL | KEY_MOUSE_UP, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseScrollUp Key(KEY_MOUSE_WHEEL | KEY_MOUSE_UP, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseScrollDn Key(KEY_MOUSE_WHEEL | KEY_MOUSE_DOWN, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseScrollDn Key(KEY_MOUSE_WHEEL | KEY_MOUSE_DOWN, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseScrollL  Key(KEY_MOUSE_WHEEL | KEY_MOUSE_LEFT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseScrollL  Key(KEY_MOUSE_WHEEL | KEY_MOUSE_LEFT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
-#define Key_mouseScrollR  Key(KEY_MOUSE_WHEEL | KEY_MOUSE_RIGHT, KEY_FLAGS|SYNTHETIC|IS_MOUSE_KEY)
+#define Key_mouseScrollR  Key(KEY_MOUSE_WHEEL | KEY_MOUSE_RIGHT, KEY_FLAGS | SYNTHETIC | IS_MOUSE_KEY)
 
 
 // The MOUSE_xxx button definitions come from our HID driver

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

@@ -122,14 +122,18 @@ void MouseWrapper::move(int8_t x, int8_t y) {
 
   if (x != 0) {
     moveX = remainderX + (x * acceleration(accel_step));
-    if (moveX > effectiveSpeedLimit) moveX = effectiveSpeedLimit;
+    if (moveX > effectiveSpeedLimit)
-    else if (moveX < -effectiveSpeedLimit) moveX = -effectiveSpeedLimit;
+      moveX = effectiveSpeedLimit;
+    else if (moveX < -effectiveSpeedLimit)
+      moveX = -effectiveSpeedLimit;
   }
 
   if (y != 0) {
     moveY = remainderY + (y * acceleration(accel_step));
-    if (moveY > effectiveSpeedLimit) moveY = effectiveSpeedLimit;
+    if (moveY > effectiveSpeedLimit)
-    else if (moveY < -effectiveSpeedLimit) moveY = -effectiveSpeedLimit;
+      moveY = effectiveSpeedLimit;
+    else if (moveY < -effectiveSpeedLimit)
+      moveY = -effectiveSpeedLimit;
   }
 
   endWarping();

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

@@ -39,7 +39,6 @@ class NumPad : public kaleidoscope::Plugin {
   EventHandlerResult afterEachCycle();
 
  private:
-
   void setKeyboardLEDColors(void);
 
   static KeyAddr numpadLayerToggleKeyAddr;

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

@@ -80,7 +80,7 @@ bool OneShot::isActive() const {
 
 bool OneShot::isSticky() const {
   for (KeyAddr key_addr : glue_addrs_) {
-    if (! temp_addrs_.read(key_addr)) {
+    if (!temp_addrs_.read(key_addr)) {
       return true;
     }
   }
@@ -94,8 +94,7 @@ bool OneShot::isSticky() const {
 // could potentially use three different color values for the three
 // states (sticky | active && !sticky | pressed && !active).
 
-__attribute__((weak))
+__attribute__((weak)) bool OneShot::isStickable(Key key) const {
-bool OneShot::isStickable(Key key) const {
   return isStickableDefault(key);
 }
 
@@ -189,7 +188,7 @@ EventHandlerResult OneShot::onNameQuery() {
   return ::Focus.sendName(F("OneShot"));
 }
 
-EventHandlerResult OneShot::onKeyEvent(KeyEvent& event) {
+EventHandlerResult OneShot::onKeyEvent(KeyEvent &event) {
 
   // Ignore injected key events. This prevents re-processing events that the
   // hook functions generate (by calling `injectNormalKey()` via one of the
@@ -274,14 +273,13 @@ EventHandlerResult OneShot::onKeyEvent(KeyEvent& event) {
       // event. This is handled in the `beforeReportingState()` hook below.
       return EventHandlerResult::ABORT;
     }
-
   }
 
   return EventHandlerResult::OK;
 }
 
 // ----------------------------------------------------------------------------
-EventHandlerResult OneShot::afterReportingState(const KeyEvent& event) {
+EventHandlerResult OneShot::afterReportingState(const KeyEvent &event) {
   return afterEachCycle();
 }
 
@@ -379,8 +377,7 @@ void OneShot::holdKey(KeyAddr key_addr) const {
   Runtime.handleKeyEvent(event);
 }
 
-__attribute__((always_inline)) inline
+__attribute__((always_inline)) inline void OneShot::releaseKey(KeyAddr key_addr) {
-void OneShot::releaseKey(KeyAddr key_addr) {
   glue_addrs_.clear(key_addr);
   temp_addrs_.clear(key_addr);
 

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

@@ -31,7 +31,7 @@
 // ----------------------------------------------------------------------------
 // Keymap macros
 
-#define OSM(k) ::kaleidoscope::plugin::OneShotModifierKey(Key_ ## k)
+#define OSM(k) ::kaleidoscope::plugin::OneShotModifierKey(Key_##k)
 #define OSL(n) ::kaleidoscope::plugin::OneShotLayerKey(n)
 
 namespace kaleidoscope {
@@ -56,8 +56,8 @@ class OneShot : public kaleidoscope::Plugin {
 
   void enableStickablity() {}
   void enableStickability(Key key);
-  template <typename... Keys>
+  template<typename... Keys>
-  void enableStickability(Key key, Keys&&... keys) {
+  void enableStickability(Key key, Keys &&...keys) {
     enableStickability(key);
     enableStickability(keys...);
   }
@@ -66,8 +66,8 @@ class OneShot : public kaleidoscope::Plugin {
 
   void disableStickability() {}
   void disableStickability(Key key);
-  template <typename... Keys>
+  template<typename... Keys>
-  void disableStickability(Key key, Keys&&... keys) {
+  void disableStickability(Key key, Keys &&...keys) {
     disableStickability(key);
     disableStickability(keys...);
   }
@@ -97,10 +97,10 @@ class OneShot : public kaleidoscope::Plugin {
   }
 
   void toggleAutoModifiers() {
-    auto_modifiers_ = ! auto_modifiers_;
+    auto_modifiers_ = !auto_modifiers_;
   }
   void toggleAutoLayers() {
-    auto_layers_ = ! auto_layers_;
+    auto_layers_ = !auto_layers_;
   }
   void toggleAutoOneShot() {
     if (auto_modifiers_ || auto_layers_) {
@@ -191,7 +191,6 @@ class OneShot : public kaleidoscope::Plugin {
   EventHandlerResult afterEachCycle();
 
  private:
-
   // --------------------------------------------------------------------------
   // Constants
   static constexpr uint8_t oneshot_key_count         = 16;

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

@@ -26,8 +26,8 @@
 
 // ----------------------------------------------------------------------------
 // Key constants
-constexpr Key OneShot_MetaStickyKey {kaleidoscope::ranges::OS_META_STICKY};
+constexpr Key OneShot_MetaStickyKey{kaleidoscope::ranges::OS_META_STICKY};
-constexpr Key OneShot_ActiveStickyKey {kaleidoscope::ranges::OS_ACTIVE_STICKY};
+constexpr Key OneShot_ActiveStickyKey{kaleidoscope::ranges::OS_ACTIVE_STICKY};
 
 namespace kaleidoscope {
 namespace plugin {
@@ -42,7 +42,6 @@ class OneShotMetaKeys : public kaleidoscope::Plugin {
 
  private:
   static bool isMetaStickyActive();
-
 };
 
 }  // namespace plugin