scopes: cleaner exposure change code and bauhaus interactions

Decouple (as much as possible) the exposure change drag/scroll
behavior from bauhaus internals. Within the scopes drawable, use a
GtkGestureDrag to handle drag events. Pass minimal event
information (delta, # of clicks, modifiers) to the handler code in
exposure iop. The exposure handler now uses the regular bauhaus
API (e.g. dt_bauhaus_slider_set()) to adjust slider values.

Dragging within the scopes widget is now much closer to how it is
handled in the colorequal iop. The exception is that this commit
doesn't use gtk_widget_event() to handle scroll events, so as not to
need to rewrite the event to account for changes in scroll direction.

Previously things were much more entangled: On a user interaction, the
scope would pass either an GtkGestureSingle, GtkEventControllerMotion,
or GtkEventControllerScroll to the exposure event handler. That event
handler would then inject the gesture/event directly into the bauhaus
press/release/motion/scroll code.

Separating things out has these benefits:

- Ease update to GTK4 by no longer require that scope, exposure, and
  bauhaus use the same event/gesture handling.
- Remove hack to handle exposure changes via scope when the exposure
  iop widgets hasn't yet been allocated.
- Acknowledges that the scopes drag regions are a widget with their
  own behavior which is different from the behavior of a bauhaus slider.
- Allow for removing the darktable.bauhaus->scroll(), ->press(),
  ->motion() and ->release() interface which was only used by scopes.

Dragging using speed multiplier modifiers (control/shift) continues to
work. Unlike bauhaus sliders, though, dragging in the scope with speed
multipliers doesn't adjust values in discrete steps, for simplicity of
code.

This commit adds a couple helpers in gtk.h & gtk.c:

- dt_gui_connect_drag(), analog to dt_gui_connect_click()
- dt_gui_deny(gesture), analog to dt_gui_claim()

This commit also:

- fixes a bug which caused all drags to effect the exposure slider,
  even when they started in the black point slider region
- removes verbose warning output in split mode when drag from waveform
  to vectorscope
- fixes double negation of direction when scrolling black point
- removes the broken behavior by which right clicking in the scopes
  widget would open a bauhaus exposure/blackpoint change popup which
  was often inaccessible as it was not under the pointer

Author: dtorop

src/bauhaus/bauhaus.c

@@ -3706,12 +3706,6 @@ static void dt_bh_class_init(DtBauhausWidgetClass *class)
   widget_class->get_preferred_height = _widget_get_preferred_height;
   // widget_class->measure = _widget_measure;
   G_OBJECT_CLASS(class)->finalize = _widget_finalize;
-
-  // for histogram -> exposure proxy
-  bh->press = _widget_button_press;
-  bh->release = _widget_button_release;
-  bh->motion = _widget_motion;
-  bh->scroll = _widget_scroll;
 }
 
 static void dt_bh_init(DtBauhausWidget *w)

src/bauhaus/bauhaus.h

@@ -154,12 +154,6 @@ typedef struct dt_bauhaus_t
   GdkRGBA graph_bg, graph_exterior, graph_border, graph_fg, graph_grid, graph_fg_active, graph_overlay, inset_histogram;
   GdkRGBA graph_colors[3];               // primaries
   GdkRGBA colorlabels[DT_COLORLABELS_LAST];
-
-  // for use by histogram -> exposure proxy
-  void (*press)(GtkGestureSingle*, int, double, double, GtkWidget*);
-  void (*release)(GtkGestureSingle*, int, double, double, GtkWidget*);
-  void (*motion)(GtkEventControllerMotion*, double, double, GtkWidget*);
-  void (*scroll)(GtkEventControllerScroll*, double, double, GtkWidget*);
 } dt_bauhaus_t;
 
 #define DT_BAUHAUS_SPACE 0

src/develop/develop.c

@@ -3334,13 +3334,12 @@ float dt_dev_exposure_get_black(dt_develop_t *dev)
   return instance && instance->get_black  && instance->module->enabled ? instance->get_black(instance->module) : 0.0f;
 }
 
