mirror of
https://github.com/kovidgoyal/kitty
synced 2026-06-06 01:05:48 +02:00
228 lines
8.1 KiB
C
Vendored
228 lines
8.1 KiB
C
Vendored
/*
|
|
* momentum-scroll.c
|
|
* Copyright (C) 2026 Kovid Goyal <kovid at kovidgoyal.net>
|
|
*
|
|
* Distributed under terms of the GPL3 license.
|
|
*/
|
|
|
|
#include "internal.h"
|
|
#include <math.h>
|
|
|
|
typedef struct ScrollSample {
|
|
double dx, dy;
|
|
monotonic_t timestamp;
|
|
} ScrollSample;
|
|
|
|
#define DEQUE_DATA_TYPE ScrollSample
|
|
#define DEQUE_NAME ScrollSamples
|
|
#include "../kitty/fixed_size_deque.h"
|
|
|
|
typedef enum ScrollerState { NONE, PHYSICAL_EVENT_IN_PROGRESS, MOMENTUM_IN_PROGRESS } ScrollerState;
|
|
|
|
typedef struct MomentumScroller {
|
|
double friction, // Deceleration inverse factor (0-1, higher = longer coast)
|
|
min_velocity, // Minimum velocity before stopping
|
|
max_velocity, // Maximum velocity to prevent runaway scrolling
|
|
velocity_scale; // Scale factor for initial velocity
|
|
monotonic_t timer_interval; // animation speed
|
|
|
|
GLFWid timer_id, window_id;
|
|
ScrollSamples samples;
|
|
ScrollerState state;
|
|
double scale;
|
|
struct { double x, y; } velocity;
|
|
int keyboard_modifiers;
|
|
struct {
|
|
monotonic_t start, duration;
|
|
struct { double x, y; } displacement;
|
|
} physical_event;
|
|
} MomentumScroller;
|
|
|
|
#define DEFAULTS { .friction = 0.96, .min_velocity = 0.5, .max_velocity = 100, .timer_interval = 10, }
|
|
static const MomentumScroller defaults = DEFAULTS;
|
|
static MomentumScroller s = DEFAULTS;
|
|
#undef DEFAULTS
|
|
|
|
GLFWAPI void
|
|
glfwConfigureMomentumScroller(double friction, double min_velocity, double max_velocity, unsigned timer_interval_ms) {
|
|
s.timer_interval = timer_interval_ms ? ms_to_monotonic_t(timer_interval_ms) : defaults.timer_interval;
|
|
s.friction = friction < 0 ? defaults.friction : MAX(0, MIN(friction, 1));
|
|
#define S(w) s.w = w >= 0 ? w : defaults.w
|
|
S(min_velocity); S(max_velocity);
|
|
#undef S
|
|
}
|
|
|
|
static void
|
|
cancel_existing_scroll(bool reset_velocity) {
|
|
if (s.timer_id) {
|
|
glfwRemoveTimer(s.timer_id);
|
|
s.timer_id = 0;
|
|
}
|
|
if (s.state == MOMENTUM_IN_PROGRESS) {
|
|
_GLFWwindow *w = _glfwWindowForId(s.window_id);
|
|
if (w) _glfwInputScroll(
|
|
w, &(GLFWScrollEvent){.momentum_type=GLFW_MOMENTUM_PHASE_CANCELED, .keyboard_modifiers=s.keyboard_modifiers});
|
|
}
|
|
s.window_id = 0;
|
|
s.keyboard_modifiers = 0;
|
|
deque_clear(&s.samples);
|
|
s.state = NONE;
|
|
if (reset_velocity) { s.velocity.x = 0; s.velocity.y = 0; }
|
|
}
|
|
|
|
static void
|
|
add_sample(double dx, double dy, monotonic_t now) {
|
|
deque_push_back(&s.samples, (ScrollSample){dx, dy, now}, NULL);
|
|
}
|
|
|
|
static void
|
|
last_sample_delta(double *dx, double *dy) {
|
|
const ScrollSample *ss;
|
|
if ((ss = deque_peek_back(&s.samples))) { *dx = ss->dx; *dy = ss->dy; }
|
|
else { *dx = 0; *dy = 0; }
|
|
}
|
|
|
|
static void
|
|
trim_old_samples(monotonic_t now) {
|
|
const ScrollSample *ss;
|
|
while ((ss = deque_peek_front(&s.samples)) && (now - ss->timestamp) > ms_to_monotonic_t(150))
|
|
deque_pop_front(&s.samples, NULL);
|
|
}
|
|
|
|
static void
|
|
add_velocity(double x, double y) {
|
|
if (x == 0 || x * s.velocity.x >= 0) s.velocity.x += x;
|
|
else s.velocity.x = x;
|
|
if (y == 0 || y * s.velocity.y >= 0) s.velocity.y += y;
|
|
else s.velocity.y = y;
|
|
s.velocity.x = MAX(-s.max_velocity, MIN(s.velocity.x, s.max_velocity));
|
|
s.velocity.y = MAX(-s.max_velocity, MIN(s.velocity.y, s.max_velocity));
|
|
}
|
|
|
|
static void
|
|
set_velocity_from_samples(monotonic_t now) {
|
|
s.timer_interval = ms_to_monotonic_t(8);
|
|
trim_old_samples(now);
|
|
ScrollSample ss;
|
|
switch (deque_size(&s.samples)) {
|
|
case 0:
|
|
return;
|
|
case 1:
|
|
deque_pop_front(&s.samples, &ss);
|
|
add_velocity(ss.dx, ss.dy);
|
|
return;
|
|
}
|
|
|
|
// Use weighted average - more recent samples have higher weight
|
|
double total_dx = 0.0, total_dy = 0.0, total_weight = 0.0;
|
|
monotonic_t first_time = deque_peek_front(&s.samples)->timestamp;
|
|
monotonic_t last_time = deque_peek_back(&s.samples)->timestamp;
|
|
double time_span = MAX(1, last_time - first_time);
|
|
for (size_t i = 0; i < deque_size(&s.samples); i++) {
|
|
const ScrollSample *ss = deque_at(&s.samples, i);
|
|
double weight = 1.0 + (ss->timestamp - first_time) / time_span;
|
|
total_dx += ss->dx * weight; total_dy += ss->dy * weight;
|
|
total_weight += weight;
|
|
}
|
|
deque_clear(&s.samples);
|
|
if (total_weight <= 0) return;
|
|
double dy = total_dy / total_weight, dx = total_dx / total_weight;
|
|
add_velocity(dx, dy);
|
|
if (false) timed_debug_print("momentum scroll: event velocity: %.1f final velocity: %.1f\n", dy, s.velocity.y);
|
|
}
|
|
|
|
static void
|
|
send_momentum_event(bool is_start) {
|
|
_GLFWwindow *w = _glfwWindowForId(s.window_id);
|
|
if (!w || w != _glfwFocusedWindow()) {
|
|
cancel_existing_scroll(true);
|
|
return;
|
|
}
|
|
s.velocity.x *= s.friction; s.velocity.y *= s.friction;
|
|
if (fabs(s.velocity.x) < s.min_velocity) s.velocity.x = 0;
|
|
if (fabs(s.velocity.y) < s.min_velocity) s.velocity.y = 0;
|
|
|
|
GLFWMomentumType m = is_start ? GLFW_MOMENTUM_PHASE_BEGAN : GLFW_MOMENTUM_PHASE_ACTIVE;
|
|
if (s.velocity.x == 0 && s.velocity.y == 0 && !is_start) {
|
|
m = GLFW_MOMENTUM_PHASE_ENDED;
|
|
if (s.timer_id) glfwRemoveTimer(s.timer_id);
|
|
s.timer_id = 0;
|
|
s.state = NONE;
|
|
}
|
|
GLFWScrollEvent e = {
|
|
.offset_type=GLFW_SCROLL_OFFEST_HIGHRES, .momentum_type=m, .unscaled.x=s.velocity.x, .unscaled.y=s.velocity.y,
|
|
.x_offset=s.scale * s.velocity.x, .y_offset=s.scale * s.velocity.y, .keyboard_modifiers=s.keyboard_modifiers
|
|
};
|
|
_glfwInputScroll(w, &e);
|
|
}
|
|
|
|
static void
|
|
momentum_timer_fired(unsigned long long timer_id UNUSED, void *data UNUSED) {
|
|
send_momentum_event(false);
|
|
}
|
|
|
|
static void
|
|
start_momentum_scroll(monotonic_t now) {
|
|
set_velocity_from_samples(now);
|
|
send_momentum_event(true);
|
|
s.timer_id = glfwAddTimer(s.timer_interval, true, momentum_timer_fired, NULL, NULL);
|
|
}
|
|
|
|
static bool
|
|
is_suitable_for_momentum(void) {
|
|
return (
|
|
MAX(fabs(s.physical_event.displacement.x), fabs(s.physical_event.displacement.y)) > 10 &&
|
|
s.physical_event.duration > ms_to_monotonic_t(2)
|
|
);
|
|
}
|
|
|
|
bool
|
|
glfw_is_momentum_scroll_enabled(void) {
|
|
return s.friction > 0;
|
|
}
|
|
|
|
void
|
|
glfw_handle_scroll_event_for_momentum(
|
|
_GLFWwindow *w, const GLFWScrollEvent *ev, bool stopped, bool is_finger_based
|
|
) {
|
|
const bool is_synthetic_momentum_start_event = stopped && momentum_scroll_gesture_detection_timeout_ms;
|
|
if (!w) { cancel_existing_scroll(true); return; }
|
|
if (!is_finger_based || ev->offset_type != GLFW_SCROLL_OFFEST_HIGHRES || !glfw_is_momentum_scroll_enabled()) {
|
|
if (ev->x_offset != 0 || ev->y_offset != 0) _glfwInputScroll(w, ev);
|
|
return;
|
|
}
|
|
monotonic_t now = monotonic();
|
|
if (is_synthetic_momentum_start_event) now -= ms_to_monotonic_t(momentum_scroll_gesture_detection_timeout_ms);
|
|
if (s.state == PHYSICAL_EVENT_IN_PROGRESS) {
|
|
s.physical_event.displacement.x += ev->unscaled.x;
|
|
s.physical_event.displacement.y += ev->unscaled.y;
|
|
if (stopped) {
|
|
s.physical_event.duration = now - s.physical_event.start;
|
|
s.physical_event.start = 0;
|
|
}
|
|
} else {
|
|
memset(&s.physical_event, 0, sizeof(s.physical_event));
|
|
s.physical_event.start = now;
|
|
}
|
|
if (ev->unscaled.y > 0) s.scale = ev->y_offset / ev->unscaled.y;
|
|
else if (ev->unscaled.x > 0) s.scale = ev->x_offset / ev->unscaled.x;
|
|
if (s.window_id && s.window_id != w->id) cancel_existing_scroll(true);
|
|
if (s.state != PHYSICAL_EVENT_IN_PROGRESS) cancel_existing_scroll(false);
|
|
if (!is_synthetic_momentum_start_event) {
|
|
// Check for change in direction
|
|
double ldx, ldy; last_sample_delta(&ldx, &ldy);
|
|
if (ldx * ev->x_offset < 0 || ldy * ev->y_offset < 0) cancel_existing_scroll(true);
|
|
}
|
|
s.window_id = w->id;
|
|
s.keyboard_modifiers = ev->keyboard_modifiers;
|
|
if (ev->offset_type == GLFW_SCROLL_OFFEST_HIGHRES) {
|
|
if (!is_synthetic_momentum_start_event) add_sample(ev->unscaled.x, ev->unscaled.y, now);
|
|
if (stopped) s.state = is_suitable_for_momentum() ? MOMENTUM_IN_PROGRESS : NONE;
|
|
else s.state = PHYSICAL_EVENT_IN_PROGRESS;
|
|
} else {
|
|
s.state = stopped ? NONE : PHYSICAL_EVENT_IN_PROGRESS;
|
|
}
|
|
if (s.state == MOMENTUM_IN_PROGRESS) start_momentum_scroll(now);
|
|
else _glfwInputScroll(w, ev);
|
|
}
|