Moves to qmk caps word and update xcase code

creativecoder · creativecoder · commit 9ed9a892fccc · 2024-04-26T18:10:04.000-05:00
diff --git a/kyria/qmk/casemodes.h b/kyria/qmk/casemodes.h
@@ -32,130 +32,122 @@
  */
 
 #ifndef DEFAULT_XCASE_SEPARATOR
-#    define DEFAULT_XCASE_SEPARATOR KC_UNDS
+#define DEFAULT_XCASE_SEPARATOR KC_UNDS
 #endif
 
-#define IS_OSM(keycode) (keycode >= QK_ONE_SHOT_MOD && keycode <= QK_ONE_SHOT_MOD_MAX)
+#ifndef DEFAULT_DELIMITERS_TERMINATE_COUNT
+#define DEFAULT_DELIMITERS_TERMINATE_COUNT 2
+#endif
 
-// enum for the xcase states
-enum xcase_state {
-    XCASE_OFF = 0,  // xcase is off
-    XCASE_ON,       // xcase is actively on
-    XCASE_WAIT,     // xcase is waiting for the delimiter input
+enum xcase_state
+{
+    XCASE_OFF = 0, // xcase is off
+    XCASE_ON,      // xcase is actively on
+    XCASE_WAIT,    // xcase is waiting for the delimiter input
 };
 
-// bool to keep track of the caps word state
-static bool caps_word_on = false;
-
 // enum to keep track of the xcase state
 static enum xcase_state xcase_state = XCASE_OFF;
 // the keycode of the xcase delimiter
 static uint16_t xcase_delimiter;
 // the number of keys to the last delimiter
 static int8_t distance_to_last_delim = -1;
-
-// Check whether caps word is on
-bool caps_word_enabled(void) { return caps_word_on; }
-
-// Enable caps word
-void enable_caps_word(void) {
-    caps_word_on = true;
-#ifndef CAPSWORD_USE_SHIFT
-    if (!host_keyboard_led_state().caps_lock) {
-        tap_code(KC_CAPS);
-    }
-#endif
-}
-
-// Disable caps word
-void disable_caps_word(void) {
-    caps_word_on = false;
-#ifndef CAPSWORD_USE_SHIFT
-    if (host_keyboard_led_state().caps_lock) {
-        tap_code(KC_CAPS);
-    }
-#else
-    unregister_mods(MOD_LSFT);
-#endif
-}
-
-// Toggle caps word
-void toggle_caps_word(void) {
-    if (caps_word_on) {
-        disable_caps_word();
-    } else {
-        enable_caps_word();
-    }
-}
+// the number of delimiters in a row
+static int8_t delimiters_count = 0;
 
 // Get xcase state
-enum xcase_state get_xcase_state(void) { return xcase_state; }
+enum xcase_state get_xcase_state(void)
+{
+    return xcase_state;
+}
 
 // Enable xcase and pickup the next keystroke as the delimiter
-void enable_xcase(void) { xcase_state = XCASE_WAIT; }
+void enable_xcase(void)
+{
+    xcase_state = XCASE_WAIT;
+}
 
 // Enable xcase with the specified delimiter
-void enable_xcase_with(uint16_t delimiter) {
-    xcase_state            = XCASE_ON;
-    xcase_delimiter        = delimiter;
+void enable_xcase_with(uint16_t delimiter)
+{
+    xcase_state = XCASE_ON;
+    xcase_delimiter = delimiter;
     distance_to_last_delim = -1;
+    delimiters_count = 0;
 }
 
 // Disable xcase
-void disable_xcase(void) { xcase_state = XCASE_OFF; }
+void disable_xcase(void)
+{
+    xcase_state = XCASE_OFF;
+}
 
 // Place the current xcase delimiter
-static void place_delimiter(void) {
-    if (IS_OSM(xcase_delimiter)) {
+static void place_delimiter(void)
+{
+    if (IS_QK_ONE_SHOT_MOD(xcase_delimiter))
+    {
         // apparently set_oneshot_mods() is dumb and doesn't deal with handedness for you
         uint8_t mods = xcase_delimiter & 0x10 ? (xcase_delimiter & 0x0F) << 4 : xcase_delimiter & 0xFF;
-        set_oneshot_mods(mods);
-    } else {
+        set_oneshot_mods(QK_ONE_SHOT_MOD_GET_MODS(mods));
+    }
+    else
+    {
         tap_code16(xcase_delimiter);
     }
 }
 
 // Removes a delimiter, used for double tap space exit
-static void remove_delimiter(void) {
-    if (IS_OSM(xcase_delimiter)) {
+static void remove_delimiter(void)
+{
+    if (IS_QK_ONE_SHOT_MOD(xcase_delimiter))
+    {
         clear_oneshot_mods();
-    } else {
-        tap_code(KC_BSPC);
+    }
+    else
+    {
+        for (int8_t i = 0; i < DEFAULT_DELIMITERS_TERMINATE_COUNT - 1; i++)
+        {
+            tap_code(KC_BSPC);
+        }
     }
 }
 
 // overrideable function to determine whether the case mode should stop
-__attribute__((weak)) bool terminate_case_modes(uint16_t keycode, const keyrecord_t *record) {
-    switch (keycode) {
-        // Keycodes to ignore (don't disable caps word)
-        case KC_A ... KC_Z:
-        case KC_1 ... KC_0:
-        case KC_MINS:
-        case KC_UNDS:
-        case KC_BSPC:
-        // Used for triggering one-shot shift
-        case KC_LSFT:
-            // If mod chording other than shift, disable the mods
-            if (record->event.pressed &&
-                // Some mods are pressed
-                get_mods() != 0 &&
-                // Neither shift mod is pressed
-                (get_mods() & MOD_MASK_SHIFT) == 0) {
-                return true;
-            }
-            break;
-        default:
-            if (record->event.pressed) {
-                return true;
-            }
-            break;
+__attribute__((weak)) bool terminate_case_modes(uint16_t keycode, const keyrecord_t *record)
+{
+    switch (keycode)
+    {
+    // Keycodes to ignore (don't disable caps word)
+    case KC_A ... KC_Z:
+    case KC_1 ... KC_0:
+    case KC_MINS:
+    case KC_UNDS:
+    case KC_BSPC:
+    // Used for triggering one-shot shift
+    case KC_LSFT:
+        // If mod chording other than shift and/or alt, disable the mods
+        if (record->event.pressed &&
+            // Ctrl or Gui is pressed
+            get_mods() & MOD_MASK_CG)
+        {
+            return true;
+        }
+        break;
+    default:
+        if (record->event.pressed)
+        {
+            return true;
+        }
+        break;
     }
     return false;
 }
 
 /* overrideable function to determine whether to use the default separator on
  * first keypress when waiting for the separator. */
-__attribute__((weak)) bool use_default_xcase_separator(uint16_t keycode, const keyrecord_t *record) {
+__attribute__((weak)) bool use_default_xcase_separator(uint16_t keycode, const keyrecord_t *record)
+{
     // for example:
     /* switch (keycode) { */
     /*     case KC_A ... KC_Z: */
@@ -165,34 +157,49 @@ __attribute__((weak)) bool use_default_xcase_separator(uint16_t keycode, const k
     return false;
 }
 
-bool process_case_modes(uint16_t keycode, const keyrecord_t *record) {
-    if (caps_word_on || xcase_state) {
-        if ((QK_MOD_TAP <= keycode && keycode <= QK_MOD_TAP_MAX) || (QK_LAYER_TAP <= keycode && keycode <= QK_LAYER_TAP_MAX)) {
+bool process_case_modes(uint16_t keycode, const keyrecord_t *record)
+{
+    if (xcase_state)
+    {
+        if ((QK_MOD_TAP <= keycode && keycode <= QK_MOD_TAP_MAX) || (QK_LAYER_TAP <= keycode && keycode <= QK_LAYER_TAP_MAX))
+        {
             // Earlier return if this has not been considered tapped yet
-            if (record->tap.count == 0) return true;
+            if (record->tap.count == 0)
+                return true;
             keycode = keycode & 0xFF;
         }
 
-        if (keycode >= QK_LAYER_TAP && keycode <= QK_ONE_SHOT_LAYER_MAX) {
+        if (keycode >= QK_LAYER_TAP && keycode <= QK_ONE_SHOT_LAYER_MAX)
+        {
             // let special keys and normal modifiers go through
             return true;
         }
 
-        if (xcase_state == XCASE_WAIT) {
+        if (xcase_state == XCASE_WAIT)
+        {
             // grab the next input to be the delimiter
-            if (use_default_xcase_separator(keycode, record)) {
+            if (use_default_xcase_separator(keycode, record))
+            {
                 enable_xcase_with(DEFAULT_XCASE_SEPARATOR);
-            } else if (record->event.pressed) {
+            }
+            else if (record->event.pressed)
+            {
                 // factor in mods
-                if (get_mods() & MOD_MASK_SHIFT) {
+                if (get_mods() & MOD_MASK_SHIFT)
+                {
                     keycode = LSFT(keycode);
-                } else if (get_mods() & MOD_BIT(KC_RALT)) {
+                }
+                else if (get_mods() & MOD_BIT(KC_RALT))
+                {
                     keycode = RALT(keycode);
                 }
                 enable_xcase_with(keycode);
                 return false;
-            } else {
-                if (IS_OSM(keycode)) {
+            }
+            else
+            {
+                if (IS_QK_ONE_SHOT_MOD(keycode))
+                {
                     // this catches the OSM release if no other key was pressed
                     set_oneshot_mods(0);
                     enable_xcase_with(keycode);
@@ -203,52 +210,61 @@ bool process_case_modes(uint16_t keycode, const keyrecord_t *record) {
             }
         }
 
-        if (record->event.pressed) {
+        if (record->event.pressed)
+        {
             // handle xcase mode
-            if (xcase_state == XCASE_ON) {
+            if (xcase_state == XCASE_ON)
+            {
                 // place the delimiter if space is tapped
-                if (keycode == KC_SPACE) {
-                    if (distance_to_last_delim != 0) {
+                if (keycode == KC_SPACE)
+                {
+                    delimiters_count++;
+                    if (delimiters_count < DEFAULT_DELIMITERS_TERMINATE_COUNT)
+                    {
                         place_delimiter();
                         distance_to_last_delim = 0;
                         return false;
                     }
+
                     // remove the delimiter and disable modes
-                    else {
+                    else
+                    {
                         remove_delimiter();
                         disable_xcase();
-                        disable_caps_word();
+                        caps_word_off();
                         return true;
                     }
                 }
                 // decrement distance to delimiter on back space
-                else if (keycode == KC_BSPC) {
+                else if (keycode == KC_BSPC)
+                {
                     --distance_to_last_delim;
+                    if (delimiters_count > 0)
+                    {
+                        --delimiters_count;
+                    }
                 }
                 // don't increment distance to last delim if negative
-                else if (distance_to_last_delim >= 0) {
+                else if (distance_to_last_delim >= 0)
+                {
                     // puts back a one shot delimiter if you we're back to the delimiter pos
-                    if (distance_to_last_delim == 0 && (IS_OSM(xcase_delimiter))) {
+                    if (distance_to_last_delim == 0 && (IS_QK_ONE_SHOT_MOD(xcase_delimiter)))
+                    {
                         place_delimiter();
                     }
                     ++distance_to_last_delim;
+                    delimiters_count = 0;
                 }
 
-            }  // end XCASE_ON
+            } // end XCASE_ON
 
             // check if the case modes have been terminated
-            if (terminate_case_modes(keycode, record)) {
-                disable_caps_word();
+            if (terminate_case_modes(keycode, record))
+            {
+                caps_word_off();
                 disable_xcase();
             }
-#ifdef CAPSWORD_USE_SHIFT
-            else if (caps_word_on && keycode >= KC_A && keycode <= KC_Z) {
-                tap_code16(LSFT(keycode));
-                return false;
-            }
-#endif
-
-        }  // end if event.pressed
+        } // end if event.pressed
 
         return true;
     }
diff --git a/kyria/qmk/config.h b/kyria/qmk/config.h
@@ -45,6 +45,9 @@
 // Make sure keycodes tap duration is long enough to be registered
 #define TAP_CODE_DELAY 25
 
+// Caps Word
+#define CAPS_WORD_INVERT_ON_SHIFT
+
 #ifdef COMBO_ENABLE
 #define COMBO_TERM 100
 #define COMBO_STRICT_TIMER
diff --git a/kyria/qmk/keymap.c b/kyria/qmk/keymap.c
@@ -227,7 +227,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record)
             }
             else
             {
-                enable_caps_word();
+                caps_word_on();
             }
         }
         return false;
@@ -236,7 +236,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record)
         {
             if (get_mods() & MOD_MASK_SHIFT)
             {
-                enable_caps_word();
+                caps_word_on();
             }
 
             if ((get_mods() & MOD_BIT(KC_LALT)) == MOD_BIT(KC_LALT))
diff --git a/kyria/qmk/rules.mk b/kyria/qmk/rules.mk
@@ -4,3 +4,4 @@ ENCODER_ENABLE = yes       # https://docs.qmk.fm/#/feature_encoders
 MOUSEKEY_ENABLE = no       # https://docs.qmk.fm/#/feature_mouse_keys
 OLED_ENABLE = no           # https://docs.qmk.fm/#/feature_oled_driver
 RGBLIGHT_ENABLE = yes      # https://docs.qmk.fm/#/feature_rgblight
+CAPS_WORD_ENABLE = yes     # https://docs.qmk.fm/#/feature_caps_word

Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record)`
`227`	`227`	`}`
`228`	`228`	`else`
`229`	`229`	`{`
`230`		`- enable_caps_word();`
	`230`	`+ caps_word_on();`
`231`	`231`	`}`
`232`	`232`	`}`
`233`	`233`	`return false;`
`@@ -236,7 +236,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record)`
`236`	`236`	`{`
`237`	`237`	`if (get_mods() & MOD_MASK_SHIFT)`
`238`	`238`	`{`
`239`		`- enable_caps_word();`
	`239`	`+ caps_word_on();`
`240`	`240`	`}`
`241`	`241`
`242`	`242`	`if ((get_mods() & MOD_BIT(KC_LALT)) == MOD_BIT(KC_LALT))`