gtk: rework MacOS-friendly attenuated smooth scrolling

Attenuate smooth scroll delta by calculating delta ** compression,
which will reduce large deltas (apparently found in momentum-based
scrolling on MacOS). On MacOS, instead of scaling down smooth scroll
by DT_UI_SCROLL_SMOOTH_DELTA_SCALE, scale down by 0.25.

It appears that for MacOS, we do not receive "scroll-begin" and
"scroll-end" events for trackpad events, so instead exam the GdkEvent,
which brings this code closer to extant working
dt_gui_get_scroll_unit_deltas().

Don't use GTK_EVENT_CONTROLLER_SCROLL_DISCRETE flag, regardless of OS,
as _scroll_discrete_proxy() will accumulate smooth scroll
events. Don't bother to handle scroll stop events as we won't receive
them from GTK and it is OK to not clear accumulated scroll on stop.

Simplify storage for proxy discrete scroll handler. Don't use an
allocated struct. We can keep dx/dy globally, as we do not expect
multiple simultaneous scrolls of multiple widgets. Store real scroll
handler as GObject data.

Note that the exponential attenuation math is on recommendation from
ChatGPT, based on very little actual data from MacOS.

Author: dtorop

src/gui/gtk.c

@@ -4669,90 +4669,73 @@ GtkEventController *(dt_gui_connect_scroll)(GtkWidget *widget,
 }
 
 typedef void (*scroll_handler_t)(GtkEventControllerScroll*, gdouble, gdouble, gpointer);
+static gdouble _scroll_discrete_dx = 0.0;
+static gdouble _scroll_discrete_dy = 0.0;
+static const char *_scroll_discrete_real_handler_key = "real-scroll-discrete-handler";
 
-#ifdef GDK_WINDOWING_QUARTZ
-typedef struct _scroll_handler_proxy_t
-{
-  scroll_handler_t scroll_callback_real;
-  gpointer scroll_data_real;
-  gboolean smooth_scroll;
-  gdouble cur_dx;
-  gdouble cur_dy;
-} _scroll_handler_proxy_t;
-
-static void _scroll_discrete_begin(GtkEventControllerScroll* self,
-                                   _scroll_handler_proxy_t *h)
-{
-  // scroll-begin is generated by events from trackpoint or touchpad
-  h->smooth_scroll = TRUE;
-  h->cur_dx = h->cur_dy = 0.0;
-}
-
-static void _scroll_discrete_end(GtkEventControllerScroll* self,
-                                 _scroll_handler_proxy_t *h)
-{
-  h->smooth_scroll = FALSE;
-}
-
-static void _scroll_discrete_proxy(GtkEventControllerScroll* self,
-                                    gdouble dx,
-                                    gdouble dy,
-                                    _scroll_handler_proxy_t *h)
+static void _scroll_discrete_proxy(GtkEventControllerScroll* controller,
+                                   gdouble dx,
+                                   gdouble dy,
+                                   gpointer user_data)
 {
-  // Even though the event controller has already accumulated smooth
-  // scroll events to discrete dx/dy, MacOS smooth scrolling events
-  // are too fast so scale them down via another accumulating stage.
-  // For GTK3, we handled this via dt_gui_get_scroll_unit_deltas(),
-  // but to be GTK4 ready, use this code, which is heavily modeled on
-  // GTK's gtk_event_controller_scroll_handle_event()
-  if(h->smooth_scroll)
+  GdkEvent *event = gtk_get_current_event();
+  if(!event) return;
+  if(gdk_event_get_event_type(event) == GDK_SCROLL
+     && event->scroll.direction == GDK_SCROLL_SMOOTH
+     // avoid double counting real and emulated events when receiving smooth scrolls
+     && !gdk_event_get_pointer_emulated(event))
   {
-    h->cur_dx += dx / DT_UI_SCROLL_SMOOTH_DELTA_SCALE;
-    h->cur_dy += dy / DT_UI_SCROLL_SMOOTH_DELTA_SCALE;
+    // MacOS scrolling is apparently distance-based, so can produce a
+    // range of large/small deltas. For GTK3, we accumulating &
+    // attenuating via dt_gui_get_scroll_unit_deltas(). For GTK4-ready
+    // "scroll" events, work as discrete scrolling implemented in
+    // gtk_event_controller_scroll_handle_event() but also attenuate
+#ifdef GDK_WINDOWING_QUARTZ
+    const double scale = 0.25;
+    const double compression = 0.7;
+#else
+    const double scale = 0.95;
+    const double compression = 0.9;
+#endif
+    _scroll_discrete_dx += copysign(pow(fabs(dx), compression), dx * scale);
+    _scroll_discrete_dy += copysign(pow(fabs(dy), compression), dy * scale);
     dx = dy = 0.0;
-    if(fabs(h->cur_dx) >= 1.0)
+    if(fabs(_scroll_discrete_dx) >= 1.0)
     {
-      int steps = trunc(h->cur_dx);
-      h->cur_dx -= steps;
+      int steps = trunc(_scroll_discrete_dx);
+      _scroll_discrete_dx -= steps;
       dx = steps;
     }
-    if(fabs(h->cur_dy) >= 1.0)
+    if(fabs(_scroll_discrete_dy) >= 1.0)
     {
-      int steps = trunc(h->cur_dy);
-      h->cur_dy -= steps;
+      int steps = trunc(_scroll_discrete_dy);
+      _scroll_discrete_dy -= steps;
       dy = steps;
     }
   }
   if(dx != 0.0 || dy != 0.0)
-    h->scroll_callback_real(self, dx, dy, h->scroll_data_real);
+  {
+    scroll_handler_t real_handler =
+      g_object_get_data(G_OBJECT(controller), _scroll_discrete_real_handler_key);
+    real_handler(controller, dx, dy, user_data);
+  }
+  gdk_event_free(event);
 }
