diff options
| -rw-r--r-- | demos/gtk-demo/listview_applauncher.c | 2 | ||||
| -rw-r--r-- | gtk/gtkgesture.c | 68 | ||||
| -rw-r--r-- | gtk/gtkgestureprivate.h | 1 | ||||
| -rw-r--r-- | gtk/gtkgesturescroll.c | 215 | ||||
| -rw-r--r-- | gtk/gtkgesturescroll.h | 46 | ||||
| -rw-r--r-- | gtk/gtkgesturescrollprivate.h | 35 | ||||
| -rw-r--r-- | gtk/gtkgesturesingle.c | 1 | ||||
| -rw-r--r-- | gtk/gtkscrolledwindow.c | 53 | ||||
| -rw-r--r-- | gtk/gtkwidget.c | 1 | ||||
| -rw-r--r-- | gtk/meson.build | 2 |
10 files changed, 398 insertions, 26 deletions
diff --git a/demos/gtk-demo/listview_applauncher.c b/demos/gtk-demo/listview_applauncher.c index 87119d12e1..10cbc35ebe 100644 --- a/demos/gtk-demo/listview_applauncher.c +++ b/demos/gtk-demo/listview_applauncher.c @@ -53,7 +53,7 @@ setup_listitem_cb (GtkListItemFactory *factory, swindow = gtk_scrolled_window_new (); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), - GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER); + GTK_POLICY_EXTERNAL, GTK_POLICY_NEVER); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (swindow), box); gtk_widget_set_size_request (box, 1000, 200); diff --git a/gtk/gtkgesture.c b/gtk/gtkgesture.c index d17855957f..5f804fdab7 100644 --- a/gtk/gtkgesture.c +++ b/gtk/gtkgesture.c @@ -255,7 +255,7 @@ _gtk_gesture_get_n_scroll_points (GtkGesture *gesture, gdk_scroll_event_is_stop (data->event))) return 0; - return 1; + return 2; } static guint @@ -346,10 +346,16 @@ gtk_gesture_check_impl (GtkGesture *gesture) { GtkGesturePrivate *priv; guint n_points; + GdkEvent *event; priv = gtk_gesture_get_instance_private (gesture); n_points = _gtk_gesture_get_n_physical_points (gesture, TRUE); + event = gtk_gesture_get_last_event (gesture, priv->last_sequence); + + if (event && gdk_event_get_event_type (event) == GDK_TOUCHPAD_HOLD) + return n_points >= 1 && n_points <= priv->n_points; + return n_points == priv->n_points; } @@ -393,10 +399,21 @@ _gtk_gesture_has_matching_touchpoints (GtkGesture *gesture) { GtkGesturePrivate *priv = gtk_gesture_get_instance_private (gesture); guint active_n_points, current_n_points; + GdkEvent *event; current_n_points = _gtk_gesture_get_n_physical_points (gesture, FALSE); active_n_points = _gtk_gesture_get_n_physical_points (gesture, TRUE); + event = gtk_gesture_get_last_event (gesture, priv->last_sequence); + + if (event && gdk_event_get_event_type (event) == GDK_TOUCHPAD_HOLD) + { + return (active_n_points <= priv->n_points && + active_n_points >= 1 && + current_n_points <= priv->n_points && + current_n_points >= 1); + } + return (active_n_points == priv->n_points && current_n_points == priv->n_points); } @@ -449,8 +466,8 @@ _update_touchpad_deltas (PointData *data) { gdk_scroll_event_get_deltas (event, &dx, &dy); - data->accum_dx -= dx; - data->accum_dy -= dy; + data->accum_dx += dx; + data->accum_dy += dy; } } @@ -488,7 +505,7 @@ _gtk_gesture_update_point (GtkGesture *gesture, GdkEventSequence *sequence; GtkGesturePrivate *priv; GdkDevice *device; - gboolean existed, touchpad, scrolling; + gboolean existed, touchpad, scrolling, hold; PointData *data; device = gdk_event_get_device (event); @@ -498,10 +515,30 @@ _gtk_gesture_update_point (GtkGesture *gesture, priv = gtk_gesture_get_instance_private (gesture); touchpad = EVENT_IS_TOUCHPAD_GESTURE (event); + hold = gdk_event_get_event_type (event) == GDK_TOUCHPAD_HOLD; scrolling = gdk_event_get_event_type (event) == GDK_SCROLL; if (add) { + gboolean was_scrolling; + + /* FIXME if it was already claimed, set the thing */ + was_scrolling = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (device), + "gtk-gesture-is-device-scrolling")); + + /* The device changes when transitioning from hold to scrolling */ + if (scrolling && priv->touchpad && !was_scrolling) + { + priv->device = device; + priv->touchpad = touchpad; + priv->scrolling = scrolling; + + if (gtk_gesture_get_sequence_state (gesture, NULL) == GTK_EVENT_SEQUENCE_DENIED) + g_object_set_data (G_OBJECT (device), + "gtk-gesture-is-device-scrolling", + GINT_TO_POINTER (TRUE)); + } + /* If the event happens with the wrong device, or * on the wrong window, ignore. */ @@ -511,9 +548,7 @@ _gtk_gesture_update_point (GtkGesture *gesture, /* Make touchpad and touchscreen gestures mutually exclusive */ if ((touchpad || scrolling) && g_hash_table_size (priv->points) > 0) return FALSE; - else if (!touchpad && priv->touchpad) - return FALSE; - else if (!scrolling && priv->scrolling) + else if (!touchpad && priv->touchpad && !scrolling) return FALSE; } else if (!priv->device) @@ -578,9 +613,11 @@ _gtk_gesture_check_empty (GtkGesture *gesture) if (g_hash_table_size (priv->points) == 0) { - if (priv->scrolling) + if (priv->scrolling) { + g_print ("%p Removing is-scrolling on %s\n", gesture, gdk_device_get_name (priv->device)); g_object_steal_data (G_OBJECT (priv->device), "gtk-gesture-is-device-scrolling"); + } priv->device = NULL; priv->touchpad = FALSE; @@ -600,9 +637,13 @@ _gtk_gesture_remove_point (GtkGesture *gesture, device = gdk_event_get_device (event); priv = gtk_gesture_get_instance_private (gesture); + g_print ("%p remove point\n", gesture); + if (priv->device != device) return; + g_print ("%p remove point device matches\n", gesture); + g_hash_table_remove (priv->points, sequence); _gtk_gesture_check_empty (gesture); } @@ -691,7 +732,7 @@ gtk_gesture_handle_event (GtkEventController *controller, GdkTouchpadGesturePhase phase = 0; GdkModifierType state; GtkWidget *target; - gboolean was_scrolling, is_scroll_stop; + gboolean was_scrolling = FALSE, is_scroll_stop = FALSE; source_device = gdk_event_get_device (event); @@ -712,7 +753,7 @@ gtk_gesture_handle_event (GtkEventController *controller, if (source != GDK_SOURCE_TOUCHPAD && source != GDK_SOURCE_TRACKPOINT) - return FALSE; + return FALSE; // FIXME is_scroll_stop = gdk_scroll_event_is_stop (event); was_scrolling = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (source_device), @@ -731,10 +772,14 @@ gtk_gesture_handle_event (GtkEventController *controller, (event_type == GDK_TOUCHPAD_HOLD && phase == GDK_TOUCHPAD_GESTURE_PHASE_BEGIN) || (event_type == GDK_SCROLL && !priv->scrolling && !is_scroll_stop && !was_scrolling)) { - if ((event_type == GDK_TOUCHPAD_PINCH || event_type == GDK_TOUCHPAD_SWIPE) && + if ((event_type == GDK_TOUCHPAD_PINCH || + event_type == GDK_TOUCHPAD_SWIPE || + event_type == GDK_TOUCHPAD_HOLD || + event_type == GDK_SCROLL) && _gtk_gesture_has_matching_touchpoints (gesture)) g_clear_handle_id (&priv->hold_timeout_id, g_source_remove); + g_print ("%p calling add, was scrolling? %d %s\n", gesture, was_scrolling, gdk_device_get_name (source_device)); if (_gtk_gesture_update_point (gesture, event, target, x, y, TRUE)) { gboolean triggered_recognition; @@ -1163,6 +1208,7 @@ gtk_gesture_set_sequence_state (GtkGesture *gesture, { GdkDevice *source_device = gdk_event_get_device (data->event); + g_print ("%p Setting is-scrolling on %s\n", gesture, gdk_device_get_name (source_device)); g_object_set_data (G_OBJECT (source_device), "gtk-gesture-is-device-scrolling", GINT_TO_POINTER (TRUE)); diff --git a/gtk/gtkgestureprivate.h b/gtk/gtkgestureprivate.h index 1e7e498a13..b30f26a9c0 100644 --- a/gtk/gtkgestureprivate.h +++ b/gtk/gtkgestureprivate.h @@ -73,7 +73,6 @@ gboolean _gtk_gesture_get_last_update_time (GtkGesture *gesture, GtkWidget *gtk_gesture_get_last_target (GtkGesture *gesture, GdkEventSequence *sequence); - G_END_DECLS #endif /* __GTK_GESTURE_PRIVATE_H__ */ diff --git a/gtk/gtkgesturescroll.c b/gtk/gtkgesturescroll.c new file mode 100644 index 0000000000..1fb94a5388 --- /dev/null +++ b/gtk/gtkgesturescroll.c @@ -0,0 +1,215 @@ +/* GTK - The GIMP Toolkit + * Copyright (C) 202, Purism SPC + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see <http://www.gnu.org/licenses/>. + * + * Author(s): Alexander Mikhaylenko <alexm@gnome.org> + */ + +/** + * GtkGestureScroll: + * + * `GtkGestureScroll` is a `GtkGesture` implementation for scrolls. + * + * The scroll operation itself can be tracked throughout the + * [signal@Gtk.GestureScroll::scroll-begin], + * [signal@Gtk.GestureScroll::scroll-update] and + * [signal@Gtk.GestureScroll::scroll-end] signals, and the relevant + * coordinates can be extracted through + * [method@Gtk.GestureScroll.get_offset] and + * [method@Gtk.GestureScroll.get_start_point]. + */ +#include "config.h" +#include "gtkgestureprivate.h" +#include "gtkgesturescrollprivate.h" +#include "gtkintl.h" +#include "gtkmarshalers.h" + +typedef struct _GtkGestureScrollPrivate GtkGestureScrollPrivate; +typedef struct _EventData EventData; + +struct _GtkGestureScrollPrivate +{ + double start_x; + double start_y; + double last_x; + double last_y; +}; + +enum { + SCROLL_BEGIN, + SCROLL, + SCROLL_END, + N_SIGNALS +}; + +static guint signals[N_SIGNALS] = { 0 }; + +G_DEFINE_TYPE_WITH_PRIVATE (GtkGestureScroll, gtk_gesture_scroll, GTK_TYPE_GESTURE) + +static GtkFilterEventStatus +gtk_gesture_scroll_filter_event (GtkEventController *controller, + GdkEvent *event) +{ + GdkEventType event_type = gdk_event_get_event_type (event); + + if (event_type == GDK_TOUCHPAD_HOLD) + { + int n_fingers = gdk_touchpad_event_get_n_fingers (event); + + if (n_fingers == 1 || n_fingers == 2) + return GTK_EVENT_HANDLE; + } + + if (event_type == GDK_SCROLL || + event_type == GDK_GRAB_BROKEN) + return GTK_EVENT_HANDLE; + + return GTK_EVENT_SKIP; +} + +static void +gtk_gesture_scroll_begin (GtkGesture *gesture, + GdkEventSequence *sequence) +{ + GtkGestureScrollPrivate *priv; +// GdkEventSequence *current; + +// current = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture)); + + priv = gtk_gesture_scroll_get_instance_private (GTK_GESTURE_SCROLL (gesture)); + gtk_gesture_get_point (gesture, NULL, &priv->last_x, &priv->last_y); + + g_signal_emit (gesture, signals[SCROLL_BEGIN], 0); +} + +static void +gtk_gesture_scroll_update (GtkGesture *gesture, + GdkEventSequence *sequence) +{ + GtkGestureScrollPrivate *priv; + double x, y; + + priv = gtk_gesture_scroll_get_instance_private (GTK_GESTURE_SCROLL (gesture)); + gtk_gesture_get_point (gesture, NULL, &x, &y); + + g_signal_emit (gesture, signals[SCROLL], 0, x - priv->last_x, y - priv->last_y); + + priv->last_x = x; + priv->last_y = y; +} + +static void +gtk_gesture_scroll_end (GtkGesture *gesture, + GdkEventSequence *sequence) +{ + g_signal_emit (gesture, signals[SCROLL_END], 0); +} + +static GObject * +gtk_gesture_scroll_constructor (GType type, + guint n_construct_properties, + GObjectConstructParam *construct_properties) +{ + GObject *object; + + object = G_OBJECT_CLASS (gtk_gesture_scroll_parent_class)->constructor (type, + n_construct_properties, + construct_properties); + g_object_set (object, "n-points", 2, NULL); + + return object; +} + +static void +gtk_gesture_scroll_class_init (GtkGestureScrollClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkEventControllerClass *event_controller_class = GTK_EVENT_CONTROLLER_CLASS (klass); + GtkGestureClass *gesture_class = GTK_GESTURE_CLASS (klass); + + object_class->constructor = gtk_gesture_scroll_constructor; + + event_controller_class->filter_event = gtk_gesture_scroll_filter_event; + + gesture_class->begin = gtk_gesture_scroll_begin; + gesture_class->update = gtk_gesture_scroll_update; + gesture_class->end = gtk_gesture_scroll_end; + + /** + * GtkGestureScroll::scroll-begin: + * @gesture: the object which received the signal + * + * Emitted whenever scrollging starts. + */ + signals[SCROLL_BEGIN] = + g_signal_new (I_("scroll-begin"), + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); + /** + * GtkGestureScroll::scroll: + * @gesture: the object which received the signal + * @dx: X delta + * @dy: Y delta + * + * Signals that the widget should scroll by the + * amount specified by @dx and @dy. + * + * For the representation unit of the deltas, see + * [method@Gtk.EventControllerScroll.get_unit]. + */ + signals[SCROLL] = + g_signal_new (I_("scroll"), + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, + _gtk_marshal_VOID__DOUBLE_DOUBLE, + G_TYPE_NONE, 2, G_TYPE_DOUBLE, G_TYPE_DOUBLE); + g_signal_set_va_marshaller (signals[SCROLL], + G_TYPE_FROM_CLASS (klass), + _gtk_marshal_VOID__DOUBLE_DOUBLEv); + /** + * GtkGestureScroll::scroll-end: + * @gesture: the object which received the signal + * + * Emitted whenever the scrollging is finished. + */ + signals[SCROLL_END] = + g_signal_new (I_("scroll-end"), + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); +} + +static void +gtk_gesture_scroll_init (GtkGestureScroll *gesture) +{ +} + +/** + * gtk_gesture_scroll_new: + * + * Returns a newly created `GtkGesture` that recognizes scrolls. + * + * Returns: a newly created `GtkGestureScroll` + **/ +GtkGesture * +gtk_gesture_scroll_new (void) +{ + return g_object_new (GTK_TYPE_GESTURE_SCROLL, + NULL); +} diff --git a/gtk/gtkgesturescroll.h b/gtk/gtkgesturescroll.h new file mode 100644 index 0000000000..cb106d440e --- /dev/null +++ b/gtk/gtkgesturescroll.h @@ -0,0 +1,46 @@ +/* GTK - The GIMP Toolkit + * Copyright (C) 202, Purism SPC + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see <http://www.gnu.org/licenses/>. + * + * Author(s): Alexander Mikhaylenko <alexm@gnome.org> + */ +#pragma once + +#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION) +#error "Only <gtk/gtk.h> can be included directly." +#endif + +#include <gtk/gtkwidget.h> +#include <gtk/gtkgesturesingle.h> + +G_BEGIN_DECLS + +#define GTK_TYPE_GESTURE_SCROLL (gtk_gesture_scroll_get_type ()) +#define GTK_GESTURE_SCROLL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_SCROLL, GtkGestureScroll)) +#define GTK_GESTURE_SCROLL_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_SCROLL, GtkGestureScrollClass)) +#define GTK_IS_GESTURE_SCROLL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_SCROLL)) +#define GTK_IS_GESTURE_SCROLL_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_SCROLL)) +#define GTK_GESTURE_SCROLL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_SCROLL, GtkGestureScrollClass)) + +typedef struct _GtkGestureScroll GtkGestureScroll; +typedef struct _GtkGestureScrollClass GtkGestureScrollClass; + +GDK_AVAILABLE_IN_ALL +GType gtk_gesture_scroll_get_type (void) G_GNUC_CONST; + +GDK_AVAILABLE_IN_ALL +GtkGesture * gtk_gesture_scroll_new (void); + +G_END_DECLS diff --git a/gtk/gtkgesturescrollprivate.h b/gtk/gtkgesturescrollprivate.h new file mode 100644 index 0000000000..2706c18a8a --- /dev/null +++ b/gtk/gtkgesturescrollprivate.h @@ -0,0 +1,35 @@ +/* GTK - The GIMP Toolkit + * Copyright (C) 202, Purism SPC + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see <http://www.gnu.org/licenses/>. + * + * Author(s): Alexander Mikhaylenko <alexm@gnome.org> + */ +#pragma once + +#include "gtkgesturesingleprivate.h" +#include "gtkgesturescroll.h" + +struct _GtkGestureScroll +{ + GtkGesture parent_instance; +}; + +struct _GtkGestureScrollClass +{ + GtkGestureClass parent_class; + + /*< private >*/ + gpointer padding[10]; +}; diff --git a/gtk/gtkgesturesingle.c b/gtk/gtkgesturesingle.c index 2b741aa9d0..b18b1b4aaf 100644 --- a/gtk/gtkgesturesingle.c +++ b/gtk/gtkgesturesingle.c @@ -508,3 +508,4 @@ gtk_gesture_single_get_current_sequence (GtkGestureSingle *gesture) return priv->current_sequence; } + diff --git a/gtk/gtkscrolledwindow.c b/gtk/gtkscrolledwindow.c index 3af0af94fa..66b3340548 100644 --- a/gtk/gtkscrolledwindow.c +++ b/gtk/gtkscrolledwindow.c @@ -32,10 +32,10 @@ #include "gtkdragsourceprivate.h" #include "gtkeventcontrollermotion.h" #include "gtkeventcontrollerprivate.h" -#include "gtkeventcontrollerwheel.h" #include "gtkgesturedrag.h" #include "gtkgesturelongpress.h" #include "gtkgesturepan.h" +#include "gtkgesturescroll.h" #include "gtkgesturesingle.h" #include "gtkgestureswipe.h" #include "gtkgestureprivate.h" @@ -1363,18 +1363,36 @@ start_scroll_deceleration_cb (gpointer user_data) return FALSE; } -static gboolean -scroll_controller_scroll (GtkEventControllerWheel *controller, - double delta_x, - double delta_y, - GtkScrolledWindow *scrolled_window) +static void +scroll_controller_scroll_begin (GtkGestureScroll *gesture, + GtkScrolledWindow *scrolled_window) +{ +} + +static void +scroll_controller_scroll (GtkGestureScroll *gesture, + double delta_x, + double delta_y, + GtkScrolledWindow *scrolled_window) { GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window); gboolean shifted; GdkModifierType state; - state = gtk_event_controller_get_current_event_state (GTK_EVENT_CONTROLLER (controller)); + if (may_hscroll (scrolled_window) && !may_vscroll (scrolled_window) && ABS (delta_x) > ABS (delta_y)) { + gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_CLAIMED); +// g_print ("claim horz\n"); + } + + if (may_vscroll (scrolled_window) && !may_hscroll (scrolled_window) && ABS (delta_y) > ABS (delta_x)) { + gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_CLAIMED); +// g_print ("claim vert\n"); + } + +// g_print ("WTF %p\n", gesture); + + state = gtk_event_controller_get_current_event_state (GTK_EVENT_CONTROLLER (gesture)); shifted = (state & GDK_SHIFT_MASK) != 0; gtk_scrolled_window_cancel_deceleration (scrolled_window); @@ -1397,13 +1415,13 @@ scroll_controller_scroll (GtkEventControllerWheel *controller, GdkScrollUnit scroll_unit; adj = gtk_scrollbar_get_adjustment (GTK_SCROLLBAR (priv->hscrollbar)); - scroll_unit = gtk_event_controller_wheel_get_unit (controller); +/* scroll_unit = gtk_event_controller_wheel_get_unit (controller); if (scroll_unit == GDK_SCROLL_UNIT_WHEEL) { delta_x *= get_wheel_detent_scroll_step (scrolled_window, GTK_ORIENTATION_HORIZONTAL); - } + } FIXME */ new_value = priv->unclamped_hadj_value + delta_x; _gtk_scrolled_window_set_adjustment_value (scrolled_window, adj, @@ -1418,13 +1436,13 @@ scroll_controller_scroll (GtkEventControllerWheel *controller, GdkScrollUnit scroll_unit; adj = gtk_scrollbar_get_adjustment (GTK_SCROLLBAR (priv->vscrollbar)); - scroll_unit = gtk_event_controller_wheel_get_unit (controller); +/* scroll_unit = gtk_event_controller_wheel_get_unit (controller); if (scroll_unit == GDK_SCROLL_UNIT_WHEEL) { delta_y *= get_wheel_detent_scroll_step (scrolled_window, GTK_ORIENTATION_VERTICAL); - } + } FIXME */ new_value = priv->unclamped_vadj_value + delta_y; _gtk_scrolled_window_set_adjustment_value (scrolled_window, adj, @@ -1440,8 +1458,13 @@ scroll_controller_scroll (GtkEventControllerWheel *controller, gdk_source_set_static_name_by_id (priv->scroll_events_overshoot_id, "[gtk] start_scroll_deceleration_cb"); } +} + +static void +scroll_controller_scroll_end (GtkGestureScroll *gesture, + GtkScrolledWindow *scrolled_window) +{ - return GDK_EVENT_STOP; } static void @@ -2073,9 +2096,13 @@ gtk_scrolled_window_init (GtkScrolledWindow *scrolled_window) gtk_css_node_set_state (priv->junction_node, gtk_css_node_get_state (widget_node)); g_object_unref (priv->junction_node); - controller = gtk_event_controller_wheel_new (); + controller = GTK_EVENT_CONTROLLER (gtk_gesture_scroll_new ()); + g_signal_connect (controller, "scroll-begin", + G_CALLBACK (scroll_controller_scroll_begin), scrolled_window); g_signal_connect (controller, "scroll", G_CALLBACK (scroll_controller_scroll), scrolled_window); + g_signal_connect (controller, "scroll-end", + G_CALLBACK (scroll_controller_scroll_end), scrolled_window); gtk_widget_add_controller (widget, controller); controller = gtk_event_controller_motion_new (); diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c index afe7e9224e..4b3a84d54f 100644 --- a/gtk/gtkwidget.c +++ b/gtk/gtkwidget.c @@ -12934,3 +12934,4 @@ gtk_widget_set_active_state (GtkWidget *widget, gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_ACTIVE); } } + diff --git a/gtk/meson.build b/gtk/meson.build index efd3468af4..bcac7293e9 100644 --- a/gtk/meson.build +++ b/gtk/meson.build @@ -266,6 +266,7 @@ gtk_public_sources = files([ 'gtkgestureclick.c', 'gtkgesturepan.c', 'gtkgesturerotate.c', + 'gtkgesturescroll.c', 'gtkgesturesingle.c', 'gtkgesturestylus.c', 'gtkgestureswipe.c', @@ -555,6 +556,7 @@ gtk_public_headers = files([ 'gtkgestureclick.h', 'gtkgesturepan.h', 'gtkgesturerotate.h', + 'gtkgesturescroll.h', 'gtkgesturesingle.h', 'gtkgesturestylus.h', 'gtkgestureswipe.h', |