Userspace: muppetjones (#1) (#13461)

* Userspace: muppetjones (#1)

Add and update lily58 to work with userspace
Add and update kyria keymap to work with userspace
Add and update planck keymap with userspace
Add etchamouse code and docs to userpace
Add userspace
Update mouse encoder for smoother movement.
Encoder + mouse
Added casemodes by andrewjrae

* Rollback lily58 state reader and add missing GPL

* Apply suggestions from code review

Co-authored-by: Drashna Jaelre <drashna@live.com>
Co-authored-by: Joel Challis <git@zvecr.com>

* fix lily58 keymap

* Updates to user and lily for muppetjones.

Updated parameters for etchamouse for smoother mouse movement. Updated lily keymap and userspace to actually work together.

* Update keyboards/lily58/keymaps/muppetjones/config.h

Co-authored-by: Drashna Jaelre <drashna@live.com>

* Updated keymaps and userspace

* Little more cleanup.

* Update keyboards/lily58/keymaps/muppetjones/rules.mk

Co-authored-by: Ryan <fauxpark@gmail.com>

* Rollback accidental libchibios update

* Apply suggestions from code review

Co-authored-by: Drashna Jaelre <drashna@live.com>

* Update kyria keymap

* Move kyria keymap to splitkb/kyria

* Update planck keymap

* Remove all changes to keyboards/lily58/lib/layer_state_reader.c

* Update lily58 keymap

* Recommended change

* Update keymap readme

* Update kyria keymap and userspace

* Apply suggestions from code review

Co-authored-by: Drashna Jaelre <drashna@live.com>

* Renamed users/muppetjones/README.md to lc

* Update keyboards/lily58/keymaps/muppetjones/config.h

Co-authored-by: Drashna Jaelre <drashna@live.com>

Co-authored-by: Drashna Jaelre <drashna@live.com>
Co-authored-by: Joel Challis <git@zvecr.com>
Co-authored-by: Ryan <fauxpark@gmail.com>

10 files changed, 778 insertions, 0 deletions

diff --git a/users/muppetjones/features/casemodes.c b/users/muppetjones/features/casemodes.c
new file mode 100644
index 0000000000..da7c5e8fa9
--- /dev/null
+++ b/users/muppetjones/features/casemodes.c
@@ -0,0 +1,247 @@
+/* Copyright 2021 Andrew Rae ajrae.nv@gmail.com @andrewjrae
+ *
+ * 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
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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 "casemodes.h"
+
+/* The caps word concept started with me @iaap on splitkb.com discord.
+ * However it has been implemented and extended by many splitkb.com users:
+ * - @theol0403 made many improvements to initial implementation
+ * - @precondition used caps lock rather than shifting
+ * - @dnaq his own implementation which also used caps lock
+ * - @sevanteri added underscores on spaces
+ * - @metheon extended on @sevanteri's work and added specific modes for
+ *   snake_case and SCREAMING_SNAKE_CASE
+ * - @baffalop came up with the idea for xcase, which he implements in his own
+ *   repo, however this is implemented by @iaap with support also for one-shot-shift.
+ * - @sevanteri
+ *     - fixed xcase waiting mode to allow more modified keys and keys from other layers.
+ *     - Added @baffalop's separator defaulting on first keypress, with a
+ *       configurable default separator and overrideable function to determine
+ *       if the default should be used.
+ */
+
+#ifndef DEFAULT_XCASE_SEPARATOR
+#    define DEFAULT_XCASE_SEPARATOR KC_UNDS
+#endif
+
+#define IS_OSM(keycode) (keycode >= QK_ONE_SHOT_MOD && keycode <= QK_ONE_SHOT_MOD_MAX)
+
+// 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();
+    }
+}
+
+// Get 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; }
+
+// Enable xcase with the specified delimiter
+void enable_xcase_with(uint16_t delimiter) {
+    xcase_state            = XCASE_ON;
+    xcase_delimiter        = delimiter;
+    distance_to_last_delim = -1;
+}
+
+// Disable xcase
+void disable_xcase(void) { xcase_state = XCASE_OFF; }
+
+// Place the current xcase delimiter
+static void place_delimiter(void) {
+    if (IS_OSM(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 {
+        tap_code16(xcase_delimiter);
+    }
+}
+
+// Removes a delimiter, used for double tap space exit
+static void remove_delimiter(void) {
+    if (IS_OSM(xcase_delimiter)) {
+        clear_oneshot_mods();
+    } else {
+        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_BSPC:
+            // If mod chording disable the mods
+            if (record->event.pressed && (get_mods() != 0)) {
+                return true;
+            }
+            break;
+        case KC_UNDS:
+            // Allow to be pressed with or without a modifier (prob w/ shift)
+            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) {
+    // for example:
+    /* switch (keycode) { */
+    /*     case KC_A ... KC_Z: */
+    /*     case KC_1 ... KC_0: */
+    /*         return true; */
+    /* } */
+    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)) {
+            // Earlier return if this has not been considered tapped yet
+            if (record->tap.count == 0) return true;
+            keycode = keycode & 0xFF;
+        }
+
+        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) {
+            // grab the next input to be the delimiter
+            if (use_default_xcase_separator(keycode, record)) {
+                enable_xcase_with(DEFAULT_XCASE_SEPARATOR);
+            } else if (record->event.pressed) {
+                // factor in mods
+                if (get_mods() & MOD_MASK_SHIFT) {
+                    keycode = LSFT(keycode);
+                } else if (get_mods() & MOD_BIT(KC_RALT)) {
+                    keycode = RALT(keycode);
+                }
+                enable_xcase_with(keycode);
+                return false;
+            } else {
+                if (IS_OSM(keycode)) {
+                    // this catches the OSM release if no other key was pressed
+                    set_oneshot_mods(0);
+                    enable_xcase_with(keycode);
+                    return false;
+                }
+                // let other special keys go through
+                return true;
+            }
+        }
+
+        if (record->event.pressed) {
+            // handle xcase mode
+            if (xcase_state == XCASE_ON) {
+                // place the delimiter if space is tapped
+                if (keycode == KC_SPACE) {
+                    if (distance_to_last_delim != 0) {
+                        place_delimiter();
+                        distance_to_last_delim = 0;
+                        return false;
+                    }
+                    // remove the delimiter and disable modes
+                    else {
+                        remove_delimiter();
+                        disable_xcase();
+                        disable_caps_word();
+                        return true;
+                    }
+                }
+                // decrement distance to delimiter on back space
+                else if (keycode == KC_BSPC) {
+                    --distance_to_last_delim;
+                }
+                // don't increment distance to last delim if negative
+                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))) {
+                        place_delimiter();
+                    }
+                    ++distance_to_last_delim;
+                }
+
+            }  // end XCASE_ON
+
+            // check if the case modes have been terminated
+            if (terminate_case_modes(keycode, record)) {
+                disable_caps_word();
+                disable_xcase();
+            }
+#ifdef CAPSWORD_USE_SHIFT
+            else if (keycode >= KC_A && keycode <= KC_Z) {
+                tap_code16(LSFT(keycode));
+                return false;
+            }
+#endif
+
+        }  // end if event.pressed
+
+        return true;
+    }
+    return true;
+}
diff --git a/users/muppetjones/features/casemodes.h b/users/muppetjones/features/casemodes.h
new file mode 100644
index 0000000000..4a8c00b3d2
--- /dev/null
+++ b/users/muppetjones/features/casemodes.h
@@ -0,0 +1,47 @@
+/* Copyright 2021 Andrew Rae ajrae.nv@gmail.com @andrewjrae
+ *
+ * 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
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include QMK_KEYBOARD_H
+
+// Check whether caps word is on
+bool caps_word_enabled(void);
+// Enable caps word
+void enable_caps_word(void);
+// Disable caps word
+void disable_caps_word(void);
+// Toggle caps word
+void toggle_caps_word(void);
+
+// 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
+};
+
+// Get xcase state
+enum xcase_state get_xcase_state(void);
+// Enable xcase and pickup the next keystroke as the delimiter
+void enable_xcase(void);
+// Enable xcase with the specified delimiter
+void enable_xcase_with(uint16_t delimiter);
+// Disable xcase
+void disable_xcase(void);
+
+// Function to be put in process user
+bool process_case_modes(uint16_t keycode, const keyrecord_t *record);
diff --git a/users/muppetjones/features/combos.c b/users/muppetjones/features/combos.c
new file mode 100644
index 0000000000..a6d14bb25c
--- /dev/null
+++ b/users/muppetjones/features/combos.c
@@ -0,0 +1,36 @@
+/* Copyright 2020 Stephen J. Bush
+ *
+ * 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
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef COMBO_ENABLE
+#    include QMK_KEYBOARD_H
+
+enum combos {
+    H_COMM_TAB,
+    L_U_SCLN,
+    J_M_CAPS,
+};
+
+const uint16_t PROGMEM h_comm_tab[] = {KC_H, KC_COMM, COMBO_END};
+const uint16_t PROGMEM l_u_scln[]   = {KC_L, KC_U, COMBO_END};
+const uint16_t PROGMEM j_m_caps[]   = {KC_J, KC_M, COMBO_END};
+
+// COMBO_COUNT defined in config.h
+combo_t key_combos[COMBO_COUNT] = {
+    [H_COMM_TAB] = COMBO(h_comm_tab, KC_TAB),
+    [L_U_SCLN]   = COMBO(l_u_scln, KC_SCLN),
+    [J_M_CAPS]   = COMBO(j_m_caps, KC_CAPS),
+};
+#endif
diff --git a/users/muppetjones/features/combos.h b/users/muppetjones/features/combos.h
new file mode 100644
index 0000000000..af092904e4
--- /dev/null
+++ b/users/muppetjones/features/combos.h
@@ -0,0 +1,17 @@
+/* Copyright 2020 Stephen J. Bush
+ *
+ * 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
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
diff --git a/users/muppetjones/features/dancelayers.c b/users/muppetjones/features/dancelayers.c
new file mode 100644
index 0000000000..e7e5f2a6f2
--- /dev/null
+++ b/users/muppetjones/features/dancelayers.c
@@ -0,0 +1,98 @@
+/* Copyright 2020 Stephen J. Bush
+ *
+ * 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
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef TAP_DANCE_ENABLE
+
+#    include QMK_KEYBOARD_H
+#    include "muppetjones.h"
+#    include "dancelayers.h"
+
+// Initialize tap structure associated with example tap dance key
+static td_tap_t lyr_tap_state = {.is_press_action = true, .state = TD_NONE};
+
+/* @brief Determine the current tap dance state
+ * @param A tap dance state struct.
+ * @return A struct.
+ */
+td_state_t cur_dance(qk_tap_dance_state_t *state) {
+    switch (state->count) {
+        case 1:
+            if (!state->pressed)
+                return TD_1X_TAP;
+            else
+                return TD_1X_HOLD;
+        case 2:
+            return TD_2X_TAP;
+            break;
+        case 3:
+            return TD_3X_TAP;
+            break;
+        case 4:
+            return TD_4X_TAP;
+            break;
+        default:
+            return TD_UNKNOWN;
+    }
+}
+
+// Functions that control what our tap dance key does
+__attribute__((weak)) void td_layer_finished(qk_tap_dance_state_t *state, void *user_data) {
+    lyr_tap_state.state = cur_dance(state);
+    switch (lyr_tap_state.state) {
+        case TD_1X_TAP:
+            if (layer_state_is(_MOUSE))
+                layer_off(_MOUSE);
+            else
+                layer_on(_MOUSE);
+            break;
+        case TD_1X_HOLD:
+            layer_on(_ADJUST);
+            break;
+        case TD_2X_TAP:
+            // Toggle lower layer
+            if (layer_state_is(_LOWER))
+                layer_off(_LOWER);
+            else
+                layer_on(_LOWER);
+            break;
+        case TD_3X_TAP:
+            // Toggle lower layer
+            if (layer_state_is(_RAISE))
+                layer_off(_RAISE);
+            else
+                layer_on(_RAISE);
+            break;
+        case TD_4X_TAP:
+            // Toggle lower layer
+            if (layer_state_is(_ADJUST))
+                layer_off(_ADJUST);
+            else
+                layer_on(_ADJUST);
+            break;
+        default:
+            break;
+    }
+}
+
+__attribute__((weak)) void td_layer_reset(qk_tap_dance_state_t *state, void *user_data) {
+    // If the key was held down and now is released then switch off the layer
+    if (lyr_tap_state.state == TD_1X_HOLD) {
+        layer_off(_ADJUST);
+    }
+    lyr_tap_state.state = TD_NONE;
+}
+
+#endif
diff --git a/users/muppetjones/features/dancelayers.h b/users/muppetjones/features/dancelayers.h
new file mode 100644
index 0000000000..23defcca92
--- /dev/null
+++ b/users/muppetjones/features/dancelayers.h
@@ -0,0 +1,82 @@
+/* Copyright 2020 Stephen J. Bush
+ *
+ * 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
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#ifdef TAP_DANCE_ENABLE
+#    include QMK_KEYBOARD_H
+
+/*
+ * TAP DANCE
+ * https://docs.qmk.fm/#/feature_tap_dance
+ */
+
+// Define a type for as many tap dance states as you need
+typedef enum {
+    TD_NONE = 0,
+    TD_UNKNOWN,
+    TD_1X_TAP,
+    TD_1X_HOLD,
+    TD_2X_TAP,
+    TD_3X_TAP,
+    TD_4X_TAP,
+} td_state_t;
+
+// Our custom tap dance key; add any other tap dance keys to this enum
+enum {
+    TD_LAYERS = 0,  // NOTE: Start at 0 as this is also an array index
+};
+#    define TD_LAYR TD(TD_LAYERS)
+
+typedef struct {
+    bool       is_press_action;
+    td_state_t state;
+} td_tap_t;
+
+// Declare the functions to be used with your tap dance key(s)
+
+/* @brief Determine the current tap dance state
+ * @param A tap dance state struct.
+ * @return A struct.
+ */
+td_state_t cur_dance(qk_tap_dance_state_t *state);
+
+// Functions associated with individual tap dances
+
+/* @brief Associate tap actions with layers.
+ *
+ * NOTE: Weak attribute. Can (and should) be defined in keymap.c
+ *
+ * @param state Pointer to a tap dance state object.
+ * @param user_data Pointer to user data.
+ * @return None.
+ */
+void td_layer_finished(qk_tap_dance_state_t *state, void *user_data);
+
+/* @brief Reset tap dance actions.
+ *
+ * NOTE: Weak attribute. Can (and should) be defined in keymap.c
+ *
+ * @param state Pointer to a tap dance state object.
+ * @param user_data Pointer to user data.
+ * @return None.
+ */
+void td_layer_reset(qk_tap_dance_state_t *state, void *user_data);
+
+/* Define tap dance actions.
+ */
+__attribute__((weak))
+qk_tap_dance_action_t tap_dance_actions[1] = {[TD_LAYERS] = ACTION_TAP_DANCE_FN_ADVANCED_TIME(NULL, td_layer_finished, td_layer_reset, 275)};
+#endif
diff --git a/users/muppetjones/features/etchamouse.c b/users/muppetjones/features/etchamouse.c
new file mode 100644
index 0000000000..e1d4c38e81
--- /dev/null
+++ b/users/muppetjones/features/etchamouse.c
@@ -0,0 +1,101 @@
+/* Copyright 2020 Stephen J. Bush
+ *
+ * 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
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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 "etchamouse.h"
+#include "pointing_device.h"
+
+#if defined(POINTING_DEVICE_ENABLE) && defined(ENCODER_ENABLE)
+
+/** Track movement separately in both directions. This will allow us to
+ *  smooth out the movement along diagonals
+ */
+typedef struct {
+    bool     clockwise : 1;
+    uint8_t  count : 7;
+    uint16_t timer : 16;
+    uint16_t elapsed : 16;
+} key_tracker_t;
+
+static key_tracker_t tracker_x = {false, 0, 0, 0};
+static key_tracker_t tracker_y = {false, 0, 0, 0};
+
+/**
+ * @brief Calculate the mouse move units for the given tracker.
+ *
+ * By using a key tracker rederence, we can minimize the amount of space
+ * required on the stack. As we will have the tracker object, we will also
+ * take the clockwise direction into account, which completely internalizes
+ * the movement unit logic within this single function.
+ *
+ * @param tracker: Pointer to a key tracker object.
+ * @return A integer from -127 to 127
+ */
+static int8_t move_unit(key_tracker_t *tracker) {
+    if (0 == tracker->count) return 0;
+
+    const uint16_t modifier = TAPPING_TERM_MOUSE_ENCODER < tracker->elapsed ? 1 : (TAPPING_TERM_MOUSE_ENCODER - tracker->elapsed) >> 1;
+    uint16_t       speed    = MOUSEKEY_INITIAL_SPEED + MOUSEKEY_MOVE_DELTA * modifier * (tracker->count >> 1);
+
+    /* convert speed to USB mouse speed 1 to 127 */
+    speed = (uint8_t)(speed / (1000.0f / MOUSEKEY_INTERVAL));
+    speed = speed < 1 ? 1 : speed;
+
+    return (tracker->clockwise ? 1 : -1) * (speed > MOUSEKEY_MOVE_MAX ? MOUSEKEY_MOVE_MAX : speed);
+}
+
+/**
+ * @brief Update key press tracker
+ *
+ * Update the time elapsed since the last keypress.
+ * If the key has not been pressed since the tapping term, then reset the count to zero.
+ * If the key was pressed, update the timer and increment the count.
+ * Number of keypresses will degrade based on tapping term and zero out based
+ * on the persistenc term.
+ *
+ * @param tracker: The object to update
+ * @param pressed: A boolean indicating whether or not the key was pressed
+ * @return None.
+ */
+static void update_tracker(key_tracker_t *tracker, bool pressed, bool clockwise) {
+    tracker->elapsed = timer_elapsed(tracker->timer);
+    if (pressed) {
+        tracker->timer = timer_read();
+        tracker->count += 1;
+        tracker->clockwise = clockwise;
+    } else if (TAPPING_TERM_PERSISTENCE < tracker->elapsed) {
+        tracker->count = 0;
+    } else if (TAPPING_TERM_MOUSE_ENCODER < tracker->elapsed) {
+        tracker->count >>= 1;
+    }
+}
+
+bool encoder_update_mouse(uint8_t index, bool clockwise) {
+    report_mouse_t curr_report = pointing_device_get_report();
+
+    update_tracker(&tracker_x, 0 == index, clockwise);
+    update_tracker(&tracker_y, 1 == index, clockwise);
+
+    curr_report.x += move_unit(&tracker_x);
+    curr_report.y += move_unit(&tracker_y);
+
+    pointing_device_set_report(curr_report);
+    pointing_device_send();
+
+    return true;
+}
+
+#endif
diff --git a/users/muppetjones/features/etchamouse.h b/users/muppetjones/features/etchamouse.h
new file mode 100644
index 0000000000..86b0d03c6e
--- /dev/null
+++ b/users/muppetjones/features/etchamouse.h
@@ -0,0 +1,59 @@
+/* Copyright 2020 Stephen J. Bush
+ *
+ * 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
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#if defined(POINTING_DEVICE_ENABLE) && defined(ENCODER_ENABLE)
+
+/* max value on report descriptor */
+#    ifndef MOUSEKEY_MOVE_MAX
+#        define MOUSEKEY_MOVE_MAX 127
+#    elif MOUSEKEY_MOVE_MAX > 127
+#        error MOUSEKEY_MOVE_MAX needs to be smaller than 127
+#    endif
+#    ifndef MOUSEKEY_MOVE_DELTA
+#        define MOUSEKEY_MOVE_DELTA 25
+#    endif
+#    ifndef MOUSEKEY_INITIAL_SPEED
+#        define MOUSEKEY_INITIAL_SPEED 100
+#    endif
+#    ifndef MOUSEKEY_INTERVAL
+#        define MOUSEKEY_INTERVAL 75
+#    endif
+
+/** Amount of time (ms) before zeroing out the count.
+ *  A higher value will result in smoother curves but may lower accuracy
+ */
+#    ifndef TAPPING_TERM_PERSISTENCE
+#        define TAPPING_TERM_PERSISTENCE 150
+#    endif
+
+/** Amount of time (ms) to register consecutive key presses
+ *  A higher value will smooth out mouse movement and increase speed for
+ *  consecutive presses.
+ */
+#    ifndef TAPPING_TERM_MOUSE_ENCODER
+#        define TAPPING_TERM_MOUSE_ENCODER 50
+#    endif
+
+/** @brief Update mouse position based on encoder movement.
+ *  @param index The encoder index. 0 controls x-axis; 1 controls y-axis.
+ *  @param clockwise Indicates direction encoder was turned.
+ *  @returns None.
+ */
+bool encoder_update_mouse(uint8_t index, bool clockwise);
+
+#endif
diff --git a/users/muppetjones/features/rgblayers.c b/users/muppetjones/features/rgblayers.c
new file mode 100644
index 0000000000..46858ae671
--- /dev/null
+++ b/users/muppetjones/features/rgblayers.c
@@ -0,0 +1,69 @@
+/* Copyright 2020 Stephen J. Bush
+ *
+ * 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
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef RGBLIGHT_ENABLE
+#    include QMK_KEYBOARD_H
+#    include "rgblayers.h"
+
+static rgblight_config_t home_rgb;
+
+__attribute__((weak)) void set_layer_hsv(layer_state_t state, HSV* offset) {}
+
+/* Placeholder function
+ * If defined in a keymap.c, this will be ignored.
+ */
+__attribute__((weak)) void post_process_record_keymap(uint16_t keycode, keyrecord_t* record) { return; }
+
+void post_process_record_user(uint16_t keycode, keyrecord_t* record) {
+    // Regular user keycode case statement
+    switch (keycode) {
+#    ifdef RGBLIGHT_ENABLE
+        case RGB_HUD:
+        case RGB_HUI:
+        case RGB_SAD:
+        case RGB_SAI:
+        case RGB_VAD:
+        case RGB_VAI:
+            set_rgb_home();
+            break;
+#    endif
+        default:
+            break;
+    }
+}
+
+void set_rgb_home(void) {
+    home_rgb.raw = eeconfig_read_rgblight();
+    // these get the current -- not eeprom
+    // home_rgb.hue = rgblight_get_hue();
+    // home_rgb.sat = rgblight_get_sat();
+    // home_rgb.val = rgblight_get_val();
+}
+
+void set_rgb_by_layer(layer_state_t state) {
+    if (!rgblight_is_enabled()) {
+        return;  // lighting not enabled
+    }
+
+    HSV layer_color = {home_rgb.hue, home_rgb.sat, home_rgb.val};
+    set_layer_hsv(state, &layer_color);
+    rgblight_sethsv_noeeprom(  //
+        layer_color.h,         // all 3 MUST be btwn 0 and 255
+        layer_color.s,         //
+        layer_color.v          //
+    );
+}
+#endif
diff --git a/users/muppetjones/features/rgblayers.h b/users/muppetjones/features/rgblayers.h
new file mode 100644
index 0000000000..35be7d7fe4
--- /dev/null
+++ b/users/muppetjones/features/rgblayers.h
@@ -0,0 +1,22 @@
+/* Copyright 2020 Stephen J. Bush
+ *
+ * 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
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#ifdef RGBLIGHT_ENABLE
+
+void set_rgb_by_layer(layer_state_t);
+void set_rgb_home(void);
+#endif