Scale down MacOS scrolling from event controllers

MacOS trackpad scroll events appear to be of much greater magnitude
than those on other systems. To make them usable, we need to scale
down the scroll deltas. For traditional GTK 3 code,
dt_gui_get_scroll_unit_deltas() took care of this. Unfortunately, this
code depends on the "scroll-event" signal. To make the code GTK 4
ready, we need to handle the "scroll" signal generated by a
GtkEventControllerScroll.

For discrete scrolls, we can handle this transparently via the
dt_gui_connect_scroll_discrete() setup function. This new function is
similar to dt_gui_connect_scroll(). There is no need to call it with
the GTK_EVENT_CONTROLLER_SCROLL_DISCRETE flag, as it adds this
automatically. If darktable is compiled for MacOS, a proxy function
will scale down the scroll events.

Note that this commit doesn't do anything to help scale down scroll
events from a non-discrete GtkEventControllerScroll.

Also: In bauhaus _widget_scroll, actually warn if called an a
non-scroll event or no event rather than having a useless NOP
conditional. Don't free the event in unlikely case we can't retrieve
it.

Also: Update/remove a couple comments. In GTK4 it seems preferable to
target events directly to widgets (as gtk_propagate_event and
gtk_event_controller_handle_event are gone) so don't apologize in
comments for using gtk_widget_event().

Fixes: #20698

Author: dtorop

src/bauhaus/bauhaus.c

@@ -3077,12 +3077,11 @@ static void _widget_scroll(GtkEventControllerScroll *controller,
 {
   GdkEvent *event = gtk_get_current_event();
   if(!event || gdk_event_get_event_type(event) != GDK_SCROLL)
+    dt_print(DT_DEBUG_ALWAYS, "[_widget_scroll] called on non-scroll event");
+  else if(dt_gui_ignore_scroll(&event->scroll))
   {
-    // NOP, should not happen
-  }
-  if(dt_gui_ignore_scroll(&event->scroll))
-  {
-    // hack: GTK3 event controller handlers can't return GDK_EVENT_PROPAGATE
+    // event controller handlers can't propagate events, so synthesize
+    // an event directly to the destination widget
     GtkWidget *sw = gtk_widget_get_ancestor(widget, GTK_TYPE_SCROLLED_WINDOW);
     if(sw)
       gtk_widget_event(sw, event);
@@ -3118,7 +3117,7 @@ static void _widget_scroll(GtkEventControllerScroll *controller,
         _combobox_next_sensitive(w, delta, 0, FALSE);
     }
   }
-  gdk_event_free(event);
+  if(event) gdk_event_free(event);
 }
 
 static gboolean _widget_key_press(GtkWidget *widget, GdkEventKey *event)
@@ -3733,9 +3732,8 @@ static void dt_bh_init(DtBauhausWidget *w)
   dt_gui_connect_motion(w, _widget_motion, _widget_enter, _widget_leave, widget);
 
   GtkEventController *scroll_controller =
-    dt_gui_connect_scroll(w, GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES
-                             | GTK_EVENT_CONTROLLER_SCROLL_DISCRETE,
-                          _widget_scroll, widget);
+    dt_gui_connect_scroll_discrete(w, GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES,
+                                   _widget_scroll, widget);
   // allows for capturing propagated events from other widgets
   gtk_event_controller_set_propagation_phase(scroll_controller, GTK_PHASE_BUBBLE);
 

src/gui/gtk.c

@@ -4668,6 +4668,93 @@ GtkEventController *(dt_gui_connect_scroll)(GtkWidget *widget,
   return controller;
 }
 
+typedef void (*scroll_handler_t)(GtkEventControllerScroll*, gdouble, gdouble, gpointer);
+
+#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)
+{
+  // 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)
+  {
+    h->cur_dx += dx / DT_UI_SCROLL_SMOOTH_DELTA_SCALE;
+    h->cur_dy += dy / DT_UI_SCROLL_SMOOTH_DELTA_SCALE;
+    dx = dy = 0.0;
+    if(fabs(h->cur_dx) >= 1.0)
+    {
+      int steps = trunc(h->cur_dx);
+      h->cur_dx -= steps;
+      dx = steps;
+    }
+    if(fabs(h->cur_dy) >= 1.0)
+    {
+      int steps = trunc(h->cur_dy);
+      h->cur_dy -= steps;
+      dy = steps;
+    }
+  }
+  if(dx != 0.0 || dy != 0.0)
+    h->scroll_callback_real(self, dx, dy, h->scroll_data_real);
+}
+#endif
+
+GtkEventController *(dt_gui_connect_scroll_discrete)(GtkWidget *widget,
+                                                     GtkEventControllerScrollFlags flags,
+                                                     GCallback scroll_callback,
+                                                     gpointer 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;
+  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);
+  return controller;
+#else
+  return dt_gui_connect_scroll(widget,
+                               flags | GTK_EVENT_CONTROLLER_SCROLL_DISCRETE,
+                               (scroll_handler_t)scroll_callback,
+                               data);
+#endif
+}
+
 
 static int busy_nest_count = 0;
 

