Merge remote-tracking branch 'upstream/master' into develop

4 files changed, 503 insertions, 210 deletions

diff --git a/users/gourdo1/custom_double_taps.h b/users/gourdo1/custom_double_taps.h
new file mode 100644
index 0000000000..4f551e1fa1
--- /dev/null
+++ b/users/gourdo1/custom_double_taps.h
@@ -0,0 +1,73 @@
+// Copyright 2022 Google LLC
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "gourdo1.h"
+
+static bool process_capsnum(uint16_t keycode, keyrecord_t * record) {
+    static bool toggled = false;
+    static bool tapped = false;
+    static uint16_t tap_timer = 0;
+
+    if (keycode == CAPSNUM) {
+        if (user_config.double_tap_shift_for_capslock) {
+            // Act as TT(_NUMPADMOUSE)
+            if (record -> event.pressed) { // CAPSNUM key was pressed
+                // Check whether the key was recently tapped
+                if (tapped && !timer_expired(record -> event.time, tap_timer)) {
+                    // This is a double tap (or possibly a triple tap or more)
+                    // Toggle the layer on.
+                    toggled = true;
+                } else if (toggled) {
+                    // Otherwise if currently toggled, turn it off
+                    toggled = false;
+                    tapped = false;
+                    layer_off(_NUMPADMOUSE);
+                }
+                // Set that the first tap occurred in a potential double tap
+                tapped = true;
+                tap_timer = record -> event.time + TAPPING_TERM;
+                layer_on(_NUMPADMOUSE);
+            } else if (!toggled) {
+                // If not currently toggled, turn off on key release
+                layer_off(_NUMPADMOUSE);
+                return false;
+            }
+        } else { // When double_tap_shift_for_capslock == false
+            // Act as KC_CAPS
+            if (record -> event.pressed) {
+                register_code(KC_CAPS);
+            } else {
+                unregister_code(KC_CAPS);
+            }
+        }
+        return false;
+    } else {
+        // On an event with any other key, reset the double tap state
+        tapped = false;
+    }
+    return true;
+}
+
+static bool process_esc_to_base(uint16_t keycode, keyrecord_t * record) {
+    static bool tapped = false;
+    static uint16_t tap_timer = 0;
+
+    if (keycode == KC_ESC) {
+        if (user_config.esc_double_tap_to_baselyr) {
+            if (record -> event.pressed) {
+                if (tapped && !timer_expired(record -> event.time, tap_timer)) {
+                    // The key was double tapped.
+                    layer_clear();
+                }
+                tapped = true;
+                tap_timer = record -> event.time + TAPPING_TERM;
+            }
+        }
+    } else {
+        // On an event with any other key, reset the double tap state.
+        tapped = false;
+    }
+    return true;
+}
diff --git a/users/gourdo1/gourdo1.c b/users/gourdo1/gourdo1.c
index 4e741ccc91..51f774061e 100644
--- a/users/gourdo1/gourdo1.c
+++ b/users/gourdo1/gourdo1.c
@@ -1,6 +1,6 @@
 /* Copyright 2021 Jonavin Eng @Jonavin
-   Copyright 2022 gourdo1 <jcblake@outlook.com>
-   
+   Copyright 2022 gourdo1 <gourdo1@outlook.com>
+
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 2 of the License, or
@@ -19,35 +19,35 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "gourdo1.h"
 
-#include "caps_word.h"
+#include "custom_double_taps.h"
 
-#ifdef TD_LSFT_CAPSLOCK_ENABLE
-// Tap once for shift, twice for Caps Lock but only if Win Key in not disabled
+// Tap once for shift, twice for Caps Lock but only if Win Key is not disabled (also disabled by user.config variable)
 void dance_LSFT_each_tap(qk_tap_dance_state_t * state, void * user_data) {
-    if (state -> count == 1 || keymap_config.no_gui) {
-        register_code16(KC_LSFT);
+    if (user_config.double_tap_shift_for_capslock) {
+        if (state -> count == 1 || keymap_config.no_gui) {
+            register_code(KC_LSFT);
+        } else {
+            register_code(KC_CAPS);
+        }
     } else {
-        register_code(KC_CAPS);
+        register_code(KC_LSFT);
     }
 }
 
 void dance_LSFT_reset(qk_tap_dance_state_t * state, void * user_data) {
     if (state -> count == 1 || keymap_config.no_gui) {
-        unregister_code16(KC_LSFT);
+        unregister_code(KC_LSFT);
     } else {
         unregister_code(KC_CAPS);
-        unregister_code16(KC_LSFT);
+        unregister_code(KC_LSFT);
     }
 }
+
 // Tap Dance definitions
 qk_tap_dance_action_t tap_dance_actions[] = {
     // Tap once for shift, twice for Caps Lock
-    [TD_LSFT_CAPSLOCK] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS),
-    [TD_LSFT_CAPS_WIN] = ACTION_TAP_DANCE_FN_ADVANCED(dance_LSFT_each_tap, NULL, dance_LSFT_reset),
-    // Tap once for Escape, twice to reset to base layer
-    [TD_ESC_BASELYR] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _BASE),
+    [TD_LSFT_CAPS_WIN] = ACTION_TAP_DANCE_FN_ADVANCED(dance_LSFT_each_tap, NULL, dance_LSFT_reset)
 };
-#endif // TD_LSFT_CAPSLOCK_ENABLE
 
 // RGB NIGHT MODE
 #ifdef RGB_MATRIX_ENABLE
@@ -126,209 +126,373 @@ __attribute__((weak)) bool process_record_keymap(uint16_t keycode, keyrecord_t *
 
 bool process_record_user(uint16_t keycode, keyrecord_t * record) {
     mod_state = get_mods();
-    if (!process_record_keymap(keycode, record)) {
-        return false;
-    }
-
-    if (!process_caps_word(keycode, record)) {
-        return false;
-    }
+    if (!process_record_keymap(keycode, record)) { return false; }
+    if (!process_capsnum(keycode, record)) { return false; }
+    if (!process_esc_to_base(keycode, record)) { return false; }
 
-    // Your macros ...
+    // Key macros ...
     switch (keycode) {
 
-    // DotCom domain macros
+        // User configuration toggles
+    case PRNCONF:  // Print verbose status of all user_config toggles (open a text editor before engaging!!)
+        if (record->event.pressed) {
+            //send_string("Left bracket with alt numcodes "SS_LALT(SS_TAP(X_KP_0) SS_TAP(X_KP_0) SS_TAP(X_KP_9) SS_TAP(X_KP_1))"\n");
+            send_string("\n\x2D\x2D\x2D\x2D\x2D\x2D\x2D\x2D\x2D\x3C\x3C\x3C\x3C\x3C\x3C\x3C\x3C\x3C");
+            send_string(" gourdo1\x27s GMMK Pro User Settings ");
+            send_string("\x3E\x3E\x3E\x3E\x3E\x3E\x3E\x3E\x3E\x2D\x2D\x2D\x2D\x2D\x2D\x2D\x2D\x2D\n");
+            send_string("Hold \x5B \bFn\x5D and the number corresponding to a setting below to toggle.\n");
+            send_string("Re-print this screen with \x5B \bFn\x5D \x5B`\x5D to see your changes reflected.\n");
+            send_string("Config also visible as RGB under number keys by holding \x5B \bFn\x5D.\n");
+            send_string("\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d");
+            send_string("\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d");
+            send_string("\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d");
+            send_string("\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\n");
+            send_string("1. CapsLock RGB highlight alpha keys................ ");
+            if (user_config.rgb_hilite_caps) {
+                send_string("\x5BON\x5D\n");
+            } else {
+                send_string("\x5BOFF\x5D\n");
+            }
+            send_string("2. Numpad RGB highlight layer keys.................. ");
+            if (user_config.rgb_hilite_numpad) {
+                send_string("\x5BON\x5D\n");
+            } else {
+                send_string("\x5BOFF\x5D\n");
+            }
+            send_string("3. Double tap ESC to revert to BASE layer........... ");
+            if (user_config.esc_double_tap_to_baselyr) {
+                send_string("\x5BON\x5D\n");
+            } else {
+                send_string("\x5BOFF\x5D\n");
+            }
+            send_string("4. DEL \x26 HOME key locations......................... ");
+            if (user_config.del_right_home_top) {
+                send_string("\x5BHOME on F13\x3B DEL right of BKSPC\x5D\n");
+            } else {
+                send_string("\x5B \bDEL on F13\x3B HOME right of BKSPC\x5D\n");
+            }
+            send_string("5. Numpad on CapsLock\x3B double tap LSHIFT for Caps... ");
+            if (user_config.double_tap_shift_for_capslock) {
+                send_string("\x5BON\x5D\n");
+            } else {
+                send_string("\x5BOFF\x5D\n");
+            }
+            send_string("6. Encoder button function.......................... ");
+            if (user_config.encoder_press_mute_or_media) {
+                send_string("\x5BMUTE\x5D\n");
+            } else {
+                send_string("\x5BMEDIA PLAY\x2FPAUSE\x5D\n");
+            }
+            send_string("7. Insert function accessed with.................... ");
+            if (user_config.ins_on_shft_bkspc_or_del) {
+                send_string("\x5BSHIFT\x2D \bBKSPC\x5D\n");
+            } else {
+                send_string("\x5BSHIFT\x2D \bDEL\x5D\n");
+            }
+            send_string("8. Force SHIFT \x26 CTRL\x2DSPACE to function like SPACE.. ");
+            if (user_config.disable_space_mods) {
+                send_string("\x5BON\x5D\n");
+            } else {
+                send_string("\x5BOFF\x5D\n");
+            }
+            send_string("\nThe latest firmware updates are always here\x3a https\x3a\x2F\x2Fgithub.com\x2Fgourdo1\x2Fgmmkpro\x2Dmedia\n");
+        }
+        break;
+
+    case TG_CAPS:  // Toggle RGB highlighting of Capslock state
+        if (record->event.pressed) {
+            user_config.rgb_hilite_caps ^= 1; // Toggles the status
+            eeconfig_update_user(user_config.raw); // Writes the new status to EEPROM
+        }
+        break;
+    case TG_PAD:  // Toggle RGB highlighting of Numpad state
+        if (record->event.pressed) {
+            user_config.rgb_hilite_numpad ^= 1; // Toggles the status
+            eeconfig_update_user(user_config.raw); // Writes the new status to EEPROM
+        }
+        break;
+    case TG_ESC:  // Toggle alternate ESC functionality
+        if (record->event.pressed) {
+            user_config.esc_double_tap_to_baselyr ^= 1; // Toggles the status
+            eeconfig_update_user(user_config.raw); // Writes the new status to EEPROM
+        }
+        break;
+    case TG_DEL:  // Toggle alternate placement of DEL and HOME keys
+        if (record->event.pressed) {
+            user_config.del_right_home_top ^= 1; // Toggles the status
+            eeconfig_update_user(user_config.raw); // Writes the new status to EEPROM
+        }
+        break;
+    case TG_TDCAP:  // Toggle alternate Capslock/Numpad functionality
+        if (record->event.pressed) {
+            user_config.double_tap_shift_for_capslock ^= 1; // Toggles the status
+            eeconfig_update_user(user_config.raw); // Writes the new status to EEPROM
+        }
+        break;
+    case TG_ENC:  // Toggle Encoder function
+        if (record->event.pressed) {
+            user_config.encoder_press_mute_or_media ^= 1; // Toggles the status
+            eeconfig_update_user(user_config.raw); // Writes the new status to EEPROM
+        }
+        break;
+    case TG_INS:  // Toggle Encoder function
+        if (record->event.pressed) {
+            user_config.ins_on_shft_bkspc_or_del ^= 1; // Toggles the status
+            eeconfig_update_user(user_config.raw); // Writes the new status to EEPROM
+        }
+        break;
+    case TG_SPCMOD:  // Toggle forcing SHIFT&CTRL-SPACE to function like SPACE
+        if (record->event.pressed) {
+            user_config.disable_space_mods ^= 1; // Toggles the status
+            eeconfig_update_user(user_config.raw); // Writes the new status to EEPROM
+        }
+        break;
+        //return false;
+
+        // Key to the left of encoder function (default HOME)
+    case LEFTOFENC:
+        if (!(user_config.del_right_home_top)) {
+            if (!(user_config.ins_on_shft_bkspc_or_del)) {
+                static bool inskey_registered;
+                if (record -> event.pressed) {
+                    // Detect the activation of either shift keys
+                    if (mod_state & MOD_MASK_SHIFT) {
+                        // First temporarily canceling both shifts so that
+                        // shift isn't applied to the KC_INS keycode
+                        del_mods(MOD_MASK_SHIFT);
+                        register_code(KC_INS);
+                        // Update the boolean variable to reflect the status of KC_INS
+                        inskey_registered = true;
+                        // Reapplying modifier state so that the held shift key(s)
+                        // still work even after having tapped the key.
+                        set_mods(mod_state);
+                        return false;
+                    } else {
+                        register_code(KC_DEL);
+                        return false;
+                    }
+                } else { // on release of KC_DEL
+                    // In case KC_INS is still being sent even after the release of KC_DEL
+                    if (inskey_registered) {
+                        unregister_code(KC_INS);
+                        inskey_registered = false;
+                        return false;
+                    } else {
+                        unregister_code(KC_DEL);
+                        return false;
+                    }
+                }
+            } else {
+                if (record -> event.pressed) {
+                    register_code(KC_DEL);
+                    return false;
+                } else {
+                    unregister_code(KC_DEL);
+                    return false;
+                }
+            }
+        } else {
+            if (record -> event.pressed) {
+                register_code(KC_HOME);
+                return false;
+            } else {
+                unregister_code(KC_HOME);
+                return false;
+            }
+        }
+        break;
+
+        // Key below encoder function (default DEL)
+    case BELOWENC:
+        if (user_config.del_right_home_top) {
+            if (!(user_config.ins_on_shft_bkspc_or_del)) {
+                static bool inskey_registered;
+                if (record -> event.pressed) {
+                    // Detect the activation of either shift keys
+                    if (mod_state & MOD_MASK_SHIFT) {
+                        // First temporarily canceling both shifts so that
+                        // shift isn't applied to the KC_INS keycode
+                        del_mods(MOD_MASK_SHIFT);
+                        register_code(KC_INS);
+                        // Update the boolean variable to reflect the status of KC_INS
+                        inskey_registered = true;
+                        // Reapplying modifier state so that the held shift key(s)
+                        // still work even after having tapped the key.
+                        set_mods(mod_state);
+                        return false;
+                    } else {
+                        register_code(KC_DEL);
+                        return false;
+                    }
+                } else { // on release of KC_DEL
+                    // In case KC_INS is still being sent even after the release of KC_DEL
+                    if (inskey_registered) {
+                        unregister_code(KC_INS);
+                        inskey_registered = false;
+                        return false;
+                    } else {
+                        unregister_code(KC_DEL);
+                        return false;
+                    }
+                }
+            } else {
+                if (record -> event.pressed) {
+                    register_code(KC_DEL);
+                    return false;
+                } else {
+                    unregister_code(KC_DEL);
+                    return false;
+                }
+            }
+        } else {
+            if (record -> event.pressed) {
+                register_code(KC_HOME);
+                return false;
+            } else {
+                unregister_code(KC_HOME);
+                return false;
+            }
+        }
+        break;
+
+        // Encoder button function
+    case ENCFUNC:
+        if (user_config.encoder_press_mute_or_media) {
+            if (record -> event.pressed) {
+                register_code(KC_MUTE);
+            } else unregister_code16(keycode);
+        }
+        else {
+            if (record -> event.pressed) {
+                register_code(KC_MPLY);
+            } else unregister_code16(keycode);
+        }
+        break;
+
+        // DotCom domain macros
     case DOTCOM:
         if (record -> event.pressed) {
-            SEND_STRING(".com");
+            send_string(".com");
         } else {
             // when keycode is released
         }
         break;
     case YAHOO:
         if (record -> event.pressed) {
-            SEND_STRING("yahoo.com");
+            send_string("yahoo.com");
         } else {
             // when keycode is released
         }
         break;
     case OUTLOOK:
         if (record -> event.pressed) {
-            SEND_STRING("outlook.com");
+            send_string("outlook.com");
         } else {
             // when keycode is released
         }
         break;
     case GMAIL:
         if (record -> event.pressed) {
-            SEND_STRING("gmail.com");
+            send_string("gmail.com");
         } else {
             // when keycode is released
         }
         break;
     case HOTMAIL:
         if (record -> event.pressed) {
-            SEND_STRING("hotmail.com");
+            send_string("hotmail.com");
         } else {
             // when keycode is released
         }
         break;
-		
-/*
-    case YAHOO:
-        if (record -> event.pressed) SEND_STRING("yahoo.com");
-        else unregister_code16(keycode);
-        break;
-    case OUTLOOK:
-        if (record -> event.pressed) SEND_STRING("outlook.com");
-        else unregister_code16(keycode);
-        break;
-    case GMAIL:
-        if (record -> event.pressed) SEND_STRING("gmail.com");
-        else unregister_code16(keycode);
-        break;
-    case HOTMAIL:
-        if (record -> event.pressed) {
-            SEND_STRING("hotmail.com");
-        } else unregister_code16(keycode);
-        break;
-    case DOTCOM:
-        if (record -> event.pressed) SEND_STRING(".com");
-        else unregister_code16(keycode);
-        break;
-*/
 
