Source/WebKit/UIProcess/gtk/GestureController.cpp - WebKit - Git at Google

 /*
  * Copyright (C) 2014 Igalia S.L.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "config.h"
 #include "GestureController.h"

 #include <WebCore/Scrollbar.h>
 #include <gtk/gtk.h>

 namespace WebKit {
 using namespace WebCore;

 static const double maximumZoom = 3.0;

 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(GdkEvent* event)
 {
     bool wasProcessingGestures = isProcessingGestures();
     bool touchEnd;
     m_dragGesture.handleEvent(event);
     m_swipeGesture.handleEvent(event);
     m_zoomGesture.handleEvent(event);
     m_longpressGesture.handleEvent(event);
     touchEnd = (gdk_event_get_event_type(event) == GDK_TOUCH_END) || (gdk_event_get_event_type(event) == GDK_TOUCH_CANCEL);
     return touchEnd ? wasProcessingGestures : isProcessingGestures();
 }

 bool GestureController::isProcessingGestures() const
 {
     return m_dragGesture.isActive() || m_swipeGesture.isActive() || m_zoomGesture.isActive() || m_longpressGesture.isActive();
 }

 GestureController::Gesture::Gesture(GtkGesture* gesture, GestureControllerClient& client)
     : m_gesture(adoptGRef(gesture))
     , m_client(client)
 {
     gtk_event_controller_set_propagation_phase(GTK_EVENT_CONTROLLER(m_gesture.get()), GTK_PHASE_NONE);
 }

 void GestureController::Gesture::reset()
 {
     gtk_event_controller_reset(GTK_EVENT_CONTROLLER(m_gesture.get()));
 }

 bool GestureController::Gesture::isActive() const
 {
     return gtk_gesture_is_active(m_gesture.get());
 }

 void GestureController::Gesture::handleEvent(GdkEvent* event)
 {
     gtk_event_controller_handle_event(GTK_EVENT_CONTROLLER(m_gesture.get()), event);
 }

 void GestureController::DragGesture::startDrag(GdkEvent* event)
 {
     ASSERT(!m_inDrag);
     m_client.startDrag(reinterpret_cast<GdkEventTouch*>(event), m_start);
 }

 void GestureController::DragGesture::handleDrag(GdkEvent* event, double x, double y)
 {
     ASSERT(m_inDrag);
     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::cancelDrag()
 {
     ASSERT(m_inDrag);
     m_client.cancelDrag();
 }

 void GestureController::DragGesture::handleTap(GdkEvent* event)
 {
     ASSERT(!m_inDrag);
     m_client.tap(reinterpret_cast<GdkEventTouch*>(event));
 }

 void GestureController::DragGesture::begin(DragGesture* dragGesture, double x, double y, GtkGesture* gesture)
 {
     GdkEventSequence* sequence = gtk_gesture_single_get_current_sequence(GTK_GESTURE_SINGLE(gesture));
     gtk_gesture_set_sequence_state(gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);
     dragGesture->m_inDrag = false;
     dragGesture->m_start.set(x, y);
     dragGesture->m_offset.set(0, 0);

     GtkWidget* widget = gtk_event_controller_get_widget(GTK_EVENT_CONTROLLER(gesture));
     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(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)));
 }

 void GestureController::DragGesture::update(DragGesture* dragGesture, double x, double y, GtkGesture* gesture)
 {
     GdkEventSequence* sequence = gtk_gesture_single_get_current_sequence(GTK_GESTURE_SINGLE(gesture));
     gtk_gesture_set_sequence_state(gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);

     GtkWidget* widget = gtk_event_controller_get_widget(GTK_EVENT_CONTROLLER(gesture));
     if (!dragGesture->m_inDrag && gtk_drag_check_threshold(widget, dragGesture->m_start.x(), dragGesture->m_start.y(), dragGesture->m_start.x() + x, dragGesture->m_start.y() + y)) {
         dragGesture->m_inDrag = true;
         dragGesture->m_longPressTimeout.stop();
     }

     if (dragGesture->m_inDrag)
         dragGesture->handleDrag(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)), x, y);
     dragGesture->m_offset.set(x, y);
 }

 void GestureController::DragGesture::end(DragGesture* dragGesture, GdkEventSequence* sequence, GtkGesture* gesture)
 {
     dragGesture->m_longPressTimeout.stop();
     if (!gtk_gesture_handles_sequence(gesture, sequence)) {
         gtk_gesture_set_state(gesture, GTK_EVENT_SEQUENCE_DENIED);
         return;
     }
     if (!dragGesture->m_inDrag) {
         dragGesture->handleTap(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)));
         gtk_gesture_set_state(gesture, GTK_EVENT_SEQUENCE_DENIED);
     }
 }

 void GestureController::DragGesture::cancel(DragGesture* dragGesture, GdkEventSequence* sequence, GtkGesture* gesture)
 {
     dragGesture->m_longPressTimeout.stop();
     dragGesture->cancelDrag();
 }

 void GestureController::DragGesture::longPressFired()
 {
     m_inDrag = true;
 }

 GestureController::DragGesture::DragGesture(GtkWidget* widget, GestureControllerClient& client)
     : Gesture(gtk_gesture_drag_new(widget), client)
     , m_longPressTimeout(RunLoop::main(), this, &GestureController::DragGesture::longPressFired)
 {
     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);
     g_signal_connect_swapped(m_gesture.get(), "drag-update", G_CALLBACK(update), this);
     g_signal_connect_swapped(m_gesture.get(), "end", G_CALLBACK(end), this);
     g_signal_connect_swapped(m_gesture.get(), "cancel", G_CALLBACK(cancel), this);
 }

 void GestureController::SwipeGesture::startMomentumScroll(GdkEvent* event, double velocityX, double velocityY)
 {
     m_client.swipe(reinterpret_cast<GdkEventTouch*>(event), FloatPoint::narrowPrecision(velocityX, velocityY));
 }

 void GestureController::SwipeGesture::swipe(SwipeGesture* swipeGesture, double velocityX, double velocityY, GtkGesture* gesture)
 {
     GdkEventSequence* sequence = gtk_gesture_single_get_current_sequence(GTK_GESTURE_SINGLE(gesture));
     if (!gtk_gesture_handles_sequence(gesture, sequence))
         return;

     gtk_gesture_set_sequence_state(gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);

     swipeGesture->startMomentumScroll(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)), velocityX, velocityY);
 }

 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;
     gtk_gesture_get_bounding_box_center(m_gesture.get(), &x, &y);
     return IntPoint(x, y);
 }

 void GestureController::ZoomGesture::startZoom()
 {
     m_client.startZoom(center(), m_initialScale, m_initialPoint);
 }

 void GestureController::ZoomGesture::handleZoom()
 {
     FloatPoint scaledZoomCenter(m_initialPoint);
     scaledZoomCenter.scale(m_scale);

     m_client.zoom(m_scale, WebCore::roundedIntPoint(FloatPoint(scaledZoomCenter - m_viewPoint)));
 }

 void GestureController::ZoomGesture::scaleChanged(ZoomGesture* zoomGesture, double scale, GtkGesture*)
 {
     zoomGesture->m_scale = zoomGesture->m_initialScale * scale;
     if (zoomGesture->m_scale < 1.0)
         zoomGesture->m_scale = 1.0;
     if (zoomGesture->m_scale > maximumZoom)
         zoomGesture->m_scale = maximumZoom;

     zoomGesture->m_viewPoint = zoomGesture->center();

     if (zoomGesture->m_idle.isActive())
         return;

     zoomGesture->m_idle.startOneShot(0_s);
 }

 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);
     g_signal_connect_swapped(m_gesture.get(), "scale-changed", G_CALLBACK(scaleChanged), this);
 }

 void GestureController::LongPressGesture::longPressed(GdkEvent* event)
 {
     m_client.longPress(reinterpret_cast<GdkEventTouch*>(event));
 }

 void GestureController::LongPressGesture::pressed(LongPressGesture* longpressGesture, double x, double y, GtkGesture* gesture)
 {
     GdkEventSequence* sequence = gtk_gesture_single_get_current_sequence(GTK_GESTURE_SINGLE(gesture));
     if (!gtk_gesture_handles_sequence(gesture, sequence))
         return;

     gtk_gesture_set_sequence_state(gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);

     longpressGesture->longPressed(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)));
 }

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

 } // namespace WebKit
	/*
	* Copyright (C) 2014 Igalia S.L.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	* THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "config.h"
	#include "GestureController.h"

	#include <WebCore/Scrollbar.h>
	#include <gtk/gtk.h>

	namespace WebKit {
	using namespace WebCore;

	static const double maximumZoom = 3.0;

	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(GdkEvent* event)
	{
	bool wasProcessingGestures = isProcessingGestures();
	bool touchEnd;
	m_dragGesture.handleEvent(event);
	m_swipeGesture.handleEvent(event);
	m_zoomGesture.handleEvent(event);
	m_longpressGesture.handleEvent(event);
	touchEnd = (gdk_event_get_event_type(event) == GDK_TOUCH_END) \|\| (gdk_event_get_event_type(event) == GDK_TOUCH_CANCEL);
	return touchEnd ? wasProcessingGestures : isProcessingGestures();
	}

	bool GestureController::isProcessingGestures() const
	{
	return m_dragGesture.isActive() \|\| m_swipeGesture.isActive() \|\| m_zoomGesture.isActive() \|\| m_longpressGesture.isActive();
	}

	GestureController::Gesture::Gesture(GtkGesture* gesture, GestureControllerClient& client)
	: m_gesture(adoptGRef(gesture))
	, m_client(client)
	{
	gtk_event_controller_set_propagation_phase(GTK_EVENT_CONTROLLER(m_gesture.get()), GTK_PHASE_NONE);
	}

	void GestureController::Gesture::reset()
	{
	gtk_event_controller_reset(GTK_EVENT_CONTROLLER(m_gesture.get()));
	}

	bool GestureController::Gesture::isActive() const
	{
	return gtk_gesture_is_active(m_gesture.get());
	}

	void GestureController::Gesture::handleEvent(GdkEvent* event)
	{
	gtk_event_controller_handle_event(GTK_EVENT_CONTROLLER(m_gesture.get()), event);
	}

	void GestureController::DragGesture::startDrag(GdkEvent* event)
	{
	ASSERT(!m_inDrag);
	m_client.startDrag(reinterpret_cast<GdkEventTouch*>(event), m_start);
	}

	void GestureController::DragGesture::handleDrag(GdkEvent* event, double x, double y)
	{
	ASSERT(m_inDrag);
	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::cancelDrag()
	{
	ASSERT(m_inDrag);
	m_client.cancelDrag();
	}

	void GestureController::DragGesture::handleTap(GdkEvent* event)
	{
	ASSERT(!m_inDrag);
	m_client.tap(reinterpret_cast<GdkEventTouch*>(event));
	}

	void GestureController::DragGesture::begin(DragGesture* dragGesture, double x, double y, GtkGesture* gesture)
	{
	GdkEventSequence* sequence = gtk_gesture_single_get_current_sequence(GTK_GESTURE_SINGLE(gesture));
	gtk_gesture_set_sequence_state(gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);
	dragGesture->m_inDrag = false;
	dragGesture->m_start.set(x, y);
	dragGesture->m_offset.set(0, 0);

	GtkWidget* widget = gtk_event_controller_get_widget(GTK_EVENT_CONTROLLER(gesture));
	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(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)));
	}

	void GestureController::DragGesture::update(DragGesture* dragGesture, double x, double y, GtkGesture* gesture)
	{
	GdkEventSequence* sequence = gtk_gesture_single_get_current_sequence(GTK_GESTURE_SINGLE(gesture));
	gtk_gesture_set_sequence_state(gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);

	GtkWidget* widget = gtk_event_controller_get_widget(GTK_EVENT_CONTROLLER(gesture));
	if (!dragGesture->m_inDrag && gtk_drag_check_threshold(widget, dragGesture->m_start.x(), dragGesture->m_start.y(), dragGesture->m_start.x() + x, dragGesture->m_start.y() + y)) {
	dragGesture->m_inDrag = true;
	dragGesture->m_longPressTimeout.stop();
	}

	if (dragGesture->m_inDrag)
	dragGesture->handleDrag(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)), x, y);
	dragGesture->m_offset.set(x, y);
	}

	void GestureController::DragGesture::end(DragGesture* dragGesture, GdkEventSequence* sequence, GtkGesture* gesture)
	{
	dragGesture->m_longPressTimeout.stop();
	if (!gtk_gesture_handles_sequence(gesture, sequence)) {
	gtk_gesture_set_state(gesture, GTK_EVENT_SEQUENCE_DENIED);
	return;
	}
	if (!dragGesture->m_inDrag) {
	dragGesture->handleTap(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)));
	gtk_gesture_set_state(gesture, GTK_EVENT_SEQUENCE_DENIED);
	}
	}

	void GestureController::DragGesture::cancel(DragGesture* dragGesture, GdkEventSequence* sequence, GtkGesture* gesture)
	{
	dragGesture->m_longPressTimeout.stop();
	dragGesture->cancelDrag();
	}

	void GestureController::DragGesture::longPressFired()
	{
	m_inDrag = true;
	}

	GestureController::DragGesture::DragGesture(GtkWidget* widget, GestureControllerClient& client)
	: Gesture(gtk_gesture_drag_new(widget), client)
	, m_longPressTimeout(RunLoop::main(), this, &GestureController::DragGesture::longPressFired)
	{
	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);
	g_signal_connect_swapped(m_gesture.get(), "drag-update", G_CALLBACK(update), this);
	g_signal_connect_swapped(m_gesture.get(), "end", G_CALLBACK(end), this);
	g_signal_connect_swapped(m_gesture.get(), "cancel", G_CALLBACK(cancel), this);
	}

	void GestureController::SwipeGesture::startMomentumScroll(GdkEvent* event, double velocityX, double velocityY)
	{
	m_client.swipe(reinterpret_cast<GdkEventTouch*>(event), FloatPoint::narrowPrecision(velocityX, velocityY));
	}

	void GestureController::SwipeGesture::swipe(SwipeGesture* swipeGesture, double velocityX, double velocityY, GtkGesture* gesture)
	{
	GdkEventSequence* sequence = gtk_gesture_single_get_current_sequence(GTK_GESTURE_SINGLE(gesture));
	if (!gtk_gesture_handles_sequence(gesture, sequence))
	return;

	gtk_gesture_set_sequence_state(gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);

	swipeGesture->startMomentumScroll(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)), velocityX, velocityY);
	}

	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;
	gtk_gesture_get_bounding_box_center(m_gesture.get(), &x, &y);
	return IntPoint(x, y);
	}

	void GestureController::ZoomGesture::startZoom()
	{
	m_client.startZoom(center(), m_initialScale, m_initialPoint);
	}

	void GestureController::ZoomGesture::handleZoom()
	{
	FloatPoint scaledZoomCenter(m_initialPoint);
	scaledZoomCenter.scale(m_scale);

	m_client.zoom(m_scale, WebCore::roundedIntPoint(FloatPoint(scaledZoomCenter - m_viewPoint)));
	}

	void GestureController::ZoomGesture::scaleChanged(ZoomGesture* zoomGesture, double scale, GtkGesture*)
	{
	zoomGesture->m_scale = zoomGesture->m_initialScale * scale;
	if (zoomGesture->m_scale < 1.0)
	zoomGesture->m_scale = 1.0;
	if (zoomGesture->m_scale > maximumZoom)
	zoomGesture->m_scale = maximumZoom;

	zoomGesture->m_viewPoint = zoomGesture->center();

	if (zoomGesture->m_idle.isActive())
	return;

	zoomGesture->m_idle.startOneShot(0_s);
	}

	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);
	g_signal_connect_swapped(m_gesture.get(), "scale-changed", G_CALLBACK(scaleChanged), this);
	}

	void GestureController::LongPressGesture::longPressed(GdkEvent* event)
	{
	m_client.longPress(reinterpret_cast<GdkEventTouch*>(event));
	}

	void GestureController::LongPressGesture::pressed(LongPressGesture* longpressGesture, double x, double y, GtkGesture* gesture)
	{
	GdkEventSequence* sequence = gtk_gesture_single_get_current_sequence(GTK_GESTURE_SINGLE(gesture));
	if (!gtk_gesture_handles_sequence(gesture, sequence))
	return;

	gtk_gesture_set_sequence_state(gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);

	longpressGesture->longPressed(const_cast<GdkEvent*>(gtk_gesture_get_last_event(gesture, sequence)));
	}

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

	} // namespace WebKit