src/gui/gtk.h

@@ -564,11 +564,6 @@ GtkGesture *(dt_gui_connect_drag)(GtkWidget *widget,
   ASSERT_FUNC_TYPE(drag_update, void(*)(GtkGestureDrag *, double, double, __typeof__(data))), \
   dt_gui_connect_drag(GTK_WIDGET(widget), G_CALLBACK(drag_begin), G_CALLBACK(drag_end), G_CALLBACK(drag_update), (data)))
 
-#define dt_gui_claim(gesture) \
-      gtk_gesture_set_state(GTK_GESTURE(gesture), GTK_EVENT_SEQUENCE_CLAIMED)
-#define dt_gui_deny(gesture) \
-      gtk_gesture_set_state(GTK_GESTURE(gesture), GTK_EVENT_SEQUENCE_DENIED)
-
 GtkEventController *(dt_gui_connect_motion)(GtkWidget *widget,
                                             GCallback motion,
                                             GCallback enter,
@@ -588,6 +583,19 @@ GtkEventController *(dt_gui_connect_scroll)(GtkWidget *widget,
   ASSERT_FUNC_TYPE(scroll, void(*)(GtkEventControllerScroll *, double, double, __typeof__(data))), \
   dt_gui_connect_scroll(GTK_WIDGET(widget), (flags), G_CALLBACK(scroll), (data)))
 
+GtkEventController *(dt_gui_connect_scroll_discrete)(GtkWidget *widget,
+						     GtkEventControllerScrollFlags flags,
+						     GCallback scroll,
+						     gpointer data);
+#define dt_gui_connect_scroll_discrete(widget, flags, scroll, data) ( \
+  ASSERT_FUNC_TYPE(scroll, void(*)(GtkEventControllerScroll *, double, double, __typeof__(data))), \
+  dt_gui_connect_scroll_discrete(GTK_WIDGET(widget), (flags), G_CALLBACK(scroll), (data)))
+
+#define dt_gui_claim(gesture) \
+      gtk_gesture_set_state(GTK_GESTURE(gesture), GTK_EVENT_SEQUENCE_CLAIMED)
+#define dt_gui_deny(gesture) \
+      gtk_gesture_set_state(GTK_GESTURE(gesture), GTK_EVENT_SEQUENCE_DENIED)
+
 // GTK4 gtk_event_controller_get_current_event_state(GTK_EVENT_CONTROLLER(controller));
 #define dt_modifier_eq(controller, mask)\
   dt_modifier_is(dt_key_modifier_state(), mask)

src/libs/histogram.c

@@ -486,7 +486,6 @@ static void _eventbox_scroll_callback(GtkEventControllerScroll* self,
                       GDK_SHIFT_MASK | GDK_MOD1_MASK))
     {
       // bubble to adjusting the overall widget size
-      // FIXME: use gtk_event_controller_handle_event()
       gtk_widget_event(s->scope_draw, event);
     }
     else if(s->highlight != DT_SCOPES_HIGHLIGHT_NONE)
@@ -863,9 +862,8 @@ void gui_init(dt_lib_module_t *self)
 
   // FIXME: add (optional) propagation phase argument to dt_gui_connect_*()
   GtkEventController *scroll_controller =
-    dt_gui_connect_scroll(eventbox, GTK_EVENT_CONTROLLER_SCROLL_VERTICAL
-                                    | GTK_EVENT_CONTROLLER_SCROLL_DISCRETE,
-                          _eventbox_scroll_callback, s);
+    dt_gui_connect_scroll_discrete(eventbox, GTK_EVENT_CONTROLLER_SCROLL_VERTICAL,
+                                   _eventbox_scroll_callback, s);
   gtk_event_controller_set_propagation_phase(scroll_controller, GTK_PHASE_CAPTURE);
   // use GTK_PHASE_TARGET to capture enter/leave events, as
   // enter/leave events apparently not bubbled in GTK < 3.24.43.