-void dt_dev_exposure_handle_event(GtkEventController *controller,
-                                  int n_press, gdouble x, gdouble delta,
-                                  const gboolean blackwhite)
+void dt_dev_exposure_handle_event(int n_press, gdouble delta,
+                                  GdkModifierType state,
+                                  const gboolean is_blackpoint)
 {
   if(darktable.develop->proxy.exposure.handle_event)
-    darktable.develop->proxy.exposure.handle_event(controller, n_press, x, delta,
-                                                   blackwhite);
+    darktable.develop->proxy.exposure.handle_event(n_press, delta, state, is_blackpoint);
 }
 
 void dt_dev_modulegroups_set(dt_develop_t *dev,

src/develop/develop.h

@@ -103,7 +103,7 @@ typedef struct dt_dev_proxy_exposure_t
   float (*get_exposure)(struct dt_iop_module_t *exp);
   float (*get_effective_exposure)(struct dt_iop_module_t *exp);
   float (*get_black)(struct dt_iop_module_t *exp);
-  void (*handle_event)(GtkEventController*, int, gdouble, gdouble, const gboolean);
+  void (*handle_event)(int, gdouble, GdkModifierType, const gboolean);
 } dt_dev_proxy_exposure_t;
 
 struct dt_dev_pixelpipe_t;
@@ -495,9 +495,9 @@ float dt_dev_exposure_get_effective_exposure(dt_develop_t *dev);
 /** get exposure black level */
 float dt_dev_exposure_get_black(dt_develop_t *dev);
 
