Merge remote-tracking branch 'origin/5.12' into dev

 Conflicts:
	src/android/templates/AndroidManifest.xml
	tests/auto/widgets/styles/qstylesheetstyle/tst_qstylesheetstyle.cpp

Change-Id: I4c9679e3a8ebba118fbf4772301ff8fde60455b9

8 files changed, 233 insertions, 99 deletions

diff --git a/src/plugins/platforms/windows/qwindowscontext.cpp b/src/plugins/platforms/windows/qwindowscontext.cpp
index 1f80ac5872..fee093f675 100644
--- a/src/plugins/platforms/windows/qwindowscontext.cpp
+++ b/src/plugins/platforms/windows/qwindowscontext.cpp
@@ -1115,8 +1115,10 @@ bool QWindowsContext::windowsProc(HWND hwnd, UINT message,
     case QtWindows::DisplayChangedEvent:
         if (QWindowsTheme *t = QWindowsTheme::instance())
             t->displayChanged();
+        QWindowsWindow::displayChanged();
         return d->m_screenManager.handleDisplayChange(wParam, lParam);
     case QtWindows::SettingChangedEvent:
+        QWindowsWindow::settingsChanged();
         return d->m_screenManager.handleScreenChanges();
     default:
         break;
diff --git a/src/plugins/platforms/windows/qwindowsglcontext.cpp b/src/plugins/platforms/windows/qwindowsglcontext.cpp
index 851a6c961e..21cb794196 100644
--- a/src/plugins/platforms/windows/qwindowsglcontext.cpp
+++ b/src/plugins/platforms/windows/qwindowsglcontext.cpp
@@ -1350,10 +1350,10 @@ bool QWindowsGLContext::makeCurrent(QPlatformSurface *surface)
     // Set the swap interval
     if (m_staticContext->wglSwapInternalExt) {
         const int interval = surface->format().swapInterval();
-        if (interval >= 0 && m_swapInterval != interval) {
+        if (m_swapInterval != interval)
             m_swapInterval = interval;
+        if (interval >= 0)
             m_staticContext->wglSwapInternalExt(interval);
-        }
     }
 
     return success;
diff --git a/src/plugins/platforms/windows/qwindowspointerhandler.cpp b/src/plugins/platforms/windows/qwindowspointerhandler.cpp
index 7935d0c36f..e428a8cf63 100644
--- a/src/plugins/platforms/windows/qwindowspointerhandler.cpp
+++ b/src/plugins/platforms/windows/qwindowspointerhandler.cpp
@@ -54,7 +54,6 @@
 #  include "qwindowsdrag.h"
 #endif
 
-#include <qpa/qwindowsysteminterface.h>
 #include <QtGui/qguiapplication.h>
 #include <QtGui/qscreen.h>
 #include <QtGui/qtouchdevice.h>
@@ -201,6 +200,8 @@ bool QWindowsPointerHandler::translatePointerEvent(QWindow *window, HWND hwnd, Q
         return false;
     }
 
+    m_lastPointerType = pointerType;
+
     // Handle non-client pen/touch as generic mouse events for compatibility with QDockWindow.
     if ((pointerType == QT_PT_TOUCH || pointerType == QT_PT_PEN) && (et & QtWindows::NonClientEventFlag)) {
         POINTER_INFO pointerInfo;
@@ -427,6 +428,15 @@ static bool isValidWheelReceiver(QWindow *candidate)
     return false;
 }
 
+static bool isMenuWindow(QWindow *window)
+{
+    if (window)
+        if (QObject *fo = window->focusObject())
+            if (fo->inherits("QMenu"))
+                return true;
+    return false;
+}
+
 static QTouchDevice *createTouchDevice()
 {
     const int digitizers = GetSystemMetrics(SM_DIGITIZER);
@@ -455,6 +465,103 @@ QTouchDevice *QWindowsPointerHandler::ensureTouchDevice()
     return m_touchDevice;
 }
 
+void QWindowsPointerHandler::handleCaptureRelease(QWindow *window,
+                                                  QWindow *currentWindowUnderPointer,
+                                                  HWND hwnd,
+                                                  QEvent::Type eventType,
+                                                  Qt::MouseButtons mouseButtons)
+{
+    QWindowsWindow *platformWindow = static_cast<QWindowsWindow *>(window->handle());
+
+    // Qt expects the platform plugin to capture the mouse on any button press until release.
+    if (!platformWindow->hasMouseCapture() && eventType == QEvent::MouseButtonPress) {
+
+        platformWindow->setMouseGrabEnabled(true);
+        platformWindow->setFlag(QWindowsWindow::AutoMouseCapture);
+        qCDebug(lcQpaEvents) << "Automatic mouse capture " << window;
+
+        // Implement "Click to focus" for native child windows (unless it is a native widget window).
+        if (!window->isTopLevel() && !window->inherits("QWidgetWindow") && QGuiApplication::focusWindow() != window)
+            window->requestActivate();
+
+    } else if (platformWindow->hasMouseCapture()
+               && platformWindow->testFlag(QWindowsWindow::AutoMouseCapture)
+               && eventType == QEvent::MouseButtonRelease
+               && !mouseButtons) {
+
+        platformWindow->setMouseGrabEnabled(false);
+        qCDebug(lcQpaEvents) << "Releasing automatic mouse capture " << window;
+    }
+
+    // Enter new window: track to generate leave event.
+    // If there is an active capture, only track if the current window is capturing,
+    // so we don't get extra leave when cursor leaves the application.
+    if (window != m_currentWindow &&
+            (!platformWindow->hasMouseCapture() || currentWindowUnderPointer == window)) {
+        trackLeave(hwnd);
+        m_currentWindow =  window;
+    }
+}
+
+void QWindowsPointerHandler::handleEnterLeave(QWindow *window,
+                                              QWindow *currentWindowUnderPointer,
+                                              QPoint globalPos)
+{
+    QWindowsWindow *platformWindow = static_cast<QWindowsWindow *>(window->handle());
+    const bool hasCapture = platformWindow->hasMouseCapture();
+
+    // No enter or leave events are sent as long as there is an autocapturing window.
+    if (!hasCapture || !platformWindow->testFlag(QWindowsWindow::AutoMouseCapture)) {
+
+        // Leave is needed if:
+        // 1) There is no capture and we move from a window to another window.
+        //    Note: Leaving the application entirely is handled in translateMouseEvent(WM_MOUSELEAVE).
+        // 2) There is capture and we move out of the capturing window.
+        // 3) There is a new capture and we were over another window.
+        if ((m_windowUnderPointer && m_windowUnderPointer != currentWindowUnderPointer
+                && (!hasCapture || window == m_windowUnderPointer))
+            || (hasCapture && m_previousCaptureWindow != window && m_windowUnderPointer
+                && m_windowUnderPointer != window)) {
+
+            qCDebug(lcQpaEvents) << "Leaving window " << m_windowUnderPointer;
+            QWindowSystemInterface::handleLeaveEvent(m_windowUnderPointer);
+
+            if (hasCapture && currentWindowUnderPointer != window) {
+                // Clear tracking if capturing and current window is not the capturing window
+                // to avoid leave when mouse actually leaves the application.
+                m_currentWindow = nullptr;
+                // We are not officially in any window, but we need to set some cursor to clear
+                // whatever cursor the left window had, so apply the cursor of the capture window.
+                platformWindow->applyCursor();
+            }
+        }
+
+        // Enter is needed if:
+        // 1) There is no capture and we move to a new window.
+        // 2) There is capture and we move into the capturing window.
+        // 3) The capture just ended and we are over non-capturing window.
+        if ((currentWindowUnderPointer && m_windowUnderPointer != currentWindowUnderPointer
+                && (!hasCapture || currentWindowUnderPointer == window))
+            || (m_previousCaptureWindow && !hasCapture && currentWindowUnderPointer
+                && currentWindowUnderPointer != m_previousCaptureWindow)) {
+
+            QPoint wumLocalPos;
+            if (QWindowsWindow *wumPlatformWindow = QWindowsWindow::windowsWindowOf(currentWindowUnderPointer)) {
+                wumLocalPos = wumPlatformWindow->mapFromGlobal(globalPos);
+                wumPlatformWindow->applyCursor();
+            }
+            qCDebug(lcQpaEvents) << "Entering window " << currentWindowUnderPointer;
+            QWindowSystemInterface::handleEnterEvent(currentWindowUnderPointer, wumLocalPos, globalPos);
+        }
+
+        // We need to track m_windowUnderPointer separately from m_currentWindow, as Windows
+        // mouse tracking will not trigger WM_MOUSELEAVE for leaving window when mouse capture is set.
+        m_windowUnderPointer = currentWindowUnderPointer;
+    }
+
+    m_previousCaptureWindow = hasCapture ? window : nullptr;
+}
+
 bool QWindowsPointerHandler::translateMouseTouchPadEvent(QWindow *window, HWND hwnd,
                                                          QtWindows::WindowsEventType et,
                                                          MSG msg, PVOID vPointerInfo)
@@ -464,9 +571,7 @@ bool QWindowsPointerHandler::translateMouseTouchPadEvent(QWindow *window, HWND h
     const QPoint localPos = QWindowsGeometryHint::mapFromGlobal(hwnd, globalPos);
     const Qt::KeyboardModifiers keyModifiers = QWindowsKeyMapper::queryKeyboardModifiers();
     const Qt::MouseButtons mouseButtons = mouseButtonsFromPointerFlags(pointerInfo->pointerFlags);
-
     QWindow *currentWindowUnderPointer = getWindowUnderPointer(window, globalPos);
-    QWindowsWindow *platformWindow = static_cast<QWindowsWindow *>(window->handle());
 
     switch (msg.message) {
     case WM_NCPOINTERDOWN:
@@ -485,38 +590,17 @@ bool QWindowsPointerHandler::translateMouseTouchPadEvent(QWindow *window, HWND h
                                                                keyModifiers, Qt::MouseEventNotSynthesized);
             return false;  // To allow window dragging, etc.
         } else {
-            if (eventType == QEvent::MouseButtonPress) {
-                // Implement "Click to focus" for native child windows (unless it is a native widget window).
-                if (!window->isTopLevel() && !window->inherits("QWidgetWindow") && QGuiApplication::focusWindow() != window)
-                    window->requestActivate();
-            }
-            if (currentWindowUnderPointer != m_windowUnderPointer) {
-                if (m_windowUnderPointer && m_windowUnderPointer == m_currentWindow) {
-                    QWindowSystemInterface::handleLeaveEvent(m_windowUnderPointer);
-                    m_currentWindow = nullptr;
-                }
-
-                if (currentWindowUnderPointer) {
-                    if (currentWindowUnderPointer != m_currentWindow) {
-                        QWindowSystemInterface::handleEnterEvent(currentWindowUnderPointer, localPos, globalPos);
-                        m_currentWindow = currentWindowUnderPointer;
-                        if (QWindowsWindow *wumPlatformWindow = QWindowsWindow::windowsWindowOf(currentWindowUnderPointer))
-                            wumPlatformWindow->applyCursor();
-                        trackLeave(hwnd);
-                    }
-                } else {
-                    platformWindow->applyCursor();
-                }
-                m_windowUnderPointer = currentWindowUnderPointer;
-            }
+
+            handleCaptureRelease(window, currentWindowUnderPointer, hwnd, eventType, mouseButtons);
+            handleEnterLeave(window, currentWindowUnderPointer, globalPos);
 
             QWindowSystemInterface::handleMouseEvent(window, localPos, globalPos, mouseButtons, button, eventType,
                                                      keyModifiers, Qt::MouseEventNotSynthesized);
 
             // The initial down click over the QSizeGrip area, which posts a resize WM_SYSCOMMAND
             // has go to through DefWindowProc() for resizing to work, so we return false here,
-            // unless the mouse is captured, as it would mess with menu processing.
-            return msg.message != WM_POINTERDOWN || GetCapture();
+            // unless the click was on a menu, as it would mess with menu processing.
+            return msg.message != WM_POINTERDOWN || isMenuWindow(window);
         }
     }
     case WM_POINTERHWHEEL:
@@ -641,6 +725,7 @@ bool QWindowsPointerHandler::translateTouchEvent(QWindow *window, HWND hwnd,
         // Only the primary pointer will generate mouse messages.
         enqueueTouchEvent(window, touchPoints, QWindowsKeyMapper::queryKeyboardModifiers());
     } else {
+        flushTouchEvents(m_touchDevice);
         QWindowSystemInterface::handleTouchEvent(window, m_touchDevice, touchPoints,
                                                  QWindowsKeyMapper::queryKeyboardModifiers());
     }
@@ -755,6 +840,16 @@ bool QWindowsPointerHandler::translatePenEvent(QWindow *window, HWND hwnd, QtWin
 #endif
 }
 
+static inline bool isMouseEventSynthesizedFromPenOrTouch()
+{
+    // For details, see
+    // https://docs.microsoft.com/en-us/windows/desktop/tablet/system-events-and-mouse-messages
+    const LONG_PTR SIGNATURE_MASK = 0xFFFFFF00;
+    const LONG_PTR MI_WP_SIGNATURE = 0xFF515700;
+
+    return ((::GetMessageExtraInfo() & SIGNATURE_MASK) == MI_WP_SIGNATURE);
+}
+
 // Process old-style mouse messages here.
 bool QWindowsPointerHandler::translateMouseEvent(QWindow *window, HWND hwnd, QtWindows::WindowsEventType et, MSG msg, LRESULT *result)
 {
@@ -763,8 +858,6 @@ bool QWindowsPointerHandler::translateMouseEvent(QWindow *window, HWND hwnd, QtW
     flushTabletEvents();
 
     *result = 0;
-    if (et != QtWindows::MouseWheelEvent && msg.message != WM_MOUSELEAVE && msg.message != WM_MOUSEMOVE)
-        return false;
 
     const QPoint eventPos(GET_X_LPARAM(msg.lParam), GET_Y_LPARAM(msg.lParam));
     QPoint localPos;
@@ -778,7 +871,26 @@ bool QWindowsPointerHandler::translateMouseEvent(QWindow *window, HWND hwnd, QtW
     }
 
     const Qt::KeyboardModifiers keyModifiers = QWindowsKeyMapper::queryKeyboardModifiers();
-    QWindowsWindow *platformWindow = static_cast<QWindowsWindow *>(window->handle());
+    const Qt::MouseButtons mouseButtons = mouseButtonsFromKeyState(msg.wParam);
+
+    // Handle "press and hold for right-clicking".
+    // We have to synthesize it here as it only comes from Windows as a fake RMB.
+    // MS docs say we could use bit 7 from extraInfo to distinguish pen from touch,
+    // but on the Surface it is set for both. So we use the last pointer type.
+    if (isMouseEventSynthesizedFromPenOrTouch()) {
+        if ((msg.message == WM_RBUTTONDOWN || msg.message == WM_RBUTTONUP)
+            && (((m_lastPointerType == QT_PT_PEN)
+                 && QCoreApplication::testAttribute(Qt::AA_SynthesizeMouseForUnhandledTabletEvents))
+                || ((m_lastPointerType == QT_PT_TOUCH)
+                    && QCoreApplication::testAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents)))) {
+            QWindowSystemInterface::handleMouseEvent(window, localPos, globalPos, mouseButtons, Qt::RightButton,
+                                                     (msg.message == WM_RBUTTONDOWN) ? QEvent::MouseButtonPress
+                                                                                     : QEvent::MouseButtonRelease,
+                                                     keyModifiers, Qt::MouseEventSynthesizedBySystem);
+        }
+        // Messages synthesized from touch/pen are only used for flushing queues and press&hold.
+        return false;
+    }
 
     if (et == QtWindows::MouseWheelEvent) {
 
@@ -799,50 +911,21 @@ bool QWindowsPointerHandler::translateMouseEvent(QWindow *window, HWND hwnd, QtW
     }
 
     if (msg.message == WM_MOUSELEAVE) {
+
         if (window == m_currentWindow) {
-            QWindowSystemInterface::handleLeaveEvent(window);
+            QWindow *leaveTarget = m_windowUnderPointer ? m_windowUnderPointer : m_currentWindow;
+            qCDebug(lcQpaEvents) << "Leaving window " << leaveTarget;
+            QWindowSystemInterface::handleLeaveEvent(leaveTarget);
             m_windowUnderPointer = nullptr;
             m_currentWindow = nullptr;
-            platformWindow->applyCursor();
         }
-        return false;
-    }
-
-    // Windows sends a mouse move with no buttons pressed to signal "Enter"
-    // when a window is shown over the cursor. Discard the event and only use
-    // it for generating QEvent::Enter to be consistent with other platforms -
-    // X11 and macOS.
-    static QPoint lastMouseMovePos;
-    const bool discardEvent = msg.wParam == 0 && (m_windowUnderPointer.isNull() || globalPos == lastMouseMovePos);
-    lastMouseMovePos = globalPos;
-
-    QWindow *currentWindowUnderPointer = getWindowUnderPointer(window, globalPos);
 
-    if (currentWindowUnderPointer != m_windowUnderPointer) {
-        if (m_windowUnderPointer && m_windowUnderPointer == m_currentWindow) {
-            QWindowSystemInterface::handleLeaveEvent(m_windowUnderPointer);
-            m_currentWindow = nullptr;
-        }
+    } else if (msg.message == WM_MOUSEMOVE) {
 
-        if (currentWindowUnderPointer) {
-            if (currentWindowUnderPointer != m_currentWindow) {
-                QWindowSystemInterface::handleEnterEvent(currentWindowUnderPointer, localPos, globalPos);
-                m_currentWindow = currentWindowUnderPointer;
-                if (QWindowsWindow *wumPlatformWindow = QWindowsWindow::windowsWindowOf(currentWindowUnderPointer))
-                    wumPlatformWindow->applyCursor();
-                trackLeave(hwnd);
-            }
-        } else {
-            platformWindow->applyCursor();
-        }
-        m_windowUnderPointer = currentWindowUnderPointer;
+        QWindow *currentWindowUnderPointer = getWindowUnderPointer(window, globalPos);
+        handleCaptureRelease(window, currentWindowUnderPointer, hwnd, QEvent::MouseMove, mouseButtons);
+        handleEnterLeave(window, currentWindowUnderPointer, globalPos);
     }
-
-    const Qt::MouseButtons mouseButtons = mouseButtonsFromKeyState(msg.wParam);
-
-    if (!discardEvent)
-        QWindowSystemInterface::handleMouseEvent(window, localPos, globalPos, mouseButtons, Qt::NoButton, QEvent::MouseMove,
-                                                 keyModifiers, Qt::MouseEventNotSynthesized);
     return false;
 }
 
diff --git a/src/plugins/platforms/windows/qwindowspointerhandler.h b/src/plugins/platforms/windows/qwindowspointerhandler.h
index 3861ebf919..ec3179e821 100644
--- a/src/plugins/platforms/windows/qwindowspointerhandler.h
+++ b/src/plugins/platforms/windows/qwindowspointerhandler.h
@@ -46,6 +46,7 @@
 #include <QtCore/qpointer.h>
 #include <QtCore/qscopedpointer.h>
 #include <QtCore/qhash.h>
+#include <qpa/qwindowsysteminterface.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -68,12 +69,16 @@ private:
     bool translateMouseTouchPadEvent(QWindow *window, HWND hwnd, QtWindows::WindowsEventType et, MSG msg, PVOID vPointerInfo);
     bool translateTouchEvent(QWindow *window, HWND hwnd, QtWindows::WindowsEventType et, MSG msg, PVOID vTouchInfo, unsigned int count);
     bool translatePenEvent(QWindow *window, HWND hwnd, QtWindows::WindowsEventType et, MSG msg, PVOID vPenInfo);
+    void handleCaptureRelease(QWindow *window, QWindow *currentWindowUnderPointer, HWND hwnd, QEvent::Type eventType, Qt::MouseButtons mouseButtons);
+    void handleEnterLeave(QWindow *window, QWindow *currentWindowUnderPointer, QPoint globalPos);
 
     QTouchDevice *m_touchDevice = nullptr;
     QHash<int, QPointF> m_lastTouchPositions;
     QPointer<QWindow> m_windowUnderPointer;
     QPointer<QWindow> m_currentWindow;
+    QWindow *m_previousCaptureWindow = nullptr;
     bool m_needsEnterOnPointerUpdate = false;
+    DWORD m_lastPointerType = 0;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/windows/qwindowssystemtrayicon.cpp b/src/plugins/platforms/windows/qwindowssystemtrayicon.cpp
index 3c27f2914d..b738007f0e 100644
--- a/src/plugins/platforms/windows/qwindowssystemtrayicon.cpp
+++ b/src/plugins/platforms/windows/qwindowssystemtrayicon.cpp
@@ -103,6 +103,13 @@ static void setIconContents(NOTIFYICONDATA &tnd, const QString &tip, HICON hIcon
     qStringToLimitedWCharArray(tip, tnd.szTip, sizeof(tnd.szTip) / sizeof(wchar_t));
 }
 
+static void setIconVisibility(NOTIFYICONDATA &tnd, bool v)
+{
+    tnd.uFlags |= NIF_STATE;
+    tnd.dwStateMask = NIS_HIDDEN;
+    tnd.dwState = v ? 0 : NIS_HIDDEN;
+}
+
 // Match the HWND of the dummy window to the instances
 struct QWindowsHwndSystemTrayIconEntry
 {
@@ -176,12 +183,6 @@ static inline HWND createTrayIconMessageWindow()
 
 QWindowsSystemTrayIcon::QWindowsSystemTrayIcon()
 {
-    // For restoring the tray icon after explorer crashes
-    if (!MYWM_TASKBARCREATED)
-        MYWM_TASKBARCREATED = RegisterWindowMessage(L"TaskbarCreated");
-    // Allow the WM_TASKBARCREATED message through the UIPI filter
-    ChangeWindowMessageFilterEx(m_hwnd, MYWM_TASKBARCREATED, MSGFLT_ALLOW, 0);
-    qCDebug(lcQpaTrayIcon) << __FUNCTION__ << this << "MYWM_TASKBARCREATED=" << MYWM_TASKBARCREATED;
 }
 
 QWindowsSystemTrayIcon::~QWindowsSystemTrayIcon()
@@ -193,12 +194,15 @@ QWindowsSystemTrayIcon::~QWindowsSystemTrayIcon()
 void QWindowsSystemTrayIcon::init()
 {
     qCDebug(lcQpaTrayIcon) << __FUNCTION__ << this;
-    ensureInstalled();
+    m_visible = true;
+    if (!setIconVisible(m_visible))
+        ensureInstalled();
 }
 
 void QWindowsSystemTrayIcon::cleanup()
 {
     qCDebug(lcQpaTrayIcon) << __FUNCTION__ << this;
+    m_visible = false;
     ensureCleanup();
 }
 
@@ -310,6 +314,13 @@ bool QWindowsSystemTrayIcon::ensureInstalled()
     m_hwnd = createTrayIconMessageWindow();
     if (Q_UNLIKELY(m_hwnd == nullptr))
         return false;
+    // For restoring the tray icon after explorer crashes
+    if (!MYWM_TASKBARCREATED)
+        MYWM_TASKBARCREATED = RegisterWindowMessage(L"TaskbarCreated");
+    // Allow the WM_TASKBARCREATED message through the UIPI filter
+    ChangeWindowMessageFilterEx(m_hwnd, MYWM_TASKBARCREATED, MSGFLT_ALLOW, nullptr);
+    qCDebug(lcQpaTrayIcon) << __FUNCTION__ << this << "MYWM_TASKBARCREATED=" << MYWM_TASKBARCREATED;
+
     QWindowsHwndSystemTrayIconEntry entry{m_hwnd, this};
     hwndTrayIconEntries()->append(entry);
     sendTrayMessage(NIM_ADD);
@@ -333,6 +344,18 @@ void QWindowsSystemTrayIcon::ensureCleanup()
     m_toolTip.clear();
 }
 
+bool QWindowsSystemTrayIcon::setIconVisible(bool visible)
+{
+    if (!isInstalled())
+        return false;
+    NOTIFYICONDATA tnd;
+    initNotifyIconData(tnd);
+    tnd.uID = q_uNOTIFYICONID;
+    tnd.hWnd = m_hwnd;
+    setIconVisibility(tnd, visible);
+    return Shell_NotifyIcon(NIM_MODIFY, &tnd) == TRUE;
+}
+
 bool QWindowsSystemTrayIcon::sendTrayMessage(DWORD msg)
 {
     NOTIFYICONDATA tnd;
@@ -340,6 +363,8 @@ bool QWindowsSystemTrayIcon::sendTrayMessage(DWORD msg)
     tnd.uID = q_uNOTIFYICONID;
     tnd.hWnd = m_hwnd;
     tnd.uFlags = NIF_SHOWTIP;
+    if (msg != NIM_DELETE && !m_visible)
+        setIconVisibility(tnd, m_visible);
     if (msg == NIM_ADD || msg == NIM_MODIFY)
         setIconContents(tnd, m_toolTip, m_hIcon);
     if (!Shell_NotifyIcon(msg, &tnd))
diff --git a/src/plugins/platforms/windows/qwindowssystemtrayicon.h b/src/plugins/platforms/windows/qwindowssystemtrayicon.h
index a8adb9641f..44e1bcc761 100644
--- a/src/plugins/platforms/windows/qwindowssystemtrayicon.h
+++ b/src/plugins/platforms/windows/qwindowssystemtrayicon.h
@@ -84,6 +84,7 @@ private:
     bool ensureInstalled();
     void ensureCleanup();
     bool sendTrayMessage(DWORD msg);
+    bool setIconVisible(bool visible);
     HICON createIcon(const QIcon &icon);
 
     QIcon m_icon;
@@ -92,6 +93,7 @@ private:
     HICON m_hIcon = nullptr;
     mutable QPointer<QWindowsPopupMenu> m_menu;
     bool m_ignoreNextMouseRelease = false;
+    bool m_visible = false;
 };
 
 #ifndef QT_NO_DEBUG_STREAM
diff --git a/src/plugins/platforms/windows/qwindowswindow.cpp b/src/plugins/platforms/windows/qwindowswindow.cpp
index 6201da7b72..8a6466c9cf 100644
--- a/src/plugins/platforms/windows/qwindowswindow.cpp
+++ b/src/plugins/platforms/windows/qwindowswindow.cpp
@@ -482,26 +482,22 @@ struct WindowCreationData
     typedef QWindowsWindowData WindowData;
     enum Flags { ForceChild = 0x1, ForceTopLevel = 0x2 };
 
-    WindowCreationData() : parentHandle(0), type(Qt::Widget), style(0), exStyle(0),
-        topLevel(false), popup(false), dialog(false),
-        tool(false), embedded(false), hasAlpha(false) {}
-
     void fromWindow(const QWindow *w, const Qt::WindowFlags flags, unsigned creationFlags = 0);
     inline WindowData create(const QWindow *w, const WindowData &data, QString title) const;
     inline void applyWindowFlags(HWND hwnd) const;
     void initialize(const QWindow *w, HWND h, bool frameChange, qreal opacityLevel) const;
 
     Qt::WindowFlags flags;
-    HWND parentHandle;
-    Qt::WindowType type;
-    unsigned style;
-    unsigned exStyle;
-    bool topLevel;
-    bool popup;
-    bool dialog;
-    bool tool;
-    bool embedded;
-    bool hasAlpha;
+    HWND parentHandle = nullptr;
+    Qt::WindowType type = Qt::Widget;
+    unsigned style = 0;
+    unsigned exStyle = 0;
+    bool topLevel = false;
+    bool popup = false;
+    bool dialog = false;
+    bool tool = false;
+    bool embedded = false;
+    bool hasAlpha = false;
 };
 
 QDebug operator<<(QDebug debug, const WindowCreationData &d)
@@ -555,12 +551,6 @@ static QScreen *screenForName(const QWindow *w, const QString &name)
     return winScreen;
 }
 
