Lerking/gtk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tmp

Browse Source
This commit is contained in:
Alexander Mikhaylenko
2022-05-11 18:30:53 +04:00
parent 7dac42a3fd
commit 74002c680a
10 changed files with 398 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
demos/gtk-demo/listview_applauncher.c
View File

@@ -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);

68
gtk/gtkgesture.c
View File

@@ -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));

1
gtk/gtkgestureprivate.h
View File

@@ -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__ */

215
gtk/gtkgesturescroll.c Normal file
View File

@@ -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);
}

46
gtk/gtkgesturescroll.h Normal file
View File

@@ -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

35
gtk/gtkgesturescrollprivate.h Normal file
View File

@@ -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];
};

1
gtk/gtkgesturesingle.c
View File

@@ -508,3 +508,4 @@ gtk_gesture_single_get_current_sequence (GtkGestureSingle *gesture)
return priv->current_sequence;
}

53
gtk/gtkscrolledwindow.c
View File

@@ -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 ();

1
gtk/gtkwidget.c
View File

@@ -12934,3 +12934,4 @@ gtk_widget_set_active_state (GtkWidget *widget,
gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_ACTIVE);
}
}

2
gtk/meson.build
View File

@@ -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',