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