-#endif
 
 GtkEventController *(dt_gui_connect_scroll_discrete)(GtkWidget *widget,
                                                      GtkEventControllerScrollFlags flags,
                                                      GCallback scroll_callback,
-                                                     gpointer data)
+                                                     gpointer user_data)
 {
-  // on macOS, set up a proxy to scale smooth scroll deltas
-#ifdef GDK_WINDOWING_QUARTZ
-  _scroll_handler_proxy_t *const h = dt_calloc1_align_type(_scroll_handler_proxy_t);
-  h->scroll_callback_real = (scroll_handler_t)scroll_callback;
-  h->scroll_data_real = data;
+  // Use proxy, not GTK discrete scrolling, to attenuate. We could use
+  // GTK discrete scrolling for non-MacOS, but it makes it hard to
+  // test if a chunk of code is particular to one OS.
   GtkEventController *controller =
-    dt_gui_connect_scroll(widget,
-                          flags | GTK_EVENT_CONTROLLER_SCROLL_DISCRETE,
-                          _scroll_discrete_proxy,
-                          h);
-  g_object_weak_ref(G_OBJECT(widget), (GWeakNotify) dt_free_align_ptr, h);
-  g_signal_connect(controller, "scroll-begin", G_CALLBACK(_scroll_discrete_begin), h);
-  g_signal_connect(controller, "scroll-end", G_CALLBACK(_scroll_discrete_end), h);
+    dt_gui_connect_scroll(widget, flags & ~GTK_EVENT_CONTROLLER_SCROLL_DISCRETE,
+                          _scroll_discrete_proxy, user_data);
+  g_object_set_data(G_OBJECT(controller),
+                    _scroll_discrete_real_handler_key, scroll_callback);
   return controller;
-#else
-  return dt_gui_connect_scroll(widget,
-                               flags | GTK_EVENT_CONTROLLER_SCROLL_DISCRETE,
-                               (scroll_handler_t)scroll_callback,
-                               data);
-#endif
 }