-void dt_dev_exposure_handle_event(GtkEventController *controller,
-                                  int n_press, gdouble x, gdouble delta,
-                                  const gboolean blackwhite);
+void dt_dev_exposure_handle_event(int n_press, gdouble delta,
+                                  GdkModifierType state,
+                                  const gboolean is_blackpoint);
 
 /*
  * modulegroups plugin hooks

src/gui/gtk.c

@@ -4617,6 +4617,24 @@ GtkGestureSingle *(dt_gui_connect_click)(GtkWidget *widget,
   return (GtkGestureSingle *)gesture;
 }
 
+GtkGesture *(dt_gui_connect_drag)(GtkWidget *widget,
+                                  GCallback drag_begin,
+                                  GCallback drag_end,
+                                  GCallback drag_update,
+                                  gpointer data)
+{
+  GtkGesture *gesture = gtk_gesture_drag_new(widget);
+  g_object_weak_ref(G_OBJECT (widget), (GWeakNotify) g_object_unref, gesture);
+  // GTK4 GtkGesture *gesture = gtk_gesture_drag_new();
+  //      gtk_widget_add_controller(widget, GTK_EVENT_CONTROLLER(gesture));
+
+  if(drag_begin) g_signal_connect(gesture, "drag-begin", G_CALLBACK(drag_begin), data);
+  if(drag_end) g_signal_connect(gesture, "drag-end", G_CALLBACK(drag_end), data);
+  if(drag_update) g_signal_connect(gesture, "drag-update", G_CALLBACK(drag_update), data);
+
+  return gesture;
+}
+
 GtkEventController *(dt_gui_connect_motion)(GtkWidget *widget,
                                             GCallback motion,
                                             GCallback enter,

src/gui/gtk.h

@@ -553,8 +553,21 @@ GtkGestureSingle *(dt_gui_connect_click)(GtkWidget *widget,
 #define dt_gui_connect_click_all(widget, pressed, released, data) \
   gtk_gesture_single_set_button(dt_gui_connect_click(widget, pressed, released, data), 0)
 
+GtkGesture *(dt_gui_connect_drag)(GtkWidget *widget,
+                                  GCallback drag_begin,
+                                  GCallback drag_end,
+				  GCallback drag_update,
+                                  gpointer data);
+#define dt_gui_connect_drag(widget, drag_begin, drag_end, drag_update, data) ( \
+  ASSERT_FUNC_TYPE(drag_begin, void(*)(GtkGestureDrag *, double, double, __typeof__(data))), \
+  ASSERT_FUNC_TYPE(drag_end, void(*)(GtkGestureDrag *, double, double, __typeof__(data))), \
+  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,

src/iop/exposure.c

@@ -825,48 +825,36 @@ static float _exposure_proxy_get_effective_exposure(dt_iop_module_t *self)
   return g->effective_exposure;
 }
 
-static void _exposure_proxy_handle_event(GtkEventController *controller,
-                                         int n_press,
-                                         gdouble x, gdouble delta,
-                                         const gboolean blackwhite)
+static void _exposure_proxy_handle_event(int n_press,
+                                         gdouble delta,
+                                         GdkModifierType state,
+                                         const gboolean is_blackpoint)
 {
-  dt_iop_module_t *self = darktable.develop->proxy.exposure.module;
+  const dt_iop_module_t *const self = darktable.develop->proxy.exposure.module;
   if(self && self->gui_data)
   {
-    static gboolean black = FALSE;
-    if((n_press > 0 && GTK_IS_GESTURE_SINGLE(controller)) // button press
-       || !n_press) // scroll event
-      black = blackwhite;
-
-    if(black)
-      x *= -1;
-
-    const dt_iop_exposure_params_t *p = self->params;
-    dt_iop_exposure_gui_data_t *g = self->gui_data;
-    GtkWidget *widget = black ? g->black :
-                        p->mode == EXPOSURE_MODE_DEFLICKER
-                      ? g->deflicker_target_level : g->exposure;
-    if(!n_press)
-      darktable.bauhaus->scroll(GTK_EVENT_CONTROLLER_SCROLL(controller), 0.0, delta, widget);
+    const dt_iop_exposure_params_t *const p = self->params;
+    const dt_iop_exposure_gui_data_t *const g = self->gui_data;
+    GtkWidget *const widget =
+      is_blackpoint ? g->black : (p->mode == EXPOSURE_MODE_DEFLICKER
+                                  ? g->deflicker_target_level : g->exposure);
+    const float val = dt_bauhaus_slider_get(widget);
+    const float accel = dt_accel_get_speed_multiplier(widget, state);
+    if(is_blackpoint)
+      delta = -delta;
+
+    if(n_press == 2)
+      dt_bauhaus_widget_reset(widget);
+    else if(!n_press)
+    { // scroll
+      const float step = dt_bauhaus_slider_get_step(widget);
+      dt_bauhaus_slider_set(widget, val + delta * step * accel);
+    }
     else
-    {
-      // ignores the quad width, but is accurate enough
-      const int slider_width = gtk_widget_get_allocated_width(widget);
-      // FIXME: it would be nice to fetch scope_height when using waveform
-      const int scope_width =
-        gtk_widget_get_allocated_width(darktable.lib->proxy.histogram.module->widget);
-      // bauhaus scales motion to slider widget, but we want to scale
-      // proportional to the scope widget, particularly when the
-      // slider has not been allocated and has a width of 1 (which can
-      // happen if its module group has not yet been displayed)
-      x = x * slider_width / scope_width;
-      if(GTK_IS_GESTURE_SINGLE(controller))
-        if(n_press > 0)
-          darktable.bauhaus->press(GTK_GESTURE_SINGLE(controller), n_press, x, 0, widget);
-        else
-          darktable.bauhaus->release(GTK_GESTURE_SINGLE(controller), -n_press, x, 0, widget);
-      else
-        darktable.bauhaus->motion(GTK_EVENT_CONTROLLER_MOTION(controller), x, 0, widget);
+    { // drag
+      const float s_min = dt_bauhaus_slider_get_soft_min(widget);
+      const float s_max = dt_bauhaus_slider_get_soft_max(widget);
+      dt_bauhaus_slider_set(widget, val + delta * (s_max - s_min) * accel);
     }
 
     gchar *text = dt_bauhaus_slider_get_text(widget, dt_bauhaus_slider_get(widget));

src/libs/histogram.c

@@ -303,72 +303,91 @@ void lib_histogram_update_tooltip(const dt_scopes_t *const scopes)
   g_free(tip);
 }
 
-static void _drawable_button_press(GtkGestureSingle *gesture,
-                                   int n_press,
-                                   double x,
-                                   double y,
-                                   dt_scopes_t *s)
+static void _drawable_drag_begin(GtkGestureDrag* gesture,
+                                 gdouble start_x,
+                                 gdouble start_y,
+                                 dt_scopes_t *s)
 {
   if(s->highlight != DT_SCOPES_HIGHLIGHT_NONE
-     && dt_scopes_func_exists(s->cur_mode, get_exposure_pos))
+     && dt_scopes_func_exists(s->cur_mode, get_exposure_delta)
+     && dt_gui_claim(gesture))
   {
     dt_control_change_cursor("grabbing");
-    s->dragging = (n_press == 1);
-    const double pos = dt_scopes_call(s->cur_mode, get_exposure_pos, x, y);
-    dt_dev_exposure_handle_event(GTK_EVENT_CONTROLLER(gesture), n_press, pos, 0.0,
-                                 s->highlight == DT_SCOPES_HIGHLIGHT_BLACK_POINT);
+    s->last_offset_x = s->last_offset_y = 0.0;
+    s->dragging = TRUE;
   }
+  else
+    dt_gui_deny(gesture);
 }
 
-static void _drawable_button_release(GtkGestureSingle *gesture,
-                                     int n_press,
-                                     double x,
-                                     double y,
-                                     dt_scopes_t *s)
+static void _drawable_drag_end(GtkGestureDrag* g, gdouble ox, gdouble oy, dt_scopes_t *s)
 {
-  if(s->highlight != DT_SCOPES_HIGHLIGHT_NONE)
+  dt_control_change_cursor("grab");
+  s->dragging = FALSE;
+}
+
+static void _drawable_drag_update(GtkGestureDrag* gesture,
+                                  gdouble offset_x,
+                                  gdouble offset_y,
+                                  dt_scopes_t *s)
+{
+  dt_scopes_mode_t *const cur_mode = s->cur_mode;
+  // GTK4: use gtk_event_controller_get_current_event_state()
+  GdkEvent *event = gtk_get_current_event();
+  if(!event) return;
+  if(gdk_event_get_event_type(event) == GDK_MOTION_NOTIFY)
   {
-    dt_control_change_cursor("grab");
-    s->dragging = FALSE;
-    dt_dev_exposure_handle_event(GTK_EVENT_CONTROLLER(gesture), -n_press, x, 0.0, FALSE);
+    // at any time user may user a modifier key to adjust speed
+    // multiplier, so calculate delta since last move, rather than
+    // offset since drag start
+    const gdouble ox = offset_x - s->last_offset_x;
+    const gdouble oy = offset_y - s->last_offset_y;
+    const double delta = dt_scopes_call(cur_mode, get_exposure_delta, ox, oy);
+    dt_dev_exposure_handle_event(1, delta, event->motion.state,
+                                 s->highlight == DT_SCOPES_HIGHLIGHT_BLACK_POINT);
+    s->last_offset_x = offset_x;
+    s->last_offset_y = offset_y;
   }
+  gdk_event_free(event);
+}
+
+static void _drawable_button_press(GtkGestureSingle *gesture,
+                                   int n_press,
+                                   double x,
+                                   double y,
+                                   dt_scopes_t *s)
+{
+  if(s->highlight != DT_SCOPES_HIGHLIGHT_NONE && n_press == 2 && dt_gui_claim(gesture))
+    dt_dev_exposure_handle_event(2, 0.0, 0,
+                                 s->highlight == DT_SCOPES_HIGHLIGHT_BLACK_POINT);
 }
 
 static void _drawable_motion(GtkEventControllerMotion *controller,
                              double x,
                              double y,
                              dt_scopes_t *s)
 {
-  dt_scopes_mode_t *const cur_mode = s->cur_mode;
-  if(s->dragging
-     && s->highlight != DT_SCOPES_HIGHLIGHT_NONE
-     && dt_scopes_func_exists(cur_mode, get_exposure_pos))
-  {
-    const double pos = dt_scopes_call(cur_mode, get_exposure_pos, x, y);
-    dt_dev_exposure_handle_event(GTK_EVENT_CONTROLLER(controller), 1, pos, 0.0, FALSE);
-  }
+  if(s->dragging) return;
+
+  GtkAllocation allocation;
+  gtk_widget_get_allocation(s->scope_draw, &allocation);
+  const double posx = x / (double)(allocation.width);
+  const double posy = y / (double)(allocation.height);
+  const dt_scopes_highlight_t prior_highlight = s->highlight;
+
+  if(dt_scopes_func_exists(s->cur_mode, get_highlight))
+    s->highlight = dt_scopes_call(s->cur_mode, get_highlight, posx, posy);
   else
+    s->highlight = DT_SCOPES_HIGHLIGHT_NONE;
+
+  if(prior_highlight != s->highlight)
   {
-    GtkAllocation allocation;
-    gtk_widget_get_allocation(s->scope_draw, &allocation);
-    const double posx = x / (double)(allocation.width);
-    const double posy = y / (double)(allocation.height);
-    const dt_scopes_highlight_t prior_highlight = s->highlight;
-
-    if(dt_scopes_func_exists(cur_mode, get_highlight))
-      s->highlight = dt_scopes_call(cur_mode, get_highlight, posx, posy);
+    lib_histogram_update_tooltip(s);
+    dt_scopes_refresh(s);
+    if(s->highlight == DT_SCOPES_HIGHLIGHT_NONE)
+      dt_control_change_cursor("default");
     else
-      s->highlight = DT_SCOPES_HIGHLIGHT_NONE;
-
-    if(prior_highlight != s->highlight)
-    {
-      lib_histogram_update_tooltip(s);
-      dt_scopes_refresh(s);
-      if(s->highlight == DT_SCOPES_HIGHLIGHT_NONE)
-        dt_control_change_cursor("default");
-      else
-        dt_control_change_cursor("grab");
-    }
+      dt_control_change_cursor("grab");
   }
 }
 
@@ -474,10 +493,11 @@ static void _eventbox_scroll_callback(GtkEventControllerScroll* self,
     {
       // FIXME: should scroll for exposure change be handled by each scope, rather than here?
       // FIXME: should handle horizontal scrolling as well?
+      // FIXME: should handle smooth scrolling rather than discrete?
       // FIXME: should scrolling of scope be handled in the drawable rather than
       //        the eventbox.
-      const gboolean black = s->highlight == DT_SCOPES_HIGHLIGHT_BLACK_POINT;
-      dt_dev_exposure_handle_event(GTK_EVENT_CONTROLLER(self), 0, 0, black ? -dy : dy, black);
+      dt_dev_exposure_handle_event(0, dy, event->scroll.state,
+                                   s->highlight == DT_SCOPES_HIGHLIGHT_BLACK_POINT);
     }
     else
     {
@@ -831,8 +851,9 @@ void gui_init(dt_lib_module_t *self)
   // FIXME: why does cursor motion over buttons trigger multiple draw callbacks?
   g_signal_connect(G_OBJECT(s->scope_draw),
                    "draw", G_CALLBACK(_drawable_draw_callback), s);
-  dt_gui_connect_click_all(s->scope_draw, _drawable_button_press,
-                           _drawable_button_release, s);
+  dt_gui_connect_drag(s->scope_draw, _drawable_drag_begin, _drawable_drag_end,
+                      _drawable_drag_update, s);
+  dt_gui_connect_click(s->scope_draw, _drawable_button_press, NULL, s);
   dt_gui_connect_motion(s->scope_draw, _drawable_motion, NULL,
                         _drawable_leave, s);
   // constrain height of button_box_right to s->scope_draw, necessary

src/libs/scopes.h

@@ -95,9 +95,11 @@ typedef struct dt_scopes_functions_t
   dt_scopes_highlight_t (*get_highlight)(const struct dt_scopes_mode_t *const self,
                                          const double posx,
                                          const double posy);
-  double (*get_exposure_pos)(const struct dt_scopes_mode_t *const self,
-                             const double x,
-                             const double y);
+  // returns 0 <= pos <= 1 where a pos of 1 is a drag across the full
+  // width/height of the scope (depending on mode exposure drag axis)
+  double (*get_exposure_delta)(const struct dt_scopes_mode_t *const self,
+                               const double offset_x,
+                               const double offset_y);
   void (*append_to_tooltip)(const struct dt_scopes_mode_t *const self,
                             gchar **tip);
   void (*eventbox_scroll)(struct dt_scopes_mode_t *const self,
@@ -139,7 +141,8 @@ typedef struct dt_scopes_t
   int update_counter;                           // most recent pixelpipe vs mode data
   dt_scopes_highlight_t highlight;              // depends on mouse position
   scopes_channels_t channels;                   // display state chosen by RGB buttons
-  gboolean dragging;                            // pre-GtkGestureDrag hack
+  gboolean dragging;                            // to block motion handling during drag
+  gdouble last_offset_x, last_offset_y;         // for drag handling
   // UI elements
   GtkWidget *overlay;                           // GtkOverlay -- scope and buttons
   GtkWidget *button_box_left;                   // GtkBox -- scope mode buttons