From a74b2b5f152ae81da6c0906afc63b8647c3a048a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tor=20Arne=20Vestb=C3=B8?= <tor.arne.vestbo@qt.io>
Date: Wed, 27 Feb 2019 11:30:31 +0100
Subject: macOS: Initialize QNSView mouse related members with other mouse
 logic
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Change-Id: I4ff67028823d62ed67bf4303a58bee127bd76501
Reviewed-by: Timur Pocheptsov <timur.pocheptsov@qt.io>
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
---
 src/plugins/platforms/cocoa/qnsview.mm       |  9 ---------
 src/plugins/platforms/cocoa/qnsview_mouse.mm | 13 +++++++++++++
 2 files changed, 13 insertions(+), 9 deletions(-)

(limited to 'src/plugins')

diff --git a/src/plugins/platforms/cocoa/qnsview.mm b/src/plugins/platforms/cocoa/qnsview.mm
index 17063f6e92..5309449dce 100644
--- a/src/plugins/platforms/cocoa/qnsview.mm
+++ b/src/plugins/platforms/cocoa/qnsview.mm
@@ -137,22 +137,13 @@
 {
     if ((self = [super initWithFrame:NSZeroRect])) {
         m_platformWindow = platformWindow;
-        m_buttons = Qt::NoButton;
-        m_acceptedMouseDowns = Qt::NoButton;
-        m_frameStrutButtons = Qt::NoButton;
         m_sendKeyEvent = false;
-        m_sendUpAsRightButton = false;
         m_inputSource = nil;
-        m_mouseMoveHelper = [[QT_MANGLE_NAMESPACE(QNSViewMouseMoveHelper) alloc] initWithView:self];
         m_resendKeyEvent = false;
-        m_scrolling = false;
         m_updatingDrag = false;
         m_currentlyInterpretedKeyEvent = nil;
-        m_dontOverrideCtrlLMB = qt_mac_resolveOption(false, platformWindow->window(),
-            "_q_platform_MacDontOverrideCtrlLMB", "QT_MAC_DONT_OVERRIDE_CTRL_LMB");
 
         self.focusRingType = NSFocusRingTypeNone;
-        self.cursor = nil;
 
         self.previousSuperview = nil;
         self.previousWindow = nil;
diff --git a/src/plugins/platforms/cocoa/qnsview_mouse.mm b/src/plugins/platforms/cocoa/qnsview_mouse.mm
index 49c94f18db..c9c87d9323 100644
--- a/src/plugins/platforms/cocoa/qnsview_mouse.mm
+++ b/src/plugins/platforms/cocoa/qnsview_mouse.mm
@@ -153,6 +153,19 @@
 
 - (void)initMouse
 {
+    m_buttons = Qt::NoButton;
+    m_acceptedMouseDowns = Qt::NoButton;
+    m_frameStrutButtons = Qt::NoButton;
+
+    m_scrolling = false;
+    self.cursor = nil;
+
+    m_sendUpAsRightButton = false;
+    m_dontOverrideCtrlLMB = qt_mac_resolveOption(false, m_platformWindow->window(),
+            "_q_platform_MacDontOverrideCtrlLMB", "QT_MAC_DONT_OVERRIDE_CTRL_LMB");
+
+    m_mouseMoveHelper = [[QT_MANGLE_NAMESPACE(QNSViewMouseMoveHelper) alloc] initWithView:self];
+
     NSUInteger trackingOptions = NSTrackingActiveInActiveApp
         | NSTrackingMouseEnteredAndExited | NSTrackingCursorUpdate;
 
-- 
cgit v1.2.3


From 070f75d3b0f5313a0f486fe5c811a8e40dd97967 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Morten=20Johan=20S=C3=B8rvig?= <morten.sorvig@qt.io>
Date: Sat, 23 Feb 2019 09:40:30 +0100
Subject: wasm: improve clipboard fallback path
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This improves handling of cut/copy/paste clipboard events,
ands allows clipboard access via the common keyboard
shortcuts.

Make the canvas be eligible for clipboard events by
setting the contenteditable attribute. Install clipboard
event handlers directly on the canvas.

Suppress Ctrl+X/C/V key event handling in the keyboard
event handler in order to make the browser generate
clipboard events. Send synthetic key events from the
clipboard event handlers to make the app copy/paste
to Qt’s clipboard at the correct time.

Access the system clipboard data using event.clipboardData.

Task-number: QTBUG-64638
Change-Id: I584b78ffa2b755b1b76e477b970255c6e5522f6a
Reviewed-by: Lorn Potter <lorn.potter@gmail.com>
---
 src/plugins/platforms/wasm/qtloader.js             |  9 +++-
 src/plugins/platforms/wasm/qwasmclipboard.cpp      | 48 +++++++++++++++-------
 .../platforms/wasm/qwasmeventtranslator.cpp        |  8 ++++
 src/plugins/platforms/wasm/wasm_shell.html         |  8 +++-
 4 files changed, 56 insertions(+), 17 deletions(-)

(limited to 'src/plugins')

diff --git a/src/plugins/platforms/wasm/qtloader.js b/src/plugins/platforms/wasm/qtloader.js
index 84694c7b9f..203213db56 100644
--- a/src/plugins/platforms/wasm/qtloader.js
+++ b/src/plugins/platforms/wasm/qtloader.js
@@ -168,7 +168,14 @@ function QtLoader(config)
             removeChildren(container);
             var canvas = document.createElement("canvas");
             canvas.className = "QtCanvas"
-            canvas.style = "height: 100%; width: 100%;"
+            canvas.style.height = "100%"
+            canvas.style.width = "100%"
+
+            // Set contentEditable in order to enable clipboard events; hide the resulting focus frame.
+            canvas.contentEditable = true;
+            canvas.style.outline = "0px solid transparent";
+            canvas.style.cursor = "default";
+
             return canvas;
         }
 
diff --git a/src/plugins/platforms/wasm/qwasmclipboard.cpp b/src/plugins/platforms/wasm/qwasmclipboard.cpp
index ec058f05dd..63fea7738d 100644
--- a/src/plugins/platforms/wasm/qwasmclipboard.cpp
+++ b/src/plugins/platforms/wasm/qwasmclipboard.cpp
@@ -67,23 +67,42 @@ static void qClipboardPromiseResolve(emscripten::val something)
     pasteClipboardData(emscripten::val("text/plain"), something);
 }
 
-static void qClipboardCopyTo(val event)
+static void qClipboardCutTo(val event)
 {
-    val target = event["target"];
-    val clipboard = event["clipboardData"];
+    if (!QWasmIntegration::get()->getWasmClipboard()->hasClipboardApi) {
+        // Send synthetic Ctrl+X to make the app cut data to Qt's clipboard
+        QWindowSystemInterface::handleKeyEvent<QWindowSystemInterface::SynchronousDelivery>(
+            0, QEvent::KeyPress, Qt::Key_X,  Qt::ControlModifier, "X");
+    }
 
     val module = val::global("Module");
     val clipdata = module.call<val>("getClipboardData");
     val clipFormat = module.call<val>("getClipboardFormat");
-    clipboard.call<void>("setData", clipFormat, clipdata);
-    target.call<void>("preventDefault");
+    event["clipboardData"].call<void>("setData", clipFormat, clipdata);
+    event.call<void>("preventDefault");
 }
 
-static void qClipboardPasteTo(val event)
+static void qClipboardCopyTo(val event)
 {
-    val target = event["clipboardData"];
+    if (!QWasmIntegration::get()->getWasmClipboard()->hasClipboardApi) {
+        // Send synthetic Ctrl+C to make the app copy data to Qt's clipboard
+        QWindowSystemInterface::handleKeyEvent<QWindowSystemInterface::SynchronousDelivery>(
+            0, QEvent::KeyPress, Qt::Key_C,  Qt::ControlModifier, "C");
+    }
+
     val module = val::global("Module");
     val clipdata = module.call<val>("getClipboardData");
+    val clipFormat = module.call<val>("getClipboardFormat");
+    event["clipboardData"].call<void>("setData", clipFormat, clipdata);
+    event.call<void>("preventDefault");
+}
+
+static void qClipboardPasteTo(val event)
+{
+    bool hasClipboardApi = QWasmIntegration::get()->getWasmClipboard()->hasClipboardApi;
+    val clipdata = hasClipboardApi ?
+        val::global("Module").call<val>("getClipboardData") :
+        event["clipboardData"].call<val>("getData", std::string("text"));
 
     const std::string data = clipdata.as<std::string>();
     if (data.length() > 0) {
@@ -99,6 +118,7 @@ EMSCRIPTEN_BINDINGS(clipboard_module) {
     function("getClipboardFormat", &getClipboardFormat);
     function("pasteClipboardData", &pasteClipboardData);
     function("qClipboardPromiseResolve", &qClipboardPromiseResolve);
+    function("qClipboardCutTo", &qClipboardCutTo);
     function("qClipboardCopyTo", &qClipboardCopyTo);
     function("qClipboardPasteTo", &qClipboardPasteTo);
 }
@@ -161,7 +181,7 @@ void QWasmClipboard::initClipboardEvents()
     val permissions = navigator["permissions"];
     val clipboard = navigator["clipboard"];
 
-    hasClipboardApi = (!clipboard.isUndefined());
+    hasClipboardApi = (!clipboard.isUndefined() && !clipboard["readText"].isUndefined());
     if (hasClipboardApi) {
         val readPermissionsMap = val::object();
         readPermissionsMap.set("name", val("clipboard-read"));
@@ -172,13 +192,13 @@ void QWasmClipboard::initClipboardEvents()
         permissions.call<val>("query", writePermissionsMap);
 
     } else {
-
-        val window = val::global("window");
-        window.call<void>("addEventListener", std::string("paste"),
-                          val::module_property("qClipboardPasteTo"));
-
-        window.call<void>("addEventListener", std::string("copy"),
+        val canvas = val::module_property("canvas");
+        canvas.call<void>("addEventListener", std::string("cut"),
+                          val::module_property("qClipboardCutTo"));
+        canvas.call<void>("addEventListener", std::string("copy"),
                           val::module_property("qClipboardCopyTo"));
+        canvas.call<void>("addEventListener", std::string("paste"),
+                          val::module_property("qClipboardPasteTo"));
     }
 }
 
diff --git a/src/plugins/platforms/wasm/qwasmeventtranslator.cpp b/src/plugins/platforms/wasm/qwasmeventtranslator.cpp
index 3fc8f600a1..05c09ec9a0 100644
--- a/src/plugins/platforms/wasm/qwasmeventtranslator.cpp
+++ b/src/plugins/platforms/wasm/qwasmeventtranslator.cpp
@@ -832,6 +832,14 @@ bool QWasmEventTranslator::processKeyboard(int eventType, const EmscriptenKeyboa
         return 0;
 
     QFlags<Qt::KeyboardModifier> mods = translateKeyboardEventModifier(keyEvent);
+
+    // Clipboard fallback path: cut/copy/paste are handled by clipboard event
+    // handlers if direct clipboard access is not available.
+    if (!QWasmIntegration::get()->getWasmClipboard()->hasClipboardApi && modifiers & Qt::ControlModifier &&
+        (qtKey == Qt::Key_X || qtKey == Qt::Key_C || qtKey == Qt::Key_V)) {
+            return 0;
+    }
+
     bool accepted = false;
 
     if (keyType == QEvent::KeyPress &&
diff --git a/src/plugins/platforms/wasm/wasm_shell.html b/src/plugins/platforms/wasm/wasm_shell.html
index 67bfcdfbdc..110d45e036 100644
--- a/src/plugins/platforms/wasm/wasm_shell.html
+++ b/src/plugins/platforms/wasm/wasm_shell.html
@@ -7,7 +7,11 @@
     <style>
       html, body { padding: 0; margin : 0; overflow:hidden; height: 100% }
       /* the canvas *must not* have any border or padding, or mouse coords will be wrong */
-      canvas { border: 0px none; background-color: white; height:100%; width:100%; }
+      canvas { border: 0px none; background-color: white; height:100%; width:100%;  }
+      /* The contenteditable property is set to true for the canvas in order to support
+         clipboard events. Hide the resulting focus frame and set the cursor back to
+         the default cursor. */
+      canvas { outline: 0px solid transparent; cursor:default }
     </style>
   </head>
   <body onload="init()">
@@ -19,7 +23,7 @@
         <noscript>JavaScript is disabled. Please enable JavaScript to use this application.</noscript>
       </center>
     </figure>
-    <canvas id="canvas" oncontextmenu="event.preventDefault()"></canvas>
+    <canvas id="canvas" oncontextmenu="event.preventDefault()" contenteditable="true"></canvas>
 
     <script type='text/javascript'>
         function init() {
-- 
cgit v1.2.3


From 65d2f0d173cb89f028c409f2dc47c494dc9bf964 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tor=20Arne=20Vestb=C3=B8?= <tor.arne.vestbo@qt.io>
Date: Thu, 28 Feb 2019 14:50:01 +0100
Subject: macOS: Modernize qnsview_dragging.mm

Style fixes, modern Objective-C usage, and use of convenience APIs.

Change-Id: I04801b0b5f0d2213b4bcf1b0158fc32e57432d28
Reviewed-by: Timur Pocheptsov <timur.pocheptsov@qt.io>
---
 src/plugins/platforms/cocoa/qnsview_dragging.mm | 100 +++++++++++-------------
 1 file changed, 45 insertions(+), 55 deletions(-)

(limited to 'src/plugins')

diff --git a/src/plugins/platforms/cocoa/qnsview_dragging.mm b/src/plugins/platforms/cocoa/qnsview_dragging.mm
index 1c38c5326c..25be73b6ab 100644
--- a/src/plugins/platforms/cocoa/qnsview_dragging.mm
+++ b/src/plugins/platforms/cocoa/qnsview_dragging.mm
@@ -57,9 +57,9 @@
                    NSFilesPromisePboardType, NSInkTextPboardType,
                    NSMultipleTextSelectionPboardType, mimeTypeGeneric]];
 
-    // Add custom types supported by the application.
+    // Add custom types supported by the application
     for (const QString &customType : qt_mac_enabledDraggedTypes())
-       [supportedTypes addObject:customType.toNSString()];
+        [supportedTypes addObject:customType.toNSString()];
 
     [self registerForDraggedTypes:supportedTypes];
 }
@@ -79,11 +79,11 @@ static QPoint mapWindowCoordinates(QWindow *source, QWindow *target, QPoint poin
     return target->mapFromGlobal(source->mapToGlobal(point));
 }
 
-- (NSDragOperation)draggingSession:(NSDraggingSession *)session
-  sourceOperationMaskForDraggingContext:(NSDraggingContext)context
+- (NSDragOperation)draggingSession:(NSDraggingSession *)session sourceOperationMaskForDraggingContext:(NSDraggingContext)context
 {
     Q_UNUSED(session);
     Q_UNUSED(context);
+
     QCocoaDrag* nativeDrag = QCocoaIntegration::instance()->drag();
     return qt_mac_mapDropActions(nativeDrag->currentDrag()->supportedActions());
 }
@@ -134,30 +134,29 @@ static QPoint mapWindowCoordinates(QWindow *source, QWindow *target, QPoint poin
 
     if (pixmapCursor.isNull()) {
         switch (response.acceptedAction()) {
-            case Qt::CopyAction:
-                nativeCursor = [NSCursor dragCopyCursor];
-                break;
-            case Qt::LinkAction:
-                nativeCursor = [NSCursor dragLinkCursor];
-                break;
-            case Qt::IgnoreAction:
-                // Uncomment the next lines if forbiden cursor wanted on non droppable targets.
-                /*nativeCursor = [NSCursor operationNotAllowedCursor];
-                break;*/
-            case Qt::MoveAction:
-            default:
-                nativeCursor = [NSCursor arrowCursor];
-                break;
+        case Qt::CopyAction:
+            nativeCursor = [NSCursor dragCopyCursor];
+            break;
+        case Qt::LinkAction:
+            nativeCursor = [NSCursor dragLinkCursor];
+            break;
+        case Qt::IgnoreAction:
+            // Uncomment the next lines if forbidden cursor is wanted on undroppable targets.
+            /*nativeCursor = [NSCursor operationNotAllowedCursor];
+            break;*/
+        case Qt::MoveAction:
+        default:
+            nativeCursor = [NSCursor arrowCursor];
+            break;
         }
-    }
-    else {
+    } else {
         NSImage *nsimage = qt_mac_create_nsimage(pixmapCursor);
         nsimage.size = NSSizeFromCGSize((pixmapCursor.size() / pixmapCursor.devicePixelRatioF()).toCGSize());
         nativeCursor = [[NSCursor alloc] initWithImage:nsimage hotSpot:NSZeroPoint];
         [nsimage release];
     }
 
-    // change the cursor
+    // Change the cursor
     [nativeCursor set];
 
     // Make sure the cursor is updated correctly if the mouse does not move and window is under cursor
@@ -169,39 +168,33 @@ static QPoint mapWindowCoordinates(QWindow *source, QWindow *target, QPoint poin
     if (m_updatingDrag)
         return;
 
-    const QPoint mousePos(QCursor::pos());
-    CGEventRef moveEvent(CGEventCreateMouseEvent(
-        NULL, kCGEventMouseMoved,
-        CGPointMake(mousePos.x(), mousePos.y()),
+    QCFType<CGEventRef> moveEvent = CGEventCreateMouseEvent(
+        nullptr, kCGEventMouseMoved, QCursor::pos().toCGPoint(),
         kCGMouseButtonLeft // ignored
-    ));
+    );
     CGEventPost(kCGHIDEventTap, moveEvent);
-    CFRelease(moveEvent);
 }
 
-- (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
+- (NSDragOperation)draggingEntered:(id<NSDraggingInfo>)sender
 {
-    return [self handleDrag : sender];
+    return [self handleDrag:sender];
 }
 
-- (NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender
+- (NSDragOperation)draggingUpdated:(id<NSDraggingInfo>)sender
 {
-    m_updatingDrag = true;
-    const NSDragOperation ret([self handleDrag : sender]);
-    m_updatingDrag = false;
-
-    return ret;
+    QScopedValueRollback<bool> rollback(m_updatingDrag, true);
+    return [self handleDrag:sender];
 }
 
 // Sends drag update to Qt, return the action
-- (NSDragOperation)handleDrag:(id <NSDraggingInfo>)sender
+- (NSDragOperation)handleDrag:(id<NSDraggingInfo>)sender
 {
     if (!m_platformWindow)
         return NSDragOperationNone;
 
-    NSPoint windowPoint = [self convertPoint: [sender draggingLocation] fromView: nil];
-    QPoint qt_windowPoint(windowPoint.x, windowPoint.y);
-    Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations([sender draggingSourceOperationMask]);
+    QPoint windowPoint = QPointF::fromCGPoint([self convertPoint:sender.draggingLocation fromView:nil]).toPoint();
+
+    Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations(sender.draggingSourceOperationMask);
 
     QWindow *target = findEventTargetWindow(m_platformWindow->window());
     if (!target)
@@ -209,7 +202,7 @@ static QPoint mapWindowCoordinates(QWindow *source, QWindow *target, QPoint poin
 
     const auto modifiers = [QNSView convertKeyModifiers:NSApp.currentEvent.modifierFlags];
     const auto buttons = currentlyPressedMouseButtons();
-    const auto point = mapWindowCoordinates(m_platformWindow->window(), target, qt_windowPoint);
+    const auto point = mapWindowCoordinates(m_platformWindow->window(), target, windowPoint);
 
     QPlatformDragQtResponse response(false, Qt::IgnoreAction, QRect());
     QCocoaDrag* nativeDrag = QCocoaIntegration::instance()->drag();
@@ -219,7 +212,7 @@ static QPoint mapWindowCoordinates(QWindow *source, QWindow *target, QPoint poin
                                                       point, qtAllowed, buttons, modifiers);
         [self updateCursorFromDragResponse:response drag:nativeDrag];
     } else {
-        QCocoaDropData mimeData([sender draggingPasteboard]);
+        QCocoaDropData mimeData(sender.draggingPasteboard);
         response = QWindowSystemInterface::handleDrag(target, &mimeData,
                                                       point, qtAllowed, buttons, modifiers);
     }
@@ -227,7 +220,7 @@ static QPoint mapWindowCoordinates(QWindow *source, QWindow *target, QPoint poin
     return qt_mac_mapDropAction(response.acceptedAction());
 }
 
-- (void)draggingExited:(id <NSDraggingInfo>)sender
+- (void)draggingExited:(id<NSDraggingInfo>)sender
 {
     if (!m_platformWindow)
         return;
@@ -236,17 +229,16 @@ static QPoint mapWindowCoordinates(QWindow *source, QWindow *target, QPoint poin
     if (!target)
         return;
 
-    NSPoint windowPoint = [self convertPoint: [sender draggingLocation] fromView: nil];
-    QPoint qt_windowPoint(windowPoint.x, windowPoint.y);
+    QPoint windowPoint = QPointF::fromCGPoint([self convertPoint:sender.draggingLocation fromView:nil]).toPoint();
 
     // Send 0 mime data to indicate drag exit
     QWindowSystemInterface::handleDrag(target, nullptr,
-                                       mapWindowCoordinates(m_platformWindow->window(), target, qt_windowPoint),
+                                       mapWindowCoordinates(m_platformWindow->window(), target, windowPoint),
                                        Qt::IgnoreAction, Qt::NoButton, Qt::NoModifier);
 }
 
-// called on drop, send the drop to Qt and return if it was accepted.
-- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
+// Called on drop, send the drop to Qt and return if it was accepted
+- (BOOL)performDragOperation:(id<NSDraggingInfo>)sender
 {
     if (!m_platformWindow)
         return false;
@@ -255,31 +247,29 @@ static QPoint mapWindowCoordinates(QWindow *source, QWindow *target, QPoint poin
     if (!target)
         return false;
 
-    NSPoint windowPoint = [self convertPoint: [sender draggingLocation] fromView: nil];
-    QPoint qt_windowPoint(windowPoint.x, windowPoint.y);
-    Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations([sender draggingSourceOperationMask]);
+    QPoint windowPoint = QPointF::fromCGPoint([self convertPoint:sender.draggingLocation fromView:nil]).toPoint();
+
+    Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations(sender.draggingSourceOperationMask);
 
     QPlatformDropQtResponse response(false, Qt::IgnoreAction);
     QCocoaDrag* nativeDrag = QCocoaIntegration::instance()->drag();
     const auto modifiers = [QNSView convertKeyModifiers:NSApp.currentEvent.modifierFlags];
     const auto buttons = currentlyPressedMouseButtons();
-    const auto point = mapWindowCoordinates(m_platformWindow->window(), target, qt_windowPoint);
+    const auto point = mapWindowCoordinates(m_platformWindow->window(), target, windowPoint);
 
     if (nativeDrag->currentDrag()) {
         // The drag was started from within the application
         response = QWindowSystemInterface::handleDrop(target, nativeDrag->dragMimeData(),
                                                       point, qtAllowed, buttons, modifiers);
     } else {
-        QCocoaDropData mimeData([sender draggingPasteboard]);
+        QCocoaDropData mimeData(sender.draggingPasteboard);
         response = QWindowSystemInterface::handleDrop(target, &mimeData,
                                                       point, qtAllowed, buttons, modifiers);
     }
     return response.isAccepted();
 }
 
-- (void)draggingSession:(NSDraggingSession *)session
-           endedAtPoint:(NSPoint)screenPoint
-              operation:(NSDragOperation)operation
+- (void)draggingSession:(NSDraggingSession *)session endedAtPoint:(NSPoint)screenPoint operation:(NSDragOperation)operation
 {
     Q_UNUSED(session);
     Q_UNUSED(screenPoint);
-- 
cgit v1.2.3


From f792fed2ff519ffac1436e41e47cc0504d253a77 Mon Sep 17 00:00:00 2001
From: Friedemann Kleint <Friedemann.Kleint@qt.io>
Date: Tue, 5 Mar 2019 14:25:45 +0100
Subject: XCB/libxkbcommon input context: Fix crash when invalid local is set

Fall back to querying the locale.

Fixes: QTBUG-74216
Change-Id: Ibd60572454741e64f649ecc3e37f593a8e2b2bda
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
---
 .../platforminputcontexts/compose/qcomposeplatforminputcontext.cpp    | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'src/plugins')

diff --git a/src/plugins/platforminputcontexts/compose/qcomposeplatforminputcontext.cpp b/src/plugins/platforminputcontexts/compose/qcomposeplatforminputcontext.cpp
index 6b9687c22d..57fe7c2fa2 100644
--- a/src/plugins/platforminputcontexts/compose/qcomposeplatforminputcontext.cpp
+++ b/src/plugins/platforminputcontexts/compose/qcomposeplatforminputcontext.cpp
@@ -70,7 +70,9 @@ void QComposeInputContext::ensureInitialized()
     }
 
     m_initialized = true;
-    const char *const locale = setlocale(LC_CTYPE, "");
+    const char *locale = setlocale(LC_CTYPE, "");
+    if (!locale)
+        locale = setlocale(LC_CTYPE, nullptr);
     qCDebug(lcXkbCompose) << "detected locale (LC_CTYPE):" << locale;
 
     m_composeTable = xkb_compose_table_new_from_locale(m_XkbContext, locale, XKB_COMPOSE_COMPILE_NO_FLAGS);
-- 
cgit v1.2.3


From 4eda22ea0db1fc571ae9f44a68825056e6245548 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tor=20Arne=20Vestb=C3=B8?= <tor.arne.vestbo@qt.io>
Date: Thu, 28 Feb 2019 13:49:11 +0100
Subject: macOS: Improve mouse logging

Change-Id: Icc81f73e728d9b3669afc37b0c1ef73588f24749
Reviewed-by: Timur Pocheptsov <timur.pocheptsov@qt.io>
---
 src/plugins/platforms/cocoa/qcocoahelpers.mm    |  2 +-
 src/plugins/platforms/cocoa/qnsview_dragging.mm | 17 +++++++++++++---
 src/plugins/platforms/cocoa/qnsview_mouse.mm    | 26 +++++++++++++++++++------
 3 files changed, 35 insertions(+), 10 deletions(-)

(limited to 'src/plugins')

diff --git a/src/plugins/platforms/cocoa/qcocoahelpers.mm b/src/plugins/platforms/cocoa/qcocoahelpers.mm
index d86e935788..9c705616ba 100644
--- a/src/plugins/platforms/cocoa/qcocoahelpers.mm
+++ b/src/plugins/platforms/cocoa/qcocoahelpers.mm
@@ -62,7 +62,7 @@ QT_BEGIN_NAMESPACE
 
 Q_LOGGING_CATEGORY(lcQpaWindow, "qt.qpa.window");
 Q_LOGGING_CATEGORY(lcQpaDrawing, "qt.qpa.drawing");
-Q_LOGGING_CATEGORY(lcQpaMouse, "qt.qpa.input.mouse");
+Q_LOGGING_CATEGORY(lcQpaMouse, "qt.qpa.input.mouse", QtCriticalMsg);
 Q_LOGGING_CATEGORY(lcQpaScreen, "qt.qpa.screen");
 
 //
diff --git a/src/plugins/platforms/cocoa/qnsview_dragging.mm b/src/plugins/platforms/cocoa/qnsview_dragging.mm
index 25be73b6ab..002cb3279e 100644
--- a/src/plugins/platforms/cocoa/qnsview_dragging.mm
+++ b/src/plugins/platforms/cocoa/qnsview_dragging.mm
@@ -177,17 +177,17 @@ static QPoint mapWindowCoordinates(QWindow *source, QWindow *target, QPoint poin
 
 - (NSDragOperation)draggingEntered:(id<NSDraggingInfo>)sender
 {
-    return [self handleDrag:sender];
+    return [self handleDrag:(QEvent::DragEnter) sender:sender];
 }
 
 - (NSDragOperation)draggingUpdated:(id<NSDraggingInfo>)sender
 {
     QScopedValueRollback<bool> rollback(m_updatingDrag, true);
-    return [self handleDrag:sender];
+    return [self handleDrag:(QEvent::DragMove) sender:sender];
 }
 
 // Sends drag update to Qt, return the action
-- (NSDragOperation)handleDrag:(id<NSDraggingInfo>)sender
+- (NSDragOperation)handleDrag:(QEvent::Type)dragType sender:(id<NSDraggingInfo>)sender
 {
     if (!m_platformWindow)
         return NSDragOperationNone;
@@ -204,6 +204,11 @@ static QPoint mapWindowCoordinates(QWindow *source, QWindow *target, QPoint poin
     const auto buttons = currentlyPressedMouseButtons();
     const auto point = mapWindowCoordinates(m_platformWindow->window(), target, windowPoint);
 
+    if (dragType == QEvent::DragEnter)
+        qCDebug(lcQpaMouse) << dragType << self << "at" << windowPoint;
+    else
+        qCDebug(lcQpaMouse) << dragType << "at" << windowPoint << "with" << buttons;
+
     QPlatformDragQtResponse response(false, Qt::IgnoreAction, QRect());
     QCocoaDrag* nativeDrag = QCocoaIntegration::instance()->drag();
     if (nativeDrag->currentDrag()) {
@@ -231,6 +236,8 @@ static QPoint mapWindowCoordinates(QWindow *source, QWindow *target, QPoint poin
 
     QPoint windowPoint = QPointF::fromCGPoint([self convertPoint:sender.draggingLocation fromView:nil]).toPoint();
 
+    qCDebug(lcQpaMouse) << QEvent::DragLeave << self << "at" << windowPoint;
+
     // Send 0 mime data to indicate drag exit
     QWindowSystemInterface::handleDrag(target, nullptr,
                                        mapWindowCoordinates(m_platformWindow->window(), target, windowPoint),
@@ -257,6 +264,8 @@ static QPoint mapWindowCoordinates(QWindow *source, QWindow *target, QPoint poin
     const auto buttons = currentlyPressedMouseButtons();
     const auto point = mapWindowCoordinates(m_platformWindow->window(), target, windowPoint);
 
+    qCDebug(lcQpaMouse) << QEvent::Drop << "at" << windowPoint << "with" << buttons;
+
     if (nativeDrag->currentDrag()) {
         // The drag was started from within the application
         response = QWindowSystemInterface::handleDrop(target, nativeDrag->dragMimeData(),
@@ -285,6 +294,8 @@ static QPoint mapWindowCoordinates(QWindow *source, QWindow *target, QPoint poin
     nativeDrag->setAcceptedAction(qt_mac_mapNSDragOperation(operation));
 
     m_buttons = currentlyPressedMouseButtons();
+
+    qCDebug(lcQpaMouse) << "Drag session" << session << "ended, with" << m_buttons;
 }
 
 @end
diff --git a/src/plugins/platforms/cocoa/qnsview_mouse.mm b/src/plugins/platforms/cocoa/qnsview_mouse.mm
index c9c87d9323..6e3cff2b48 100644
--- a/src/plugins/platforms/cocoa/qnsview_mouse.mm
+++ b/src/plugins/platforms/cocoa/qnsview_mouse.mm
@@ -93,6 +93,7 @@
 
 - (void)resetMouseButtons
 {
+    qCDebug(lcQpaMouse) << "Reseting mouse buttons";
     m_buttons = Qt::NoButton;
     m_frameStrutButtons = Qt::NoButton;
 }
@@ -145,6 +146,9 @@
     QPoint qtScreenPoint = QCocoaScreen::mapFromNative(screenPoint).toPoint();
 
     ulong timestamp = [theEvent timestamp] * 1000;
+
+    auto eventType = cocoaEvent2QtMouseEvent(theEvent);
+    qCInfo(lcQpaMouse) << "Frame-strut" << eventType << "at" << qtWindowPoint << "with" << m_frameStrutButtons << "in" << self.window;
     QWindowSystemInterface::handleFrameStrutMouseEvent(m_platformWindow->window(), timestamp, qtWindowPoint, qtScreenPoint, m_frameStrutButtons);
 }
 @end
@@ -254,6 +258,11 @@
         button = Qt::RightButton;
     const auto eventType = cocoaEvent2QtMouseEvent(theEvent);
 
+    if (eventType == QEvent::MouseMove)
+        qCDebug(lcQpaMouse) << eventType << "at" << qtWindowPoint << "with" << buttons;
+    else
+        qCInfo(lcQpaMouse) << eventType << "of" << button << "at" << qtWindowPoint << "with" << buttons;
+
     QWindowSystemInterface::handleMouseEvent(targetView->m_platformWindow->window(),
                                              timestamp, qtWindowPoint, qtScreenPoint,
                                              buttons, button, eventType, modifiers);
@@ -459,16 +468,16 @@
 
 - (void)cursorUpdate:(NSEvent *)theEvent
 {
-    qCDebug(lcQpaMouse) << "Updating cursor for" << self << "to" << self.cursor;
-
     // Note: We do not get this callback when moving from a subview that
     // uses the legacy cursorRect API, so the cursor is reset to the arrow
     // cursor. See rdar://34183708
 
-    if (self.cursor)
+    if (self.cursor && self.cursor != NSCursor.currentCursor) {
+        qCInfo(lcQpaMouse) << "Updating cursor for" << self << "to" << self.cursor;
         [self.cursor set];
-    else
+    } else {
         [super cursorUpdate:theEvent];
+    }
 }
 
 - (void)mouseMovedImpl:(NSEvent *)theEvent
@@ -523,6 +532,8 @@
     QPointF screenPoint;
     [self convertFromScreen:[self screenMousePoint:theEvent] toWindowPoint:&windowPoint andScreenPoint:&screenPoint];
     m_platformWindow->m_enterLeaveTargetWindow = m_platformWindow->childWindowAt(windowPoint.toPoint());
+
+    qCInfo(lcQpaMouse) << QEvent::Enter << self << "at" << windowPoint << "with" << currentlyPressedMouseButtons();
     QWindowSystemInterface::handleEnterEvent(m_platformWindow->m_enterLeaveTargetWindow, windowPoint, screenPoint);
 }
 
@@ -541,6 +552,7 @@
     if (!m_platformWindow->isContentView())
         return;
 
+    qCInfo(lcQpaMouse) << QEvent::Leave << self;
     QWindowSystemInterface::handleLeaveEvent(m_platformWindow->m_enterLeaveTargetWindow);
     m_platformWindow->m_enterLeaveTargetWindow = 0;
 }
@@ -639,8 +651,10 @@
     // "isInverted": natural OS X scrolling, inverted from the Qt/other platform/Jens perspective.
     bool isInverted  = [theEvent isDirectionInvertedFromDevice];
 
-    qCDebug(lcQpaMouse) << "scroll wheel @ window pos" << qt_windowPoint << "delta px" << pixelDelta
-            << "angle" << angleDelta << "phase" << phase << (isInverted ? "inverted" : "");
+    qCInfo(lcQpaMouse).nospace() << phase << " at " << qt_windowPoint
+        << " pixelDelta=" << pixelDelta << " angleDelta=" << angleDelta
+        << (isInverted ? " inverted=true" : "");
+
     QWindowSystemInterface::handleWheelEvent(m_platformWindow->window(), qt_timestamp, qt_windowPoint,
             qt_screenPoint, pixelDelta, angleDelta, m_currentWheelModifiers, phase, source, isInverted);
 }
-- 
cgit v1.2.3


From 452c644c5c51d78d72dde703c81fc7789e5b84f1 Mon Sep 17 00:00:00 2001
From: Lorn Potter <lorn.potter@gmail.com>
Date: Thu, 31 Jan 2019 14:06:39 +1000
Subject: wasm: make wasm platform target a specific canvas instead of default
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This allows for multi canvas use

Task-number: QTBUG-64079
Change-Id: I69c998aa4c2869bb5b7f14ba65bb63284365ad70
Reviewed-by: Morten Johan Sørvig <morten.sorvig@qt.io>
---
 .../platforms/wasm/qwasmeventtranslator.cpp        | 63 +++++++++++++++-------
 src/plugins/platforms/wasm/qwasmeventtranslator.h  |  3 ++
 src/plugins/platforms/wasm/qwasmintegration.cpp    | 55 ++++---------------
 src/plugins/platforms/wasm/qwasmintegration.h      |  3 +-
 src/plugins/platforms/wasm/qwasmopenglcontext.cpp  | 12 +++--
 src/plugins/platforms/wasm/qwasmopenglcontext.h    |  2 +-
 src/plugins/platforms/wasm/qwasmscreen.cpp         | 29 ++++++++++
 src/plugins/platforms/wasm/qwasmscreen.h           |  4 +-
 8 files changed, 98 insertions(+), 73 deletions(-)

(limited to 'src/plugins')

diff --git a/src/plugins/platforms/wasm/qwasmeventtranslator.cpp b/src/plugins/platforms/wasm/qwasmeventtranslator.cpp
index 05c09ec9a0..23bf9a7de6 100644
--- a/src/plugins/platforms/wasm/qwasmeventtranslator.cpp
+++ b/src/plugins/platforms/wasm/qwasmeventtranslator.cpp
@@ -327,34 +327,25 @@ QWasmEventTranslator::QWasmEventTranslator(QObject *parent)
     , pressedButtons(Qt::NoButton)
     , resizeMode(QWasmWindow::ResizeNone)
 {
-    emscripten_set_keydown_callback(0, (void *)this, 1, &keyboard_cb);
-    emscripten_set_keyup_callback(0, (void *)this, 1, &keyboard_cb);
-
-    emscripten_set_mousedown_callback(0, (void *)this, 1, &mouse_cb);
-    emscripten_set_mouseup_callback(0, (void *)this, 1, &mouse_cb);
-    emscripten_set_mousemove_callback(0, (void *)this, 1, &mouse_cb);
-
-    emscripten_set_focus_callback(0, (void *)this, 1, &focus_cb);
-
-    emscripten_set_wheel_callback(0, (void *)this, 1, &wheel_cb);
-
     touchDevice = new QTouchDevice;
     touchDevice->setType(QTouchDevice::TouchScreen);
     touchDevice->setCapabilities(QTouchDevice::Position | QTouchDevice::Area | QTouchDevice::NormalizedPosition);
     QWindowSystemInterface::registerTouchDevice(touchDevice);
 
-    emscripten_set_touchstart_callback("#canvas", (void *)this, 1, &touchCallback);
-    emscripten_set_touchend_callback("#canvas", (void *)this, 1, &touchCallback);
-    emscripten_set_touchmove_callback("#canvas", (void *)this, 1, &touchCallback);
-    emscripten_set_touchcancel_callback("#canvas", (void *)this, 1, &touchCallback);
+    QWasmScreen *wasmScreen = QWasmIntegration::get()->screen();
+    initEventHandlers(wasmScreen->m_canvasId);
+}
 
+void QWasmEventTranslator::initEventHandlers(const QString &canvas)
+{
+    const char *canvasId = canvas.toLocal8Bit().constData();
     // The Platform Detect: expand coverage and move as needed
     enum Platform {
         GenericPlatform,
         MacOSPlatform
     };
-  Platform platform = Platform(emscripten::val::global("navigator")["platform"]
-          .call<bool>("includes", emscripten::val("Mac")));
+    Platform platform = Platform(emscripten::val::global("navigator")["platform"]
+            .call<bool>("includes", emscripten::val("Mac")));
     g_usePlatformMacCtrlMetaSwitching = (platform == MacOSPlatform);
 
     if (platform == MacOSPlatform) {
@@ -362,11 +353,30 @@ QWasmEventTranslator::QWasmEventTranslator(QObject *parent)
 
         if (emscripten::val::global("window")["safari"].isUndefined()) {
 
-            emscripten::val::global("canvas").call<void>("addEventListener",
+            emscripten::val::global(canvasId).call<void>("addEventListener",
                                                          std::string("wheel"),
                                                          val::module_property("mouseWheelEvent"));
         }
     }
+
+    emscripten_set_keydown_callback(canvasId, (void *)this, 1, &keyboard_cb);
+    emscripten_set_keyup_callback(canvasId, (void *)this, 1, &keyboard_cb);
+
+    emscripten_set_mousedown_callback(canvasId, (void *)this, 1, &mouse_cb);
+    emscripten_set_mouseup_callback(canvasId, (void *)this, 1, &mouse_cb);
+    emscripten_set_mousemove_callback(canvasId, (void *)this, 1, &mouse_cb);
+
+    emscripten_set_focus_callback(canvasId, (void *)this, 1, &focus_cb);
+
+    emscripten_set_wheel_callback(canvasId, (void *)this, 1, &wheel_cb);
+
+    emscripten_set_touchstart_callback(canvasId, (void *)this, 1, &touchCallback);
+    emscripten_set_touchend_callback(canvasId, (void *)this, 1, &touchCallback);
+    emscripten_set_touchmove_callback(canvasId, (void *)this, 1, &touchCallback);
+    emscripten_set_touchcancel_callback(canvasId, (void *)this, 1, &touchCallback);
+
+    emscripten_set_resize_callback(canvasId, (void *)this, 1, uiEvent_cb);
+
 }
 
 template <typename Event>
@@ -865,4 +875,21 @@ bool QWasmEventTranslator::processKeyboard(int eventType, const EmscriptenKeyboa
     return accepted;
 }
 
+int QWasmEventTranslator::uiEvent_cb(int eventType, const EmscriptenUiEvent *e, void *userData)
+{
+    Q_UNUSED(e)
+    Q_UNUSED(userData)
+
+    if (eventType == EMSCRIPTEN_EVENT_RESIZE) {
+        // This resize event is called when the HTML window is resized. Depending
+        // on the page layout the the canvas might also have been resized, so we
+        // update the Qt screen size (and canvas render size).
+        QWasmScreen *wasmScreen = QWasmIntegration::get()->screen();
+
+        wasmScreen->updateQScreenAndCanvasRenderSize(wasmScreen->m_canvasId.toLocal8Bit().constData());
+    }
+
+    return 0;
+}
+
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/wasm/qwasmeventtranslator.h b/src/plugins/platforms/wasm/qwasmeventtranslator.h
index 25e2a630b6..a9a00eab0b 100644
--- a/src/plugins/platforms/wasm/qwasmeventtranslator.h
+++ b/src/plugins/platforms/wasm/qwasmeventtranslator.h
@@ -57,7 +57,10 @@ public:
 
     static int touchCallback(int eventType, const EmscriptenTouchEvent *ev, void *userData);
 
+    static int uiEvent_cb(int eventType, const EmscriptenUiEvent *e, void *userData);
+
     void processEvents();
+    void initEventHandlers(const QString &);
 
 Q_SIGNALS:
     void getWindowAt(const QPoint &point, QWindow **window);
diff --git a/src/plugins/platforms/wasm/qwasmintegration.cpp b/src/plugins/platforms/wasm/qwasmintegration.cpp
index 6f96ec69da..f45048ffa4 100644
--- a/src/plugins/platforms/wasm/qwasmintegration.cpp
+++ b/src/plugins/platforms/wasm/qwasmintegration.cpp
@@ -75,11 +75,18 @@ QWasmIntegration::QWasmIntegration()
       m_eventDispatcher(nullptr),
       m_clipboard(new QWasmClipboard)
 {
+
+    globalHtml5Integration = this;
     s_instance = this;
 
-    updateQScreenAndCanvasRenderSize();
+    emscripten::val defaultCanvasId = emscripten::val::global("canvas");
+    canvasIds.append(QString::fromStdString(defaultCanvasId["id"].as<std::string>()));
+    m_screen->setCanvas(canvasIds.at(0));
+
+    globalHtml5Integration = this;
+
+    screen()->updateQScreenAndCanvasRenderSize(m_screen->m_canvasId);
     screenAdded(m_screen);
-    emscripten_set_resize_callback(0, (void *)this, 1, uiEvent_cb);
 
     m_eventTranslator = new QWasmEventTranslator;
 
@@ -168,50 +175,6 @@ QPlatformTheme *QWasmIntegration::createPlatformTheme(const QString &name) const
     return QPlatformIntegration::createPlatformTheme(name);
 }
 
-int QWasmIntegration::uiEvent_cb(int eventType, const EmscriptenUiEvent *e, void *userData)
-{
-    Q_UNUSED(e)
-    Q_UNUSED(userData)
-
-    if (eventType == EMSCRIPTEN_EVENT_RESIZE) {
-        // This resize event is called when the HTML window is resized. Depending
-        // on the page layout the the canvas might also have been resized, so we
-        // update the Qt screen size (and canvas render size).
-        updateQScreenAndCanvasRenderSize();
-    }
-
-    return 0;
-}
-
-static void set_canvas_size(double width, double height)
-{
-    emscripten::val canvas = emscripten::val::global("canvas");
-    canvas.set("width", width);
-    canvas.set("height", height);
-}
-
-void QWasmIntegration::updateQScreenAndCanvasRenderSize()
-{
-    // The HTML canvas has two sizes: the CSS size and the canvas render size.
-    // The CSS size is determined according to standard CSS rules, while the
-    // render size is set using the "width" and "height" attributes. The render
-    // size must be set manually and is not auto-updated on CSS size change.
-    // Setting the render size to a value larger than the CSS size enables high-dpi
-    // rendering.
-
-    double css_width;
-    double css_height;
-    emscripten_get_element_css_size(0, &css_width, &css_height);
-    QSizeF cssSize(css_width, css_height);
-
-    QWasmScreen *screen = QWasmIntegration::get()->m_screen;
-    QSizeF canvasSize = cssSize * screen->devicePixelRatio();
-
-    set_canvas_size(canvasSize.width(), canvasSize.height());
-    screen->setGeometry(QRect(QPoint(0, 0), cssSize.toSize()));
-    QWasmIntegration::get()->m_compositor->redrawWindowContent();
-}
-
 QPlatformClipboard* QWasmIntegration::clipboard() const
 {
     if (!m_clipboard)
diff --git a/src/plugins/platforms/wasm/qwasmintegration.h b/src/plugins/platforms/wasm/qwasmintegration.h
index 4c5aeb4ebc..0b73303bf4 100644
--- a/src/plugins/platforms/wasm/qwasmintegration.h
+++ b/src/plugins/platforms/wasm/qwasmintegration.h
@@ -78,7 +78,7 @@ public:
 
     static QWasmIntegration *get() { return s_instance; }
     static void QWasmBrowserExit();
-    static void updateQScreenAndCanvasRenderSize();
+    QStringList canvasIds;
 
 private:
     mutable QWasmFontDatabase *m_fontDb;
@@ -86,7 +86,6 @@ private:
     mutable QWasmScreen *m_screen;
     mutable QWasmEventTranslator *m_eventTranslator;
     mutable QWasmEventDispatcher *m_eventDispatcher;
-    static int uiEvent_cb(int eventType, const EmscriptenUiEvent *e, void *userData);
     mutable QHash<QWindow *, QWasmBackingStore *> m_backingStores;
 
     mutable QWasmClipboard *m_clipboard;
diff --git a/src/plugins/platforms/wasm/qwasmopenglcontext.cpp b/src/plugins/platforms/wasm/qwasmopenglcontext.cpp
index 73af3d1878..e71da0c217 100644
--- a/src/plugins/platforms/wasm/qwasmopenglcontext.cpp
+++ b/src/plugins/platforms/wasm/qwasmopenglcontext.cpp
@@ -28,7 +28,7 @@
 ****************************************************************************/
 
 #include "qwasmopenglcontext.h"
-
+#include "qwasmintegration.h"
 #include <EGL/egl.h>
 
 QT_BEGIN_NAMESPACE
@@ -57,7 +57,9 @@ void QWasmOpenGLContext::maybeRecreateEmscriptenContext(QPlatformSurface *surfac
             emscripten_webgl_destroy_context(m_context);
 
         // Create new context
-        const char *canvasId = 0; // (use default canvas) FIXME: get the actual canvas from the surface.
+        QWasmScreen *wasmScreen = QWasmIntegration::get()->screen();
+        const QString canvasId = wasmScreen->m_canvasId;
+         // FIXME: get the actual canvas from the surface.
         m_context = createEmscriptenContext(canvasId, m_requestedFormat);
 
         // Register context-lost callback.
@@ -73,11 +75,11 @@ void QWasmOpenGLContext::maybeRecreateEmscriptenContext(QPlatformSurface *surfac
             return true;
         };
         bool capture = true;
-        emscripten_set_webglcontextlost_callback(canvasId, this, capture, callback);
+        emscripten_set_webglcontextlost_callback(canvasId.toLocal8Bit().constData(), this, capture, callback);
     }
 }
 
-EMSCRIPTEN_WEBGL_CONTEXT_HANDLE QWasmOpenGLContext::createEmscriptenContext(const char *canvasId, QSurfaceFormat format)
+EMSCRIPTEN_WEBGL_CONTEXT_HANDLE QWasmOpenGLContext::createEmscriptenContext(const QString &canvasId, QSurfaceFormat format)
 {
     EmscriptenWebGLContextAttributes attributes;
     emscripten_webgl_init_context_attributes(&attributes); // Populate with default attributes
@@ -96,7 +98,7 @@ EMSCRIPTEN_WEBGL_CONTEXT_HANDLE QWasmOpenGLContext::createEmscriptenContext(cons
     attributes.depth = format.depthBufferSize() > 0;
     attributes.stencil = format.stencilBufferSize() > 0;
 
-    EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context(canvasId, &attributes);
+    EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context(canvasId.toLocal8Bit().constData(), &attributes);
 
     return context;
 }
diff --git a/src/plugins/platforms/wasm/qwasmopenglcontext.h b/src/plugins/platforms/wasm/qwasmopenglcontext.h
index 9123100479..126b596a7e 100644
--- a/src/plugins/platforms/wasm/qwasmopenglcontext.h
+++ b/src/plugins/platforms/wasm/qwasmopenglcontext.h
@@ -51,7 +51,7 @@ public:
 
 private:
     void maybeRecreateEmscriptenContext(QPlatformSurface *surface);
-    static EMSCRIPTEN_WEBGL_CONTEXT_HANDLE createEmscriptenContext(const char *canvasId, QSurfaceFormat format);
+    static EMSCRIPTEN_WEBGL_CONTEXT_HANDLE createEmscriptenContext(const QString &canvasId, QSurfaceFormat format);
 
     bool m_contextLost = false;
     QSurfaceFormat m_requestedFormat;
diff --git a/src/plugins/platforms/wasm/qwasmscreen.cpp b/src/plugins/platforms/wasm/qwasmscreen.cpp
index 37f1efadc6..fb14803ff8 100644
--- a/src/plugins/platforms/wasm/qwasmscreen.cpp
+++ b/src/plugins/platforms/wasm/qwasmscreen.cpp
@@ -114,4 +114,33 @@ void QWasmScreen::setGeometry(const QRect &rect)
     resizeMaximizedWindows();
 }
 
+static void set_canvas_size(double width, double height, const char *canvasId)
+{
+    emscripten::val canvas = emscripten::val::global(canvasId);
+    canvas.set("width", width);
+    canvas.set("height", height);
+}
+
+void QWasmScreen::updateQScreenAndCanvasRenderSize(const QString &canvasId)
+{
+    // The HTML canvas has two sizes: the CSS size and the canvas render size.
+    // The CSS size is determined according to standard CSS rules, while the
+    // render size is set using the "width" and "height" attributes. The render
+    // size must be set manually and is not auto-updated on CSS size change.
+    // Setting the render size to a value larger than the CSS size enables high-dpi
+    // rendering.
+
+    double css_width;
+    double css_height;
+    emscripten_get_element_css_size(canvasId.toLocal8Bit().constData(), &css_width, &css_height);
+    QSizeF cssSize(css_width, css_height);
+
+    QWasmScreen *screen = QWasmIntegration::get()->screen();
+    QSizeF canvasSize = cssSize * screen->devicePixelRatio();
+
+    set_canvas_size(canvasSize.width(), canvasSize.height(), canvasId.toLocal8Bit().constData());
+    screen->setGeometry(QRect(QPoint(0, 0), cssSize.toSize()));
+    QWasmIntegration::get()->compositor()->redrawWindowContent();
+}
+
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/wasm/qwasmscreen.h b/src/plugins/platforms/wasm/qwasmscreen.h
index 3891db77bb..d5080835c9 100644
--- a/src/plugins/platforms/wasm/qwasmscreen.h
+++ b/src/plugins/platforms/wasm/qwasmscreen.h
@@ -64,10 +64,12 @@ public:
     QWindow *topLevelAt(const QPoint &p) const override;
 
     void invalidateSize();
+    static void updateQScreenAndCanvasRenderSize(const QString &);
+    QString m_canvasId;
+    void setCanvas(const QString &canvasId) { m_canvasId = canvasId; }
 
 public slots:
     void setGeometry(const QRect &rect);
-protected:
 
 private:
     QWasmCompositor *m_compositor;
-- 
cgit v1.2.3


From caa74f16d41ebe65e1edbea219f799cf246d6067 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Morten=20Johan=20S=C3=B8rvig?= <morten.sorvig@qt.io>
Date: Fri, 15 Feb 2019 22:04:09 +0100
Subject: wasm: support rendering to multiple canvases

Qt (via the the qtloader.js API) now supports rendering
to multiple canvases. The application sees each canvas
as a QScreen.

Make qtloader.js support multiple canvases:

  var qtloader = QtLoader({
    canvasElements : [array-of-canvas],
    showCanvas: function() {
      // make canvas(es) visible
    },
 });

The canvases were previously created/returned by showCanvas(),
however this function is called after the Qt app has
been started and adding screens that that point is
too late. (This worked before since there was only one
screen, and no need to connect each screen instance
to specific canvas.)

Remove QWasmScreen, QWasmCompositor, and QWasmEventTranslator
singletons from QWasmIntegration. These are are now
crated per-screen and are owned by the QWasmScreen.

Task-number: QTBUG-64079
Change-Id: I24689929fd5bfb7ff0ba076f66937728fa4bc4e4
Reviewed-by: Lorn Potter <lorn.potter@gmail.com>
---
 src/plugins/platforms/wasm/qtloader.js             | 55 +++++++++--------
 src/plugins/platforms/wasm/qwasmclipboard.cpp      | 53 +++++++++--------
 src/plugins/platforms/wasm/qwasmclipboard.h        |  1 +
 src/plugins/platforms/wasm/qwasmcompositor.cpp     | 25 ++++----
 src/plugins/platforms/wasm/qwasmcompositor.h       |  7 +--
 src/plugins/platforms/wasm/qwasmcursor.cpp         | 16 ++---
 .../platforms/wasm/qwasmeventtranslator.cpp        | 38 +++++++-----
 src/plugins/platforms/wasm/qwasmeventtranslator.h  |  6 +-
 src/plugins/platforms/wasm/qwasmintegration.cpp    | 56 +++++++++++-------
 src/plugins/platforms/wasm/qwasmintegration.h      | 11 ++--
 src/plugins/platforms/wasm/qwasmopenglcontext.cpp  |  4 +-
 src/plugins/platforms/wasm/qwasmscreen.cpp         | 69 ++++++++++++++++------
 src/plugins/platforms/wasm/qwasmscreen.h           | 25 +++++---
 src/plugins/platforms/wasm/wasm_shell.html         | 14 ++---
 14 files changed, 224 insertions(+), 156 deletions(-)

(limited to 'src/plugins')

diff --git a/src/plugins/platforms/wasm/qtloader.js b/src/plugins/platforms/wasm/qtloader.js
index 203213db56..049eb1c35e 100644
--- a/src/plugins/platforms/wasm/qtloader.js
+++ b/src/plugins/platforms/wasm/qtloader.js
@@ -50,6 +50,7 @@
 // External mode.usage:
 //
 //    var config = {
+//        canvasElements : [$("canvas-id")],
 //        showLoader: function() {
 //            loader.style.display = 'block'
 //            canvas.style.display = 'hidden'
@@ -69,6 +70,8 @@
 //      One or more HTML elements. QtLoader will display loader elements
 //      on these while loading the applicaton, and replace the loader with a
 //      canvas on load complete.
+//  canvasElements : [canvas-element, ...]
+//      One or more canvas elements.
 //  showLoader : function(status, containerElement)
 //      Optional loading element constructor function. Implement to create
 //      a custom loading screen. This function may be called multiple times,
@@ -146,8 +149,25 @@ function QtLoader(config)
         while (element.firstChild) element.removeChild(element.firstChild);
     }
 
-    // Set default state handler functions if needed
+    function createCanvas() {
+        var canvas = document.createElement("canvas");
+        canvas.className = "QtCanvas";
+        canvas.style.height = "100%";
+        canvas.style.width = "100%";
+
+        // Set contentEditable in order to enable clipboard events; hide the resulting focus frame.
+        canvas.contentEditable = true;
+        canvas.style.outline = "0px solid transparent";
+        canvas.style.cursor = "default";
+
+        return canvas;
+    }
+
+    // Set default state handler functions and create canvases if needed
     if (config.containerElements !== undefined) {
+
+        config.canvasElements = config.containerElements.map(createCanvas);
+
         config.showError = config.showError || function(errorText, container) {
             removeChildren(container);
             var errorTextElement = document.createElement("text");
@@ -164,19 +184,8 @@ function QtLoader(config)
             return loadingText;
         };
 
-        config.showCanvas = config.showCanvas || function(container) {
+        config.showCanvas = config.showCanvas || function(canvas, container) {
             removeChildren(container);
-            var canvas = document.createElement("canvas");
-            canvas.className = "QtCanvas"
-            canvas.style.height = "100%"
-            canvas.style.width = "100%"
-
-            // Set contentEditable in order to enable clipboard events; hide the resulting focus frame.
-            canvas.contentEditable = true;
-            canvas.style.outline = "0px solid transparent";
-            canvas.style.cursor = "default";
-
-            return canvas;
         }
 
         config.showExit = config.showExit || function(crashed, exitCode, container) {
@@ -391,6 +400,8 @@ function QtLoader(config)
 
         Module.mainScriptUrlOrBlob = new Blob([emscriptenModuleSource], {type: 'text/javascript'});
 
+        Module.qtCanvasElements = config.canvasElements;
+
         config.restart = function() {
 
             // Restart by reloading the page. This will wipe all state which means
@@ -445,19 +456,17 @@ function QtLoader(config)
     }
 
     function setCanvasContent() {
-        var firstCanvas;
         if (config.containerElements === undefined) {
-            firstCanvas = config.showCanvas();
-        } else {
-            for (container of config.containerElements) {
-                var canvasElement = config.showCanvas(container);
-                container.appendChild(canvasElement);
-            }
-            firstCanvas = config.containerElements[0].firstChild;
+            if (config.showCanvas !== undefined)
+                config.showCanvas();
+            return;
         }
 
-        if (Module.canvas === undefined) {
-            Module.canvas = firstCanvas;
+        for (var i = 0; i < config.containerElements.length; ++i) {
+            var container = config.containerElements[i];
+            var canvas = config.canvasElements[i];
+            config.showCanvas(canvas, container);
+            container.appendChild(canvas);
         }
     }
 
diff --git a/src/plugins/platforms/wasm/qwasmclipboard.cpp b/src/plugins/platforms/wasm/qwasmclipboard.cpp
index 63fea7738d..7a7b253b19 100644
--- a/src/plugins/platforms/wasm/qwasmclipboard.cpp
+++ b/src/plugins/platforms/wasm/qwasmclipboard.cpp
@@ -123,9 +123,11 @@ EMSCRIPTEN_BINDINGS(clipboard_module) {
     function("qClipboardPasteTo", &qClipboardPasteTo);
 }
 
-QWasmClipboard::QWasmClipboard() :
-    hasClipboardApi(false)
+QWasmClipboard::QWasmClipboard()
 {
+    val clipboard = val::global("navigator")["clipboard"];
+    hasClipboardApi = (!clipboard.isUndefined() && !clipboard["readText"].isUndefined());
+
     initClipboardEvents();
 }
 
@@ -177,29 +179,32 @@ void QWasmClipboard::qWasmClipboardPaste(QMimeData *mData)
 
 void QWasmClipboard::initClipboardEvents()
 {
-    val navigator = val::global("navigator");
-    val permissions = navigator["permissions"];
-    val clipboard = navigator["clipboard"];
+    if (!hasClipboardApi)
+        return;
 
-    hasClipboardApi = (!clipboard.isUndefined() && !clipboard["readText"].isUndefined());
-    if (hasClipboardApi) {
-        val readPermissionsMap = val::object();
-        readPermissionsMap.set("name", val("clipboard-read"));
-        permissions.call<val>("query", readPermissionsMap);
-
-        val writePermissionsMap = val::object();
-        writePermissionsMap.set("name", val("clipboard-write"));
-        permissions.call<val>("query", writePermissionsMap);
-
-    } else {
-        val canvas = val::module_property("canvas");
-        canvas.call<void>("addEventListener", std::string("cut"),
-                          val::module_property("qClipboardCutTo"));
-        canvas.call<void>("addEventListener", std::string("copy"),
-                          val::module_property("qClipboardCopyTo"));
-        canvas.call<void>("addEventListener", std::string("paste"),
-                          val::module_property("qClipboardPasteTo"));
-    }
+    val permissions = val::global("navigator")["permissions"];
+    val readPermissionsMap = val::object();
+    readPermissionsMap.set("name", val("clipboard-read"));
+    permissions.call<val>("query", readPermissionsMap);
+
+    val writePermissionsMap = val::object();
+    writePermissionsMap.set("name", val("clipboard-write"));
+    permissions.call<val>("query", writePermissionsMap);
+}
+
+void QWasmClipboard::installEventHandlers(const QString &canvasId)
+{
+    if (hasClipboardApi)
+        return;
+
+    // Fallback path for browsers which do not support direct clipboard access
+    val canvas = val::global(canvasId.toUtf8().constData());
+    canvas.call<void>("addEventListener", std::string("cut"),
+                      val::module_property("qClipboardCutTo"));
+    canvas.call<void>("addEventListener", std::string("copy"),
+                      val::module_property("qClipboardCopyTo"));
+    canvas.call<void>("addEventListener", std::string("paste"),
+                      val::module_property("qClipboardPasteTo"));
 }
 
 void QWasmClipboard::readTextFromClipboard()
diff --git a/src/plugins/platforms/wasm/qwasmclipboard.h b/src/plugins/platforms/wasm/qwasmclipboard.h
index e64b2e5007..00aae8fead 100644
--- a/src/plugins/platforms/wasm/qwasmclipboard.h
+++ b/src/plugins/platforms/wasm/qwasmclipboard.h
@@ -51,6 +51,7 @@ public:
 
     static void qWasmClipboardPaste(QMimeData *mData);
     void initClipboardEvents();
+    void installEventHandlers(const QString &canvasId);
     bool hasClipboardApi;
     void readTextFromClipboard();
     void writeTextToClipboard();
diff --git a/src/plugins/platforms/wasm/qwasmcompositor.cpp b/src/plugins/platforms/wasm/qwasmcompositor.cpp
index 3dc6b7d2f3..90cc20789d 100644
--- a/src/plugins/platforms/wasm/qwasmcompositor.cpp
+++ b/src/plugins/platforms/wasm/qwasmcompositor.cpp
@@ -56,8 +56,9 @@ QWasmCompositedWindow::QWasmCompositedWindow()
 {
 }
 
-QWasmCompositor::QWasmCompositor()
-    : m_frameBuffer(nullptr)
+QWasmCompositor::QWasmCompositor(QWasmScreen *screen)
+    :QObject(screen)
+    , m_frameBuffer(nullptr)
     , m_blitter(new QOpenGLTextureBlitter)
     , m_needComposit(false)
     , m_inFlush(false)
@@ -107,11 +108,6 @@ void QWasmCompositor::removeWindow(QWasmWindow *window)
     notifyTopWindowChanged(window);
 }
 
-void QWasmCompositor::setScreen(QWasmScreen *screen)
-{
-    m_screen = screen;
-}
-
 void QWasmCompositor::setVisible(QWasmWindow *window, bool visible)
 {
     QWasmCompositedWindow &compositedWindow = m_compositedWindows[window];
@@ -654,7 +650,7 @@ void QWasmCompositor::frame()
 
     m_needComposit = false;
 
-    if (m_windowStack.empty() || !m_screen)
+    if (m_windowStack.empty() || !screen())
         return;
 
     QWasmWindow *someWindow = nullptr;
@@ -673,7 +669,7 @@ void QWasmCompositor::frame()
     if (m_context.isNull()) {
         m_context.reset(new QOpenGLContext());
         //mContext->setFormat(mScreen->format());
-        m_context->setScreen(m_screen->screen());
+        m_context->setScreen(screen()->screen());
         m_context->create();
     }
 
@@ -682,8 +678,8 @@ void QWasmCompositor::frame()
     if (!m_blitter->isCreated())
         m_blitter->create();
 
-    qreal dpr = m_screen->devicePixelRatio();
-    glViewport(0, 0, m_screen->geometry().width() * dpr, m_screen->geometry().height() * dpr);
+    qreal dpr = screen()->devicePixelRatio();
+    glViewport(0, 0, screen()->geometry().width() * dpr, screen()->geometry().height() * dpr);
 
     m_context->functions()->glClearColor(0.2, 0.2, 0.2, 1.0);
     m_context->functions()->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
@@ -697,7 +693,7 @@ void QWasmCompositor::frame()
         if (!compositedWindow.visible)
             continue;
 
-        drawWindow(m_blitter.data(), m_screen, window);
+        drawWindow(m_blitter.data(), screen(), window);
     }
 
     m_blitter->release();
@@ -719,3 +715,8 @@ void QWasmCompositor::notifyTopWindowChanged(QWasmWindow *window)
     requestRedraw();
     QWindowSystemInterface::handleWindowActivated(window->window());
 }
+
+QWasmScreen *QWasmCompositor::screen()
+{
+    return static_cast<QWasmScreen *>(parent());
+}
diff --git a/src/plugins/platforms/wasm/qwasmcompositor.h b/src/plugins/platforms/wasm/qwasmcompositor.h
index 4e5ed46cec..ed6facdcc3 100644
--- a/src/plugins/platforms/wasm/qwasmcompositor.h
+++ b/src/plugins/platforms/wasm/qwasmcompositor.h
@@ -62,7 +62,7 @@ class QWasmCompositor : public QObject
 {
     Q_OBJECT
 public:
-    QWasmCompositor();
+    QWasmCompositor(QWasmScreen *screen);
     ~QWasmCompositor();
 
     enum QWasmSubControl {
@@ -103,7 +103,6 @@ public:
 
     void addWindow(QWasmWindow *window, QWasmWindow *parentWindow = nullptr);
     void removeWindow(QWasmWindow *window);
-    void setScreen(QWasmScreen *screen);
 
     void setVisible(QWasmWindow *window, bool visible);
     void raise(QWasmWindow *window);
@@ -129,8 +128,7 @@ private slots:
     void frame();
 
 private:
-    void createFrameBuffer();
-    void flushCompletedCallback(int32_t);
+    QWasmScreen *screen();
     void notifyTopWindowChanged(QWasmWindow *window);
     void drawWindow(QOpenGLTextureBlitter *blitter, QWasmScreen *screen, QWasmWindow *window);
     void drawWindowContent(QOpenGLTextureBlitter *blitter, QWasmScreen *screen, QWasmWindow *window);
@@ -142,7 +140,6 @@ private:
     QImage *m_frameBuffer;
     QScopedPointer<QOpenGLContext> m_context;
     QScopedPointer<QOpenGLTextureBlitter> m_blitter;
-    QWasmScreen *m_screen;
 
     QHash<QWasmWindow *, QWasmCompositedWindow> m_compositedWindows;
     QList<QWasmWindow *> m_windowStack;
diff --git a/src/plugins/platforms/wasm/qwasmcursor.cpp b/src/plugins/platforms/wasm/qwasmcursor.cpp
index 744b160dd1..2b3f37300d 100644
--- a/src/plugins/platforms/wasm/qwasmcursor.cpp
+++ b/src/plugins/platforms/wasm/qwasmcursor.cpp
@@ -28,20 +28,21 @@
 ****************************************************************************/
 
 #include "qwasmcursor.h"
+#include "qwasmscreen.h"
 
 #include <QtCore/qdebug.h>
+#include <QtGui/qwindow.h>
 
 #include <emscripten/emscripten.h>
 #include <emscripten/bind.h>
 
 void QWasmCursor::changeCursor(QCursor *windowCursor, QWindow *window)
 {
-    if (windowCursor == nullptr)
+    if (!windowCursor || !window)
+        return;
+    QScreen *screen = window->screen();
+    if (!screen)
         return;
-
-    // FIXME: The HTML5 plugin sets the cursor on the native canvas; when using multiple windows
-    // multiple cursors need to be managed taking mouse postion and stacking into account.
-    Q_UNUSED(window);
 
     // Bitmap and custom cursors are not implemented (will fall back to "auto")
     if (windowCursor->shape() == Qt::BitmapCursor || windowCursor->shape() >= Qt::CustomCursor)
@@ -52,8 +53,9 @@ void QWasmCursor::changeCursor(QCursor *windowCursor, QWindow *window)
     if (htmlCursorName.isEmpty())
         htmlCursorName = "auto";
 
-    // Set cursor on the main canvas
-    emscripten::val canvasStyle = emscripten::val::module_property("canvas")["style"];
+    // Set cursor on the canvas
+    QString canvasId = QWasmScreen::get(screen)->canvasId();
+    emscripten::val canvasStyle = emscripten::val::global(canvasId.toUtf8().constData())["style"];
     canvasStyle.set("cursor", emscripten::val(htmlCursorName.constData()));
 }
 
diff --git a/src/plugins/platforms/wasm/qwasmeventtranslator.cpp b/src/plugins/platforms/wasm/qwasmeventtranslator.cpp
index 23bf9a7de6..14222da807 100644
--- a/src/plugins/platforms/wasm/qwasmeventtranslator.cpp
+++ b/src/plugins/platforms/wasm/qwasmeventtranslator.cpp
@@ -320,8 +320,8 @@ EMSCRIPTEN_BINDINGS(mouse_module) {
     function("mouseWheelEvent", &mouseWheelEvent);
 }
 
-QWasmEventTranslator::QWasmEventTranslator(QObject *parent)
-    : QObject(parent)
+QWasmEventTranslator::QWasmEventTranslator(QWasmScreen *screen)
+    : QObject(screen)
     , draggedWindow(nullptr)
     , lastWindow(nullptr)
     , pressedButtons(Qt::NoButton)
@@ -332,13 +332,16 @@ QWasmEventTranslator::QWasmEventTranslator(QObject *parent)
     touchDevice->setCapabilities(QTouchDevice::Position | QTouchDevice::Area | QTouchDevice::NormalizedPosition);
     QWindowSystemInterface::registerTouchDevice(touchDevice);
 
-    QWasmScreen *wasmScreen = QWasmIntegration::get()->screen();
-    initEventHandlers(wasmScreen->m_canvasId);
+    initEventHandlers();
 }
 
-void QWasmEventTranslator::initEventHandlers(const QString &canvas)
+void QWasmEventTranslator::initEventHandlers()
 {
-    const char *canvasId = canvas.toLocal8Bit().constData();
+    qDebug() << "QWasmEventTranslator::initEventHandlers";
+
+    QByteArray _canvasId = screen()->canvasId().toUtf8();
+    const char *canvasId = _canvasId.constData();
+
     // The Platform Detect: expand coverage and move as needed
     enum Platform {
         GenericPlatform,
@@ -375,7 +378,7 @@ void QWasmEventTranslator::initEventHandlers(const QString &canvas)
     emscripten_set_touchmove_callback(canvasId, (void *)this, 1, &touchCallback);
     emscripten_set_touchcancel_callback(canvasId, (void *)this, 1, &touchCallback);
 
-    emscripten_set_resize_callback(canvasId, (void *)this, 1, uiEvent_cb);
+    emscripten_set_resize_callback(nullptr, (void *)this, 1, uiEvent_cb); // Note: handles browser window resize
 
 }
 
@@ -425,6 +428,11 @@ int QWasmEventTranslator::keyboard_cb(int eventType, const EmscriptenKeyboardEve
     return accepted ? 1 : 0;
 }
 
+QWasmScreen *QWasmEventTranslator::screen()
+{
+    return static_cast<QWasmScreen *>(parent());
+}
+
 Qt::Key QWasmEventTranslator::translateEmscriptKey(const EmscriptenKeyboardEvent *emscriptKey)
 {
     Qt::Key qtKey = Qt::Key_unknown;
@@ -541,14 +549,14 @@ void resizeWindow(QWindow *window, QWasmWindow::ResizeMode mode,
 void QWasmEventTranslator::processMouse(int eventType, const EmscriptenMouseEvent *mouseEvent)
 {
     auto timestamp = mouseEvent->timestamp;
-    QPoint point(mouseEvent->canvasX, mouseEvent->canvasY);
+    QPoint point(mouseEvent->targetX, mouseEvent->targetY);
 
     QEvent::Type buttonEventType = QEvent::None;
 
     Qt::MouseButton button = translateMouseButton(mouseEvent->button);
     Qt::KeyboardModifiers modifiers = translateMouseEventModifier(mouseEvent);
 
-    QWindow *window2 = QWasmIntegration::get()->compositor()->windowAt(point, 5);
+    QWindow *window2 = screen()->compositor()->windowAt(point, 5);
     if (window2 != nullptr)
         lastWindow = window2;
 
@@ -645,6 +653,7 @@ int QWasmEventTranslator::wheel_cb(int eventType, const EmscriptenWheelEvent *wh
 {
     Q_UNUSED(eventType)
 
+    QWasmEventTranslator *eventTranslator = static_cast<QWasmEventTranslator *>(userData);
     EmscriptenMouseEvent mouseEvent = wheelEvent->mouse;
 
     int scrollFactor = 0;
@@ -668,7 +677,7 @@ int QWasmEventTranslator::wheel_cb(int eventType, const EmscriptenWheelEvent *wh
     auto timestamp = mouseEvent.timestamp;
     QPoint globalPoint(mouseEvent.canvasX, mouseEvent.canvasY);
 
-    QWindow *window2 = QWasmIntegration::get()->compositor()->windowAt(globalPoint, 5);
+    QWindow *window2 = eventTranslator->screen()->compositor()->windowAt(globalPoint, 5);
 
     QPoint localPoint(globalPoint.x() - window2->geometry().x(), globalPoint.y() - window2->geometry().y());
 
@@ -686,6 +695,7 @@ int QWasmEventTranslator::wheel_cb(int eventType, const EmscriptenWheelEvent *wh
 
 int QWasmEventTranslator::touchCallback(int eventType, const EmscriptenTouchEvent *touchEvent, void *userData)
 {
+    QWasmEventTranslator *eventTranslator = static_cast<QWasmEventTranslator *>(userData);
     QList<QWindowSystemInterface::TouchPoint> touchPointList;
     touchPointList.reserve(touchEvent->numTouches);
     QWindow *window2;
@@ -695,7 +705,7 @@ int QWasmEventTranslator::touchCallback(int eventType, const EmscriptenTouchEven
         const EmscriptenTouchPoint *touches = &touchEvent->touches[i];
 
         QPoint point(touches->canvasX, touches->canvasY);
-        window2 = QWasmIntegration::get()->compositor()->windowAt(point, 5);
+        window2 = eventTranslator->screen()->compositor()->windowAt(point, 5);
 
         QWindowSystemInterface::TouchPoint touchPoint;
 
@@ -878,15 +888,13 @@ bool QWasmEventTranslator::processKeyboard(int eventType, const EmscriptenKeyboa
 int QWasmEventTranslator::uiEvent_cb(int eventType, const EmscriptenUiEvent *e, void *userData)
 {
     Q_UNUSED(e)
-    Q_UNUSED(userData)
+    QWasmEventTranslator *eventTranslator = static_cast<QWasmEventTranslator *>(userData);
 
     if (eventType == EMSCRIPTEN_EVENT_RESIZE) {
         // This resize event is called when the HTML window is resized. Depending
         // on the page layout the the canvas might also have been resized, so we
         // update the Qt screen size (and canvas render size).
-        QWasmScreen *wasmScreen = QWasmIntegration::get()->screen();
-
-        wasmScreen->updateQScreenAndCanvasRenderSize(wasmScreen->m_canvasId.toLocal8Bit().constData());
+        eventTranslator->screen()->updateQScreenAndCanvasRenderSize();
     }
 
     return 0;
diff --git a/src/plugins/platforms/wasm/qwasmeventtranslator.h b/src/plugins/platforms/wasm/qwasmeventtranslator.h
index a9a00eab0b..ba08dce946 100644
--- a/src/plugins/platforms/wasm/qwasmeventtranslator.h
+++ b/src/plugins/platforms/wasm/qwasmeventtranslator.h
@@ -48,7 +48,7 @@ class QWasmEventTranslator : public QObject
 
 public:
 
-    explicit QWasmEventTranslator(QObject *parent = 0);
+    explicit QWasmEventTranslator(QWasmScreen *screen);
 
     static int keyboard_cb(int eventType, const EmscriptenKeyboardEvent *keyEvent, void *userData);
     static int mouse_cb(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData);
@@ -60,12 +60,12 @@ public:
     static int uiEvent_cb(int eventType, const EmscriptenUiEvent *e, void *userData);
 
     void processEvents();
-    void initEventHandlers(const QString &);
+    void initEventHandlers();
 
 Q_SIGNALS:
     void getWindowAt(const QPoint &point, QWindow **window);
 private:
-
+    QWasmScreen *screen();
     Qt::Key translateEmscriptKey(const EmscriptenKeyboardEvent *emscriptKey);
     template <typename Event>
     QFlags<Qt::KeyboardModifier> translatKeyModifier(const Event *event);
diff --git a/src/plugins/platforms/wasm/qwasmintegration.cpp b/src/plugins/platforms/wasm/qwasmintegration.cpp
index f45048ffa4..1964cefdad 100644
--- a/src/plugins/platforms/wasm/qwasmintegration.cpp
+++ b/src/plugins/platforms/wasm/qwasmintegration.cpp
@@ -70,36 +70,35 @@ QWasmIntegration *QWasmIntegration::s_instance;
 
 QWasmIntegration::QWasmIntegration()
     : m_fontDb(nullptr),
-      m_compositor(new QWasmCompositor),
-      m_screen(new QWasmScreen(m_compositor)),
       m_eventDispatcher(nullptr),
       m_clipboard(new QWasmClipboard)
 {
-
-    globalHtml5Integration = this;
     s_instance = this;
 
-    emscripten::val defaultCanvasId = emscripten::val::global("canvas");
-    canvasIds.append(QString::fromStdString(defaultCanvasId["id"].as<std::string>()));
-    m_screen->setCanvas(canvasIds.at(0));
-
-    globalHtml5Integration = this;
-
-    screen()->updateQScreenAndCanvasRenderSize(m_screen->m_canvasId);
-    screenAdded(m_screen);
-
-    m_eventTranslator = new QWasmEventTranslator;
+    // We expect that qtloader.js has populated Module.qtCanvasElements with one or more canvases.
+    // Also check Module.canvas, which may be set if the emscripen or a custom loader is used.
+    emscripten::val qtCanvaseElements = val::module_property("qtCanvasElements");
+    emscripten::val canvas = val::module_property("canvas");
+
+    if (!qtCanvaseElements.isUndefined()) {
+        int screenCount = qtCanvaseElements["length"].as<int>();
+        for (int i = 0; i < screenCount; ++i) {
+            emscripten::val canvas = qtCanvaseElements[i].as<emscripten::val>();
+            QString canvasId = QString::fromStdString(canvas["id"].as<std::string>());
+            addScreen(canvasId);
+        }
+    } else if (!canvas.isUndefined()){
+        QString canvasId = QString::fromStdString(canvas["id"].as<std::string>());
+        addScreen(canvasId);
+    }
 
     emscripten::val::global("window").set("onbeforeunload", val::module_property("browserBeforeUnload"));
-
 }
 
 QWasmIntegration::~QWasmIntegration()
 {
-    delete m_compositor;
-    destroyScreen(m_screen);
     delete m_fontDb;
-    delete m_eventTranslator;
+    qDeleteAll(m_screens);
     s_instance = nullptr;
 }
 
@@ -124,13 +123,15 @@ bool QWasmIntegration::hasCapability(QPlatformIntegration::Capability cap) const
 
 QPlatformWindow *QWasmIntegration::createPlatformWindow(QWindow *window) const
 {
-    return new QWasmWindow(window, m_compositor, m_backingStores.value(window));
+    QWasmCompositor *compositor = QWasmScreen::get(window->screen())->compositor();
+    return new QWasmWindow(window, compositor, m_backingStores.value(window));
 }
 
 QPlatformBackingStore *QWasmIntegration::createPlatformBackingStore(QWindow *window) const
 {
 #ifndef QT_NO_OPENGL
-    QWasmBackingStore *backingStore = new QWasmBackingStore(m_compositor, window);
+    QWasmCompositor *compositor = QWasmScreen::get(window->screen())->compositor();
+    QWasmBackingStore *backingStore = new QWasmBackingStore(compositor, window);
     m_backingStores.insert(window, backingStore);
     return backingStore;
 #else
@@ -177,9 +178,20 @@ QPlatformTheme *QWasmIntegration::createPlatformTheme(const QString &name) const
 
 QPlatformClipboard* QWasmIntegration::clipboard() const
 {
-    if (!m_clipboard)
-        m_clipboard = new QWasmClipboard;
     return m_clipboard;
 }
 
+QVector<QWasmScreen *> QWasmIntegration::screens()
+{
+    return m_screens;
+}
+
+void QWasmIntegration::addScreen(const QString &canvasId)
+{
+    QWasmScreen *screen = new QWasmScreen(canvasId);
+    m_clipboard->installEventHandlers(canvasId);
+    m_screens.append(screen);
+    screenAdded(screen);
+}
+
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/wasm/qwasmintegration.h b/src/plugins/platforms/wasm/qwasmintegration.h
index 0b73303bf4..5c0ac0b297 100644
--- a/src/plugins/platforms/wasm/qwasmintegration.h
+++ b/src/plugins/platforms/wasm/qwasmintegration.h
@@ -71,23 +71,20 @@ public:
     QPlatformTheme *createPlatformTheme(const QString &name) const override;
     QPlatformClipboard *clipboard() const override;
 
-    QWasmScreen *screen() { return m_screen; }
-    QWasmCompositor *compositor() { return m_compositor; }
-    QWasmEventTranslator *eventTranslator() { return m_eventTranslator; }
+    QVector<QWasmScreen *>screens();
     QWasmClipboard *getWasmClipboard() { return m_clipboard; }
 
     static QWasmIntegration *get() { return s_instance; }
     static void QWasmBrowserExit();
-    QStringList canvasIds;
 
 private:
+    void addScreen(const QString &canvasId);
+
     mutable QWasmFontDatabase *m_fontDb;
-    QWasmCompositor *m_compositor;
-    mutable QWasmScreen *m_screen;
-    mutable QWasmEventTranslator *m_eventTranslator;
     mutable QWasmEventDispatcher *m_eventDispatcher;
     mutable QHash<QWindow *, QWasmBackingStore *> m_backingStores;
 
+    QVector<QWasmScreen *> m_screens;
     mutable QWasmClipboard *m_clipboard;
     static QWasmIntegration *s_instance;
 };
diff --git a/src/plugins/platforms/wasm/qwasmopenglcontext.cpp b/src/plugins/platforms/wasm/qwasmopenglcontext.cpp
index e71da0c217..ae43e2ebf0 100644
--- a/src/plugins/platforms/wasm/qwasmopenglcontext.cpp
+++ b/src/plugins/platforms/wasm/qwasmopenglcontext.cpp
@@ -57,9 +57,7 @@ void QWasmOpenGLContext::maybeRecreateEmscriptenContext(QPlatformSurface *surfac
             emscripten_webgl_destroy_context(m_context);
 
         // Create new context
-        QWasmScreen *wasmScreen = QWasmIntegration::get()->screen();
-        const QString canvasId = wasmScreen->m_canvasId;
-         // FIXME: get the actual canvas from the surface.
+        const QString canvasId = QWasmScreen::get(surface->screen())->canvasId();
         m_context = createEmscriptenContext(canvasId, m_requestedFormat);
 
         // Register context-lost callback.
diff --git a/src/plugins/platforms/wasm/qwasmscreen.cpp b/src/plugins/platforms/wasm/qwasmscreen.cpp
index fb14803ff8..a26cafa900 100644
--- a/src/plugins/platforms/wasm/qwasmscreen.cpp
+++ b/src/plugins/platforms/wasm/qwasmscreen.cpp
@@ -29,8 +29,10 @@
 
 #include "qwasmscreen.h"
 #include "qwasmwindow.h"
+#include "qwasmeventtranslator.h"
 #include "qwasmcompositor.h"
 #include <emscripten/bind.h>
+#include <emscripten/val.h>
 
 #include <QtEglSupport/private/qeglconvenience_p.h>
 #ifndef QT_NO_OPENGL
@@ -44,12 +46,13 @@
 
 QT_BEGIN_NAMESPACE
 
-QWasmScreen::QWasmScreen(QWasmCompositor *compositor)
-    : m_compositor(compositor)
-    , m_depth(32)
-    , m_format(QImage::Format_RGB32)
+QWasmScreen::QWasmScreen(const QString &canvasId)
+    : m_canvasId(canvasId)
+
 {
-    m_compositor->setScreen(this);
+    m_compositor = new QWasmCompositor(this);
+    m_eventTranslator = new QWasmEventTranslator(this);
+    updateQScreenAndCanvasRenderSize();
 }
 
 QWasmScreen::~QWasmScreen()
@@ -57,6 +60,31 @@ QWasmScreen::~QWasmScreen()
 
 }
 
+QWasmScreen *QWasmScreen::get(QPlatformScreen *screen)
+{
+    return static_cast<QWasmScreen *>(screen);
+}
+
+QWasmScreen *QWasmScreen::get(QScreen *screen)
+{
+    return get(screen->handle());
+}
+
+QWasmCompositor *QWasmScreen::compositor()
+{
+    return m_compositor;
+}
+
+QWasmEventTranslator *QWasmScreen::eventTranslator()
+{
+    return m_eventTranslator;
+}
+
+QString QWasmScreen::canvasId() const
+{
+    return m_canvasId;
+}
+
 QRect QWasmScreen::geometry() const
 {
     return m_geometry;
@@ -82,6 +110,11 @@ qreal QWasmScreen::devicePixelRatio() const
     return qreal(htmlWindowDpr);
 }
 
+QString QWasmScreen::name() const
+{
+    return m_canvasId;
+}
+
 QPlatformCursor *QWasmScreen::cursor() const
 {
     return const_cast<QWasmCursor *>(&m_cursor);
@@ -114,14 +147,7 @@ void QWasmScreen::setGeometry(const QRect &rect)
     resizeMaximizedWindows();
 }
 
-static void set_canvas_size(double width, double height, const char *canvasId)
-{
-    emscripten::val canvas = emscripten::val::global(canvasId);
-    canvas.set("width", width);
-    canvas.set("height", height);
-}
-
-void QWasmScreen::updateQScreenAndCanvasRenderSize(const QString &canvasId)
+void QWasmScreen::updateQScreenAndCanvasRenderSize()
 {
     // The HTML canvas has two sizes: the CSS size and the canvas render size.
     // The CSS size is determined according to standard CSS rules, while the
@@ -130,17 +156,22 @@ void QWasmScreen::updateQScreenAndCanvasRenderSize(const QString &canvasId)
     // Setting the render size to a value larger than the CSS size enables high-dpi
     // rendering.
 
+    QByteArray canvasId = m_canvasId.toUtf8();
     double css_width;
     double css_height;
-    emscripten_get_element_css_size(canvasId.toLocal8Bit().constData(), &css_width, &css_height);
+    emscripten_get_element_css_size(canvasId.constData(), &css_width, &css_height);
     QSizeF cssSize(css_width, css_height);
 
-    QWasmScreen *screen = QWasmIntegration::get()->screen();
-    QSizeF canvasSize = cssSize * screen->devicePixelRatio();
+    QSizeF canvasSize = cssSize * devicePixelRatio();
+    emscripten::val canvas = emscripten::val::global(canvasId.constData());
+    canvas.set("width", canvasSize.width());
+    canvas.set("height", canvasSize.height());
+
+    emscripten::val rect = canvas.call<emscripten::val>("getBoundingClientRect");
+    QPoint position(rect["left"].as<int>(), rect["top"].as<int>());
 
-    set_canvas_size(canvasSize.width(), canvasSize.height(), canvasId.toLocal8Bit().constData());
-    screen->setGeometry(QRect(QPoint(0, 0), cssSize.toSize()));
-    QWasmIntegration::get()->compositor()->redrawWindowContent();
+    setGeometry(QRect(position, cssSize.toSize()));
+    m_compositor->redrawWindowContent();
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/wasm/qwasmscreen.h b/src/plugins/platforms/wasm/qwasmscreen.h
index d5080835c9..82d2a83edb 100644
--- a/src/plugins/platforms/wasm/qwasmscreen.h
+++ b/src/plugins/platforms/wasm/qwasmscreen.h
@@ -43,20 +43,28 @@ class QPlatformOpenGLContext;
 class QWasmWindow;
 class QWasmBackingStore;
 class QWasmCompositor;
+class QWasmEventTranslator;
 class QOpenGLContext;
 
 class QWasmScreen : public QObject, public QPlatformScreen
 {
     Q_OBJECT
 public:
-
-    QWasmScreen(QWasmCompositor *compositor);
+    QWasmScreen(const QString &canvasId);
     ~QWasmScreen();
 
+    static QWasmScreen *get(QPlatformScreen *screen);
+    static QWasmScreen *get(QScreen *screen);
+    QString canvasId() const;
+
+    QWasmCompositor *compositor();
+    QWasmEventTranslator *eventTranslator();
+
     QRect geometry() const override;
     int depth() const override;
     QImage::Format format() const override;
     qreal devicePixelRatio() const override;
+    QString name() const override;
     QPlatformCursor *cursor() const override;
 
     void resizeMaximizedWindows();
@@ -64,19 +72,18 @@ public:
     QWindow *topLevelAt(const QPoint &p) const override;
 
     void invalidateSize();
-    static void updateQScreenAndCanvasRenderSize(const QString &);
-    QString m_canvasId;
-    void setCanvas(const QString &canvasId) { m_canvasId = canvasId; }
+    void updateQScreenAndCanvasRenderSize();
 
 public slots:
     void setGeometry(const QRect &rect);
 
 private:
-    QWasmCompositor *m_compositor;
-
+    QString m_canvasId;
+    QWasmCompositor *m_compositor = nullptr;
+    QWasmEventTranslator *m_eventTranslator = nullptr;
     QRect m_geometry = QRect(0, 0, 100, 100);
-    int m_depth;
-    QImage::Format m_format;
+    int m_depth = 32;
+    QImage::Format m_format = QImage::Format_RGB32;
     QWasmCursor m_cursor;
 };
 
diff --git a/src/plugins/platforms/wasm/wasm_shell.html b/src/plugins/platforms/wasm/wasm_shell.html
index 110d45e036..39bb711b6b 100644
--- a/src/plugins/platforms/wasm/wasm_shell.html
+++ b/src/plugins/platforms/wasm/wasm_shell.html
@@ -15,23 +15,24 @@
     </style>
   </head>
   <body onload="init()">
-    <figure style="overflow:visible;" id="spinner">
+    <figure style="overflow:visible;" id="qtspinner">
       <center style="margin-top:1.5em; line-height:150%">
         <img src="qtlogo.svg"; width=320; height=200; style="display:block"> </img>
         <strong>Qt for WebAssembly: APPNAME</strong>
-        <div id="status"></div>
+        <div id="qtstatus"></div>
         <noscript>JavaScript is disabled. Please enable JavaScript to use this application.</noscript>
       </center>
     </figure>
-    <canvas id="canvas" oncontextmenu="event.preventDefault()" contenteditable="true"></canvas>
+    <canvas id="qtcanvas" oncontextmenu="event.preventDefault()" contenteditable="true"></canvas>
 
     <script type='text/javascript'>
         function init() {
-          var spinner = document.getElementById('spinner');
-          var canvas = document.getElementById('canvas');
-          var status = document.getElementById('status')
+          var spinner = document.getElementById('qtspinner');
+          var canvas = document.getElementById('qtcanvas');
+          var status = document.getElementById('qtstatus')
 
           var qtLoader = QtLoader({
+              canvasElements : [canvas],
               showLoader: function(loaderStatus) {
                   spinner.style.display = 'block';
                   canvas.style.display = 'none';
@@ -54,7 +55,6 @@
               showCanvas: function() {
                   spinner.style.display = 'none';
                   canvas.style.display = 'block';
-                  return canvas;
               },
           });
           qtLoader.loadEmscriptenModule("APPNAME");
-- 
cgit v1.2.3