Modified: trunk/Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp (227892 => 227893)
--- trunk/Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp 2018-01-31 09:09:48 UTC (rev 227892)
+++ trunk/Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp 2018-01-31 09:14:33 UTC (rev 227893)
@@ -95,9 +95,8 @@
previousClickButton = 0;
}
- int currentClickCountForGdkButtonEvent(GdkEventButton* buttonEvent)
+ int currentClickCountForGdkButtonEvent(GdkEvent* event)
{
- GdkEvent* event = reinterpret_cast<GdkEvent*>(buttonEvent);
int doubleClickDistance = 250;
int doubleClickTime = 5;
g_object_get(gtk_settings_get_for_screen(gdk_event_get_screen(event)),
@@ -118,10 +117,10 @@
}
if ((event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS)
- || ((std::abs(buttonEvent->x - previousClickPoint.x()) < doubleClickDistance)
- && (std::abs(buttonEvent->y - previousClickPoint.y()) < doubleClickDistance)
+ || ((std::abs(event->button.x - previousClickPoint.x()) < doubleClickDistance)
+ && (std::abs(event->button.y - previousClickPoint.y()) < doubleClickDistance)
&& (eventTime - previousClickTime < static_cast<unsigned>(doubleClickTime))
- && (buttonEvent->button == previousClickButton)))
+ && (event->button.button == previousClickButton)))
currentClickCount++;
else
currentClickCount = 1;
@@ -129,7 +128,7 @@
double x, y;
gdk_event_get_coords(event, &x, &y);
previousClickPoint = IntPoint(x, y);
- previousClickButton = buttonEvent->button;
+ previousClickButton = event->button.button;
previousClickTime = eventTime;
return currentClickCount;
@@ -741,33 +740,59 @@
return GDK_EVENT_STOP;
}
-static gboolean webkitWebViewBaseButtonPressEvent(GtkWidget* widget, GdkEventButton* buttonEvent)
+static void webkitWebViewBaseHandleMouseEvent(WebKitWebViewBase* webViewBase, GdkEvent* event)
{
- WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(widget);
WebKitWebViewBasePrivate* priv = webViewBase->priv;
+ ASSERT(!priv->authenticationDialog);
- if (priv->authenticationDialog)
- return GDK_EVENT_STOP;
+ int clickCount = 0;
- gtk_widget_grab_focus(widget);
+ switch (event->type) {
+ case GDK_BUTTON_PRESS:
+ case GDK_2BUTTON_PRESS:
+ case GDK_3BUTTON_PRESS: {
+ // For double and triple clicks GDK sends both a normal button press event
+ // and a specific type (like GDK_2BUTTON_PRESS). If we detect a special press
+ // coming up, ignore this event as it certainly generated the double or triple
+ // click. The consequence of not eating this event is two DOM button press events
+ // are generated.
+ GUniquePtr<GdkEvent> nextEvent(gdk_event_peek());
+ if (nextEvent && (nextEvent->any.type == GDK_2BUTTON_PRESS || nextEvent->any.type == GDK_3BUTTON_PRESS))
+ return;
- priv->inputMethodFilter.notifyMouseButtonPress();
+ priv->inputMethodFilter.notifyMouseButtonPress();
- // For double and triple clicks GDK sends both a normal button press event
- // and a specific type (like GDK_2BUTTON_PRESS). If we detect a special press
- // coming up, ignore this event as it certainly generated the double or triple
- // click. The consequence of not eating this event is two DOM button press events
- // are generated.
- GUniquePtr<GdkEvent> nextEvent(gdk_event_peek());
- if (nextEvent && (nextEvent->any.type == GDK_2BUTTON_PRESS || nextEvent->any.type == GDK_3BUTTON_PRESS))
+ // If it's a right click event save it as a possible context menu event.
+ if (event->button.button == GDK_BUTTON_SECONDARY)
+ priv->contextMenuEvent.reset(gdk_event_copy(event));
+
+ clickCount = priv->clickCounter.currentClickCountForGdkButtonEvent(event);
+ }
+ FALLTHROUGH;
+ case GDK_BUTTON_RELEASE:
+ gtk_widget_grab_focus(GTK_WIDGET(webViewBase));
+ break;
+ case GDK_MOTION_NOTIFY:
+ case GDK_ENTER_NOTIFY:
+ case GDK_LEAVE_NOTIFY:
+ break;
+ default:
+ ASSERT_NOT_REACHED();
+ }
+
+ priv->pageProxy->handleMouseEvent(NativeWebMouseEvent(event, clickCount));
+}
+
+static gboolean webkitWebViewBaseButtonPressEvent(GtkWidget* widget, GdkEventButton* event)
+{
+ WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(widget);
+ WebKitWebViewBasePrivate* priv = webViewBase->priv;
+
+ if (priv->authenticationDialog)
return GDK_EVENT_STOP;
- // If it's a right click event save it as a possible context menu event.
- if (buttonEvent->button == 3)
- priv->contextMenuEvent.reset(gdk_event_copy(reinterpret_cast<GdkEvent*>(buttonEvent)));
+ webkitWebViewBaseHandleMouseEvent(webViewBase, reinterpret_cast<GdkEvent*>(event));
- priv->pageProxy->handleMouseEvent(NativeWebMouseEvent(reinterpret_cast<GdkEvent*>(buttonEvent),
- priv->clickCounter.currentClickCountForGdkButtonEvent(buttonEvent)));
return GDK_EVENT_STOP;
}
@@ -779,12 +804,21 @@
if (priv->authenticationDialog)
return GDK_EVENT_STOP;
- gtk_widget_grab_focus(widget);
- priv->pageProxy->handleMouseEvent(NativeWebMouseEvent(reinterpret_cast<GdkEvent*>(event), 0 /* currentClickCount */));
+ webkitWebViewBaseHandleMouseEvent(webViewBase, reinterpret_cast<GdkEvent*>(event));
return GDK_EVENT_STOP;
}
+static void webkitWebViewBaseHandleWheelEvent(WebKitWebViewBase* webViewBase, GdkEvent* event, std::optional<WebWheelEvent::Phase> phase = std::nullopt, std::optional<WebWheelEvent::Phase> momentum = std::nullopt)
+{
+ WebKitWebViewBasePrivate* priv = webViewBase->priv;
+ ASSERT(!priv->authenticationDialog);
+ if (phase)
+ priv->pageProxy->handleWheelEvent(NativeWebWheelEvent(event, phase.value(), momentum.value_or(WebWheelEvent::Phase::PhaseNone)));
+ else
+ priv->pageProxy->handleWheelEvent(NativeWebWheelEvent(event));
+}
+
static gboolean webkitWebViewBaseScrollEvent(GtkWidget* widget, GdkEventScroll* event)
{
WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(widget);
@@ -796,7 +830,7 @@
if (priv->authenticationDialog)
return GDK_EVENT_PROPAGATE;
- priv->pageProxy->handleWheelEvent(NativeWebWheelEvent(reinterpret_cast<GdkEvent*>(event)));
+ webkitWebViewBaseHandleWheelEvent(webViewBase, reinterpret_cast<GdkEvent*>(event));
return GDK_EVENT_STOP;
}
@@ -825,7 +859,7 @@
return widgetClass->motion_notify_event ? widgetClass->motion_notify_event(widget, event) : GDK_EVENT_PROPAGATE;
}
- priv->pageProxy->handleMouseEvent(NativeWebMouseEvent(reinterpret_cast<GdkEvent*>(event), 0 /* currentClickCount */));
+ webkitWebViewBaseHandleMouseEvent(webViewBase, reinterpret_cast<GdkEvent*>(event));
return GDK_EVENT_PROPAGATE;
}
@@ -866,7 +900,7 @@
copiedEvent->crossing.y = y;
}
- priv->pageProxy->handleMouseEvent(NativeWebMouseEvent(copiedEvent ? copiedEvent.get() : event, 0 /* currentClickCount */));
+ webkitWebViewBaseHandleMouseEvent(webViewBase, copiedEvent ? copiedEvent.get() : event);
return GDK_EVENT_PROPAGATE;
}
@@ -960,11 +994,109 @@
#endif // ENABLE(TOUCH_EVENTS)
#if HAVE(GTK_GESTURES)
+class ViewGestureController final : public GestureControllerClient {
+ WTF_MAKE_FAST_ALLOCATED;
+
+public:
+ explicit ViewGestureController(WebKitWebViewBase* webViewBase)
+ : m_webView(webViewBase)
+ {
+ }
+
+private:
+ static GUniquePtr<GdkEvent> createScrollEvent(GdkEventTouch* event, const FloatPoint& point, const FloatPoint& delta, bool isStop = false)
+ {
+ GUniquePtr<GdkEvent> scrollEvent(gdk_event_new(GDK_SCROLL));
+ scrollEvent->scroll.time = event->time;
+ scrollEvent->scroll.x = point.x();
+ scrollEvent->scroll.y = point.y();
+ scrollEvent->scroll.x_root = event->x_root;
+ scrollEvent->scroll.y_root = event->y_root;
+ scrollEvent->scroll.direction = GDK_SCROLL_SMOOTH;
+ scrollEvent->scroll.delta_x = delta.x();
+ scrollEvent->scroll.delta_y = delta.y();
+ scrollEvent->scroll.state = event->state;
+#if GTK_CHECK_VERSION(3, 20, 0)
+ scrollEvent->scroll.is_stop = isStop;
+#else
+ UNUSED_PARAM(isStop);
+#endif
+ return scrollEvent;
+ }
+
+ void simulateMouseClick(const GdkEventTouch* event, unsigned button)
+ {
+ GUniquePtr<GdkEvent> pointerEvent(gdk_event_new(GDK_MOTION_NOTIFY));
+ pointerEvent->motion.time = event->time;
+ pointerEvent->motion.x = event->x;
+ pointerEvent->motion.y = event->y;
+ pointerEvent->motion.x_root = event->x_root;
+ pointerEvent->motion.y_root = event->y_root;
+ pointerEvent->motion.state = event->state;
+ webkitWebViewBaseHandleMouseEvent(m_webView, pointerEvent.get());
+
+ pointerEvent.reset(gdk_event_new(GDK_BUTTON_PRESS));
+ pointerEvent->button.button = button;
+ pointerEvent->button.time = event->time;
+ pointerEvent->button.x = event->x;
+ pointerEvent->button.y = event->y;
+ pointerEvent->button.x_root = event->x_root;
+ pointerEvent->button.y_root = event->y_root;
+ webkitWebViewBaseHandleMouseEvent(m_webView, pointerEvent.get());
+
+ pointerEvent->type = GDK_BUTTON_RELEASE;
+ webkitWebViewBaseHandleMouseEvent(m_webView, pointerEvent.get());
+ }
+
+ void tap(GdkEventTouch* event) final
+ {
+ simulateMouseClick(event, GDK_BUTTON_PRIMARY);
+ }
+
+ void startDrag(GdkEventTouch* event, const FloatPoint& startPoint) final
+ {
+ GUniquePtr<GdkEvent> scrollEvent = createScrollEvent(event, startPoint, { });
+ webkitWebViewBaseHandleWheelEvent(m_webView, scrollEvent.get(), WebWheelEvent::Phase::PhaseBegan);
+ }
+
+ void drag(GdkEventTouch* event, const FloatPoint& point, const FloatPoint& delta) final
+ {
+ GUniquePtr<GdkEvent> scrollEvent = createScrollEvent(event, point, delta);
+ webkitWebViewBaseHandleWheelEvent(m_webView, scrollEvent.get(), WebWheelEvent::Phase::PhaseChanged);
+ }
+
+ void swipe(GdkEventTouch* event, const FloatPoint& velocity) final
+ {
+ GUniquePtr<GdkEvent> scrollEvent = createScrollEvent(event, FloatPoint::narrowPrecision(event->x, event->y), velocity, true);
+ webkitWebViewBaseHandleWheelEvent(m_webView, scrollEvent.get(), WebWheelEvent::Phase::PhaseNone, WebWheelEvent::Phase::PhaseBegan);
+ }
+
+ void startZoom(const IntPoint& center, double& initialScale, IntPoint& initialPoint) final
+ {
+ auto* page = webkitWebViewBaseGetPage(m_webView);
+ ASSERT(page);
+ initialScale = page->pageZoomFactor();
+ page->getCenterForZoomGesture(center, initialPoint);
+ }
+
+ void zoom(double scale) final
+ {
+ m_webView->priv->pageClient->zoom(scale);
+ }
+
+ void longPress(GdkEventTouch* event) final
+ {
+ simulateMouseClick(event, GDK_BUTTON_SECONDARY);
+ }
+
+ WebKitWebViewBase* m_webView;
+};
+
GestureController& webkitWebViewBaseGestureController(WebKitWebViewBase* webViewBase)
{
WebKitWebViewBasePrivate* priv = webViewBase->priv;
if (!priv->gestureController)
- priv->gestureController = std::make_unique<GestureController>(*priv->pageProxy);
+ priv->gestureController = std::make_unique<GestureController>(GTK_WIDGET(webViewBase), std::make_unique<ViewGestureController>(webViewBase));
return *priv->gestureController;
}
#endif
Modified: trunk/Source/WebKit/UIProcess/gtk/GestureController.cpp (227892 => 227893)
--- trunk/Source/WebKit/UIProcess/gtk/GestureController.cpp 2018-01-31 09:09:48 UTC (rev 227892)
+++ trunk/Source/WebKit/UIProcess/gtk/GestureController.cpp 2018-01-31 09:14:33 UTC (rev 227893)
@@ -28,11 +28,6 @@
#if HAVE(GTK_GESTURES)
-#include "NativeWebMouseEvent.h"
-#include "NativeWebWheelEvent.h"
-#include "WebKitWebView.h"
-#include "WebPageProxy.h"
-#include <WebCore/FloatPoint.h>
#include <WebCore/Scrollbar.h>
#include <gtk/gtk.h>
@@ -40,15 +35,16 @@
namespace WebKit {
-GestureController::GestureController(WebPageProxy& page)
- : m_dragGesture(page)
- , m_swipeGesture(page)
- , m_zoomGesture(page)
- , m_longpressGesture(page)
+GestureController::GestureController(GtkWidget* widget, std::unique_ptr<GestureControllerClient>&& client)
+ : m_client(WTFMove(client))
+ , m_dragGesture(widget, *m_client)
+ , m_swipeGesture(widget, *m_client)
+ , m_zoomGesture(widget, *m_client)
+ , m_longpressGesture(widget, *m_client)
{
}
-bool GestureController::handleEvent(const GdkEvent* event)
+bool GestureController::handleEvent(GdkEvent* event)
{
bool wasProcessingGestures = isProcessingGestures();
bool touchEnd;
@@ -65,9 +61,9 @@
return m_dragGesture.isActive() || m_swipeGesture.isActive() || m_zoomGesture.isActive() || m_longpressGesture.isActive();
}
-GestureController::Gesture::Gesture(GtkGesture* gesture, WebPageProxy& page)
+GestureController::Gesture::Gesture(GtkGesture* gesture, GestureControllerClient& client)
: m_gesture(adoptGRef(gesture))
- , m_page(page)
+ , m_client(client)
{
gtk_event_controller_set_propagation_phase(GTK_EVENT_CONTROLLER(m_gesture.get()), GTK_PHASE_NONE);
}
@@ -82,75 +78,28 @@
return gtk_gesture_is_active(m_gesture.get());
}
-void GestureController::Gesture::handleEvent(const GdkEvent* event)
+void GestureController::Gesture::handleEvent(GdkEvent* event)
{
gtk_event_controller_handle_event(GTK_EVENT_CONTROLLER(m_gesture.get()), event);
}
-void GestureController::Gesture::simulateMouseClick(const GdkEvent* event, unsigned buttonType)
+void GestureController::DragGesture::startDrag(GdkEvent* event)
{
- GUniquePtr<GdkEvent> pointerEvent(gdk_event_new(GDK_MOTION_NOTIFY));
- pointerEvent->motion.time = event->touch.time;
- pointerEvent->motion.x = event->touch.x;
- pointerEvent->motion.y = event->touch.y;
- pointerEvent->motion.x_root = event->touch.x_root;
- pointerEvent->motion.y_root = event->touch.y_root;
- pointerEvent->motion.state = event->touch.state;
- m_page.handleMouseEvent(NativeWebMouseEvent(pointerEvent.get(), 0));
-
- pointerEvent.reset(gdk_event_new(GDK_BUTTON_PRESS));
- pointerEvent->button.button = buttonType;
- pointerEvent->button.time = event->touch.time;
- pointerEvent->button.x = event->touch.x;
- pointerEvent->button.y = event->touch.y;
- pointerEvent->button.x_root = event->touch.x_root;
- pointerEvent->button.y_root = event->touch.y_root;
- m_page.handleMouseEvent(NativeWebMouseEvent(pointerEvent.get(), 1));
-
- pointerEvent->type = GDK_BUTTON_RELEASE;
- m_page.handleMouseEvent(NativeWebMouseEvent(pointerEvent.get(), 0));
-}
-
-static GUniquePtr<GdkEvent> createScrollEvent(const GdkEvent* event, double x, double y, double deltaX, double deltaY, gboolean isStop)
-{
- GUniquePtr<GdkEvent> scrollEvent(gdk_event_new(GDK_SCROLL));
- scrollEvent->scroll.time = event->touch.time;
- scrollEvent->scroll.x = x;
- scrollEvent->scroll.y = y;
- scrollEvent->scroll.x_root = event->touch.x_root;
- scrollEvent->scroll.y_root = event->touch.y_root;
- scrollEvent->scroll.direction = GDK_SCROLL_SMOOTH;
- scrollEvent->scroll.delta_x = deltaX;
- scrollEvent->scroll.delta_y = deltaY;
- scrollEvent->scroll.state = event->touch.state;
-#if GTK_CHECK_VERSION(3, 20, 0)
- scrollEvent->scroll.is_stop = isStop;
-#endif
- return scrollEvent;
-}
-
-void GestureController::DragGesture::startDrag(const GdkEvent* event)
-{
ASSERT(!m_inDrag);
- GUniquePtr<GdkEvent> scrollEvent = createScrollEvent(event, m_start.x(), m_start.y(), 0, 0, FALSE);
- m_page.handleWheelEvent(NativeWebWheelEvent(scrollEvent.get(), WebWheelEvent::Phase::PhaseBegan, WebWheelEvent::Phase::PhaseNone));
+ m_client.startDrag(reinterpret_cast<GdkEventTouch*>(event), m_start);
}
-void GestureController::DragGesture::handleDrag(const GdkEvent* event, double x, double y)
+void GestureController::DragGesture::handleDrag(GdkEvent* event, double x, double y)
{
ASSERT(m_inDrag);
- GUniquePtr<GdkEvent> scrollEvent = createScrollEvent(event,
- m_start.x(), m_start.y(),
- (m_offset.x() - x) / Scrollbar::pixelsPerLineStep(),
- (m_offset.y() - y) / Scrollbar::pixelsPerLineStep(),
- FALSE);
- m_page.handleWheelEvent(NativeWebWheelEvent(scrollEvent.get(), WebWheelEvent::Phase::PhaseChanged, WebWheelEvent::Phase::PhaseNone));
+ m_client.drag(reinterpret_cast<GdkEventTouch*>(event), m_start,
+ FloatPoint::narrowPrecision((m_offset.x() - x) / Scrollbar::pixelsPerLineStep(), (m_offset.y() - y) / Scrollbar::pixelsPerLineStep()));
}
-void GestureController::DragGesture::handleTap(const GdkEvent* event)
+void GestureController::DragGesture::handleTap(GdkEvent* event)
{
ASSERT(!m_inDrag);
- simulateMouseClick(event, GDK_BUTTON_PRIMARY);
+ m_client.tap(reinterpret_cast<GdkEventTouch*>(event));
}
void GestureController::DragGesture::begin(DragGesture* dragGesture, double x, double y, GtkGesture* gesture)
@@ -165,7 +114,7 @@
unsigned delay;
g_object_get(gtk_widget_get_settings(widget), "gtk-long-press-time", &delay, nullptr);
dragGesture->m_longPressTimeout.startOneShot(1_ms * delay);
- dragGesture->startDrag(gtk_gesture_get_last_event(gesture, sequence));
+ dragGesture->startDrag(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)));
}
void GestureController::DragGesture::update(DragGesture* dragGesture, double x, double y, GtkGesture* gesture)
@@ -180,7 +129,7 @@
}
if (dragGesture->m_inDrag)
- dragGesture->handleDrag(gtk_gesture_get_last_event(gesture, sequence), x, y);
+ dragGesture->handleDrag(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)), x, y);
dragGesture->m_offset.set(x, y);
}
@@ -192,7 +141,7 @@
return;
}
if (!dragGesture->m_inDrag) {
- dragGesture->handleTap(gtk_gesture_get_last_event(gesture, sequence));
+ dragGesture->handleTap(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)));
gtk_gesture_set_state(gesture, GTK_EVENT_SEQUENCE_DENIED);
}
}
@@ -202,10 +151,9 @@
m_inDrag = true;
}
-GestureController::DragGesture::DragGesture(WebPageProxy& page)
- : Gesture(gtk_gesture_drag_new(page.viewWidget()), page)
+GestureController::DragGesture::DragGesture(GtkWidget* widget, GestureControllerClient& client)
+ : Gesture(gtk_gesture_drag_new(widget), client)
, m_longPressTimeout(RunLoop::main(), this, &GestureController::DragGesture::longPressFired)
- , m_inDrag(false)
{
gtk_gesture_single_set_touch_only(GTK_GESTURE_SINGLE(m_gesture.get()), TRUE);
g_signal_connect_swapped(m_gesture.get(), "drag-begin", G_CALLBACK(begin), this);
@@ -213,10 +161,9 @@
g_signal_connect_swapped(m_gesture.get(), "end", G_CALLBACK(end), this);
}
-void GestureController::SwipeGesture::startMomentumScroll(const GdkEvent* event, double velocityX, double velocityY)
+void GestureController::SwipeGesture::startMomentumScroll(GdkEvent* event, double velocityX, double velocityY)
{
- GUniquePtr<GdkEvent> scrollEvent = createScrollEvent(event, event->touch.x, event->touch.y, velocityX, velocityY, TRUE);
- m_page.handleWheelEvent(NativeWebWheelEvent(scrollEvent.get(), WebWheelEvent::Phase::PhaseNone, WebWheelEvent::Phase::PhaseBegan));
+ m_client.swipe(reinterpret_cast<GdkEventTouch*>(event), FloatPoint::narrowPrecision(velocityX, velocityY));
}
void GestureController::SwipeGesture::swipe(SwipeGesture* swipeGesture, double velocityX, double velocityY, GtkGesture* gesture)
@@ -227,16 +174,22 @@
gtk_gesture_set_sequence_state(gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);
- swipeGesture->startMomentumScroll(gtk_gesture_get_last_event(gesture, sequence), velocityX, velocityY);
+ swipeGesture->startMomentumScroll(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)), velocityX, velocityY);
}
-GestureController::SwipeGesture::SwipeGesture(WebPageProxy& page)
- : Gesture(gtk_gesture_swipe_new(page.viewWidget()), page)
+GestureController::SwipeGesture::SwipeGesture(GtkWidget* widget, GestureControllerClient& client)
+ : Gesture(gtk_gesture_swipe_new(widget), client)
{
gtk_gesture_single_set_touch_only(GTK_GESTURE_SINGLE(m_gesture.get()), TRUE);
g_signal_connect_swapped(m_gesture.get(), "swipe", G_CALLBACK(swipe), this);
}
+void GestureController::ZoomGesture::begin(ZoomGesture* zoomGesture, GdkEventSequence*, GtkGesture* gesture)
+{
+ gtk_gesture_set_state(gesture, GTK_EVENT_SEQUENCE_CLAIMED);
+ zoomGesture->startZoom();
+}
+
IntPoint GestureController::ZoomGesture::center() const
{
double x, y;
@@ -244,17 +197,14 @@
return IntPoint(x, y);
}
-void GestureController::ZoomGesture::begin(ZoomGesture* zoomGesture, GdkEventSequence*, GtkGesture* gesture)
+void GestureController::ZoomGesture::startZoom()
{
- gtk_gesture_set_state(gesture, GTK_EVENT_SEQUENCE_CLAIMED);
-
- zoomGesture->m_initialScale = zoomGesture->m_page.pageZoomFactor();
- zoomGesture->m_page.getCenterForZoomGesture(zoomGesture->center(), zoomGesture->m_initialPoint);
+ m_client.startZoom(center(), m_initialScale, m_initialPoint);
}
void GestureController::ZoomGesture::handleZoom()
{
- webkit_web_view_set_zoom_level(WEBKIT_WEB_VIEW(m_page.viewWidget()), m_scale);
+ m_client.zoom(m_scale);
}
void GestureController::ZoomGesture::scaleChanged(ZoomGesture* zoomGesture, double scale, GtkGesture*)
@@ -267,10 +217,8 @@
zoomGesture->m_idle.startOneShot(0_s);
}
-GestureController::ZoomGesture::ZoomGesture(WebPageProxy& page)
- : Gesture(gtk_gesture_zoom_new(page.viewWidget()), page)
- , m_initialScale(0)
- , m_scale(0)
+GestureController::ZoomGesture::ZoomGesture(GtkWidget* widget, GestureControllerClient& client)
+ : Gesture(gtk_gesture_zoom_new(widget), client)
, m_idle(RunLoop::main(), this, &GestureController::ZoomGesture::handleZoom)
{
g_signal_connect_swapped(m_gesture.get(), "begin", G_CALLBACK(begin), this);
@@ -277,9 +225,9 @@
g_signal_connect_swapped(m_gesture.get(), "scale-changed", G_CALLBACK(scaleChanged), this);
}
-void GestureController::LongPressGesture::longPressed(const GdkEvent* event)
+void GestureController::LongPressGesture::longPressed(GdkEvent* event)
{
- simulateMouseClick(event, GDK_BUTTON_SECONDARY);
+ m_client.longPress(reinterpret_cast<GdkEventTouch*>(event));
}
void GestureController::LongPressGesture::pressed(LongPressGesture* longpressGesture, double x, double y, GtkGesture* gesture)
@@ -290,11 +238,11 @@
gtk_gesture_set_sequence_state(gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);
- longpressGesture->longPressed(gtk_gesture_get_last_event(gesture, sequence));
+ longpressGesture->longPressed(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)));
}
-GestureController::LongPressGesture::LongPressGesture(WebPageProxy& page)
- : Gesture(gtk_gesture_long_press_new(page.viewWidget()), page)
+GestureController::LongPressGesture::LongPressGesture(GtkWidget* widget, GestureControllerClient& client)
+ : Gesture(gtk_gesture_long_press_new(widget), client)
{
gtk_gesture_single_set_touch_only(GTK_GESTURE_SINGLE(m_gesture.get()), TRUE);
g_signal_connect_swapped(m_gesture.get(), "pressed", G_CALLBACK(pressed), this);
Modified: trunk/Source/WebKit/UIProcess/gtk/GestureController.h (227892 => 227893)
--- trunk/Source/WebKit/UIProcess/gtk/GestureController.h 2018-01-31 09:09:48 UTC (rev 227892)
+++ trunk/Source/WebKit/UIProcess/gtk/GestureController.h 2018-01-31 09:14:33 UTC (rev 227893)
@@ -23,8 +23,7 @@
* THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef GestureController_h
-#define GestureController_h
+#pragma once
#if HAVE(GTK_GESTURES)
@@ -34,20 +33,36 @@
#include <wtf/glib/GRefPtr.h>
typedef union _GdkEvent GdkEvent;
+typedef struct _GdkEventTouch GdkEventTouch;
typedef struct _GdkEventSequence GdkEventSequence;
typedef struct _GtkGesture GtkGesture;
namespace WebKit {
-class WebPageProxy;
+class GestureControllerClient {
+public:
+ virtual void tap(GdkEventTouch*) = 0;
+
+ virtual void startDrag(GdkEventTouch*, const WebCore::FloatPoint&) = 0;
+ virtual void drag(GdkEventTouch*, const WebCore::FloatPoint&, const WebCore::FloatPoint&) = 0;
+
+ virtual void swipe(GdkEventTouch*, const WebCore::FloatPoint&) = 0;
+
+ virtual void startZoom(const WebCore::IntPoint& center, double& initialScale, WebCore::IntPoint& initialPoint) = 0;
+ virtual void zoom(double) = 0;
+
+ virtual void longPress(GdkEventTouch*) = 0;
+};
+
class GestureController {
WTF_MAKE_NONCOPYABLE(GestureController);
+ WTF_MAKE_FAST_ALLOCATED;
public:
- GestureController(WebPageProxy&);
+ GestureController(GtkWidget*, std::unique_ptr<GestureControllerClient>&&);
bool isProcessingGestures() const;
- bool handleEvent(const GdkEvent*);
+ bool handleEvent(GdkEvent*);
void reset()
{
@@ -62,25 +77,24 @@
public:
void reset();
bool isActive() const;
- void handleEvent(const GdkEvent*);
- void simulateMouseClick(const GdkEvent*, unsigned);
+ void handleEvent(GdkEvent*);
protected:
- Gesture(GtkGesture*, WebPageProxy&);
+ Gesture(GtkGesture*, GestureControllerClient&);
GRefPtr<GtkGesture> m_gesture;
- WebPageProxy& m_page;
+ GestureControllerClient& m_client;
};
class DragGesture final : public Gesture {
public:
- DragGesture(WebPageProxy&);
+ DragGesture(GtkWidget*, GestureControllerClient&);
private:
// Notify that a drag started, allowing to stop kinetic deceleration.
- void startDrag(const GdkEvent*);
- void handleDrag(const GdkEvent*, double x, double y);
- void handleTap(const GdkEvent*);
+ void startDrag(GdkEvent*);
+ void handleDrag(GdkEvent*, double x, double y);
+ void handleTap(GdkEvent*);
void longPressFired();
static void begin(DragGesture*, double x, double y, GtkGesture*);
@@ -91,15 +105,15 @@
WebCore::FloatPoint m_offset;
RunLoop::Timer<DragGesture> m_longPressTimeout;
GRefPtr<GtkGesture> m_longPress;
- bool m_inDrag;
+ bool m_inDrag { false };
};
class SwipeGesture final : public Gesture {
public:
- SwipeGesture(WebPageProxy&);
+ SwipeGesture(GtkWidget*, GestureControllerClient&);
private:
- void startMomentumScroll(const GdkEvent*, double velocityX, double velocityY);
+ void startMomentumScroll(GdkEvent*, double velocityX, double velocityY);
static void swipe(SwipeGesture*, double velocityX, double velocityY, GtkGesture*);
};
@@ -106,17 +120,18 @@
class ZoomGesture final : public Gesture {
public:
- ZoomGesture(WebPageProxy&);
+ ZoomGesture(GtkWidget*, GestureControllerClient&);
private:
WebCore::IntPoint center() const;
+ void startZoom();
void handleZoom();
static void begin(ZoomGesture*, GdkEventSequence*, GtkGesture*);
static void scaleChanged(ZoomGesture*, double scale, GtkGesture*);
- gdouble m_initialScale;
- gdouble m_scale;
+ double m_initialScale { 0 };
+ double m_scale { 0 };
WebCore::IntPoint m_initialPoint;
WebCore::IntPoint m_viewPoint;
RunLoop::Timer<ZoomGesture> m_idle;
@@ -124,14 +139,15 @@
class LongPressGesture final : public Gesture {
public:
- LongPressGesture(WebPageProxy&);
+ LongPressGesture(GtkWidget*, GestureControllerClient&);
private:
- void longPressed(const GdkEvent*);
+ void longPressed(GdkEvent*);
static void pressed(LongPressGesture*, double x, double y, GtkGesture*);
};
+ std::unique_ptr<GestureControllerClient> m_client;
DragGesture m_dragGesture;
SwipeGesture m_swipeGesture;
ZoomGesture m_zoomGesture;
@@ -141,5 +157,3 @@
} // namespace WebKit
#endif // HAVE(GTK_GESTURES)
-
-#endif // GestureController_h
