wasm: add QWindow parameter to DragEvent

Perparing for enhanced Darg Drop support

Done-with: Mikolaj.Boc@qt.io
Change-Id: I24ce72570ce0754c8a5c152a92192eebeae5b340
Reviewed-by: Lorn Potter <lorn.potter@gmail.com>
(cherry picked from commit 585f348f3c8137cec4ab503eecc28296da2798f7)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>

src/plugins/platforms/wasm/qwasmevent.cpp

@@ -86,7 +86,10 @@ QFlags<Qt::KeyboardModifier> getForEvent<EmscriptenKeyboardEvent>(
 }
 }  // namespace KeyboardModifier
 
-Event::Event(EventType type, emscripten::val target) : type(type), target(target) { }
+Event::Event(EventType type, emscripten::val webEvent)
+    : webEvent(webEvent), type(type)
+{
+}
 
 Event::~Event() = default;
 
@@ -98,7 +101,7 @@ Event &Event::operator=(const Event &other) = default;
 
 Event &Event::operator=(Event &&other) = default;
 
-KeyEvent::KeyEvent(EventType type, emscripten::val event) : Event(type, event["target"])
+KeyEvent::KeyEvent(EventType type, emscripten::val event) : Event(type, event)
 {
     const auto code = event["code"].as<std::string>();
     const auto webKey = event["key"].as<std::string>();
@@ -143,7 +146,7 @@ std::optional<KeyEvent> KeyEvent::fromWebWithDeadKeyTranslation(emscripten::val
     return result;
 }
 
-MouseEvent::MouseEvent(EventType type, emscripten::val event) : Event(type, event["target"])
+MouseEvent::MouseEvent(EventType type, emscripten::val event) : Event(type, event)
 {
     mouseButton = MouseEvent::buttonFromWeb(event["button"].as<int>());
     mouseButtons = MouseEvent::buttonsFromWeb(event["buttons"].as<unsigned short>());
@@ -218,8 +221,8 @@ std::optional<PointerEvent> PointerEvent::fromWeb(emscripten::val event)
     return PointerEvent(*eventType, event);
 }
 
-DragEvent::DragEvent(EventType type, emscripten::val event)
+DragEvent::DragEvent(EventType type, emscripten::val event, QWindow *window)
-    : MouseEvent(type, event), dataTransfer(event["dataTransfer"])
+    : MouseEvent(type, event), dataTransfer(event["dataTransfer"]), targetWindow(window)
 {
     dropAction = ([event]() {
         const std::string effect = event["dataTransfer"]["dropEffect"].as<std::string>();
@@ -244,18 +247,42 @@ DragEvent &DragEvent::operator=(const DragEvent &other) = default;
 
 DragEvent &DragEvent::operator=(DragEvent &&other) = default;
 
-std::optional<DragEvent> DragEvent::fromWeb(emscripten::val event)
+std::optional<DragEvent> DragEvent::fromWeb(emscripten::val event, QWindow *targetWindow)
 {
     const auto eventType = ([&event]() -> std::optional<EventType> {
         const auto eventTypeString = event["type"].as<std::string>();
 
+        if (eventTypeString == "dragend")
+            return EventType::DragEnd;
+        if (eventTypeString == "dragover")
+            return EventType::DragOver;
+        if (eventTypeString == "dragstart")
+            return EventType::DragStart;
         if (eventTypeString == "drop")
             return EventType::Drop;
         return std::nullopt;
     })();
     if (!eventType)
         return std::nullopt;
-    return DragEvent(*eventType, event);
+    return DragEvent(*eventType, event, targetWindow);
+}
+
+void DragEvent::cancelDragStart()
+{
+    Q_ASSERT_X(type == EventType::DragStart, Q_FUNC_INFO, "Only supported for DragStart");
+    webEvent.call<void>("preventDefault");
+}
+
+void DragEvent::acceptDragOver()
+{
+    Q_ASSERT_X(type == EventType::DragOver, Q_FUNC_INFO, "Only supported for DragOver");
+   webEvent.call<void>("preventDefault");
+}
+
+void DragEvent::acceptDrop()
+{
+    Q_ASSERT_X(type == EventType::Drop, Q_FUNC_INFO, "Only supported for Drop");
+    webEvent.call<void>("preventDefault");
 }
 
 WheelEvent::WheelEvent(EventType type, emscripten::val event) : MouseEvent(type, event)

src/plugins/platforms/wasm/qwasmevent.h

@@ -18,8 +18,12 @@
 QT_BEGIN_NAMESPACE
 
 class QWasmDeadKeySupport;
+class QWindow;
 
 enum class EventType {
+    DragEnd,
+    DragOver,
+    DragStart,
     Drop,
     KeyDown,
     KeyUp,
@@ -119,15 +123,16 @@ QFlags<Qt::KeyboardModifier> getForEvent<EmscriptenKeyboardEvent>(
 
 struct Event
 {
-    Event(EventType type, emscripten::val target);
+    Event(EventType type, emscripten::val webEvent);
     ~Event();
     Event(const Event &other);
     Event(Event &&other);
     Event &operator=(const Event &other);
     Event &operator=(Event &&other);
 
+    emscripten::val webEvent;
     EventType type;
-    emscripten::val target = emscripten::val::undefined();
+    emscripten::val target() const { return webEvent["target"]; }
 };
 
 struct KeyEvent : public Event
@@ -221,17 +226,22 @@ struct PointerEvent : public MouseEvent
 
 struct DragEvent : public MouseEvent
 {
-    static std::optional<DragEvent> fromWeb(emscripten::val webEvent);
+    static std::optional<DragEvent> fromWeb(emscripten::val webEvent, QWindow *targetQWindow);
 
-    DragEvent(EventType type, emscripten::val webEvent);
+    DragEvent(EventType type, emscripten::val webEvent, QWindow *targetQWindow);
     ~DragEvent();
     DragEvent(const DragEvent &other);
     DragEvent(DragEvent &&other);
     DragEvent &operator=(const DragEvent &other);
     DragEvent &operator=(DragEvent &&other);
 
+    void cancelDragStart();
+    void acceptDragOver();
+    void acceptDrop();
+
     Qt::DropAction dropAction;
     emscripten::val dataTransfer;
+    QWindow *targetWindow;
 };
 
 struct WheelEvent : public MouseEvent

src/plugins/platforms/wasm/qwasmwindow.cpp

@@ -117,7 +117,7 @@ QWasmWindow::QWasmWindow(QWindow *w, QWasmDeadKeySupport *deadKeySupport,
 
     m_dropCallback = std::make_unique<qstdweb::EventCallback>(
             m_qtWindow, "drop", [this](emscripten::val event) {
-                if (processDrop(*DragEvent::fromWeb(event)))
+                if (processDrop(*DragEvent::fromWeb(event, window())))
                     event.call<void>("preventDefault");
             });
 
@@ -188,7 +188,7 @@ void QWasmWindow::onNonClientAreaInteraction()
 bool QWasmWindow::onNonClientEvent(const PointerEvent &event)
 {
     QPointF pointInScreen = platformScreen()->mapFromLocal(
-            dom::mapPoint(event.target, platformScreen()->element(), event.localPoint));
+        dom::mapPoint(event.target(), platformScreen()->element(), event.localPoint));
     return QWindowSystemInterface::handleMouseEvent(
             window(), QWasmIntegration::getTimestamp(), window()->mapFromGlobal(pointInScreen),
             pointInScreen, event.mouseButtons, event.mouseButton,
@@ -521,7 +521,7 @@ bool QWasmWindow::processPointer(const PointerEvent &event)
     switch (event.type) {
     case EventType::PointerEnter: {
         const auto pointInScreen = platformScreen()->mapFromLocal(
-                dom::mapPoint(event.target, platformScreen()->element(), event.localPoint));
+            dom::mapPoint(event.target(), platformScreen()->element(), event.localPoint));
         QWindowSystemInterface::handleEnterEvent(
                 window(), m_window->mapFromGlobal(pointInScreen), pointInScreen);
         break;
@@ -575,7 +575,7 @@ bool QWasmWindow::processWheel(const WheelEvent &event)
     })();
 
     const auto pointInScreen = platformScreen()->mapFromLocal(
-            dom::mapPoint(event.target, platformScreen()->element(), event.localPoint));
+        dom::mapPoint(event.target(), platformScreen()->element(), event.localPoint));
 
     return QWindowSystemInterface::handleWheelEvent(
             window(), QWasmIntegration::getTimestamp(), window()->mapFromGlobal(pointInScreen),

src/plugins/platforms/wasm/qwasmwindowclientarea.cpp

@@ -57,7 +57,7 @@ bool ClientArea::processPointer(const PointerEvent &event)
 bool ClientArea::deliverEvent(const PointerEvent &event)
 {
     const auto pointInScreen = m_screen->mapFromLocal(
-            dom::mapPoint(event.target, m_screen->element(), event.localPoint));
+        dom::mapPoint(event.target(), m_screen->element(), event.localPoint));
 
     const auto geometryF = m_screen->geometry().toRectF();
     const QPointF targetPointClippedToScreen(

src/plugins/platforms/wasm/qwasmwindownonclientarea.cpp

@@ -208,7 +208,7 @@ void Resizer::startResize(Qt::Edges resizeEdges, const PointerEvent &event)
     m_currentResizeData.reset(new ResizeData{
             .edges = resizeEdges,
             .originInScreenCoords = dom::mapPoint(
-                    event.target, m_window->platformScreen()->element(), event.localPoint),
+            event.target(), m_window->platformScreen()->element(), event.localPoint),
     });
 
     const auto resizeConstraints = getResizeConstraints();
@@ -225,7 +225,7 @@ void Resizer::startResize(Qt::Edges resizeEdges, const PointerEvent &event)
 void Resizer::continueResize(const PointerEvent &event)
 {
     const auto pointInScreen =
-            dom::mapPoint(event.target, m_window->platformScreen()->element(), event.localPoint);
+        dom::mapPoint(event.target(), m_window->platformScreen()->element(), event.localPoint);
     const auto amount = (pointInScreen - m_currentResizeData->originInScreenCoords).toPoint();
     const QPoint cappedGrowVector(
             std::min(m_currentResizeData->maxGrow.x(),