Smallish overhaul of Auto-Shift feature (#6067)

* Fix edge case when using One Shot Layer with Auto Shift, and it not triggering the cleanup
* Remove junk code (no longer used)
* Replace `(un)register_code` calls with `tap_code` where appropriate
* Fixed up Switch check to be more readable (less verbose)
* Simplified modifier check (if it comes back non-zero, there are mods)
* Add additional function calls for autoshift settings
* Made all variables static, since there are function calls to get their status
* Fixed up documentation
* Re-add special characters that were missed
* formatting pass

docs/feature_auto_shift.md

@@ -51,12 +51,15 @@ By default, Auto Shift is disabled for any key press that is accompanied by one
 modifiers. Thus, Ctrl+A that you hold for a really long time is not the same
 as Ctrl+Shift+A.
 
-You can re-enable Auto Shift for modifiers by adding another rule to your `rules.mk`
+You can re-enable Auto Shift for modifiers by adding a define to your `config.h`
 
-    AUTO_SHIFT_MODIFIERS = yes
+```c
+#define AUTO_SHIFT_MODIFIERS
+```
 
 In which case, Ctrl+A held past the `AUTO_SHIFT_TIMEOUT` will be sent as Ctrl+Shift+A
 
+
 ## Configuring Auto Shift
 
 If desired, there is some configuration that can be done to change the
@@ -65,15 +68,12 @@ behavior of Auto Shift. This is done by setting various variables the
 
 A sample is
 
-    #ifndef CONFIG_USER_H
-    #define CONFIG_USER_H
-
-    #include "../../config.h"
-
-    #define AUTO_SHIFT_TIMEOUT 150
-    #define NO_AUTO_SHIFT_SPECIAL
+```c
+#pragma once
 
-    #endif
+#define AUTO_SHIFT_TIMEOUT 150
+#define NO_AUTO_SHIFT_SPECIAL
+```
 
 ### AUTO_SHIFT_TIMEOUT (Value in ms)
 

quantum/process_keycode/process_auto_shift.c

@@ -20,19 +20,10 @@
 
 #    include "process_auto_shift.h"
 
-#    define TAP(key)        \
-        register_code(key); \
-        unregister_code(key)
-
-#    define TAP_WITH_MOD(mod, key) \
-        register_code(mod);        \
-        register_code(key);        \
-        unregister_code(key);      \
-        unregister_code(mod)
-
-uint16_t autoshift_time    = 0;
-uint16_t autoshift_timeout = AUTO_SHIFT_TIMEOUT;
-uint16_t autoshift_lastkey = KC_NO;
+static bool     autoshift_enabled = true;
+static uint16_t autoshift_time    = 0;
+static uint16_t autoshift_timeout = AUTO_SHIFT_TIMEOUT;
+static uint16_t autoshift_lastkey = KC_NO;
 
 void autoshift_timer_report(void) {
     char display[8];
@@ -52,14 +43,9 @@ void autoshift_flush(void) {
         uint16_t elapsed = timer_elapsed(autoshift_time);
 
         if (elapsed > autoshift_timeout) {
-            register_code(KC_LSFT);
-        }
-
-        register_code(autoshift_lastkey);
-        unregister_code(autoshift_lastkey);
-
-        if (elapsed > autoshift_timeout) {
-            unregister_code(KC_LSFT);
+            tap_code16(LSFT(autoshift_lastkey));
+        } else {
+            tap_code(autoshift_lastkey);
         }
 
         autoshift_time    = 0;
@@ -67,8 +53,6 @@ void autoshift_flush(void) {
     }
 }
 
-bool autoshift_enabled = true;
-
 void autoshift_enable(void) { autoshift_enabled = true; }
 void autoshift_disable(void) {
     autoshift_enabled = false;
@@ -84,106 +68,62 @@ void autoshift_toggle(void) {
     }
 }
 
-bool autoshift_state(void) { return autoshift_enabled; }
+bool get_autoshift_state(void) { return autoshift_enabled; }
 
-bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {
-#    ifndef AUTO_SHIFT_MODIFIERS
-    static uint8_t any_mod_pressed;
-#    endif
+uint16_t get_autoshift_timeout(void) { return autoshift_timeout; }
 
+void set_autoshift_timeout(uint16_t timeout) { autoshift_timeout = timeout; }
+
+bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {
     if (record->event.pressed) {
         switch (keycode) {
             case KC_ASUP:
                 autoshift_timeout += 5;
-                return false;
+                return true;
 
             case KC_ASDN:
                 autoshift_timeout -= 5;
-                return false;
+                return true;
 
             case KC_ASRP:
                 autoshift_timer_report();
-                return false;
+                return true;
 
             case KC_ASTG:
                 autoshift_toggle();
-                return false;
+                return true;
             case KC_ASON:
                 autoshift_enable();
-                return false;
+                return true;
             case KC_ASOFF:
                 autoshift_disable();
-                return false;
+                return true;
 
 #    ifndef NO_AUTO_SHIFT_ALPHA
-            case KC_A:
-            case KC_B:
-            case KC_C:
-            case KC_D:
-            case KC_E:
-            case KC_F:
-            case KC_G:
-            case KC_H:
-            case KC_I:
-            case KC_J:
-            case KC_K:
-            case KC_L:
-            case KC_M:
-            case KC_N:
-            case KC_O:
-            case KC_P:
-            case KC_Q:
-            case KC_R:
-            case KC_S:
-            case KC_T:
-            case KC_U:
-            case KC_V:
-            case KC_W:
-            case KC_X:
-            case KC_Y:
-            case KC_Z:
+            case KC_A ... KC_Z:
 #    endif
 #    ifndef NO_AUTO_SHIFT_NUMERIC
-            case KC_1:
-            case KC_2:
-            case KC_3:
-            case KC_4:
-            case KC_5:
-            case KC_6:
-            case KC_7:
-            case KC_8:
-            case KC_9:
-            case KC_0:
+            case KC_1 ... KC_0:
 #    endif
 #    ifndef NO_AUTO_SHIFT_SPECIAL
-            case KC_MINUS:
-            case KC_EQL:
             case KC_TAB:
-            case KC_LBRC:
-            case KC_RBRC:
-            case KC_BSLS:
-            case KC_SCLN:
-            case KC_QUOT:
-            case KC_COMM:
-            case KC_DOT:
-            case KC_SLSH:
-            case KC_GRAVE:
+            case KC_MINUS ... KC_SLASH:
             case KC_NONUS_BSLASH:
-            case KC_NONUS_HASH:
 #    endif
-
                 autoshift_flush();
                 if (!autoshift_enabled) return true;
 
 #    ifndef AUTO_SHIFT_MODIFIERS
-                any_mod_pressed = get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI) | MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT) | MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL) | MOD_BIT(KC_LSFT) | MOD_BIT(KC_RSFT));
-
-                if (any_mod_pressed) {
+                if (get_mods()) {
                     return true;
                 }
 #    endif
-
                 autoshift_on(keycode);
+
+                // We need some extra handling here for OSL edge cases
+#    if !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING)
+                clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
+#    endif
                 return false;
 
             default:

quantum/process_keycode/process_auto_shift.h

@@ -14,8 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef PROCESS_AUTO_SHIFT_H
-#define PROCESS_AUTO_SHIFT_H
+#pragma once
 
 #include "quantum.h"
 
@@ -25,9 +24,9 @@
 
 bool process_auto_shift(uint16_t keycode, keyrecord_t *record);
 
-void autoshift_enable(void);
-void autoshift_disable(void);
-void autoshift_toggle(void);
-bool autoshift_state(void);
-
-#endif
+void     autoshift_enable(void);
+void     autoshift_disable(void);
+void     autoshift_toggle(void);
+bool     get_autoshift_state(void);
+uint16_t get_autoshift_timeout(void);
+void     set_autoshift_timeout(uint16_t timeout);