caps word implementation

kmk/modules/capsword.py

@@ -0,0 +1,98 @@
+from kmk.keys import KC, ModifierKey, make_key
+from kmk.modules import Module
+
+
+class CapsWord(Module):
+    # default timeout is 8000
+    # alphabets, numbers and few more keys will not disable capsword
+    def __init__(self, timeout=8000):
+        self.alphabets = range(KC.A.code, KC.Z.code)
+        self.numbers = range(KC.N1.code, KC.N0.code)
+        self.keys_ignored = (
+            KC.MINS,
+            KC.BSPC,
+            KC.UNDS,
+        )
+        self._timeout_key = False
+        self._cw_active = False
+        self.timeout = timeout
+        make_key(
+            names=(
+                'CAPSWORD',
+                'CW',
+            ),
+        )
+
+    def during_bootup(self, keyboard):
+        return
+
+    def matrix_detected_press(self, keyboard):
+        return keyboard.matrix_update is None
+
+    def before_matrix_scan(self, keyboard):
+        return
+
+    def process_key(self, keyboard, key, is_pressed, int_coord):
+        if self._cw_active and key != KC.CW:
+            continue_cw = False
+            # capitalize alphabets
+            if key.code in self.alphabets:
+                continue_cw = True
+                keyboard.process_key(KC.LSFT, is_pressed)
+            elif (
+                key.code in self.numbers
+                or isinstance(key, ModifierKey)
+                or key in self.keys_ignored
+                or key.code >= 1000  # user defined keys are also ignored
+            ):
+                continue_cw = True
+            # requests and cancels existing timeouts
+            if is_pressed:
+                if continue_cw:
+                    self.discard_timeout(keyboard)
+                    self.request_timeout(keyboard)
+                else:
+                    self.process_timeout()
+
+        # enables/disables capsword
+        if key == KC.CW and is_pressed:
+            if not self._cw_active:
+                self._cw_active = True
+                self.discard_timeout(keyboard)
+                self.request_timeout(keyboard)
+            else:
+                self.discard_timeout(keyboard)
+                self.process_timeout()
+        return key
+
+    def before_hid_send(self, keyboard):
+        return
+
+    def after_hid_send(self, keyboard):
+        return
+
+    def on_powersave_enable(self, keyboard):
+        return
+
+    def on_powersave_disable(self, keyboard):
+        return
+
+    def after_matrix_scan(self, keyboard):
+        return
+
+    def process_timeout(self):
+        self._cw_active = False
+        self._timeout_key = False
+
+    def request_timeout(self, keyboard):
+        if self._cw_active:
+            if self.timeout:
+                self._timeout_key = keyboard.set_timeout(
+                    self.timeout, lambda: self.process_timeout()
+                )
+
+    def discard_timeout(self, keyboard):
+        if self._timeout_key:
+            if self.timeout:
+                keyboard.cancel_timeout(self._timeout_key)
+            self._timeout_key = False