678 lines
21 KiB
C
678 lines
21 KiB
C
/* Copyright 2023 Alabastard (@Alabastard-64)
|
|
*
|
|
* 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_MODES_ENABLE
|
|
|
|
# include "pointing_device_modes.h"
|
|
|
|
// initialize local functions
|
|
static report_mouse_t process_pointing_mode(pointing_mode_t pointing_mode, report_mouse_t mouse_report);
|
|
static uint8_t get_pointing_mode_direction(void);
|
|
static uint8_t get_pointing_mode_divisor(void);
|
|
static uint8_t divisor_postprocess(uint8_t divisor);
|
|
|
|
// local variables
|
|
# if POINTING_MODES_DEVICE_CONTROL_COUNT > 1
|
|
static uint8_t current_device = POINTING_MODES_DEFAULT_DEVICE;
|
|
# else
|
|
static const uint8_t current_device = 0;
|
|
# if defined(POINTING_MODES_SINGLE_CONTROL)
|
|
static uint8_t selected_device = POINTING_MODES_DEFAULT_DEVICE;
|
|
# endif
|
|
# endif
|
|
|
|
static uint8_t current_direction = 0;
|
|
static uint8_t current_divisor = POINTING_DEFAULT_DIVISOR;
|
|
static uint8_t toggle_ids[] = {[0 ... POINTING_MODES_DEVICE_CONTROL_COUNT - 1] = POINTING_MODE_DEFAULT};
|
|
static pointing_mode_t pointing_modes[] = {[0 ... POINTING_MODES_DEVICE_CONTROL_COUNT - 1] = {.id = POINTING_MODE_DEFAULT}};
|
|
|
|
// set up clamping and divisor application functions
|
|
static inline int8_t clamp_int_16_to_8(int16_t value) {
|
|
if (value < INT8_MIN) {
|
|
return INT8_MIN;
|
|
} else if (value > INT8_MAX) {
|
|
return INT8_MAX;
|
|
} else {
|
|
return value;
|
|
}
|
|
}
|
|
|
|
static inline int16_t clamp_int_32_to_16(int32_t value) {
|
|
if (value < INT16_MIN) {
|
|
return INT16_MIN;
|
|
} else if (value > INT16_MAX) {
|
|
return INT16_MAX;
|
|
} else {
|
|
return value;
|
|
}
|
|
}
|
|
|
|
static inline uint16_t clamp_uint_16_to_8(uint16_t value) {
|
|
if (value > UINT8_MAX) return UINT8_MAX;
|
|
return value;
|
|
}
|
|
|
|
static int16_t divisor_multiply16(int16_t value) {
|
|
return clamp_int_32_to_16(value * (int16_t)current_divisor);
|
|
}
|
|
|
|
static int8_t divisor_divide8(int16_t value) {
|
|
return clamp_int_16_to_8(value / (int16_t)current_divisor);
|
|
}
|
|
|
|
static int16_t divisor_divide16(int16_t value) {
|
|
return value / (int16_t)current_divisor;
|
|
}
|
|
|
|
/**
|
|
* @brief divides value by current divisor return mouse x/y
|
|
*
|
|
* Intended for modifying pointing_mode x/y values
|
|
*
|
|
* @params value[in] value int16_t
|
|
*
|
|
* @return quotient clamped to mouse_xy_report_t range
|
|
*/
|
|
mouse_xy_report_t apply_divisor_xy(int16_t value) {
|
|
# ifdef MOUSE_EXTENDED_REPORT
|
|
return divisor_divide16(value);
|
|
# else
|
|
return divisor_divide8(value);
|
|
# endif
|
|
}
|
|
|
|
/**
|
|
* @brief divides value by current divisor return mouse h/v
|
|
*
|
|
* Intended for modifying pointing_mode x/y values
|
|
*
|
|
* @params value[in] value int16_t
|
|
*
|
|
* @return quotient clamped to int8_t range
|
|
*/
|
|
int8_t apply_divisor_hv(int16_t value) {
|
|
return divisor_divide8(value);
|
|
}
|
|
|
|
/**
|
|
* @brief multiplies mouse x/y value by current divisor
|
|
*
|
|
* Intended for collecting residuals by subtracting quotient * divisor from the dividend
|
|
* as modulo can be large and slow on some chips
|
|
*
|
|
* @params value[in] value mouse_xy_report_t mouse x/y axis value to multiply
|
|
*
|
|
* @return product clamped to int16_t range
|
|
*/
|
|
int16_t multiply_divisor_xy(mouse_xy_report_t value) {
|
|
return divisor_multiply16((int16_t)value);
|
|
}
|
|
|
|
/**
|
|
* @brief multiplies mouse h/v value by current divisor
|
|
*
|
|
* Intended for collecting residuals by subtracting quotient * divisor from the dividend
|
|
* as modulo can be large and slow on some chips
|
|
*
|
|
* @params value[in] value int8_t mouse h/v axis value to multiply
|
|
*
|
|
* @return modified and clamped value int16_t
|
|
*/
|
|
int16_t multiply_divisor_hv(int8_t value) {
|
|
return divisor_multiply16((int16_t)value);
|
|
}
|
|
|
|
/**
|
|
* @brief Return device id of current controlled device
|
|
*
|
|
* @return current device id [uint8_t]
|
|
*/
|
|
uint8_t get_pointing_mode_device(void) {
|
|
# ifdef POINTING_MODES_SINGLE_CONTROL
|
|
return selected_device;
|
|
# else
|
|
return current_device;
|
|
# endif
|
|
}
|
|
|
|
/**
|
|
* @brief Change current device
|
|
*
|
|
* Will change which device (PM_LEFT_DEVICE, PM_RIGHT_DEVICE, etc.) is currently being modified
|
|
*
|
|
* NOTE: If mode is set to out of range device number device is silently set to zero (this allows cycling)
|
|
*
|
|
* @params[in] new side uint8_t
|
|
*/
|
|
void set_pointing_mode_device(uint8_t device) {
|
|
# if (POINTING_MODES_NUM_DEVICES > 1)
|
|
if (device > (POINTING_MODES_NUM_DEVICES - 1)) device = 0;
|
|
# ifdef POINTING_MODES_SINGLE_CONTROL
|
|
selected_device = device;
|
|
# else
|
|
current_device = device;
|
|
# endif
|
|
# else
|
|
;
|
|
# endif
|
|
}
|
|
|
|
/**
|
|
* @brief Reset pointing mode data
|
|
*
|
|
* Clear poiting mode and set to defaults
|
|
*/
|
|
void pointing_mode_reset(void) {
|
|
memset(&pointing_modes[current_device], 0, sizeof(pointing_mode_t));
|
|
pointing_modes[current_device].id = toggle_ids[current_device];
|
|
}
|
|
|
|
/**
|
|
* @brief set current pointing mode data
|
|
*
|
|
* @param[in] pointing_mode pointing_mode_t
|
|
*/
|
|
void set_pointing_mode(pointing_mode_t pointing_mode) {
|
|
// skip if same
|
|
if (!memcmp(&pointing_modes[current_device], &pointing_mode, sizeof(pointing_mode_t))) return;
|
|
memcpy(&pointing_modes[current_device], &pointing_mode, sizeof(pointing_mode_t));
|
|
}
|
|
|
|
/**
|
|
* @brief access current pointing mode id
|
|
*
|
|
* @return uint8_t current pointing mode id
|
|
*/
|
|
uint8_t get_pointing_mode_id(void) {
|
|
return pointing_modes[current_device].id;
|
|
}
|
|
|
|
/**
|
|
* @brief set pointing mode id
|
|
*
|
|
* @param[in] mode_id uint8_t
|
|
*/
|
|
void set_pointing_mode_id(uint8_t mode_id) {
|
|
if (get_pointing_mode_id() != mode_id) {
|
|
pointing_mode_reset();
|
|
pointing_modes[current_device].id = mode_id;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Access current toggled pointing mode
|
|
*
|
|
* @return uint8_t toggle pointing mode
|
|
*/
|
|
uint8_t get_toggled_pointing_mode_id(void) {
|
|
return toggle_ids[current_device];
|
|
}
|
|
|
|
/**
|
|
* @brief Toggle pointing mode id on/off
|
|
*
|
|
* Will change tg_mode_id setting to POINTING_MODE_DEFAULT when toggling "off"
|
|
*
|
|
* @param[in] mode_id uint8_t
|
|
*/
|
|
void toggle_pointing_mode_id(uint8_t mode_id) {
|
|
if (get_toggled_pointing_mode_id() == mode_id) {
|
|
toggle_ids[current_device] = POINTING_MODE_DEFAULT;
|
|
} else {
|
|
toggle_ids[current_device] = mode_id;
|
|
}
|
|
if (get_pointing_mode_id() != get_toggled_pointing_mode_id()) pointing_mode_reset();
|
|
}
|
|
|
|
/**
|
|
* @brief Weak function to convert x/y axes to h/v
|
|
*
|
|
* The default uses accumulation based on inversion defines and
|
|
* halts cursor movement
|
|
*
|
|
* @params pointing_modes[in] pointing_mode_t
|
|
* @params mouse_report[in] report_mouse_t
|
|
*
|
|
* @return updated mouse_report report_mouse_t
|
|
*/
|
|
__attribute__((weak)) report_mouse_t pointing_modes_axes_conv(pointing_mode_t pointing_mode, report_mouse_t mouse_report) {
|
|
# ifdef POINTING_DEVICE_MODES_INVERT_X
|
|
pointing_mode.x -= mouse_report.x;
|
|
# else
|
|
pointing_mode.x += mouse_report.x;
|
|
# endif
|
|
# ifdef POINTING_DEVICE_MODES_INVERT_Y
|
|
pointing_mode.y -= mouse_report.y;
|
|
# else
|
|
pointing_mode.y += mouse_report.y;
|
|
# endif
|
|
set_pointing_mode(pointing_mode);
|
|
mouse_report.x = 0;
|
|
mouse_report.y = 0;
|
|
return mouse_report;
|
|
}
|
|
|
|
/**
|
|
* @brief Modifies divisor after
|
|
*
|
|
* @params pointing_modes[in] uint8_t
|
|
* @params direction[in] uint8_t
|
|
*
|
|
* @return divisor uint8_t
|
|
*/
|
|
static uint8_t divisor_postprocess(uint8_t divisor) {
|
|
if (!(pointing_mode_divisor_postprocess_user(&divisor) && pointing_mode_divisor_postprocess_kb(&divisor))) {
|
|
// never return without zero checking
|
|
return divisor ? divisor : POINTING_DEFAULT_DIVISOR;
|
|
}
|
|
// Modify divisor if precision is toggled
|
|
if (get_toggled_pointing_mode_id() == PM_PRECISION && !(get_pointing_mode_id() == PM_PRECISION)) {
|
|
divisor = clamp_uint_16_to_8(divisor * POINTING_PRECISION_DIVISOR);
|
|
}
|
|
// never return without zero checking
|
|
return divisor ? divisor : POINTING_DEFAULT_DIVISOR;
|
|
}
|
|
|
|
/**
|
|
* @brief override current divisor value
|
|
*
|
|
* Will only take effect until next cycle update or next call of this process
|
|
*
|
|
* @param[in] divisor uint8_t
|
|
*/
|
|
void pointing_mode_divisor_override(uint8_t divisor) {
|
|
current_divisor = divisor_postprocess(divisor);
|
|
}
|
|
|
|
/**
|
|
* @brief local function to get pointing mode divisor
|
|
*
|
|
* Will handle default divisors and call weak kb and user functions
|
|
*
|
|
* NOTE: Expects that pointing mode and direction has been updated
|
|
*
|
|
* @return divisor uint8_t
|
|
*/
|
|
static uint8_t get_pointing_mode_divisor(void) {
|
|
uint8_t divisor = 0;
|
|
// allow for user and keyboard overrides
|
|
divisor = get_pointing_mode_divisor_user(get_pointing_mode_id(), current_pointing_mode_direction());
|
|
if (divisor) return divisor_postprocess(divisor);
|
|
divisor = get_pointing_mode_divisor_kb(get_pointing_mode_id(), current_pointing_mode_direction());
|
|
if (divisor) return divisor_postprocess(divisor);
|
|
// built in divisors
|
|
switch (get_pointing_mode_id()) {
|
|
case PM_PRECISION:
|
|
divisor = POINTING_PRECISION_DIVISOR;
|
|
break;
|
|
|
|
case PM_DRAG:
|
|
divisor = POINTING_DRAG_DIVISOR;
|
|
break;
|
|
|
|
case PM_CARET:
|
|
divisor = current_pointing_mode_direction() < PD_LEFT ? POINTING_CARET_DIVISOR_V : POINTING_CARET_DIVISOR_H;
|
|
break;
|
|
|
|
case PM_HISTORY:
|
|
divisor = POINTING_HISTORY_DIVISOR;
|
|
break;
|
|
|
|
# ifdef EXTRAKEY_ENABLE
|
|
case PM_VOLUME:
|
|
divisor = POINTING_VOLUME_DIVISOR;
|
|
break;
|
|
# endif
|
|
}
|
|
return divisor_postprocess(divisor);
|
|
}
|
|
|
|
/**
|
|
* @brief local function to get single direction based on h/v
|
|
*
|
|
* Determines direction based on axis with largest magnitude
|
|
*
|
|
* NOTE: Defaults to PD_DOWN
|
|
*
|
|
* @return direction uint8_t
|
|
*/
|
|
static uint8_t get_pointing_mode_direction(void) {
|
|
if (abs(pointing_modes[current_device].x) > abs(pointing_modes[current_device].y)) {
|
|
if (pointing_modes[current_device].x > 0) {
|
|
return PD_RIGHT;
|
|
} else {
|
|
return PD_LEFT;
|
|
}
|
|
} else {
|
|
if (pointing_modes[current_device].y > 0) {
|
|
return PD_UP;
|
|
} else {
|
|
return PD_DOWN;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief update dependent parameters of pointing_mode
|
|
*
|
|
* Will update the direction and divisor values based on mode id and h, and v axis values
|
|
*
|
|
*/
|
|
void pointing_mode_update(void) {
|
|
current_direction = get_pointing_mode_direction();
|
|
current_divisor = get_pointing_mode_divisor();
|
|
}
|
|
|
|
/**
|
|
* @brief Access current pointing mode direction
|
|
*
|
|
* @return uint8_t direction
|
|
*/
|
|
uint8_t current_pointing_mode_direction(void) {
|
|
return current_direction;
|
|
}
|
|
|
|
/**
|
|
* @brief Access current pointing mode divisor
|
|
*
|
|
* @return uint8_t divisor
|
|
*/
|
|
uint8_t current_pointing_mode_divisor(void) {
|
|
return current_divisor;
|
|
}
|
|
|
|
/**
|
|
* @brief Tap keycodes based on mode axis values
|
|
*
|
|
* Will translate current mode x & y values into keycode taps based on divisor value.
|
|
* Array should be ordered {DOWN, UP, LEFT, RIGHT} and will output 1 keytap/divisor
|
|
* x and y values will be automatically updated
|
|
*
|
|
* NOTE: favours staying on axis and weakly favours the horizontal over the vertical axis
|
|
* and will clear the orthogonal axis
|
|
*
|
|
* @param[in] uint16_t* array pointer to set of four keycodes
|
|
*/
|
|
static void pointing_tap_keycodes_raw(uint16_t* pm_keycodes) {
|
|
int16_t count = 0;
|
|
uint8_t dir = current_pointing_mode_direction();
|
|
|
|
switch (dir) {
|
|
case PD_DOWN ... PD_UP:
|
|
count = divisor_divide16(pointing_modes[current_device].y);
|
|
if (!count) return; // exit if accumulated y is too low
|
|
pointing_modes[current_device].y -= divisor_multiply16(count);
|
|
pointing_modes[current_device].x = 0;
|
|
break;
|
|
case PD_LEFT ... PD_RIGHT:
|
|
count = divisor_divide16(pointing_modes[current_device].x);
|
|
if (!count) return; // exit if accumulated x is too low
|
|
pointing_modes[current_device].x -= divisor_multiply16(count);
|
|
pointing_modes[current_device].y = 0;
|
|
break;
|
|
}
|
|
// skip if KC_TRNS or KC_NO (but allow for axes update above)
|
|
// if (pm_keycodes[dir] < 2) return;
|
|
|
|
// tap codes
|
|
uint8_t taps = clamp_uint_16_to_8((uint16_t)abs(count));
|
|
do {
|
|
tap_code16_delay(pm_keycodes[dir], POINTING_TAP_DELAY);
|
|
} while (--taps);
|
|
}
|
|
|
|
/**
|
|
* @brief external wrapper for pointing_tap_keycodes to allow easier input
|
|
*
|
|
* keycode order follow VIM convention (LEFT, DOWN, UP, RIGHT).s
|
|
*
|
|
* @params kc_left[in] uint16_t keycode for negative x
|
|
* @params kc_down[in] uint16_t keycode for negative y
|
|
* @params kc_up[in] uint16_t keycode for positive y
|
|
* @params kc_right[in] uint16_t keycode for positive x
|
|
*/
|
|
void pointing_tap_codes(uint16_t kc_left, uint16_t kc_down, uint16_t kc_up, uint16_t kc_right) {
|
|
uint16_t pm_keycodes[4] = {kc_down, kc_up, kc_left, kc_right};
|
|
pointing_tap_keycodes_raw(pm_keycodes);
|
|
}
|
|
|
|
/**
|
|
* @brief Tap keycodes from pointing mode maps
|
|
*
|
|
* Will translate internal x & y axes into mode map keycode taps.
|
|
* and will update the x and y values.-
|
|
*
|
|
* NOTE: favours staying on axis and favours the horizontal over the vertical axis
|
|
* and will clear the orthogonal axis
|
|
*
|
|
* @params map_id id of current map
|
|
*/
|
|
# ifdef POINTING_MODE_MAP_ENABLE
|
|
static void pointing_exec_mapping(uint8_t map_id) {
|
|
int16_t count = 0;
|
|
uint8_t dir = current_pointing_mode_direction();
|
|
|
|
switch (dir) {
|
|
case PD_DOWN ... PD_UP:
|
|
count = divisor_divide16(pointing_modes[current_device].y);
|
|
if (!count) return; // exit if accumulated y is too low
|
|
pointing_modes[current_device].y -= divisor_multiply16(count);
|
|
pointing_modes[current_device].x = 0;
|
|
break;
|
|
case PD_LEFT ... PD_RIGHT:
|
|
count = divisor_divide16(pointing_modes[current_device].x);
|
|
if (!count) return; // exit if accumulated x is too low
|
|
pointing_modes[current_device].x -= divisor_multiply16(count);
|
|
pointing_modes[current_device].y = 0;
|
|
break;
|
|
}
|
|
|
|
// tap codes
|
|
uint8_t taps = clamp_uint_16_to_8((uint16_t)abs(count));
|
|
do {
|
|
action_exec(MAKE_POINTING_MODE_EVENT(map_id, dir, true));
|
|
# if POINTING_TAP_DELAY > 0
|
|
wait_ms(POINTING_TAP_DELAY);
|
|
# endif // POINTING_TAP_DELAY > 0
|
|
action_exec(MAKE_POINTING_MODE_EVENT(map_id, dir, false));
|
|
} while (--taps);
|
|
}
|
|
# endif
|
|
|
|
/**
|
|
* @brief Core function to handle pointing mode task
|
|
*
|
|
* Meant to be implemented in pointing_device_task
|
|
*
|
|
* @param[in] mouse_report report_mouse_t
|
|
*
|
|
* @return mouse_report report_mouse_t
|
|
*/
|
|
report_mouse_t pointing_device_modes_task(report_mouse_t mouse_report) {
|
|
// skip all processing if pointing mode is PM_NONE
|
|
if (get_pointing_mode_id() == PM_NONE) return mouse_report;
|
|
|
|
mouse_report = pointing_modes_axes_conv(pointing_modes[current_device], mouse_report);
|
|
pointing_mode_update();
|
|
mouse_report = process_pointing_mode(pointing_modes[current_device], mouse_report);
|
|
|
|
return mouse_report;
|
|
}
|
|
|
|
/**
|
|
* @brief Handle processing of pointing modes
|
|
*
|
|
* Takes in report_mouse_t and pointing_mode_t allowing manipulation of mouse_report
|
|
* and pointing_mode via set_pointing_mode
|
|
*
|
|
* @return mouse_report report_mouse_t
|
|
*/
|
|
static report_mouse_t process_pointing_mode(pointing_mode_t pointing_mode, report_mouse_t mouse_report) {
|
|
// allow overwrite of pointing modes by user, and kb
|
|
if (!(process_pointing_mode_user(pointing_mode, &mouse_report) && process_pointing_mode_kb(pointing_mode, &mouse_report))) {
|
|
return mouse_report;
|
|
}
|
|
switch (pointing_mode.id) {
|
|
// precision mode (reduce x y sensitivity temporarily)
|
|
case PM_PRECISION:
|
|
# ifdef POINTING_DEVICE_MODES_INVERT_X
|
|
mouse_report.x -= apply_divisor_xy(pointing_mode.x);
|
|
pointing_mode.x += multiply_divisor_xy(mouse_report.x);
|
|
# else
|
|
mouse_report.x += apply_divisor_xy(pointing_mode.x);
|
|
pointing_mode.x -= multiply_divisor_xy(mouse_report.x);
|
|
# endif
|
|
# ifdef POINTING_DEVICE_MODES_INVERT_Y
|
|
mouse_report.y -= apply_divisor_xy(pointing_mode.y);
|
|
pointing_mode.y += multiply_divisor_xy(mouse_report.y);
|
|
# else
|
|
mouse_report.y += apply_divisor_xy(pointing_mode.y);
|
|
pointing_mode.y -= multiply_divisor_xy(mouse_report.y);
|
|
# endif
|
|
set_pointing_mode(pointing_mode);
|
|
break;
|
|
|
|
// drag scroll mode (sets mouse axes to mouse_report h & v with divisor)
|
|
case PM_DRAG:
|
|
mouse_report.h = apply_divisor_hv(pointing_mode.x);
|
|
pointing_mode.x -= multiply_divisor_hv(mouse_report.h);
|
|
mouse_report.v = apply_divisor_hv(pointing_mode.y);
|
|
pointing_mode.y -= multiply_divisor_hv(mouse_report.v);
|
|
set_pointing_mode(pointing_mode);
|
|
break;
|
|
|
|
// caret mode (uses arrow keys to move cursor)
|
|
case PM_CARET:
|
|
pointing_tap_codes(KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT);
|
|
break;
|
|
|
|
// history scroll mode (will scroll through undo/redo history)
|
|
case PM_HISTORY:
|
|
pointing_tap_codes(C(KC_Z), KC_NO, KC_NO, C(KC_Y));
|
|
break;
|
|
|
|
# ifdef EXTRAKEY_ENABLE
|
|
// volume scroll mode (adjusts audio volume)
|
|
case PM_VOLUME:
|
|
pointing_tap_codes(KC_NO, KC_VOLD, KC_VOLU, KC_NO);
|
|
break;
|
|
# endif
|
|
|
|
# ifdef POINTING_MODE_MAP_ENABLE
|
|
default:
|
|
if (pointing_mode.id > POINTING_MODE_MAP_START) {
|
|
pointing_exec_mapping(pointing_mode.id - POINTING_MODE_MAP_START);
|
|
}
|
|
# endif
|
|
}
|
|
return mouse_report;
|
|
}
|
|
|
|
/**
|
|
* @brief User level processing of pointing device modes
|
|
*
|
|
* Takes pointing_mode_t struct, and pointer to the report_mouse_t struct used in pointing mode process allowing
|
|
* modification of mouse_report directly and pointing mode using set_pointing_mode(pointing_mode) and the returned
|
|
* bool controls the continued processing of pointing modes.
|
|
*
|
|
* NOTE: returning false will stop mode processing (for overwriting modes)
|
|
*
|
|
* @params pointing_modes[in] pointing_mode_t
|
|
* @params mouse_report[in] pointer to report_mouse_t
|
|
*
|
|
* @return bool continue processing flag
|
|
*/
|
|
__attribute__((weak)) bool process_pointing_mode_user(pointing_mode_t pointing_mode, report_mouse_t* mouse_report) {
|
|
return true; // continue processing
|
|
}
|
|
|
|
/**
|
|
* @brief Keyboard level processing of pointing device modes
|
|
*
|
|
* Takes pointing_mode_t struct, and pointer to the report_mouse_t struct used in pointing mode process allowing
|
|
* modification of mouse_report directly and pointing mode using set_pointing_mode(pointing_mode) and the returned
|
|
* bool controls the continued processing of pointing modes.
|
|
*
|
|
* NOTE: returning false will stop mode processing (for overwriting modes)
|
|
*
|
|
* @params pointing_modes[in] pointing_mode_t
|
|
* @params mouse_report[in] pointer to report_mouse_t
|
|
*
|
|
* @return bool continue processing flag
|
|
*/
|
|
__attribute__((weak)) bool process_pointing_mode_kb(pointing_mode_t pointing_mode, report_mouse_t* mouse_report) {
|
|
return true; // continue processing
|
|
}
|
|
|
|
/**
|
|
* @brief Weak function for user level adding of pointing mode divisors
|
|
*
|
|
* Takes in mode id and direction allowing for divisor values to be
|
|
* determined based on these parameters
|
|
*
|
|
* @params pointing_modes[in] uint8_t
|
|
* @params direction[in] uint8_t
|
|
*
|
|
* @return divisor uint8_t
|
|
*/
|
|
__attribute__((weak)) uint8_t get_pointing_mode_divisor_user(uint8_t mode_id, uint8_t direction) {
|
|
return 0; // continue processing
|
|
}
|
|
|
|
/**
|
|
* @brief Weak function for user level adding of pointing mode divisors
|
|
*
|
|
* Takes in mode id and direction allowing for divisor values to be
|
|
* determined based on these parameters
|
|
*
|
|
* @params pointing_modes[in] uint8_t
|
|
* @params direction[in] uint8_t
|
|
*
|
|
* @return divisor uint8_t
|
|
*/
|
|
__attribute__((weak)) uint8_t get_pointing_mode_divisor_kb(uint8_t mode_id, uint8_t direction) {
|
|
return 0; // continue processing
|
|
}
|
|
|
|
/**
|
|
* @brief Keyboard level modifying of divisors after being set and before use
|
|
*
|
|
* Allows modification the divisor after being set by get_pointing_mode_divisor stack before
|
|
* handing off to default post processing
|
|
*
|
|
* @params[in] pointer to divisor uint8_t
|
|
*
|
|
* @return bool continue processing flag
|
|
*/
|
|
__attribute__((weak)) bool pointing_mode_divisor_postprocess_kb(uint8_t* divisor) {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief User level modifying of divisors after being set and before use
|
|
*
|
|
* Allows modification the divisor after being set by get_pointing_mode_divisor stack before
|
|
* handing off to default post processing
|
|
*
|
|
* @params[in] pointer to divisor uint8_t
|
|
*
|
|
* @return bool continue processing flag
|
|
*/
|
|
__attribute__((weak)) bool pointing_mode_divisor_postprocess_user(uint8_t* divisor) {
|
|
return true;
|
|
}
|
|
|
|
#endif // POINTING_DEVICE_MODES_ENABLE
|