fdo-mirrors/libinput
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libinput/libinput.git synced 2026-03-24 21:50:41 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

filter: remove an unnecessary layer of indirection

Browse source 
This is a leftover from when some of the filter code was shared between
pointer acceleration methods (pre v1.11 or so). Now these functions are
duplicated across files, so both the names and what they do isn't
necessarily reflective anymore.

Let's drop one layer of indirection to make the code a bit easier to
understand.

No functional changes.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
This commit is contained in:
Peter Hutterer 2022-09-02 14:34:56 +10:00
parent 87c769f3f2
commit b6e1f5d120
3 changed files with 39 additions and 117 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

41
src/filter-low-dpi.c
View file

@ -125,42 +125,23 @@ calculate_acceleration_factor(struct pointer_accelerator_low_dpi *accel,
return accel_factor;
}
static struct device_float_coords
accelerator_filter_generic(struct motion_filter *filter,
static struct normalized_coords
accelerator_filter_low_dpi(struct motion_filter *filter,
const struct device_float_coords *unaccelerated,
void *data, uint64_t time)
{
struct pointer_accelerator_low_dpi *accel =
(struct pointer_accelerator_low_dpi *) filter;
double accel_value; /* unitless factor */
struct device_float_coords accelerated;
accel_value = calculate_acceleration_factor(accel,
unaccelerated,
data,
time);
accelerated.x = accel_value * unaccelerated->x;
accelerated.y = accel_value * unaccelerated->y;
return accelerated;
}
static struct normalized_coords
accelerator_filter_unnormalized(struct motion_filter *filter,
const struct device_float_coords *unaccelerated,
void *data, uint64_t time)
{
struct device_float_coords accelerated;
struct normalized_coords normalized;
/* Accelerate for device units and return device units */
accelerated = accelerator_filter_generic(filter,
unaccelerated,
data,
time);
normalized.x = accelerated.x;
normalized.y = accelerated.y;
double accel_factor = calculate_acceleration_factor(accel,
unaccelerated,
data,
time);
const struct normalized_coords normalized = {
.x = accel_factor * unaccelerated->x,
.y = accel_factor * unaccelerated->y,
};
return normalized;
}
@ -226,7 +207,7 @@ accelerator_set_speed(struct motion_filter *filter,
struct motion_filter_interface accelerator_interface_low_dpi = {
.type = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
.filter = accelerator_filter_unnormalized,
.filter = accelerator_filter_low_dpi,
.filter_constant = accelerator_filter_noop,
.restart = accelerator_restart,
.destroy = accelerator_destroy,

60
src/filter-mouse.c
View file

@ -99,55 +99,25 @@ calculate_acceleration_factor(struct pointer_accelerator *accel,
return accel_factor;
}
/**
* Generic filter that calculates the acceleration factor and applies it to
* the coordinates.
*
* @param filter The acceleration filter
* @param unaccelerated The raw delta in the device's dpi
* @param data Caller-specific data
* @param time Current time in µs
*
* @return An accelerated tuple of coordinates representing accelerated
* motion, still in device units.
*/
static struct normalized_coords
accelerator_filter_generic(struct motion_filter *filter,
const struct normalized_coords *unaccelerated,
void *data, uint64_t time)
accelerator_filter_linear(struct motion_filter *filter,
const struct device_float_coords *unaccelerated,
void *data, uint64_t time)
{
struct pointer_accelerator *accel =
(struct pointer_accelerator *) filter;
double accel_value; /* unitless factor */
struct normalized_coords accelerated;
accel_value = calculate_acceleration_factor(accel,
unaccelerated,
data,
time);
accelerated.x = accel_value * unaccelerated->x;
accelerated.y = accel_value * unaccelerated->y;
return accelerated;
}
static struct normalized_coords
accelerator_filter_pre_normalized(struct motion_filter *filter,
const struct device_float_coords *unaccelerated,
void *data, uint64_t time)
{
struct pointer_accelerator *accel =
(struct pointer_accelerator *) filter;
struct normalized_coords normalized, accelerated;
/* Accelerate for normalized units and return normalized units.
API requires device_floats, so we just copy the bits around */
normalized = normalize_for_dpi(unaccelerated, accel->dpi);
accelerated = accelerator_filter_generic(filter,
&normalized,
data,
time);
/* Accelerate for normalized units and return normalized units */
const struct normalized_coords normalized = normalize_for_dpi(unaccelerated,
accel->dpi);
double accel_factor = calculate_acceleration_factor(accel,
&normalized,
data,
time);
struct normalized_coords accelerated = {
.x = normalized.x * accel_factor,
.y = normalized.y * accel_factor,
};
return accelerated;
}
@ -301,7 +271,7 @@ pointer_accel_profile_linear(struct motion_filter *filter,
struct motion_filter_interface accelerator_interface = {
.type = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
.filter = accelerator_filter_pre_normalized,
.filter = accelerator_filter_linear,
.filter_constant = accelerator_filter_noop,
.restart = accelerator_restart,
.destroy = accelerator_destroy,

55
src/filter-touchpad.c
View file

@ -90,53 +90,24 @@ calculate_acceleration_factor(struct touchpad_accelerator *accel,
return accel_factor;
}
/**
* Generic filter that calculates the acceleration factor and applies it to
* the coordinates.
*
* @param filter The acceleration filter
* @param unaccelerated The raw delta in the device's dpi
* @param data Caller-specific data
* @param time Current time in µs
*
* @return An accelerated tuple of coordinates representing accelerated
* motion, still in device units.
*/
static struct device_float_coords
accelerator_filter_generic(struct motion_filter *filter,
const struct device_float_coords *unaccelerated,
void *data, uint64_t time)
{
struct touchpad_accelerator *accel =
(struct touchpad_accelerator *) filter;
double accel_value; /* unitless factor */
struct device_float_coords accelerated;
accel_value = calculate_acceleration_factor(accel,
unaccelerated,
data,
time);
accelerated.x = accel_value * unaccelerated->x;
accelerated.y = accel_value * unaccelerated->y;
return accelerated;
}
static struct normalized_coords
accelerator_filter_post_normalized(struct motion_filter *filter,
const struct device_float_coords *unaccelerated,
void *data, uint64_t time)
accelerator_filter_touchpad(struct motion_filter *filter,
const struct device_float_coords *unaccelerated,
void *data, uint64_t time)
{
struct touchpad_accelerator *accel =
(struct touchpad_accelerator *) filter;
struct device_float_coords accelerated;
/* Accelerate for device units, normalize afterwards */
accelerated = accelerator_filter_generic(filter,
unaccelerated,
data,
time);
double accel_factor = calculate_acceleration_factor(accel,
unaccelerated,
data,
time);
const struct device_float_coords accelerated = {
.x = unaccelerated->x * accel_factor,
.y = unaccelerated->y * accel_factor,
};
return normalize_for_dpi(&accelerated, accel->dpi);
}
@ -315,7 +286,7 @@ touchpad_accel_profile_linear(struct motion_filter *filter,
struct motion_filter_interface accelerator_interface_touchpad = {
.type = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
.filter = accelerator_filter_post_normalized,
.filter = accelerator_filter_touchpad,
.filter_constant = touchpad_constant_filter,
.restart = touchpad_accelerator_restart,
.destroy = touchpad_accelerator_destroy,