make astyle

examples/TypingBreaks/TypingBreaks.ino

@@ -20,31 +20,31 @@
 #include <Kaleidoscope-TypingBreaks.h>
 
 const Key keymaps[][ROWS][COLS] PROGMEM = {
-  [0] = KEYMAP_STACKED
+    [0] = KEYMAP_STACKED
-  (
+    (
-   Key_NoKey,    Key_1, Key_2, Key_3, Key_4, Key_5, Key_NoKey,
+        Key_NoKey,    Key_1, Key_2, Key_3, Key_4, Key_5, Key_NoKey,
-   Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab,
+        Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab,
-   Key_PageUp,   Key_A, Key_S, Key_D, Key_F, Key_G,
+        Key_PageUp,   Key_A, Key_S, Key_D, Key_F, Key_G,
-   Key_PageDown,   Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape,
+        Key_PageDown,   Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape,
 
-   Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,
+        Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,
-   Key_skip,
+        Key_skip,
 
-   Key_skip,  Key_6, Key_7, Key_8,     Key_9,      Key_0,         Key_skip,
+        Key_skip,  Key_6, Key_7, Key_8,     Key_9,      Key_0,         Key_skip,
-   Key_Enter, Key_Y, Key_U, Key_I,     Key_O,      Key_P,         Key_Equals,
+        Key_Enter, Key_Y, Key_U, Key_I,     Key_O,      Key_P,         Key_Equals,
-              Key_H, Key_J, Key_K,     Key_L,      Key_Semicolon, Key_Quote,
+        Key_H, Key_J, Key_K,     Key_L,      Key_Semicolon, Key_Quote,
-   Key_skip,  Key_N, Key_M, Key_Comma, Key_Period, Key_Slash,     Key_Minus,
+        Key_skip,  Key_N, Key_M, Key_Comma, Key_Period, Key_Slash,     Key_Minus,
 
-   Key_RightShift, Key_RightAlt, Key_Spacebar, Key_RightControl,
+        Key_RightShift, Key_RightAlt, Key_Spacebar, Key_RightControl,
-   Key_skip
+        Key_skip
-   ),
+    ),
 };
 
 void setup () {
-  Kaleidoscope.setup ();
+    Kaleidoscope.setup ();
-  USE_PLUGINS (&TypingBreaks);
+    USE_PLUGINS (&TypingBreaks);
 }
 
 void loop () {
-  Kaleidoscope.loop ();
+    Kaleidoscope.loop ();
 }

src/Kaleidoscope/TypingBreaks.cpp

