diff options
Diffstat (limited to 'quantum/pointing_device/pointing_device_auto_mouse.c')
| -rw-r--r-- | quantum/pointing_device/pointing_device_auto_mouse.c | 384 | 
1 files changed, 384 insertions, 0 deletions
| diff --git a/quantum/pointing_device/pointing_device_auto_mouse.c b/quantum/pointing_device/pointing_device_auto_mouse.c new file mode 100644 index 0000000000..edffd44787 --- /dev/null +++ b/quantum/pointing_device/pointing_device_auto_mouse.c @@ -0,0 +1,384 @@ +/* Copyright 2021 Christopher Courtney, aka Drashna Jael're  (@drashna) <[email protected]> + * Copyright 2022 Alabastard + * + * 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 POINTING_DEVICE_AUTO_MOUSE_ENABLE + +#    include "pointing_device_auto_mouse.h" + +/* local data structure for tracking auto mouse */ +static auto_mouse_context_t auto_mouse_context = {.config.layer = (uint8_t)AUTO_MOUSE_DEFAULT_LAYER}; + +/* local functions */ +static bool is_mouse_record(uint16_t keycode, keyrecord_t* record); +static void auto_mouse_reset(void); + +/* check for target layer deactivation overrides */ +static inline bool layer_hold_check(void) { +    return get_auto_mouse_toggle() || +#    ifndef NO_ACTION_ONESHOT +           get_oneshot_layer() == (AUTO_MOUSE_TARGET_LAYER) || +#    endif +           false; +} + +/* check all layer activation criteria */ +static inline bool is_auto_mouse_active(void) { +    return auto_mouse_context.status.is_activated || auto_mouse_context.status.mouse_key_tracker || layer_hold_check(); +} + +/** + * @brief Get auto mouse enable state + * + * Return is_enabled value + * + * @return bool true: auto mouse enabled false: auto mouse disabled + */ +bool get_auto_mouse_enable(void) { +    return auto_mouse_context.config.is_enabled; +} + +/** + * @brief get current target layer index + * + * NOTE: (AUTO_MOUSE_TARGET_LAYER) is an alias for this function + * + * @return uint8_t target layer index + */ +uint8_t get_auto_mouse_layer(void) { +    return auto_mouse_context.config.layer; +} + +/** + * @brief get layer_toggled value + * + * @return bool of current layer_toggled state + */ +bool get_auto_mouse_toggle(void) { +    return auto_mouse_context.status.is_toggled; +} + +/** + * @brief Reset auto mouse context + * + * Clear timers and status + * + * NOTE: this will set is_toggled to false so careful when using it + */ +static void auto_mouse_reset(void) { +    memset(&auto_mouse_context.status, 0, sizeof(auto_mouse_context.status)); +    memset(&auto_mouse_context.timer, 0, sizeof(auto_mouse_context.timer)); +} + +/** + * @brief Set auto mouse enable state + * + * Set local auto mouse enabled state + * + * @param[in] state bool + */ +void set_auto_mouse_enable(bool enable) { +    // skip if unchanged +    if (auto_mouse_context.config.is_enabled == enable) return; +    auto_mouse_context.config.is_enabled = enable; +    auto_mouse_reset(); +} + +/** + * @brief Change target layer for auto mouse + * + * Sets input as the new target layer if different from current and resets auto mouse + * + * NOTE: remove_auto_mouse_layer(state, false) or auto_mouse_layer_off should be called + *       before this function to avoid issues with layers getting stuck + * + * @param[in] layer uint8_t + */ +void set_auto_mouse_layer(uint8_t layer) { +    // skip if unchanged +    if (auto_mouse_context.config.layer == layer) return; +    auto_mouse_context.config.layer = layer; +    auto_mouse_reset(); +} + +/** + * @brief toggle mouse layer setting + * + * Change state of local layer_toggled bool meant to track when the mouse layer is toggled on by other means + * + * NOTE: While is_toggled is true it will prevent deactiving target layer (but not activation) + */ +void auto_mouse_toggle(void) { +    auto_mouse_context.status.is_toggled ^= 1; +    auto_mouse_context.timer.delay = 0; +} + +/** + * @brief Remove current auto mouse target layer from layer state + * + * Will remove auto mouse target layer from given layer state if appropriate. + * + * NOTE: Removal can be forced, ignoring appropriate critera + * + * @params state[in] layer_state_t original layer state + * @params force[in] bool force removal + * + * @return layer_state_t modified layer state + */ +layer_state_t remove_auto_mouse_layer(layer_state_t state, bool force) { +    if (force || ((AUTO_MOUSE_ENABLED) && !layer_hold_check())) { +        state &= ~((layer_state_t)1 << (AUTO_MOUSE_TARGET_LAYER)); +    } +    return state; +} + +/** + * @brief Disable target layer + * + * Will disable target layer if appropriate. + * NOTE: NOT TO BE USED in layer_state_set stack!!! + */ +void auto_mouse_layer_off(void) { +    if (layer_state_is((AUTO_MOUSE_TARGET_LAYER)) && (AUTO_MOUSE_ENABLED) && !layer_hold_check()) { +        layer_off((AUTO_MOUSE_TARGET_LAYER)); +    } +} + +/** + * @brief Weak function to handel testing if pointing_device is active + * + * Will trigger target layer activation(if delay timer has expired) and prevent deactivation when true. + * May be replaced by bool in report_mouse_t in future + * + * NOTE: defined weakly to allow for changing and adding conditions for specific hardware/customization + * + * @param[in] mouse_report report_mouse_t + * @return bool of pointing_device activation + */ +__attribute__((weak)) bool auto_mouse_activation(report_mouse_t mouse_report) { +    return mouse_report.x != 0 || mouse_report.y != 0 || mouse_report.h != 0 || mouse_report.v != 0 || mouse_report.buttons; +} + +/** + * @brief Update the auto mouse based on mouse_report + * + * Handel activation/deactivation of target layer based on auto_mouse_activation and state timers and local key/layer tracking data + * + * @param[in] mouse_report report_mouse_t + */ +void pointing_device_task_auto_mouse(report_mouse_t mouse_report) { +    // skip if disabled, delay timer running, or debounce +    if (!(AUTO_MOUSE_ENABLED) || timer_elapsed(auto_mouse_context.timer.active) <= AUTO_MOUSE_DEBOUNCE || timer_elapsed(auto_mouse_context.timer.delay) <= AUTO_MOUSE_DELAY) { +        return; +    } +    // update activation and reset debounce +    auto_mouse_context.status.is_activated = auto_mouse_activation(mouse_report); +    if (is_auto_mouse_active()) { +        auto_mouse_context.timer.active = timer_read(); +        auto_mouse_context.timer.delay  = 0; +        if (!layer_state_is((AUTO_MOUSE_TARGET_LAYER))) { +            layer_on((AUTO_MOUSE_TARGET_LAYER)); +        } +    } else if (layer_state_is((AUTO_MOUSE_TARGET_LAYER)) && timer_elapsed(auto_mouse_context.timer.active) > AUTO_MOUSE_TIME) { +        layer_off((AUTO_MOUSE_TARGET_LAYER)); +        auto_mouse_context.timer.active = 0; +    } +} + +/** + * @brief Handle mouskey event + * + * Increments/decrements mouse_key_tracker and restart active timer + * + * @param[in] pressed bool + */ +void auto_mouse_keyevent(bool pressed) { +    if (pressed) { +        auto_mouse_context.status.mouse_key_tracker++; +    } else { +        auto_mouse_context.status.mouse_key_tracker--; +    } +    auto_mouse_context.timer.delay = 0; +} + +/** + * @brief Handle auto mouse non mousekey reset + * + * Start/restart delay timer and reset auto mouse on keydown as well as turn the + * target layer off if on and reset toggle status + * + * NOTE: NOT TO BE USED in layer_state_set stack!!! + * + * @param[in] pressed bool + */ +void auto_mouse_reset_trigger(bool pressed) { +    if (pressed) { +        if (layer_state_is((AUTO_MOUSE_TARGET_LAYER))) { +            layer_off((AUTO_MOUSE_TARGET_LAYER)); +        }; +        auto_mouse_reset(); +    } +    auto_mouse_context.timer.delay = timer_read(); +} + +/** + * @brief handle key events processing for auto mouse + * + * Will process keys differently depending on if key is defined as mousekey or not. + * Some keys have built in behaviour(not overwritable): + * mouse buttons        : auto_mouse_keyevent() + * non-mouse keys       : auto_mouse_reset_trigger() + * mod keys             : skip auto mouse key processing + * mod tap              : skip on hold (mod keys) + * QK mods e.g. LCTL(kc): default to non-mouse key, add at kb/user level as needed + * non target layer keys: skip auto mouse key processing (same as mod keys) + * MO(target layer)     : auto_mouse_keyevent() + * target layer toggles : auto_mouse_toggle() (on both key up and keydown) + * target layer tap     : default processing on tap mouse key on hold + * all other keycodes   : default to non-mouse key, add at kb/user level as needed + * + * Will deactivate target layer once a non mouse key is pressed if nothing is holding the layer active + * such as held mousekey, toggled current target layer, or auto_mouse_activation is true + * + * @params keycode[in] uint16_t + * @params record[in] keyrecord_t pointer + */ +bool process_auto_mouse(uint16_t keycode, keyrecord_t* record) { +    // skip if not enabled or mouse_layer not set +    if (!(AUTO_MOUSE_ENABLED)) return true; + +    switch (keycode) { +        // Skip Mod keys to avoid layer reset +        case KC_LEFT_CTRL ... KC_RIGHT_GUI: +        case QK_MODS ... QK_MODS_MAX: +            break; +        // TO((AUTO_MOUSE_TARGET_LAYER))------------------------------------------------------------------------------- +        case QK_TO ... QK_TO_MAX: // same proccessing as next +        // TG((AUTO_MOUSE_TARGET_LAYER))------------------------------------------------------------------------------- +        case QK_TOGGLE_LAYER ... QK_TOGGLE_LAYER_MAX: +            if ((keycode & 0xff) == (AUTO_MOUSE_TARGET_LAYER)) { +                if (!(record->event.pressed)) auto_mouse_toggle(); +            } +            break; +        // MO((AUTO_MOUSE_TARGET_LAYER))------------------------------------------------------------------------------- +        case QK_MOMENTARY ... QK_MOMENTARY_MAX: +            if ((keycode & 0xff) == (AUTO_MOUSE_TARGET_LAYER)) { +                auto_mouse_keyevent(record->event.pressed); +            } +        // DF --------------------------------------------------------------------------------------------------------- +        case QK_DEF_LAYER ... QK_DEF_LAYER_MAX: +#    ifndef NO_ACTION_ONESHOT +        // OSL((AUTO_MOUSE_TARGET_LAYER))------------------------------------------------------------------------------ +        case QK_ONE_SHOT_LAYER ... QK_ONE_SHOT_LAYER_MAX: +        case QK_ONE_SHOT_MOD ... QK_ONE_SHOT_MOD_MAX: +#    endif +            break; +        // LM((AUTO_MOUSE_TARGET_LAYER), mod)-------------------------------------------------------------------------- +        case QK_LAYER_MOD ... QK_LAYER_MOD_MAX: +            if (((keycode >> 8) & 0x0f) == (AUTO_MOUSE_TARGET_LAYER)) { +                auto_mouse_keyevent(record->event.pressed); +            } +            break; +            // TT((AUTO_MOUSE_TARGET_LAYER))--------------------------------------------------------------------------- +#    ifndef NO_ACTION_TAPPING +        case QK_LAYER_TAP_TOGGLE ... QK_LAYER_TAP_TOGGLE_MAX: +            if ((keycode & 0xff) == (AUTO_MOUSE_TARGET_LAYER)) { +                auto_mouse_keyevent(record->event.pressed); +#        if TAPPING_TOGGLE != 0 +                if (record->tap.count == TAPPING_TOGGLE) { +                    if (record->event.pressed) { +                        auto_mouse_context.status.mouse_key_tracker--; +                    } else { +                        auto_mouse_toggle(); +                        auto_mouse_context.status.mouse_key_tracker++; +                    } +                } +#        endif +            } +            break; +        // LT((AUTO_MOUSE_TARGET_LAYER), kc)--------------------------------------------------------------------------- +        case QK_LAYER_TAP ... QK_LAYER_TAP_MAX: +            if (!record->tap.count) { +                if (((keycode >> 8) & 0x0f) == (AUTO_MOUSE_TARGET_LAYER)) { +                    auto_mouse_keyevent(record->event.pressed); +                } +                break; +            } +        // MT(kc) only skip on hold +        case QK_MOD_TAP ... QK_MOD_TAP_MAX: +            if (!record->tap.count) break; +#    endif +        // QK_MODS goes to default +        default: +            // skip on no event +            if (IS_NOEVENT(record->event)) break; +            // check if keyrecord is mousekey +            if (is_mouse_record(keycode, record)) { +                auto_mouse_keyevent(record->event.pressed); +            } else if (!is_auto_mouse_active()) { +                // all non-mousekey presses restart delay timer and reset status +                auto_mouse_reset_trigger(record->event.pressed); +            } +    } +    if (auto_mouse_context.status.mouse_key_tracker < 0) { +        auto_mouse_context.status.mouse_key_tracker = 0; +        dprintf("key tracker error (<0) \n"); +    } +    return true; +} + +/** + * @brief Local function to handle checking if a keycode is a mouse button + * + * Starts code stack for checking keyrecord if defined as mousekey + * + * @params keycode[in] uint16_t + * @params record[in]  keyrecord_t pointer + * @return bool true: keyrecord is mousekey false: keyrecord is not mousekey + */ +static bool is_mouse_record(uint16_t keycode, keyrecord_t* record) { +    // allow for keyboard to hook in and override if need be +    if (is_mouse_record_kb(keycode, record) || IS_MOUSEKEY(keycode)) return true; +    return false; +} + +/** + * @brief Weakly defined keyboard level callback for adding keyrecords as mouse keys + * + * Meant for redefinition at keyboard level and should return is_mouse_record_user by default at end of function + * + * @params keycode[in] uint16_t + * @params record[in] keyrecord_t pointer + * @return bool true: keyrecord is defined as mouse key false: keyrecord is not defined as mouse key + */ +__attribute__((weak)) bool is_mouse_record_kb(uint16_t keycode, keyrecord_t* record) { +    return is_mouse_record_user(keycode, record); +} + +/** + * @brief Weakly defined keymap/user level callback for adding keyrecords as mouse keys + * + * Meant for redefinition at keymap/user level and should return false by default at end of function + * + * @params keycode[in] uint16_t + * @params record[in] keyrecord_t pointer + * @return bool true: keyrecord is defined as mouse key false: keyrecord is not defined as mouse key + */ +__attribute__((weak)) bool is_mouse_record_user(uint16_t keycode, keyrecord_t* record) { +    return false; +} + +#endif // POINTING_DEVICE_AUTO_MOUSE_ENABLE | 