-static QScreen *forcedScreenForGLWindow(const QWindow *w)
-{
-    const QString forceToScreen = GpuDescription::detect().gpuSuitableScreen;
-    return forceToScreen.isEmpty() ? nullptr : screenForName(w, forceToScreen);
-}
-
 static QPoint calcPosition(const QWindow *w, const QWindowCreationContextPtr &context, const QMargins &invMargins)
 {
     const QPoint orgPos(context->frameX - invMargins.left(), context->frameY - invMargins.top());
@@ -569,7 +559,7 @@ static QPoint calcPosition(const QWindow *w, const QWindowCreationContextPtr &co
         return orgPos;
 
     // Workaround for QTBUG-50371
-    const QScreen *screenForGL = forcedScreenForGLWindow(w);
+    const QScreen *screenForGL = QWindowsWindow::forcedScreenForGLWindow(w);
     if (!screenForGL)
         return orgPos;
 
@@ -1364,6 +1354,28 @@ void QWindowsWindow::setDropSiteEnabled(bool dropEnabled)
 #endif // QT_CONFIG(clipboard) && QT_CONFIG(draganddrop)
 }
 
+bool QWindowsWindow::m_screenForGLInitialized = false;
+
+void QWindowsWindow::displayChanged()
+{
+    m_screenForGLInitialized = false;
+}
+
+void QWindowsWindow::settingsChanged()
+{
+    m_screenForGLInitialized = false;
+}
+
+QScreen *QWindowsWindow::forcedScreenForGLWindow(const QWindow *w)
+{
+    static QString forceToScreen;
+    if (!m_screenForGLInitialized) {
+        forceToScreen = GpuDescription::detect().gpuSuitableScreen;
+        m_screenForGLInitialized = true;
+    }
+    return forceToScreen.isEmpty() ? nullptr : screenForName(w, forceToScreen);
+}
+
 // Returns topmost QWindowsWindow ancestor even if there are embedded windows in the chain.
 // Returns this window if it is the topmost ancestor.
 QWindow *QWindowsWindow::topLevelOf(QWindow *w)
diff --git a/src/plugins/platforms/windows/qwindowswindow.h b/src/plugins/platforms/windows/qwindowswindow.h
index 4d136151fe..b07bd15d2a 100644
--- a/src/plugins/platforms/windows/qwindowswindow.h
+++ b/src/plugins/platforms/windows/qwindowswindow.h
@@ -297,6 +297,9 @@ public:
     void handleHidden();
     void handleCompositionSettingsChanged();
 
+    static void displayChanged();
+    static void settingsChanged();
+    static QScreen *forcedScreenForGLWindow(const QWindow *w);
     static QWindowsWindow *windowsWindowOf(const QWindow *w);
     static QWindow *topLevelOf(QWindow *w);
     static inline void *userDataOf(HWND hwnd);
@@ -378,6 +381,8 @@ private:
     HICON m_iconBig = 0;
     void *m_surface = nullptr;
 
+    static bool m_screenForGLInitialized;
+
 #if QT_CONFIG(vulkan)
     // note: intentionally not using void * in order to avoid breaking x86
     VkSurfaceKHR m_vkSurface = 0;