@@ -21,99 +21,99 @@
 #include <Kaleidoscope-Focus.h>
 
 namespace KaleidoscopePlugins {
-  TypingBreaks::settings_t TypingBreaks::settings = {
+TypingBreaks::settings_t TypingBreaks::settings = {
     .idleTimeLimit = 10000, // 10s
     .lockTimeOut = 2700000, // 45m
     .lockLength = 300000,   //  5m
     .leftHandMaxKeys = 0,
     .rightHandMaxKeys = 0
-  };
+};
 
-  uint32_t TypingBreaks::sessionStartTime;
+uint32_t TypingBreaks::sessionStartTime;
-  uint32_t TypingBreaks::lastKeyTime;
+uint32_t TypingBreaks::lastKeyTime;
-  uint32_t TypingBreaks::lockStartTime;
+uint32_t TypingBreaks::lockStartTime;
-  uint16_t TypingBreaks::leftHandKeys;
+uint16_t TypingBreaks::leftHandKeys;
-  uint16_t TypingBreaks::rightHandKeys;
+uint16_t TypingBreaks::rightHandKeys;
-  uint16_t TypingBreaks::settingsBase;
+uint16_t TypingBreaks::settingsBase;
 
-  TypingBreaks::TypingBreaks (void) {
+TypingBreaks::TypingBreaks (void) {
-  }
+}
 
-  void
+void
-  TypingBreaks::begin (void) {
+TypingBreaks::begin (void) {
     event_handler_hook_use (this->eventHandlerHook);
-  }
+}
 
-  Key
+Key
-  TypingBreaks::eventHandlerHook (Key mappedKey, byte row, byte col, uint8_t keyState) {
+TypingBreaks::eventHandlerHook (Key mappedKey, byte row, byte col, uint8_t keyState) {
     // If we are locked, and didn't time out yet, no key has to be pressed.
     if (lockStartTime && (millis () - lockStartTime <= settings.lockLength))
-      return Key_NoKey;
+        return Key_NoKey;
 
     // If we are locked...
     if (lockStartTime) {
-      // ...and the lock has not expired yet
+        // ...and the lock has not expired yet
-      if (millis () - lockStartTime <= settings.lockLength)
+        if (millis () - lockStartTime <= settings.lockLength)
-        return Key_NoKey; // remain locked
+            return Key_NoKey; // remain locked
 
-      // ...otherwise clear the lock
+        // ...otherwise clear the lock
-      lockStartTime = 0;
+        lockStartTime = 0;
-      leftHandKeys = rightHandKeys = 0;
+        leftHandKeys = rightHandKeys = 0;
-      sessionStartTime = millis ();
+        sessionStartTime = millis ();
 
-      TypingBreak (false);
+        TypingBreak (false);
     }
 
     // Any other case, we are not locked yet! (or we just unlocked)
 
     // Are we still in the same session?
     if (lastKeyTime && (millis () - lastKeyTime) >= settings.idleTimeLimit) {
-      // No, we are not. Clear timers and start over.
+        // No, we are not. Clear timers and start over.
-      lockStartTime = 0;
+        lockStartTime = 0;
-      leftHandKeys = rightHandKeys = 0;
+        leftHandKeys = rightHandKeys = 0;
-      sessionStartTime = millis ();
+        sessionStartTime = millis ();
     }
 
     // If we have a limit on the left hand, and we reached it, lock up!
     if (settings.leftHandMaxKeys && leftHandKeys >= settings.leftHandMaxKeys) {
-      lockStartTime = millis ();
+        lockStartTime = millis ();
-      TypingBreak (true);
+        TypingBreak (true);
-      return Key_NoKey;
+        return Key_NoKey;
     }
 
     // If we have a limit on the right hand, and we reached it, lock up!
     if (settings.rightHandMaxKeys && rightHandKeys >= settings.rightHandMaxKeys) {
-      lockStartTime = millis ();
-      TypingBreak (true);
-      return Key_NoKey;
-    }
-
-    if (settings.lockTimeOut) {
-      // Is the session longer than lockTimeOut?
-      if (millis () - sessionStartTime >= settings.lockTimeOut) {
-        // Yeah, it is.
         lockStartTime = millis ();
         TypingBreak (true);
         return Key_NoKey;
-      }
+    }
+
+    if (settings.lockTimeOut) {
+        // Is the session longer than lockTimeOut?
+        if (millis () - sessionStartTime >= settings.lockTimeOut) {
+            // Yeah, it is.
+            lockStartTime = millis ();
+            TypingBreak (true);
+            return Key_NoKey;
+        }
     }
 
     // So it seems we did not need to lock up. In this case, lets increase key
     // counters if need be.
 
     if (key_toggled_on (keyState)) {
-      if (col <= COLS / 2)
+        if (col <= COLS / 2)
-        leftHandKeys++;
+            leftHandKeys++;
-      else
+        else
-        rightHandKeys++;
+            rightHandKeys++;
-      lastKeyTime = millis ();
+        lastKeyTime = millis ();
     }
 
     return mappedKey;
-  }
+}
 
-  void
+void
-  TypingBreaks::enableEEPROM (void) {
+TypingBreaks::enableEEPROM (void) {
     settingsBase = ::EEPROMSettings.requestSlice (sizeof (settings));
 
     // If idleTime is max, assume that EEPROM is uninitialized, and store the
@@ -121,78 +121,78 @@ namespace KaleidoscopePlugins {
     uint32_t idleTime;
     EEPROM.get (settingsBase, idleTime);
     if (idleTime == 0xffffffff) {
-      EEPROM.put (settingsBase, settings);
+        EEPROM.put (settingsBase, settings);
     }
 
     EEPROM.get (settingsBase, settings);
-  }
+}
 
-  bool
+bool
-  TypingBreaks::focusHook (const char *command) {
+TypingBreaks::focusHook (const char *command) {
     enum {
-      IDLE_TIME_LIMIT,
+        IDLE_TIME_LIMIT,
-      LOCK_TIMEOUT,
+        LOCK_TIMEOUT,
-      LOCK_LENGTH,
+        LOCK_LENGTH,
-      LEFT_MAX,
+        LEFT_MAX,
-      RIGHT_MAX,
+        RIGHT_MAX,
     } subCommand;
 
     if (strncmp_P (command, PSTR ("typingbreaks."), 13) != 0)
-      return false;
+        return false;
     if (strcmp_P (command + 13, PSTR ("idleTimeLimit")) == 0)
-      subCommand = IDLE_TIME_LIMIT;
+        subCommand = IDLE_TIME_LIMIT;
     else if (strcmp_P (command + 13, PSTR ("lockTimeOut")) == 0)
-      subCommand = LOCK_TIMEOUT;
+        subCommand = LOCK_TIMEOUT;
     else if (strcmp_P (command + 13, PSTR ("lockLength")) == 0)
-      subCommand = LOCK_LENGTH;
+        subCommand = LOCK_LENGTH;
     else if (strcmp_P (command + 13, PSTR ("leftMaxKeys")) == 0)
-      subCommand = LEFT_MAX;
+        subCommand = LEFT_MAX;
     else if (strcmp_P (command + 13, PSTR ("rightMaxKeys")) == 0)
-      subCommand = RIGHT_MAX;
+        subCommand = RIGHT_MAX;
     else
-      return false;
+        return false;
 
     switch (subCommand) {
     case IDLE_TIME_LIMIT:
-      if (Serial.peek () == '\n') {
+        if (Serial.peek () == '\n') {
-        Serial.println (settings.idleTimeLimit);
+            Serial.println (settings.idleTimeLimit);
-      } else {
+        } else {
-        settings.idleTimeLimit = Serial.parseInt ();
+            settings.idleTimeLimit = Serial.parseInt ();
-      }
+        }
-      break;
+        break;
     case LOCK_TIMEOUT:
-      if (Serial.peek () == '\n') {
+        if (Serial.peek () == '\n') {
-        Serial.println (settings.lockTimeOut);
+            Serial.println (settings.lockTimeOut);
-      } else {
+        } else {
-        settings.lockTimeOut = Serial.parseInt ();
+            settings.lockTimeOut = Serial.parseInt ();
-      }
+        }
-      break;
+        break;
     case LOCK_LENGTH:
-      if (Serial.peek () == '\n') {
+        if (Serial.peek () == '\n') {
-        Serial.println (settings.lockLength);
+            Serial.println (settings.lockLength);
-      } else {
+        } else {
-        settings.lockLength = Serial.parseInt ();
+            settings.lockLength = Serial.parseInt ();
-      }
+        }
-      break;
+        break;
     case LEFT_MAX:
-      if (Serial.peek () == '\n') {
+        if (Serial.peek () == '\n') {
-        Serial.println (settings.leftHandMaxKeys);
+            Serial.println (settings.leftHandMaxKeys);
-      } else {
+        } else {
-        settings.leftHandMaxKeys = Serial.parseInt ();
+            settings.leftHandMaxKeys = Serial.parseInt ();
-      }
+        }
-      break;
+        break;
     case RIGHT_MAX:
-      if (Serial.peek () == '\n') {
+        if (Serial.peek () == '\n') {
-        Serial.println (settings.rightHandMaxKeys);
+            Serial.println (settings.rightHandMaxKeys);
-      } else {
+        } else {
-        settings.rightHandMaxKeys = Serial.parseInt ();
+            settings.rightHandMaxKeys = Serial.parseInt ();
-      }
+        }
-      break;
+        break;
     }
 
     EEPROM.put (settingsBase, settings);
     return true;
-  }
+}
 };
 
 KaleidoscopePlugins::TypingBreaks TypingBreaks;

src/Kaleidoscope/TypingBreaks.h

@@ -21,7 +21,7 @@
 #include <Kaleidoscope.h>
 
 namespace KaleidoscopePlugins {
-  class TypingBreaks : public KaleidoscopePlugin {
+class TypingBreaks : public KaleidoscopePlugin {
   public:
     TypingBreaks (void);
 
@@ -31,11 +31,11 @@ namespace KaleidoscopePlugins {
     static bool focusHook (const char *command);
 
     typedef struct settings_t {
-      uint32_t idleTimeLimit;
+        uint32_t idleTimeLimit;
-      uint32_t lockTimeOut;
+        uint32_t lockTimeOut;
-      uint32_t lockLength;
+        uint32_t lockLength;
-      uint16_t leftHandMaxKeys;
+        uint16_t leftHandMaxKeys;
-      uint16_t rightHandMaxKeys;
+        uint16_t rightHandMaxKeys;
     } settings_t;
 
     static settings_t settings;
@@ -50,7 +50,7 @@ namespace KaleidoscopePlugins {
     static uint16_t settingsBase;
 
     static Key eventHandlerHook (Key mappedKey, byte row, byte col, uint8_t keyState);
-  };
+};
 };
 
 extern KaleidoscopePlugins::TypingBreaks TypingBreaks;