void PageClientImpl::doneWithTouchEvent(const NativeWebTouchEvent& event, bool wasEventHandled)
{
if (wasEventHandled)
return;
#if HAVE(GTK_GESTURES)
GestureController& gestureController = webkitWebViewBaseGestureController(WEBKIT_WEB_VIEW_BASE(m_viewWidget));
if (gestureController.handleEvent(event.nativeEvent()))
return;
#endif
// Emulate pointer events if unhandled.
const GdkEvent* touchEvent = event.nativeEvent();
if (!touchEvent->touch.emulating_pointer)
return;
GUniquePtr<GdkEvent> pointerEvent;
if (touchEvent->type == GDK_TOUCH_UPDATE) {
pointerEvent.reset(gdk_event_new(GDK_MOTION_NOTIFY));
pointerEvent->motion.time = touchEvent->touch.time;
pointerEvent->motion.x = touchEvent->touch.x;
pointerEvent->motion.y = touchEvent->touch.y;
pointerEvent->motion.x_root = touchEvent->touch.x_root;
pointerEvent->motion.y_root = touchEvent->touch.y_root;
pointerEvent->motion.state = touchEvent->touch.state | GDK_BUTTON1_MASK;
} else {
switch (touchEvent->type) {
case GDK_TOUCH_END:
pointerEvent.reset(gdk_event_new(GDK_BUTTON_RELEASE));
pointerEvent->button.state = touchEvent->touch.state | GDK_BUTTON1_MASK;
break;
case GDK_TOUCH_BEGIN:
pointerEvent.reset(gdk_event_new(GDK_BUTTON_PRESS));
break;
default:
ASSERT_NOT_REACHED();
}
pointerEvent->button.button = 1;
pointerEvent->button.time = touchEvent->touch.time;
pointerEvent->button.x = touchEvent->touch.x;
pointerEvent->button.y = touchEvent->touch.y;
pointerEvent->button.x_root = touchEvent->touch.x_root;
pointerEvent->button.y_root = touchEvent->touch.y_root;
}
gdk_event_set_device(pointerEvent.get(), gdk_event_get_device(touchEvent));
gdk_event_set_source_device(pointerEvent.get(), gdk_event_get_source_device(touchEvent));
pointerEvent->any.window = GDK_WINDOW(g_object_ref(touchEvent->any.window));
pointerEvent->any.send_event = TRUE;
gtk_widget_event(m_viewWidget, pointerEvent.get());
}
void QtWebPageEventHandler::doneWithTouchEvent(const NativeWebTouchEvent& event, bool wasEventHandled)
{
if (wasEventHandled || event.type() == WebEvent::TouchCancel) {
m_panGestureRecognizer.cancel();
m_pinchGestureRecognizer.cancel();
if (event.type() != WebEvent::TouchMove)
m_tapGestureRecognizer.cancel();
return;
}
const QTouchEvent* ev = event.nativeEvent();
handleInputEvent(ev);
}
void QtWebPageEventHandler::doneWithTouchEvent(const NativeWebTouchEvent& event, bool wasEventHandled)
{
if (!m_interactionEngine)
return;
if (wasEventHandled || event.type() == WebEvent::TouchCancel) {
resetGestureRecognizers();
return;
}
const QTouchEvent* ev = event.nativeEvent();
switch (ev->type()) {
case QEvent::TouchBegin:
ASSERT(!m_interactionEngine->panGestureActive());
ASSERT(!m_interactionEngine->pinchGestureActive());
// The interaction engine might still be animating kinetic scrolling or a scale animation
// such as double-tap to zoom or the bounce back effect. A touch stops the kinetic scrolling
// where as it does not stop the scale animation.
if (m_interactionEngine->scrollAnimationActive())
m_interactionEngine->interruptScrollAnimation();
break;
case QEvent::TouchUpdate:
// The scale animation can only be interrupted by a pinch gesture, which will then take over.
if (m_interactionEngine->scaleAnimationActive() && m_pinchGestureRecognizer.isRecognized())
m_interactionEngine->interruptScaleAnimation();
break;
default:
break;
}
// If the scale animation is active we don't pass the event to the recognizers. In the future
// we would want to queue the event here and repost then when the animation ends.
if (m_interactionEngine->scaleAnimationActive())
return;
// Convert the event timestamp from second to millisecond.
qint64 eventTimestampMillis = static_cast<qint64>(event.timestamp() * 1000);
m_panGestureRecognizer.recognize(ev, eventTimestampMillis);
m_pinchGestureRecognizer.recognize(ev);
if (m_panGestureRecognizer.isRecognized() || m_pinchGestureRecognizer.isRecognized())
m_tapGestureRecognizer.reset();
else {
const QTouchEvent* ev = event.nativeEvent();
m_tapGestureRecognizer.recognize(ev, eventTimestampMillis);
}
}
void PageClientImpl::doneWithTouchEvent(const NativeWebTouchEvent& touchEvent, bool wasEventHandled)
{
if (wasEventHandled)
return;
const struct wpe_input_touch_event_raw* touchPoint = touchEvent.nativeFallbackTouchPoint();
if (touchPoint->type == wpe_input_touch_event_type_null)
return;
struct wpe_input_pointer_event pointerEvent{
wpe_input_pointer_event_type_null, touchPoint->time,
touchPoint->x, touchPoint->y,
1, 0
};
switch (touchPoint->type) {
case wpe_input_touch_event_type_down:
pointerEvent.type = wpe_input_pointer_event_type_button;
pointerEvent.state = 1;
break;
case wpe_input_touch_event_type_motion:
pointerEvent.type = wpe_input_pointer_event_type_motion;
pointerEvent.state = 1;
break;
case wpe_input_touch_event_type_up:
pointerEvent.type = wpe_input_pointer_event_type_button;
pointerEvent.state = 0;
break;
case wpe_input_pointer_event_type_null:
ASSERT_NOT_REACHED();
return;
}
m_view.page().handleMouseEvent(NativeWebMouseEvent(&pointerEvent));
}
void WebViewClient::doneWithTouchEvent(WebView* view, const NativeWebTouchEvent& event, bool wasEventHandled)
{
#if PLATFORM(EFL)
if (!m_client.doneWithTouchEvent)
return;
m_client.doneWithTouchEvent(toAPI(view), toAPI(const_cast<EwkTouchEvent*>(event.nativeEvent())), wasEventHandled, m_client.base.clientInfo);
#else
notImplemented();
UNUSED_PARAM(view);
UNUSED_PARAM(event);
UNUSED_PARAM(wasEventHandled);
#endif
}
void QtWebPageEventHandler::doneWithTouchEvent(const NativeWebTouchEvent& event, bool wasEventHandled)
{
if (!m_interactionEngine)
return;
if (wasEventHandled || event.type() == WebEvent::TouchCancel) {
resetGestureRecognizers();
return;
}
const QTouchEvent* ev = event.nativeEvent();
switch (ev->type()) {
case QEvent::TouchBegin:
ASSERT(!m_interactionEngine->panGestureActive());
ASSERT(!m_interactionEngine->pinchGestureActive());
m_interactionEngine->touchBegin();
// The interaction engine might still be animating kinetic scrolling or a scale animation
// such as double-tap to zoom or the bounce back effect. A touch stops the kinetic scrolling
// where as it does not stop the scale animation.
// The gesture recognizer stops the kinetic scrolling animation if needed.
break;
case QEvent::TouchUpdate:
// The scale animation can only be interrupted by a pinch gesture, which will then take over.
if (m_interactionEngine->scaleAnimationActive() && m_pinchGestureRecognizer.isRecognized())
m_interactionEngine->interruptScaleAnimation();
break;
case QEvent::TouchEnd:
m_interactionEngine->touchEnd();
break;
default:
break;
}
// If the scale animation is active we don't pass the event to the recognizers. In the future
// we would want to queue the event here and repost then when the animation ends.
if (m_interactionEngine->scaleAnimationActive())
return;
const QList<QTouchEvent::TouchPoint>& touchPoints = ev->touchPoints();
const int touchPointCount = touchPoints.size();
qint64 eventTimestampMillis = ev->timestamp();
QList<QTouchEvent::TouchPoint> activeTouchPoints;
activeTouchPoints.reserve(touchPointCount);
for (int i = 0; i < touchPointCount; ++i) {
if (touchPoints[i].state() != Qt::TouchPointReleased)
activeTouchPoints << touchPoints[i];
}
const int activeTouchPointCount = activeTouchPoints.size();
if (!activeTouchPointCount) {
if (touchPointCount == 1) {
// No active touch points, one finger released.
if (!m_panGestureRecognizer.isRecognized())
m_tapGestureRecognizer.update(ev->type(), touchPoints.first());
m_panGestureRecognizer.finish(touchPoints.first(), eventTimestampMillis);
} else
m_pinchGestureRecognizer.finish();
// Early return since this was a touch-end event.
return;
} else if (activeTouchPointCount == 1) {
// If the pinch gesture recognizer was previously in active state the content might
// be out of valid zoom boundaries, thus we need to finish the pinch gesture here.
// This will resume the content to valid zoom levels before the pan gesture is started.
m_pinchGestureRecognizer.finish();
m_panGestureRecognizer.update(activeTouchPoints.first(), eventTimestampMillis);
} else if (activeTouchPointCount == 2) {
m_panGestureRecognizer.cancel();
m_pinchGestureRecognizer.update(activeTouchPoints.first(), activeTouchPoints.last());
}
if (m_panGestureRecognizer.isRecognized() || m_pinchGestureRecognizer.isRecognized() || m_webView->isMoving())
m_tapGestureRecognizer.cancel();
else if (touchPointCount == 1)
m_tapGestureRecognizer.update(ev->type(), touchPoints.first());
}
void WebViewNix::doneWithTouchEvent(const NativeWebTouchEvent& event, bool wasEventHandled)
{
m_viewClientNix.doneWithTouchEvent(this, *event.nativeEvent(), wasEventHandled);
}