-    // Windows key lock		
-    case KC_WINLCK:
+        // Windows Key lockout
+    case WINLOCK:
         if (record -> event.pressed) {
             keymap_config.no_gui = !keymap_config.no_gui; //toggle status
         } else unregister_code16(keycode);
         break;
 
-    // Double Zero    
+        // Double Zero
     case KC_00:
         if (record -> event.pressed) {
             // when keycode KC_00 is pressed
-            SEND_STRING("00");
+            send_string("00");
         } else unregister_code16(keycode);
         break;
 
-    // Treat Control+Space as if regular Space
-    case KC_SPC: {
-        // Initialize a boolean variable that keeps track of the space key status: registered or not?
-        static bool spckey_registered;
-        if (record -> event.pressed) {
-            // Detect the activation of either ctrl keys
-            if (mod_state & MOD_MASK_CTRL) {
-                // First temporarily canceling both ctrls so that
-                // ctrl isn't applied to the KC_SPC keycode
-                del_mods(MOD_MASK_CTRL);
-                register_code(KC_SPC);
-                // Update the boolean variable to reflect the status of KC_SPC
-                spckey_registered = true;
-                // Reapplying modifier state so that the held ctrl key(s)
-                // still work even after having tapped the Space key.
-                set_mods(mod_state);
-                return false;
-            }
-        } else { // on release of KC_SPC
-            // In case KC_SPC is still being sent even after the release of KC_SPC
-            if (spckey_registered) {
-                unregister_code(KC_SPC);
-                spckey_registered = false;
-                return false;
-            }
-        }
-        }
-        break;
-
-    // Treat Shift+Space as if regular Space
-    case KC_SHIFTSPC: {
-        // Initialize a boolean variable that keeps track of the space key status: registered or not?
-        static bool spc2key_registered;
-        if (record -> event.pressed) {
-            // Detect the activation of either shift keys
-            if (mod_state & MOD_MASK_SHIFT) {
-                // First temporarily canceling both shifts so that
-                // shift isn't applied to the KC_SPC keycode
-                del_mods(MOD_MASK_SHIFT);
-                register_code(KC_SPC);
-                // Update the boolean variable to reflect the status of KC_SPC
-                spc2key_registered = true;
-                // Reapplying modifier state so that the held shift key(s)
-                // still work even after having tapped the Space key.
-                set_mods(mod_state);
-                return false;
-            }
-        } else { // on release of KC_SPC
-            // In case KC_SPC is still being sent even after the release of KC_SPC
-            if (spc2key_registered) {
-                unregister_code(KC_SPC);
-                spc2key_registered = false;
-                return false;
+        // Treat Control & Shift-Space as if regular Space
+    case KC_SPC:
+        if (user_config.disable_space_mods) {
+            // Initialize a boolean variable that keeps track of the space key status: registered or not?
+            static bool spckey_registered;
+            if (record -> event.pressed) {
+                // Detect the activation of either ctrl keys
+                if (mod_state & MOD_MASK_CTRL) {
+                    // First temporarily canceling both ctrls so that
+                    // ctrl isn't applied to the KC_SPC keycode
+                    del_mods(MOD_MASK_CTRL);
+                    register_code(KC_SPC);
+                    // Update the boolean variable to reflect the status of KC_SPC
+                    spckey_registered = true;
+                    // Reapplying modifier state so that the held ctrl key(s)
+                    // still work even after having tapped the Space key.
+                    set_mods(mod_state);
+                    return false;
+                }
+                else if (mod_state & MOD_MASK_SHIFT) {
+                    // First temporarily canceling both shifts so that
+                    // shift isn't applied to the KC_SPC keycode
+                    del_mods(MOD_MASK_SHIFT);
+                    register_code(KC_SPC);
+                    // Update the boolean variable to reflect the status of KC_SPC
+                    spckey_registered = true;
+                    // Reapplying modifier state so that the held shift key(s)
+                    // still work even after having tapped the Space key.
+                    set_mods(mod_state);
+                    return false;
+                }
+            } else { // on release of KC_SPC
+                // In case KC_SPC is still being sent even after the release of KC_SPC
+                if (spckey_registered) {
+                    unregister_code(KC_SPC);
+                    spckey_registered = false;
+                    return false;
+                }
             }
         }
-        }
         break;
 
-    // Add INS as SHIFT-modified BackSpace key
+    // INS as SHIFT-modified BackSpace key
     case KC_BSPC: {
-        // Initialize a boolean variable that keeps track of the delete key status: registered or not?
-        static bool inskey_registered;
-        if (record -> event.pressed) {
-            // Detect the activation of either shift keys
-            if (mod_state & MOD_MASK_SHIFT) {
-                // First temporarily canceling both shifts so that
-                // shift isn't applied to the KC_INS keycode
-                del_mods(MOD_MASK_SHIFT);
-                register_code(KC_INS);
-                // Update the boolean variable to reflect the status of KC_INS
-                inskey_registered = true;
-                // Reapplying modifier state so that the held shift key(s)
-                // still work even after having tapped the Delete/Insert key.
-                set_mods(mod_state);
-                return false;
-            }
-        } else { // on release of KC_BSPC
-            // In case KC_INS is still being sent even after the release of KC_BSPC
-            if (inskey_registered) {
-                unregister_code(KC_INS);
-                inskey_registered = false;
-                return false;
+        if (user_config.ins_on_shft_bkspc_or_del) {
+            // Initialize a boolean variable that keeps track of the ins key status: registered or not?
+            static bool inskey_registered;
+            if (record -> event.pressed) {
+                // Detect the activation of either shift keys
+                if (mod_state & MOD_MASK_SHIFT) {
+                    // First temporarily canceling both shifts so that
+                    // shift isn't applied to the KC_INS keycode
+                    del_mods(MOD_MASK_SHIFT);
+                    register_code(KC_INS);
+                    // Update the boolean variable to reflect the status of KC_INS
+                    inskey_registered = true;
+                    // Reapplying modifier state so that the held shift key(s)
+                    // still work even after having tapped the key.
+                    set_mods(mod_state);
+                    return false;
+                }
+            } else { // on release of KC_BSPC
+                // In case KC_INS is still being sent even after the release of KC_BSPC
+                if (inskey_registered) {
+                    unregister_code(KC_INS);
+                    inskey_registered = false;
+                    return false;
+                }
             }
         }
-        }
-        break;
-
-    /* Add INS as SHIFT-modified DEL key
-    case KC_DEL: {
-        // Initialize a boolean variable that keeps track of the delete key status: registered or not?
-        static bool inskey_registered;
-        if (record->event.pressed) {
-            // Detect the activation of either shift keys
-            if (mod_state & MOD_MASK_SHIFT) {
-                // First temporarily canceling both shifts so that
-                // shift isn't applied to the KC_INS keycode
-                del_mods(MOD_MASK_SHIFT);
-                register_code(KC_INS);
-                // Update the boolean variable to reflect the status of KC_INS
-                inskey_registered = true;
-                // Reapplying modifier state so that the held shift key(s)
-                // still work even after having tapped the Delete/Insert key.
-                set_mods(mod_state);
-                return false;
-            }
-        } else { // on release of KC_DEL
-            // In case KC_INS is still being sent even after the release of KC_DEL
-            if (inskey_registered) {
-                unregister_code(KC_INS);
-                inskey_registered = false;
-                return false;
-            }
-        }
-        }
-        break;
-    */
+    }
+    break;
 
     #ifdef IDLE_TIMEOUT_ENABLE
     case RGB_TOI:
@@ -352,27 +516,27 @@ bool process_record_user(uint16_t keycode, keyrecord_t * record) {
 
         #ifdef EMOTICON_ENABLE
     case EMO_SHRUG:
-        if (record -> event.pressed) SEND_STRING("`\\_(\"/)_/`");
+        if (record -> event.pressed) send_string("`\\_(\"/)_/`");
         else unregister_code16(keycode);
         break;
     case EMO_CONFUSE:
-        if (record -> event.pressed) SEND_STRING("(*_*)");
+        if (record -> event.pressed) send_string("(*_*)");
         else unregister_code16(keycode);
         break;
     case EMO_TEARS:
-        if (record -> event.pressed) SEND_STRING("(T_T)");
+        if (record -> event.pressed) send_string("(T_T)");
         else unregister_code16(keycode);
         break;
     case EMO_NERVOUS:
-        if (record -> event.pressed) SEND_STRING("(~_~;)");
+        if (record -> event.pressed) send_string("(~_~;)");
         else unregister_code16(keycode);
         break;
     case EMO_JOY:
-        if (record -> event.pressed) SEND_STRING("(^o^)");
+        if (record -> event.pressed) send_string("(^o^)");
         else unregister_code16(keycode);
         break;
     case EMO_SAD:
-        if (record -> event.pressed) SEND_STRING(":'-(");
+        if (record -> event.pressed) send_string(":'-(");
         else unregister_code16(keycode);
         break;
         #endif // EMOTICON_ENABLE
@@ -398,15 +562,32 @@ bool process_record_user(uint16_t keycode, keyrecord_t * record) {
     return true;
 };
 
-uint16_t get_tapping_term(uint16_t keycode, keyrecord_t * record) {
+// Define custom Caps Word continuity characters
+bool caps_word_press_user(uint16_t keycode) {
     switch (keycode) {
-    case KC_SFTUP:
-        return 300;
-    case KC_RAISESPC:
-    case KC_LOWERSPC:
-        return 450;
-    default:
-        return TAPPING_TERM;
+        // Keycodes that continue Caps Word, with shift applied.
+        case KC_A ... KC_Z:
+        case KC_TILD:
+        case KC_UNDS:
+        case KC_DQT:
+        case KC_COLN:
+        case KC_RSFT:
+        case LSFTCAPSWIN:
+            add_weak_mods(MOD_BIT(KC_LSFT));  // Apply shift to next key.
+            return true;
+
+        // Keycodes that continue Caps Word, without shifting.
+        case KC_1 ... KC_0:
+        case KC_GRV:
+        case KC_MINS:
+        case KC_QUOT:
+        case KC_SCLN:
+        case KC_BSPC:
+        case KC_DEL:
+            return true;
+
+        default:
+            return false;  // Deactivate Caps Word.
     }
 }
 
@@ -418,15 +599,32 @@ void activate_numlock(bool turn_on) {
 }
 
 // INITIAL STARTUP
-
-__attribute__((weak)) void keyboard_post_init_keymap(void) {}
+__attribute__((weak)) void keyboard_post_init_keymap(void) {
+}
 
 void keyboard_post_init_user(void) {
+    // Read the user config from EEPROM
+    user_config.raw = eeconfig_read_user();
     keyboard_post_init_keymap();
     #ifdef STARTUP_NUMLOCK_ON
     activate_numlock(true); // turn on Num lock by default so that the numpad layer always has predictable results
-    #endif // STARTUP_NUMLOC_ON
+    #endif // STARTUP_NUMLOCK_ON
     #ifdef IDLE_TIMEOUT_ENABLE
-    timeout_timer = timer_read(); // set inital time for ide timeout
+    timeout_timer = timer_read(); // set initial time for idle timeout
     #endif
-}
\ No newline at end of file
+}
+
+/* Set defaults for EEPROM user configuration variables */
+void eeconfig_init_user(void) {
+    user_config.raw                           = 0;
+    user_config.rgb_hilite_caps               = true;
+    user_config.rgb_hilite_numpad             = true;
+    user_config.double_tap_shift_for_capslock = true;
+    user_config.del_right_home_top            = true;
+    user_config.encoder_press_mute_or_media   = true;
+    user_config.esc_double_tap_to_baselyr     = true;
+    user_config.ins_on_shft_bkspc_or_del      = true;
+    user_config.disable_space_mods            = true;
+
+    eeconfig_update_user(user_config.raw);
+}
diff --git a/users/gourdo1/gourdo1.h b/users/gourdo1/gourdo1.h
index c6861ca0ca..aa91a192d2 100644
--- a/users/gourdo1/gourdo1.h
+++ b/users/gourdo1/gourdo1.h
@@ -1,5 +1,5 @@
 /* Copyright 2021 Jonavin Eng @Jonavin
-   Copyright 2022 gourdo1 <jcblake@outlook.com>
+   Copyright 2022 gourdo1 <gourdo1@outlook.com>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -20,36 +20,49 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // DEFINE MACROS
 #define ARRAYSIZE(arr) sizeof(arr) / sizeof(arr[0])
 
-// LAYERS
+// LAYERS -- Note: to avoid compile problems, make sure total layers matches DYNAMIC_KEYMAP_LAYER_COUNT defined in config.h (where _COLEMAK layer is defined)
 enum custom_user_layers {
     _BASE,
     _FN1,
     _NUMPADMOUSE,
     _MOUSEKEY,
+    #ifdef GAME_ENABLE
+    _GAME
+    #endif //GAME_ENABLE
 };
 
 #define KC_CAD LALT(LCTL(KC_DEL))
+#define LOCKPC LGUI(KC_L)
 #define KC_AF4 LALT(KC_F4)
 #define KC_TASK LCTL(LSFT(KC_ESC))
 #define CT_PGUP RCTL(KC_PGUP)
 #define CT_PGDN RCTL(KC_PGDN)
 #define CT_HOME RCTL(KC_HOME)
 #define CT_END RCTL(KC_END)
-#define KC_SFTUP RSFT_T(KC_UP) // Shift when held, Up arrow when tapped
-#define KC_RAISESPC LT(_MOUSEKEY, KC_SPC) // _MOUSEKEY layer mod when held, space when tapped
-#define KC_LOWERSPC LT(_NUMPADMOUSE, KC_SPC) // _NUMPAD-MOUSE layer mod when held, space when tapped
-#define KC_SHIFTSPC LSFT(KC_SPC)
-#define SWAP_L SGUI(KC_LEFT) // Swap application to left display
-#define SWAP_R SGUI(KC_RGHT) // Swap application to right display
+#define SWAP_L SGUI(KC_LEFT)                 // Swap application to left display
+#define SWAP_R SGUI(KC_RGHT)                 // Swap application to right display
 
 // KEYCODES
 enum custom_user_keycodes {
     KC_00 = SAFE_RANGE,
-        ENCFUNC,
-        KC_WINLCK,     // Toggles Win key on and off
+        ENCFUNC,       // Encoder function
+        CAPSNUM,       // Capslock key function
+        LEFTOFENC,     // Key to the left of the encoder (i.e. F13)
+        BELOWENC,      // Key below encoder
+        PRNCONF,       // Print verbose statuses of all user_config toggles
+        WINLOCK,       // Toggles Windows key on and off
         RGB_TOI,       // Timeout idle time up
         RGB_TOD,       // Timeout idle time down
-        RGB_NITE,      // Turns off all rgb but allow rgb indicators to work
+        RGB_NITE,      // Disables RGB backlighting effects but allows RGB indicators to still work
+
+        TG_CAPS,       // Toggles RGB highlighting of alphas during capslock
+        TG_PAD,        // Toggles RGB highlighting of keys on numpad+mousekeys layer
+        TG_TDCAP,      // Toggles double tap shift (tapdance) for CapsLock
+        TG_DEL,        // Swaps DEL and HOME key locations
+        TG_ENC,        // Toggle Encoder functionality
+        TG_ESC,        // Toggle ESC tapdance for _BASE layer
+        TG_INS,        // Toggle location of INS
+        TG_SPCMOD,     // Toggle disabling of modded-SPACE functions
 
         YAHOO,         // yahoo.com
         OUTLOOK,       // outlook.com
@@ -66,24 +79,33 @@ enum custom_user_keycodes {
 
         KC_TSTOG,      // Tab Scroll Toggle
 
-        NEW_SAFE_RANGE // new safe range for keymap level custom keycodes
+        NEW_SAFE_RANGE // New safe range for keymap level custom keycodes
 };
 
-#ifdef TD_LSFT_CAPSLOCK_ENABLE
+
 // Tap Dance Definitions
 enum custom_tapdance {
-    TD_LSFT_CAPSLOCK,
     TD_LSFT_CAPS_WIN,
-    TD_ESC_BASELYR
 };
-#define KC_LSFTCAPS TD(TD_LSFT_CAPSLOCK)
-#define KC_LSFTCAPSWIN TD(TD_LSFT_CAPS_WIN)
-#define KC_ESCLYR TD(TD_ESC_BASELYR)
-#else // regular Shift
-#define KC_LSFTCAPS KC_LSFT
-// regular Escape
-#define KC_ESCLYR KC_ESC
-#endif // TD_LSFT_CAPSLOCK_ENABLE
+
+// Set up boolean variables to track user customizable configuration options
+typedef union {
+  uint32_t raw;
+  struct {
+    bool     rgb_hilite_caps :1;
+    bool     rgb_hilite_numpad :1;
+    bool     esc_double_tap_to_baselyr :1;
+    bool     del_right_home_top :1;
+    bool     double_tap_shift_for_capslock :1;
+    bool     encoder_press_mute_or_media :1;
+    bool     ins_on_shft_bkspc_or_del :1;
+    bool     disable_space_mods :1;
+  };
+} user_config_t;
+
+user_config_t user_config;
+
+#define LSFTCAPSWIN TD(TD_LSFT_CAPS_WIN)
 
 // ENCODER ACTIONS
 #ifdef ENCODER_ENABLE
diff --git a/users/gourdo1/gourdo1_encoder.c b/users/gourdo1/gourdo1_encoder.c
index 72f8c3c354..5a19b63c6e 100644
--- a/users/gourdo1/gourdo1_encoder.c
+++ b/users/gourdo1/gourdo1_encoder.c
@@ -1,5 +1,5 @@
 /* Copyright 2021 Jonavin Eng @Jonavin
-   Copyright 2022 gourdo1 <jcblake@outlook.com>
+   Copyright 2022 gourdo1 <gourdo1@outlook.com>
    
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -15,8 +15,8 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #include QMK_KEYBOARD_H
+
 #include "gourdo1.h"
 
 #ifdef ENCODER_ENABLE