Add ability to distinguish device scroll events from inertial scroll events

[edwloef]

Description

On some platforms the system sends its own inertial scrolling events. For example, on MacOS these can be identified by checking whether the event's momentumPhase is set.

However, an application may want to distinguish between "device" scroll events and "synthetic" scroll events. For example, changing the value of a slider or knob by scrolling on it should ideally be free of inertia. I propose adding a is_synthetic: bool field to the MouseWheel event, similar to the KeyboardInput event, and setting that to true for an event that originates from inertial scrolling.

Relevant platforms

No response

[Ph4ntomas]

I think is_synthetic is a bit too limited, and it's hard to see if that would work on other platform.

I'm way more versed in the wayland side of thing, but there, you get the following:

axis_source { wheel, finger, continuous, wheel_tilt }

With this information, an app can decide whether to synthesize its own scroll event (e.g., if the event_source was finger and the event stopped, one could internally decide to trigger inertial scrolling).

A well behaved compositor should only set finger if an actual finger is touching the touchpad surface, but may decide to continue sending synthetic events using the continuous source. However, the continuous source being set doesn't necessarily means momentum-based scrolling events are being synthesized.

In my opinion, it would be better to have an scroll_source enum instead of the binary is_synthetic:

enum ScrollSource {
    Wheel, // a physical wheel was used (e.g. wheel & wheel-tilt wayland event, or a standard (non momentum based) scroll event for macos)
    Finger, // a finger/touchpad gesture is driving the scroll
    Other, // This could be anything else (wayland `continuous`, w3c `wheelevent::momentum`, macos momentum based events)
}

I've put a lot in Other but the enum itself could be more finely defined (e.g. a momentum variant may be warranted since that distinction exists on several platform).

[kchibisov]

I think on Wayland the defacto is client does all the innertial/kinetic scrolling. There's no xniput like synthesis at all, same for pretty much everything.

untill it changed recently ofc, but that's what I remember.

[Ph4ntomas]

I think on Wayland the defacto is client does all the innertial/kinetic scrolling. There's no xniput like synthesis at all, same for pretty much everything.

That's partially true. libinput doesn't do innertial scrolling as the synaptic driver did on x11, and there aren't many compositor level implementation at the moment, but the protocol doesn'd disallow it.

However https://github.com/savonovv/hypr-kinetic-scroll is one such implementation which does properly send the continuous event source for the synthetic events