qwindow.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qwindow.h"
 
#include <qpa/qplatformwindow.h>
#include <qpa/qplatformintegration.h>
#ifndef QT_NO_CONTEXTMENU
#include <qpa/qplatformtheme.h>
#endif
#include "qsurfaceformat.h"
#ifndef QT_NO_OPENGL
#include <qpa/qplatformopenglcontext.h>
#include "qopenglcontext.h"
#include "qopenglcontext_p.h"
#endif
#include "qscreen.h"
 
#include "qwindow_p.h"
#include "qguiapplication_p.h"
#if QT_CONFIG(accessibility)
#  include "qaccessible.h"
#endif
#include "qhighdpiscaling_p.h"
#if QT_CONFIG(draganddrop)
#include "qshapedpixmapdndwindow_p.h"
#endif // QT_CONFIG(draganddrop)
 
#include <private/qevent_p.h>
 
#include <QtCore/QTimer>
#include <QtCore/QDebug>
 
#include <QStyleHints>
#include <qpa/qplatformcursor.h>
#include <qpa/qplatformwindow_p.h>
 
QT_BEGIN_NAMESPACE
 
QWindow::QWindow(QScreen *targetScreen)
    : QObject(*new QWindowPrivate(), nullptr)
    , QSurface(QSurface::Window)
{
    Q_D(QWindow);
    d->init(targetScreen);
}
 
static QWindow *nonDesktopParent(QWindow *parent)
{
    if (parent && parent->type() == Qt::Desktop) {
        qWarning("QWindows cannot be reparented into desktop windows");
        return nullptr;
    }
 
    return parent;
}
 
QWindow::QWindow(QWindow *parent)
    : QWindow(*new QWindowPrivate(), parent)
{
}
 
QWindow::QWindow(QWindowPrivate &dd, QWindow *parent)
    : QObject(dd, nonDesktopParent(parent))
    , QSurface(QSurface::Window)
{
    Q_D(QWindow);
    d->init();
}
 
QWindow::~QWindow()
{
    Q_D(QWindow);
    d->destroy();
    QGuiApplicationPrivate::window_list.removeAll(this);
    if (!QGuiApplicationPrivate::is_app_closing)
        QGuiApplicationPrivate::instance()->modalWindowList.removeOne(this);
 
    // thse are normally cleared in destroy(), but the window may in
    // some cases end up becoming the focus window again, or receive an enter
    // event. Clear it again here as a workaround. See QTBUG-75326.
    if (QGuiApplicationPrivate::focus_window == this)
        QGuiApplicationPrivate::focus_window = nullptr;
    if (QGuiApplicationPrivate::currentMouseWindow == this)
        QGuiApplicationPrivate::currentMouseWindow = nullptr;
    if (QGuiApplicationPrivate::currentMousePressWindow == this)
        QGuiApplicationPrivate::currentMousePressWindow = nullptr;
 
    d->isWindow = false;
}
 
QWindowPrivate::QWindowPrivate()
    = default;
 
QWindowPrivate::~QWindowPrivate()
    = default;
 
void QWindowPrivate::init(QScreen *targetScreen)
{
    Q_Q(QWindow);
 
    isWindow = true;
    parentWindow = static_cast<QWindow *>(q->QObject::parent());
 
    QScreen *connectScreen = targetScreen ? targetScreen : QGuiApplication::primaryScreen();
 
    if (!parentWindow)
        connectToScreen(connectScreen);
 
    // If your application aborts here, you are probably creating a QWindow
    // before the screen list is populated.
    if (Q_UNLIKELY(!parentWindow && !topLevelScreen)) {
        qFatal("Cannot create window: no screens available");
    }
    QGuiApplicationPrivate::window_list.prepend(q);
 
    requestedFormat = QSurfaceFormat::defaultFormat();
    devicePixelRatio = connectScreen->devicePixelRatio();
}
 
QWindow::Visibility QWindow::visibility() const
{
    Q_D(const QWindow);
    return d->visibility;
}
 
void QWindow::setVisibility(Visibility v)
{
    switch (v) {
    case Hidden:
        hide();
        break;
    case AutomaticVisibility:
        show();
        break;
    case Windowed:
        showNormal();
        break;
    case Minimized:
        showMinimized();
        break;
    case Maximized:
        showMaximized();
        break;
    case FullScreen:
        showFullScreen();
        break;
    default:
        Q_ASSERT(false);
    }
}
 
/*
    Subclasses may override this function to run custom setVisible
    logic. Subclasses that do so must call the base class implementation
    at some point to make the native window visible, and must not
    call QWindow::setVisble() since that will recurse back here.
*/
void QWindowPrivate::setVisible(bool visible)
{
    Q_Q(QWindow);
 
    if (this->visible != visible) {
        this->visible = visible;
        emit q->visibleChanged(visible);
        updateVisibility();
    } else if (platformWindow) {
        // Visibility hasn't changed, and the platform window is in sync
        return;
    }
 
    if (!platformWindow) {
        // If we have a parent window, but the parent hasn't been created yet, we
        // can defer creation until the parent is created or we're re-parented.
        if (parentWindow && !parentWindow->handle())
            return;
 
        // We only need to create the window if it's being shown
        if (visible) {
            // FIXME: At this point we've already updated the visible state of
            // the QWindow, so if the platform layer reads the window state during
            // creation, and reflects that in the native window, it will end up
            // with a visible window. This may in turn result in resize or expose
            // events from the platform before we have sent the show event below.
            q->create();
        }
    }
 
    if (visible) {
        // remove posted quit events when showing a new window
        QCoreApplication::removePostedEvents(qApp, QEvent::Quit);
 
        if (q->type() == Qt::Window) {
            QGuiApplicationPrivate *app_priv = QGuiApplicationPrivate::instance();
            QString &firstWindowTitle = app_priv->firstWindowTitle;
            if (!firstWindowTitle.isEmpty()) {
                q->setTitle(firstWindowTitle);
                firstWindowTitle = QString();
            }
            if (!app_priv->forcedWindowIcon.isNull())
                q->setIcon(app_priv->forcedWindowIcon);
 
            // Handling of the -qwindowgeometry, -geometry command line arguments
            static bool geometryApplied = false;
            if (!geometryApplied) {
                geometryApplied = true;
                QGuiApplicationPrivate::applyWindowGeometrySpecificationTo(q);
            }
        }
 
        QShowEvent showEvent;
        QGuiApplication::sendEvent(q, &showEvent);
    }
 
    if (q->isModal()) {
        if (visible)
            QGuiApplicationPrivate::showModalWindow(q);
        else
            QGuiApplicationPrivate::hideModalWindow(q);
    // QShapedPixmapWindow is used on some platforms for showing a drag pixmap, so don't block
    // input to this window as it is performing a drag - QTBUG-63846
    } else if (visible && QGuiApplication::modalWindow()
#if QT_CONFIG(draganddrop)
               && !qobject_cast<QShapedPixmapWindow *>(q)
#endif // QT_CONFIG(draganddrop)
              ) {
        QGuiApplicationPrivate::updateBlockedStatus(q);
    }
 
#ifndef QT_NO_CURSOR
    if (visible && (hasCursor || QGuiApplication::overrideCursor()))
        applyCursor();
#endif
 
    if (platformWindow)
        platformWindow->setVisible(visible);
 
    if (!visible) {
        QHideEvent hideEvent;
        QGuiApplication::sendEvent(q, &hideEvent);
    }
}
 
void QWindowPrivate::updateVisibility()
{
    Q_Q(QWindow);
 
    QWindow::Visibility old = visibility;
 
    if (!visible)
        visibility = QWindow::Hidden;
    else if (windowState & Qt::WindowMinimized)
        visibility = QWindow::Minimized;
    else if (windowState & Qt::WindowFullScreen)
        visibility = QWindow::FullScreen;
    else if (windowState & Qt::WindowMaximized)
        visibility = QWindow::Maximized;
    else
        visibility = QWindow::Windowed;
 
    if (visibility != old)
        emit q->visibilityChanged(visibility);
}
 
void QWindowPrivate::updateSiblingPosition(SiblingPosition position)
{
    Q_Q(QWindow);
 
    if (!q->parent())
        return;
 
    QObjectList &siblings = q->parent()->d_ptr->children;
 
    const qsizetype siblingCount = siblings.size() - 1;
    if (siblingCount == 0)
        return;
 
    const qsizetype currentPosition = siblings.indexOf(q);
    Q_ASSERT(currentPosition >= 0);
 
    const qsizetype targetPosition = position == PositionTop ? siblingCount : 0;
 
    if (currentPosition == targetPosition)
        return;
 
    siblings.move(currentPosition, targetPosition);
}
 
bool QWindowPrivate::windowRecreationRequired(QScreen *newScreen) const
{
    Q_Q(const QWindow);
    const QScreen *oldScreen = q->screen();
    return oldScreen != newScreen && (platformWindow || !oldScreen)
        && !(oldScreen && oldScreen->virtualSiblings().contains(newScreen));
}
 
void QWindowPrivate::disconnectFromScreen()
{
    if (topLevelScreen)
        topLevelScreen = nullptr;
}
 
void QWindowPrivate::connectToScreen(QScreen *screen)
{
    disconnectFromScreen();
    topLevelScreen = screen;
}
 
void QWindowPrivate::emitScreenChangedRecursion(QScreen *newScreen)
{
    Q_Q(QWindow);
    emit q->screenChanged(newScreen);
    for (QObject *child : q->children()) {
        if (child->isWindowType())
            static_cast<QWindow *>(child)->d_func()->emitScreenChangedRecursion(newScreen);
    }
}
 
void QWindowPrivate::setTopLevelScreen(QScreen *newScreen, bool recreate)
{
    Q_Q(QWindow);
    if (parentWindow) {
        qWarning() << q << '(' << newScreen << "): Attempt to set a screen on a child window.";
        return;
    }
    if (newScreen != topLevelScreen) {
        const bool shouldRecreate = recreate && windowRecreationRequired(newScreen);
        const bool shouldShow = visibilityOnDestroy && !topLevelScreen;
        if (shouldRecreate && platformWindow)
            q->destroy();
        connectToScreen(newScreen);
        if (shouldShow)
            q->setVisible(true);
        else if (newScreen && shouldRecreate)
            create(true);
        emitScreenChangedRecursion(newScreen);
    }
}
 
void QWindowPrivate::create(bool recursive, WId nativeHandle)
{
    Q_Q(QWindow);
    if (platformWindow)
        return;
 
    // avoid losing update requests when re-creating
    const bool needsUpdate = updateRequestPending;
    // the platformWindow, if there was one, is now gone, so make this flag reflect reality now
    updateRequestPending = false;
 
    if (q->parent())
        q->parent()->create();
 
    // QPlatformWindow will poll geometry() during construction below. Set the
    // screen here so that high-dpi scaling will use the correct scale factor.
    if (q->isTopLevel()) {
        if (QScreen *screen = screenForGeometry(geometry))
            setTopLevelScreen(screen, false);
    }
 
    QPlatformIntegration *platformIntegration = QGuiApplicationPrivate::platformIntegration();
    platformWindow = nativeHandle ? platformIntegration->createForeignWindow(q, nativeHandle)
        : platformIntegration->createPlatformWindow(q);
    Q_ASSERT(platformWindow);
 
    if (!platformWindow) {
        qWarning() << "Failed to create platform window for" << q << "with flags" << q->flags();
        return;
    }
 
    platformWindow->initialize();
 
    QObjectList childObjects = q->children();
    for (int i = 0; i < childObjects.size(); i ++) {
        QObject *object = childObjects.at(i);
        if (!object->isWindowType())
            continue;
 
        QWindow *childWindow = static_cast<QWindow *>(object);
        if (recursive)
            childWindow->d_func()->create(recursive);
 
        // The child may have had deferred creation due to this window not being created
        // at the time setVisible was called, so we re-apply the visible state, which
        // may result in creating the child, and emitting the appropriate signals.
        if (childWindow->isVisible())
            childWindow->setVisible(true);
 
        if (QPlatformWindow *childPlatformWindow = childWindow->d_func()->platformWindow)
            childPlatformWindow->setParent(this->platformWindow);
    }
 
    QPlatformSurfaceEvent e(QPlatformSurfaceEvent::SurfaceCreated);
    QGuiApplication::sendEvent(q, &e);
 
    updateDevicePixelRatio();
 
    if (needsUpdate)
        q->requestUpdate();
}
 
void QWindowPrivate::clearFocusObject()
{
}
 
// Allows for manipulating the suggested geometry before a resize/move
// event in derived classes for platforms that support it, for example to
// implement heightForWidth().
QRectF QWindowPrivate::closestAcceptableGeometry(const QRectF &rect) const
{
    Q_UNUSED(rect);
    return QRectF();
}
 
void QWindowPrivate::setMinOrMaxSize(QSize *oldSizeMember, const QSize &size,
                                     qxp::function_ref<void()> funcWidthChanged,
                                     qxp::function_ref<void()> funcHeightChanged)
{
    Q_Q(QWindow);
    Q_ASSERT(oldSizeMember);
    const QSize adjustedSize =
            size.expandedTo(QSize(0, 0)).boundedTo(QSize(QWINDOWSIZE_MAX, QWINDOWSIZE_MAX));
    if (*oldSizeMember == adjustedSize)
        return;
    const bool widthChanged = adjustedSize.width() != oldSizeMember->width();
    const bool heightChanged = adjustedSize.height() != oldSizeMember->height();
    *oldSizeMember = adjustedSize;
 
    if (platformWindow && q->isTopLevel())
        platformWindow->propagateSizeHints();
 
    if (widthChanged)
        funcWidthChanged();
    if (heightChanged)
        funcHeightChanged();
 
    // resize window if current size is outside of min and max limits
    if (minimumSize.width() <= maximumSize.width()
        || minimumSize.height() <= maximumSize.height()) {
        q->resize(q->geometry().size().expandedTo(minimumSize).boundedTo(maximumSize));
    }
}
 
void QWindow::setSurfaceType(SurfaceType surfaceType)
{
    Q_D(QWindow);
    d->surfaceType = surfaceType;
}
 
QWindow::SurfaceType QWindow::surfaceType() const
{
    Q_D(const QWindow);
    return d->surfaceType;
}
 
void QWindow::setVisible(bool visible)
{
    Q_D(QWindow);
 
    d->setVisible(visible);
}
 
bool QWindow::isVisible() const
{
    Q_D(const QWindow);
 
    return d->visible;
}
 
void QWindow::create()
{
    Q_D(QWindow);
    d->create(false);
}
 
WId QWindow::winId() const
{
    Q_D(const QWindow);
 
    if (!d->platformWindow)
        const_cast<QWindow *>(this)->create();
 
    return d->platformWindow->winId();
}
 
QWindow *QWindow::parent(AncestorMode mode) const
{
    Q_D(const QWindow);
    return d->parentWindow ? d->parentWindow : (mode == IncludeTransients ? transientParent() : nullptr);
}
 
void QWindow::setParent(QWindow *parent)
{
    parent = nonDesktopParent(parent);
 
    Q_D(QWindow);
    if (d->parentWindow == parent)
        return;
 
    QScreen *newScreen = parent ? parent->screen() : screen();
    if (d->windowRecreationRequired(newScreen)) {
        qWarning() << this << '(' << parent << "): Cannot change screens (" << screen() << newScreen << ')';
        return;
    }
 
    QObject::setParent(parent);
    d->parentWindow = parent;
 
    if (parent)
        d->disconnectFromScreen();
    else
        d->connectToScreen(newScreen);
 
    // If we were set visible, but not created because we were a child, and we're now
    // re-parented into a created parent, or to being a top level, we need re-apply the
    // visibility state, which will also create.
    if (isVisible() && (!parent || parent->handle()))
        setVisible(true);
 
    if (d->platformWindow) {
        if (parent)
            parent->create();
 
        d->platformWindow->setParent(parent ? parent->d_func()->platformWindow : nullptr);
    }
 
    QGuiApplicationPrivate::updateBlockedStatus(this);
}
 
bool QWindow::isTopLevel() const
{
    Q_D(const QWindow);
    return d->parentWindow == nullptr;
}
 
bool QWindow::isModal() const
{
    Q_D(const QWindow);
    return d->modality != Qt::NonModal;
}
 
Qt::WindowModality QWindow::modality() const
{
    Q_D(const QWindow);
    return d->modality;
}
 
void QWindow::setModality(Qt::WindowModality modality)
{
    Q_D(QWindow);
    if (d->modality == modality)
        return;
    d->modality = modality;
    emit modalityChanged(modality);
}
 
void QWindow::setFormat(const QSurfaceFormat &format)
{
    Q_D(QWindow);
    d->requestedFormat = format;
}
 
QSurfaceFormat QWindow::requestedFormat() const
{
    Q_D(const QWindow);
    return d->requestedFormat;
}
 
QSurfaceFormat QWindow::format() const
{
    Q_D(const QWindow);
    if (d->platformWindow)
        return d->platformWindow->format();
    return d->requestedFormat;
}
 
void QWindow::setFlags(Qt::WindowFlags flags)
{
    Q_D(QWindow);
    if (d->windowFlags == flags)
        return;
 
    if (d->platformWindow)
        d->platformWindow->setWindowFlags(flags);
    d->windowFlags = flags;
}
 
Qt::WindowFlags QWindow::flags() const
{
    Q_D(const QWindow);
    Qt::WindowFlags flags = d->windowFlags;
 
    if (d->platformWindow && d->platformWindow->isForeignWindow())
        flags |= Qt::ForeignWindow;
 
    return flags;
}
 
void QWindow::setFlag(Qt::WindowType flag, bool on)
{
    Q_D(QWindow);
    if (on)
        setFlags(d->windowFlags | flag);
    else
        setFlags(d->windowFlags & ~flag);
}
 
Qt::WindowType QWindow::type() const
{
    return static_cast<Qt::WindowType>(int(flags() & Qt::WindowType_Mask));
}
 
void QWindow::setTitle(const QString &title)
{
    Q_D(QWindow);
    bool changed = false;
    if (d->windowTitle != title) {
        d->windowTitle = title;
        changed = true;
    }
    if (d->platformWindow && type() != Qt::Desktop)
        d->platformWindow->setWindowTitle(title);
    if (changed)
        emit windowTitleChanged(title);
}
 
QString QWindow::title() const
{
    Q_D(const QWindow);
    return d->windowTitle;
}
 
void QWindow::setFilePath(const QString &filePath)
{
    Q_D(QWindow);
    d->windowFilePath = filePath;
    if (d->platformWindow)
        d->platformWindow->setWindowFilePath(filePath);
}
 
QString QWindow::filePath() const
{
    Q_D(const QWindow);
    return d->windowFilePath;
}
 
void QWindow::setIcon(const QIcon &icon)
{
    Q_D(QWindow);
    d->windowIcon = icon;
    if (d->platformWindow)
        d->platformWindow->setWindowIcon(icon);
    QEvent e(QEvent::WindowIconChange);
    QCoreApplication::sendEvent(this, &e);
}
 
QIcon QWindow::icon() const
{
    Q_D(const QWindow);
    if (d->windowIcon.isNull())
        return QGuiApplication::windowIcon();
    return d->windowIcon;
}
 
void QWindow::raise()
{
    Q_D(QWindow);
 
    d->updateSiblingPosition(QWindowPrivate::PositionTop);
 
    if (d->platformWindow)
        d->platformWindow->raise();
}
 
void QWindow::lower()
{
    Q_D(QWindow);
 
    d->updateSiblingPosition(QWindowPrivate::PositionBottom);
 
    if (d->platformWindow)
        d->platformWindow->lower();
}
 
bool QWindow::startSystemResize(Qt::Edges edges)
{
    Q_D(QWindow);
    if (Q_UNLIKELY(!isVisible() || !d->platformWindow || d->maximumSize == d->minimumSize))
        return false;
 
    const bool isSingleEdge = edges == Qt::TopEdge || edges == Qt::RightEdge || edges == Qt::BottomEdge || edges == Qt::LeftEdge;
    const bool isCorner =
            edges == (Qt::TopEdge | Qt::LeftEdge) ||
            edges == (Qt::TopEdge | Qt::RightEdge) ||
            edges == (Qt::BottomEdge | Qt::RightEdge) ||
            edges == (Qt::BottomEdge | Qt::LeftEdge);
 
    if (Q_UNLIKELY(!isSingleEdge && !isCorner)) {
        qWarning() << "Invalid edges" << edges << "passed to QWindow::startSystemResize, ignoring.";
        return false;
    }
 
    return d->platformWindow->startSystemResize(edges);
}
 
bool QWindow::startSystemMove()
{
    Q_D(QWindow);
    if (Q_UNLIKELY(!isVisible() || !d->platformWindow))
        return false;
 
    return d->platformWindow->startSystemMove();
}
 
void QWindow::setOpacity(qreal level)
{
    Q_D(QWindow);
    if (level == d->opacity)
        return;
    d->opacity = level;
    if (d->platformWindow) {
        d->platformWindow->setOpacity(level);
        emit opacityChanged(level);
    }
}
 
qreal QWindow::opacity() const
{
    Q_D(const QWindow);
    return d->opacity;
}
 
void QWindow::setMask(const QRegion &region)
{
    Q_D(QWindow);
    if (d->platformWindow)
        d->platformWindow->setMask(QHighDpi::toNativeLocalRegion(region, this));
    d->mask = region;
}
 
QRegion QWindow::mask() const
{
    Q_D(const QWindow);
    return d->mask;
}
 
void QWindow::requestActivate()
{
    Q_D(QWindow);
    if (flags() & Qt::WindowDoesNotAcceptFocus) {
        qWarning() << "requestActivate() called for " << this << " which has Qt::WindowDoesNotAcceptFocus set.";
        return;
    }
    if (d->platformWindow)
        d->platformWindow->requestActivateWindow();
}
 
bool QWindow::isExposed() const
{
    Q_D(const QWindow);
    return d->exposed;
}
 
bool QWindow::isActive() const
{
    Q_D(const QWindow);
    if (!d->platformWindow)
        return false;
 
    QWindow *focus = QGuiApplication::focusWindow();
 
    // Means the whole application lost the focus
    if (!focus)
        return false;
 
    if (focus == this)
        return true;
 
    if (QWindow *p = parent(IncludeTransients))
        return p->isActive();
    else
        return isAncestorOf(focus);
}
 
void QWindow::reportContentOrientationChange(Qt::ScreenOrientation orientation)
{
    Q_D(QWindow);
    if (d->contentOrientation == orientation)
        return;
    if (d->platformWindow)
        d->platformWindow->handleContentOrientationChange(orientation);
    d->contentOrientation = orientation;
    emit contentOrientationChanged(orientation);
}
 
Qt::ScreenOrientation QWindow::contentOrientation() const
{
    Q_D(const QWindow);
    return d->contentOrientation;
}
 
qreal QWindow::devicePixelRatio() const
{
    Q_D(const QWindow);
    return d->devicePixelRatio;
}
 
/*
    Updates the cached devicePixelRatio value by polling for a new value.
    Sends QEvent::DevicePixelRatioChange to the window if the DPR has changed.
*/
void QWindowPrivate::updateDevicePixelRatio()
{
    Q_Q(QWindow);
 
    // If there is no platform window use the associated screen's devicePixelRatio,
    // which typically is the primary screen and will be correct for single-display
    // systems (a very common case).
    const qreal newDevicePixelRatio = platformWindow ?
        platformWindow->devicePixelRatio() * QHighDpiScaling::factor(q) : q->screen()->devicePixelRatio();
 
    if (newDevicePixelRatio == devicePixelRatio)
        return;
 
    devicePixelRatio = newDevicePixelRatio;
    QEvent dprChangeEvent(QEvent::DevicePixelRatioChange);
    QGuiApplication::sendEvent(q, &dprChangeEvent);
}
 
Qt::WindowState QWindowPrivate::effectiveState(Qt::WindowStates state)
{
    if (state & Qt::WindowMinimized)
        return Qt::WindowMinimized;
    else if (state & Qt::WindowFullScreen)
        return Qt::WindowFullScreen;
    else if (state & Qt::WindowMaximized)
        return Qt::WindowMaximized;
    return Qt::WindowNoState;
}
 
void QWindow::setWindowState(Qt::WindowState state)
{
    setWindowStates(state);
}
 
void QWindow::setWindowStates(Qt::WindowStates state)
{
    Q_D(QWindow);
    if (state & Qt::WindowActive) {
        qWarning("QWindow::setWindowStates does not accept Qt::WindowActive");
        state &= ~Qt::WindowActive;
    }
 
    if (d->platformWindow)
        d->platformWindow->setWindowState(state);
 
    auto originalEffectiveState = QWindowPrivate::effectiveState(d->windowState);
    d->windowState = state;
    auto newEffectiveState = QWindowPrivate::effectiveState(d->windowState);
    if (newEffectiveState != originalEffectiveState)
        emit windowStateChanged(newEffectiveState);
 
    d->updateVisibility();
}
 
Qt::WindowState QWindow::windowState() const
{
    Q_D(const QWindow);
    return QWindowPrivate::effectiveState(d->windowState);
}
 
Qt::WindowStates QWindow::windowStates() const
{
    Q_D(const QWindow);
    return d->windowState;
}
 
void QWindow::setTransientParent(QWindow *parent)
{
    Q_D(QWindow);
    if (parent && !parent->isTopLevel()) {
        qWarning() << parent << "must be a top level window.";
        return;
    }
    if (parent == this) {
        qWarning() << "transient parent" << parent << "cannot be same as window";
        return;
    }
 
    d->transientParent = parent;
 
    QGuiApplicationPrivate::updateBlockedStatus(this);
    emit transientParentChanged(parent);
}
 
QWindow *QWindow::transientParent() const
{
    Q_D(const QWindow);
    return d->transientParent.data();
}
 
/*
    The setter for the QWindow::transientParent property.
    The only reason this exists is to set the transientParentPropertySet flag
    so that Qt Quick knows whether it was set programmatically (because of
    Window declaration context) or because the user set the property.
*/
void QWindowPrivate::setTransientParent(QWindow *parent)
{
    Q_Q(QWindow);
    q->setTransientParent(parent);
    transientParentPropertySet = true;
}
 
bool QWindow::isAncestorOf(const QWindow *child, AncestorMode mode) const
{
    if (child->parent() == this || (mode == IncludeTransients && child->transientParent() == this))
        return true;
 
    if (QWindow *parent = child->parent(mode)) {
        if (isAncestorOf(parent, mode))
            return true;
    } else if (handle() && child->handle()) {
        if (handle()->isAncestorOf(child->handle()))
            return true;
    }
 
    return false;
}
 
QSize QWindow::minimumSize() const
{
    Q_D(const QWindow);
    return d->minimumSize;
}
 
QSize QWindow::maximumSize() const
{
    Q_D(const QWindow);
    return d->maximumSize;
}
 
QSize QWindow::baseSize() const
{
    Q_D(const QWindow);
    return d->baseSize;
}
 
QSize QWindow::sizeIncrement() const
{
    Q_D(const QWindow);
    return d->sizeIncrement;
}
 
void QWindow::setMinimumSize(const QSize &size)
{
    Q_D(QWindow);
    d->setMinOrMaxSize(
            &d->minimumSize, size, [this, d]() { emit minimumWidthChanged(d->minimumSize.width()); },
            [this, d]() { emit minimumHeightChanged(d->minimumSize.height()); });
}
 
void QWindow::setX(int arg)
{
    Q_D(QWindow);
    if (x() != arg)
        setGeometry(QRect(arg, y(), width(), height()));
    else
        d->positionAutomatic = false;
}
 
void QWindow::setY(int arg)
{
    Q_D(QWindow);
    if (y() != arg)
        setGeometry(QRect(x(), arg, width(), height()));
    else
        d->positionAutomatic = false;
}
 
void QWindow::setWidth(int arg)
{
    if (width() != arg)
        resize(arg, height());
}
 
void QWindow::setHeight(int arg)
{
    if (height() != arg)
        resize(width(), arg);
}
 
void QWindow::setMinimumWidth(int w)
{
    setMinimumSize(QSize(w, minimumHeight()));
}
 
void QWindow::setMinimumHeight(int h)
{
    setMinimumSize(QSize(minimumWidth(), h));
}
 
void QWindow::setMaximumSize(const QSize &size)
{
    Q_D(QWindow);
    d->setMinOrMaxSize(
            &d->maximumSize, size, [this, d]() { emit maximumWidthChanged(d->maximumSize.width()); },
            [this, d]() { emit maximumHeightChanged(d->maximumSize.height()); });
}
 
void QWindow::setMaximumWidth(int w)
{
    setMaximumSize(QSize(w, maximumHeight()));
}
 
void QWindow::setMaximumHeight(int h)
{
    setMaximumSize(QSize(maximumWidth(), h));
}
 
void QWindow::setBaseSize(const QSize &size)
{
    Q_D(QWindow);
    if (d->baseSize == size)
        return;
    d->baseSize = size;
    if (d->platformWindow && isTopLevel())
        d->platformWindow->propagateSizeHints();
}
 
void QWindow::setSizeIncrement(const QSize &size)
{
    Q_D(QWindow);
    if (d->sizeIncrement == size)
        return;
    d->sizeIncrement = size;
    if (d->platformWindow && isTopLevel())
        d->platformWindow->propagateSizeHints();
}
 
void QWindow::setGeometry(int posx, int posy, int w, int h)
{
    setGeometry(QRect(posx, posy, w, h));
}
 
void QWindow::setGeometry(const QRect &rect)
{
    Q_D(QWindow);
    d->positionAutomatic = false;
    const QRect oldRect = geometry();
    if (rect == oldRect)
        return;
 
    d->positionPolicy = QWindowPrivate::WindowFrameExclusive;
    if (d->platformWindow) {
        QScreen *newScreen = d->screenForGeometry(rect);
        if (newScreen && isTopLevel())
            d->setTopLevelScreen(newScreen, true);
        d->platformWindow->setGeometry(QHighDpi::toNativeWindowGeometry(rect, this));
    } else {
        d->geometry = rect;
 
        if (rect.x() != oldRect.x())
            emit xChanged(rect.x());
        if (rect.y() != oldRect.y())
            emit yChanged(rect.y());
        if (rect.width() != oldRect.width())
            emit widthChanged(rect.width());
        if (rect.height() != oldRect.height())
            emit heightChanged(rect.height());
    }
}
 
/*
  This is equivalent to QPlatformWindow::screenForGeometry, but in platform
  independent coordinates. The duplication is unfortunate, but there is a
  chicken and egg problem here: we cannot convert to native coordinates
  before we know which screen we are on.
*/
QScreen *QWindowPrivate::screenForGeometry(const QRect &newGeometry) const
{
    Q_Q(const QWindow);
    QScreen *currentScreen = q->screen();
    QScreen *fallback = currentScreen;
    QPoint center = newGeometry.center();
    if (!q->parent() && currentScreen && !currentScreen->geometry().contains(center)) {
        const auto screens = currentScreen->virtualSiblings();
        for (QScreen* screen : screens) {
            if (screen->geometry().contains(center))
                return screen;
            if (screen->geometry().intersects(newGeometry))
                fallback = screen;
        }
    }
    return fallback;
}
 
 
QRect QWindow::geometry() const
{
    Q_D(const QWindow);
    if (d->platformWindow) {
        const auto nativeGeometry = d->platformWindow->geometry();
        return QHighDpi::fromNativeWindowGeometry(nativeGeometry, this);
    }
    return d->geometry;
}
 
QMargins QWindow::frameMargins() const
{
    Q_D(const QWindow);
    if (d->platformWindow)
        return QHighDpi::fromNativePixels(d->platformWindow->frameMargins(), this);
    return QMargins();
}
 
QRect QWindow::frameGeometry() const
{
    Q_D(const QWindow);
    if (d->platformWindow) {
        QMargins m = frameMargins();
        return QHighDpi::fromNativeWindowGeometry(d->platformWindow->geometry(), this).adjusted(-m.left(), -m.top(), m.right(), m.bottom());
    }
    return d->geometry;
}
 
QPoint QWindow::framePosition() const
{
    Q_D(const QWindow);
    if (d->platformWindow) {
        QMargins margins = frameMargins();
        return QHighDpi::fromNativeWindowGeometry(d->platformWindow->geometry().topLeft(), this) - QPoint(margins.left(), margins.top());
    }
    return d->geometry.topLeft();
}
 
void QWindow::setFramePosition(const QPoint &point)
{
    Q_D(QWindow);
    d->positionPolicy = QWindowPrivate::WindowFrameInclusive;
    d->positionAutomatic = false;
    if (d->platformWindow) {
        d->platformWindow->setGeometry(QHighDpi::toNativeWindowGeometry(QRect(point, size()), this));
    } else {
        d->geometry.moveTopLeft(point);
    }
}
 
void QWindow::setPosition(const QPoint &pt)
{
    setGeometry(QRect(pt, size()));
}
 
void QWindow::setPosition(int posx, int posy)
{
    setPosition(QPoint(posx, posy));
}
 
void QWindow::resize(int w, int h)
{
    resize(QSize(w, h));
}
 
void QWindow::resize(const QSize &newSize)
{
    Q_D(QWindow);
    d->positionPolicy = QWindowPrivate::WindowFrameExclusive;
    if (d->platformWindow) {
        d->platformWindow->setGeometry(
            QHighDpi::toNativeWindowGeometry(QRect(position(), newSize), this));
    } else {
        const QSize oldSize = d->geometry.size();
        d->geometry.setSize(newSize);
        if (newSize.width() != oldSize.width())
            emit widthChanged(newSize.width());
        if (newSize.height() != oldSize.height())
            emit heightChanged(newSize.height());
    }
}
 
void QWindow::destroy()
{
    Q_D(QWindow);
    if (!d->platformWindow)
        return;
 
    if (d->platformWindow->isForeignWindow())
        return;
 
    d->destroy();
}
 
void QWindowPrivate::destroy()
{
    if (!platformWindow)
        return;
 
    Q_Q(QWindow);
    QObjectList childrenWindows = q->children();
    for (int i = 0; i < childrenWindows.size(); i++) {
        QObject *object = childrenWindows.at(i);
        if (object->isWindowType()) {
            QWindow *w = static_cast<QWindow*>(object);
            qt_window_private(w)->destroy();
        }
    }
 
    bool wasVisible = q->isVisible();
    visibilityOnDestroy = wasVisible && platformWindow;
 
    q->setVisible(false);
 
    // Let subclasses act, typically by doing graphics resource cleaup, when
    // the window, to which graphics resource may be tied, is going away.
    //
    // NB! This is dysfunctional when destroy() is invoked from the dtor since
    // a reimplemented event() will not get called in the subclasses at that
    // stage. However, the typical QWindow cleanup involves either close() or
    // going through QWindowContainer, both of which will do an explicit, early
    // destroy(), which is good here.
 
    QPlatformSurfaceEvent e(QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed);
    QGuiApplication::sendEvent(q, &e);
 
    // Unset platformWindow before deleting, so that the destructor of the
    // platform window does not recurse back into the platform window via
    // this window during destruction (e.g. as a result of platform events).
    delete std::exchange(platformWindow, nullptr);
 
    if (QGuiApplicationPrivate::focus_window == q)
        QGuiApplicationPrivate::focus_window = q->parent();
    if (QGuiApplicationPrivate::currentMouseWindow == q)
        QGuiApplicationPrivate::currentMouseWindow = q->parent();
    if (QGuiApplicationPrivate::currentMousePressWindow == q)
        QGuiApplicationPrivate::currentMousePressWindow = q->parent();
 
    for (int i = 0; i < QGuiApplicationPrivate::tabletDevicePoints.size(); ++i)
        if (QGuiApplicationPrivate::tabletDevicePoints.at(i).target == q)
            QGuiApplicationPrivate::tabletDevicePoints[i].target = q->parent();
 
    resizeEventPending = true;
    receivedExpose = false;
    exposed = false;
}
 
QPlatformWindow *QWindow::handle() const
{
    Q_D(const QWindow);
    return d->platformWindow;
}
 
QPlatformSurface *QWindow::surfaceHandle() const
{
    Q_D(const QWindow);
    return d->platformWindow;
}
 
bool QWindow::setKeyboardGrabEnabled(bool grab)
{
    Q_D(QWindow);
    if (d->platformWindow)
        return d->platformWindow->setKeyboardGrabEnabled(grab);
    return false;
}
 
bool QWindow::setMouseGrabEnabled(bool grab)
{
    Q_D(QWindow);
    if (d->platformWindow)
        return d->platformWindow->setMouseGrabEnabled(grab);
    return false;
}
 
QScreen *QWindow::screen() const
{
    Q_D(const QWindow);
    return d->parentWindow ? d->parentWindow->screen() : d->topLevelScreen.data();
}
 
void QWindow::setScreen(QScreen *newScreen)
{
    Q_D(QWindow);
    if (!newScreen)
        newScreen = QGuiApplication::primaryScreen();
    d->setTopLevelScreen(newScreen, newScreen != nullptr);
}
 
QAccessibleInterface *QWindow::accessibleRoot() const
{
    return nullptr;
}
 
QObject *QWindow::focusObject() const
{
    return const_cast<QWindow *>(this);
}
 
void QWindow::show()
{
    Qt::WindowState defaultState = QGuiApplicationPrivate::platformIntegration()->defaultWindowState(d_func()->windowFlags);
    if (defaultState == Qt::WindowFullScreen)
        showFullScreen();
    else if (defaultState == Qt::WindowMaximized)
        showMaximized();
    else
        showNormal();
}
 
void QWindow::hide()
{
    setVisible(false);
}
 
void QWindow::showMinimized()
{
    setWindowStates(Qt::WindowMinimized);
    setVisible(true);
}
 
void QWindow::showMaximized()
{
    setWindowStates(Qt::WindowMaximized);
    setVisible(true);
}
 
void QWindow::showFullScreen()
{
    setWindowStates(Qt::WindowFullScreen);
    setVisible(true);
#if !defined Q_OS_QNX // On QNX this window will be activated anyway from libscreen
                      // activating it here before libscreen activates it causes problems
    requestActivate();
#endif
}
 
void QWindow::showNormal()
{
    setWindowStates(Qt::WindowNoState);
    setVisible(true);
}
 
bool QWindow::close()
{
    Q_D(QWindow);
    if (d->inClose)
        return true;
 
    // Do not close non top level windows
    if (!isTopLevel())
        return false;
 
    if (!d->platformWindow)
        return true;
 
    // The window might be deleted during close,
    // as a result of delivering the close event.
    QPointer guard(this);
    d->inClose = true;
    bool success = d->platformWindow->close();
    if (guard)
        d->inClose = false;
 
    return success;
}
 
bool QWindowPrivate::participatesInLastWindowClosed() const
{
    Q_Q(const QWindow);
 
    if (!q->isTopLevel())
        return false;
 
    // Tool-tip widgets do not normally have Qt::WA_QuitOnClose,
    // but since we do not have a similar flag for non-widget
    // windows we need an explicit exclusion here as well.
    if (q->type() == Qt::ToolTip)
        return false;
 
    // A window with a transient parent is not a primary window,
    // it's a secondary window.
    if (q->transientParent())
        return false;
 
    return true;
}
 
bool QWindowPrivate::treatAsVisible() const
{
    Q_Q(const QWindow);
    return q->isVisible();
}
 
void QWindow::exposeEvent(QExposeEvent *ev)
{
    ev->ignore();
}
 
void QWindow::paintEvent(QPaintEvent *ev)
{
    ev->ignore();
}
 
void QWindow::moveEvent(QMoveEvent *ev)
{
    ev->ignore();
}
 
void QWindow::resizeEvent(QResizeEvent *ev)
{
    ev->ignore();
}
 
void QWindow::showEvent(QShowEvent *ev)
{
    ev->ignore();
}
 
void QWindow::hideEvent(QHideEvent *ev)
{
    ev->ignore();
}
 
void QWindow::closeEvent(QCloseEvent *ev)
{
    Q_UNUSED(ev);
}
 
bool QWindow::event(QEvent *ev)
{
    switch (ev->type()) {
    case QEvent::MouseMove:
        mouseMoveEvent(static_cast<QMouseEvent*>(ev));
        break;
 
    case QEvent::MouseButtonPress:
        mousePressEvent(static_cast<QMouseEvent*>(ev));
        break;
 
    case QEvent::MouseButtonRelease:
        mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
        break;
 
    case QEvent::MouseButtonDblClick:
        mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
        break;
 
    case QEvent::TouchBegin:
    case QEvent::TouchUpdate:
    case QEvent::TouchEnd:
    case QEvent::TouchCancel:
        touchEvent(static_cast<QTouchEvent *>(ev));
        break;
 
    case QEvent::Move:
        moveEvent(static_cast<QMoveEvent*>(ev));
        break;
 
    case QEvent::Resize:
        resizeEvent(static_cast<QResizeEvent*>(ev));
        break;
 
    case QEvent::KeyPress:
        keyPressEvent(static_cast<QKeyEvent *>(ev));
        break;
 
    case QEvent::KeyRelease:
        keyReleaseEvent(static_cast<QKeyEvent *>(ev));
        break;
 
    case QEvent::FocusIn: {
        focusInEvent(static_cast<QFocusEvent *>(ev));
#if QT_CONFIG(accessibility)
        QAccessible::State state;
        state.active = true;
        QAccessibleStateChangeEvent event(this, state);
        QAccessible::updateAccessibility(&event);
#endif
        break; }
 
    case QEvent::FocusOut: {
        focusOutEvent(static_cast<QFocusEvent *>(ev));
#if QT_CONFIG(accessibility)
        QAccessible::State state;
        state.active = true;
        QAccessibleStateChangeEvent event(this, state);
        QAccessible::updateAccessibility(&event);
#endif
        break; }
 
#if QT_CONFIG(wheelevent)
    case QEvent::Wheel:
        wheelEvent(static_cast<QWheelEvent*>(ev));
        break;
#endif
 
    case QEvent::Close: {
 
        Q_D(QWindow);
        const bool wasVisible = d->treatAsVisible();
        const bool participatesInLastWindowClosed = d->participatesInLastWindowClosed();
 
        // The window might be deleted in the close event handler
        QPointer<QWindow> deletionGuard(this);
        closeEvent(static_cast<QCloseEvent*>(ev));
 
        if (ev->isAccepted()) {
            if (deletionGuard)
                destroy();
            if (wasVisible && participatesInLastWindowClosed)
                QGuiApplicationPrivate::instance()->maybeLastWindowClosed();
        }
 
        break;
    }
 
    case QEvent::Expose:
        exposeEvent(static_cast<QExposeEvent *>(ev));
        break;
 
    case QEvent::Paint:
        paintEvent(static_cast<QPaintEvent *>(ev));
        break;
 
    case QEvent::Show:
        showEvent(static_cast<QShowEvent *>(ev));
        break;
 
    case QEvent::Hide:
        hideEvent(static_cast<QHideEvent *>(ev));
        break;
 
    case QEvent::ApplicationWindowIconChange:
        setIcon(icon());
        break;
 
#if QT_CONFIG(tabletevent)
    case QEvent::TabletPress:
    case QEvent::TabletMove:
    case QEvent::TabletRelease:
        tabletEvent(static_cast<QTabletEvent *>(ev));
        break;
#endif
 
    case QEvent::PlatformSurface: {
        if ((static_cast<QPlatformSurfaceEvent *>(ev))->surfaceEventType() == QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed) {
#ifndef QT_NO_OPENGL
            QOpenGLContext *context = QOpenGLContext::currentContext();
            if (context && context->surface() == static_cast<QSurface *>(this))
                context->doneCurrent();
#endif
        }
        break;
    }
 
    default:
        return QObject::event(ev);
    }
 
#ifndef QT_NO_CONTEXTMENU
    /*
        QGuiApplicationPrivate::processContextMenuEvent blocks mouse-triggered
        context menu events that the QPA plugin might generate. In practice that
        never happens, as even on Windows WM_CONTEXTMENU is never generated by
        the OS (we never call the default window procedure that would do that in
        response to unhandled WM_RBUTTONUP).
 
        So, we always have to syntheize QContextMenuEvent for mouse events anyway.
        QWidgetWindow synthesizes QContextMenuEvent similar to this code, and
        never calls QWindow::event, so we have to do it here as well.
 
        This logic could be simplified by always synthesizing events in
        QGuiApplicationPrivate, or perhaps even in each QPA plugin. See QTBUG-93486.
    */
    static const QEvent::Type contextMenuTrigger =
        QGuiApplicationPrivate::platformTheme()->themeHint(QPlatformTheme::ContextMenuOnMouseRelease).toBool() ?
        QEvent::MouseButtonRelease : QEvent::MouseButtonPress;
    auto asMouseEvent = [](QEvent *ev) {
        const auto t = ev->type();
        return t == QEvent::MouseButtonPress || t == QEvent::MouseButtonRelease
                ? static_cast<QMouseEvent *>(ev) : nullptr ;
    };
    if (QMouseEvent *me = asMouseEvent(ev); me &&
        ev->type() == contextMenuTrigger && me->button() == Qt::RightButton) {
        QContextMenuEvent e(QContextMenuEvent::Mouse, me->position().toPoint(),
                            me->globalPosition().toPoint(), me->modifiers());
        QGuiApplication::sendEvent(this, &e);
    }
#endif
    return true;
}
 
void QWindow::requestUpdate()
{
    Q_ASSERT_X(QThread::currentThread() == QCoreApplication::instance()->thread(),
        "QWindow", "Updates can only be scheduled from the GUI (main) thread");
 
    Q_D(QWindow);
    if (d->updateRequestPending || !d->platformWindow)
        return;
    d->updateRequestPending = true;
    d->platformWindow->requestUpdate();
}
 
void QWindow::keyPressEvent(QKeyEvent *ev)
{
    ev->ignore();
}
 
void QWindow::keyReleaseEvent(QKeyEvent *ev)
{
    ev->ignore();
}
 
void QWindow::focusInEvent(QFocusEvent *ev)
{
    ev->ignore();
}
 
void QWindow::focusOutEvent(QFocusEvent *ev)
{
    ev->ignore();
}
 
void QWindow::mousePressEvent(QMouseEvent *ev)
{
    ev->ignore();
}
 
void QWindow::mouseReleaseEvent(QMouseEvent *ev)
{
    ev->ignore();
}
 
void QWindow::mouseDoubleClickEvent(QMouseEvent *ev)
{
    ev->ignore();
}
 
void QWindow::mouseMoveEvent(QMouseEvent *ev)
{
    ev->ignore();
}
 
#if QT_CONFIG(wheelevent)
void QWindow::wheelEvent(QWheelEvent *ev)
{
    ev->ignore();
}
#endif // QT_CONFIG(wheelevent)
 
void QWindow::touchEvent(QTouchEvent *ev)
{
    ev->ignore();
}
 
#if QT_CONFIG(tabletevent)
void QWindow::tabletEvent(QTabletEvent *ev)
{
    ev->ignore();
}
#endif
 
bool QWindow::nativeEvent(const QByteArray &eventType, void *message, qintptr *result)
{
    Q_UNUSED(eventType);
    Q_UNUSED(message);
    Q_UNUSED(result);
    return false;
}
 
QPointF QWindow::mapToGlobal(const QPointF &pos) const
{
    Q_D(const QWindow);
    // QTBUG-43252, prefer platform implementation for foreign windows.
    if (d->platformWindow
        && (d->platformWindow->isForeignWindow() || d->platformWindow->isEmbedded())) {
        return QHighDpi::fromNativeGlobalPosition(d->platformWindow->mapToGlobalF(QHighDpi::toNativeLocalPosition(pos, this)), this);
    }
 
    if (!QHighDpiScaling::isActive())
        return pos + d->globalPosition();
 
    // The normal pos + windowGlobalPos calculation may give a point which is outside
    // screen geometry for windows which span multiple screens, due to the way QHighDpiScaling
    // creates gaps between screens in the the device indendent cooordinate system.
    //
    // Map the position (and the window's global position) to native coordinates, perform
    // the addition, and then map back to device independent coordinates.
    QPointF nativeLocalPos = QHighDpi::toNativeLocalPosition(pos, this);
    QPointF nativeWindowGlobalPos = QHighDpi::toNativeGlobalPosition(QPointF(d->globalPosition()), this);
    QPointF nativeGlobalPos = nativeLocalPos + nativeWindowGlobalPos;
    QPointF deviceIndependentGlobalPos = QHighDpi::fromNativeGlobalPosition(nativeGlobalPos, this);
    return deviceIndependentGlobalPos;
}
 
QPoint QWindow::mapToGlobal(const QPoint &pos) const
{
    return mapToGlobal(QPointF(pos)).toPoint();
}
 
QPointF QWindow::mapFromGlobal(const QPointF &pos) const
{
    Q_D(const QWindow);
    // QTBUG-43252, prefer platform implementation for foreign windows.
    if (d->platformWindow
        && (d->platformWindow->isForeignWindow() || d->platformWindow->isEmbedded())) {
        return QHighDpi::fromNativeLocalPosition(d->platformWindow->mapFromGlobalF(QHighDpi::toNativeGlobalPosition(pos, this)), this);
    }
 
    if (!QHighDpiScaling::isActive())
        return pos - d->globalPosition();
 
    // Calculate local position in the native coordinate system. (See comment for the
    // corresponding mapToGlobal() code above).
    QPointF nativeGlobalPos = QHighDpi::toNativeGlobalPosition(pos, this);
    QPointF nativeWindowGlobalPos = QHighDpi::toNativeGlobalPosition(QPointF(d->globalPosition()), this);
    QPointF nativeLocalPos = nativeGlobalPos - nativeWindowGlobalPos;
    QPointF deviceIndependentLocalPos = QHighDpi::fromNativeLocalPosition(nativeLocalPos, this);
    return deviceIndependentLocalPos;
}
 
QPoint QWindow::mapFromGlobal(const QPoint &pos) const
{
    return QWindow::mapFromGlobal(QPointF(pos)).toPoint();
}
 
QPoint QWindowPrivate::globalPosition() const
{
    Q_Q(const QWindow);
    QPoint offset = q->position();
    for (const QWindow *p = q->parent(); p; p = p->parent()) {
        QPlatformWindow *pw = p->handle();
        if (pw && (pw->isForeignWindow() || pw->isEmbedded())) {
            // Use mapToGlobal() for foreign windows
            offset += p->mapToGlobal(QPoint(0, 0));
            break;
        } else {
            offset += p->position();
        }
    }
    return offset;
}
 
Q_GUI_EXPORT QWindowPrivate *qt_window_private(QWindow *window)
{
    return window->d_func();
}
 
QWindow *QWindowPrivate::topLevelWindow(QWindow::AncestorMode mode) const
{
    Q_Q(const QWindow);
 
    QWindow *window = const_cast<QWindow *>(q);
 
    while (window) {
        QWindow *parent = window->parent(mode);
        if (!parent)
            break;
 
        window = parent;
    }
 
    return window;
}
 
QWindow *QWindow::fromWinId(WId id)
{
    if (!QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ForeignWindows)) {
        qWarning("QWindow::fromWinId(): platform plugin does not support foreign windows.");
        return nullptr;
    }
 
    QWindow *window = new QWindow;
    qt_window_private(window)->create(false, id);
 
    if (!window->handle()) {
        delete window;
        return nullptr;
    }
 
    return window;
}
 
void QWindow::alert(int msec)
{
    Q_D(QWindow);
    if (!d->platformWindow || d->platformWindow->isAlertState() || isActive())
        return;
    d->platformWindow->setAlertState(true);
    if (d->platformWindow->isAlertState() && msec)
        QTimer::singleShot(msec, this, SLOT(_q_clearAlert()));
}
 
void QWindowPrivate::_q_clearAlert()
{
    if (platformWindow && platformWindow->isAlertState())
        platformWindow->setAlertState(false);
}
 
#ifndef QT_NO_CURSOR
void QWindow::setCursor(const QCursor &cursor)
{
    Q_D(QWindow);
    d->setCursor(&cursor);
}
 
void QWindow::unsetCursor()
{
    Q_D(QWindow);
    d->setCursor(nullptr);
}
 
QCursor QWindow::cursor() const
{
    Q_D(const QWindow);
    return d->cursor;
}
 
void QWindowPrivate::setCursor(const QCursor *newCursor)
{
 
    Q_Q(QWindow);
    if (newCursor) {
        const Qt::CursorShape newShape = newCursor->shape();
        if (newShape <= Qt::LastCursor && hasCursor && newShape == cursor.shape())
            return; // Unchanged and no bitmap/custom cursor.
        cursor = *newCursor;
        hasCursor = true;
    } else {
        if (!hasCursor)
            return;
        cursor = QCursor(Qt::ArrowCursor);
        hasCursor = false;
    }
    // Only attempt to emit signal if there is an actual platform cursor
    if (applyCursor()) {
        QEvent event(QEvent::CursorChange);
        QGuiApplication::sendEvent(q, &event);
    }
}
 
// Apply the cursor and returns true iff the platform cursor exists
bool QWindowPrivate::applyCursor()
{
    Q_Q(QWindow);
    if (QScreen *screen = q->screen()) {
        if (QPlatformCursor *platformCursor = screen->handle()->cursor()) {
            if (!platformWindow)
                return true;
            QCursor *c = QGuiApplication::overrideCursor();
            if (c != nullptr && platformCursor->capabilities().testFlag(QPlatformCursor::OverrideCursor))
                return true;
            if (!c && hasCursor)
                c = &cursor;
            platformCursor->changeCursor(c, q);
            return true;
        }
    }
    return false;
}
#endif // QT_NO_CURSOR
 
void *QWindow::resolveInterface(const char *name, int revision) const
{
    using namespace QNativeInterface::Private;
 
    auto *platformWindow = handle();
    Q_UNUSED(platformWindow);
    Q_UNUSED(name);
    Q_UNUSED(revision);
 
#if defined(Q_OS_WIN)
    QT_NATIVE_INTERFACE_RETURN_IF(QWindowsWindow, platformWindow);
#endif
 
#if QT_CONFIG(xcb)
    QT_NATIVE_INTERFACE_RETURN_IF(QXcbWindow, platformWindow);
#endif
 
#if defined(Q_OS_MACOS)
    QT_NATIVE_INTERFACE_RETURN_IF(QCocoaWindow, platformWindow);
#endif
 
#if defined(Q_OS_UNIX)
    QT_NATIVE_INTERFACE_RETURN_IF(QWaylandWindow, platformWindow);
#endif
 
#if defined(Q_OS_WASM)
    QT_NATIVE_INTERFACE_RETURN_IF(QWasmWindow, platformWindow);
#endif
 
    return nullptr;
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug debug, const QWindow *window)
{
    QDebugStateSaver saver(debug);
    debug.nospace();
    if (window) {
        debug << window->metaObject()->className() << '(' << (const void *)window;
        if (!window->objectName().isEmpty())
            debug << ", name=" << window->objectName();
        if (debug.verbosity() > 2) {
            const QRect geometry = window->geometry();
            if (window->isVisible())
                debug << ", visible";
            if (window->isExposed())
                debug << ", exposed";
            debug << ", state=" << window->windowState()
                << ", type=" << window->type() << ", flags=" << window->flags()
                << ", surface type=" << window->surfaceType();
            if (window->isTopLevel())
                debug << ", toplevel";
            debug << ", " << geometry.width() << 'x' << geometry.height()
                << Qt::forcesign << geometry.x() << geometry.y() << Qt::noforcesign;
            const QMargins margins = window->frameMargins();
            if (!margins.isNull())
                debug << ", margins=" << margins;
            debug << ", devicePixelRatio=" << window->devicePixelRatio();
            if (const QPlatformWindow *platformWindow = window->handle())
                debug << ", winId=0x" << Qt::hex << platformWindow->winId() << Qt::dec;
            if (const QScreen *screen = window->screen())
                debug << ", on " << screen->name();
        }
        debug << ')';
    } else {
        debug << "QWindow(0x0)";
    }
    return debug;
}
#endif // !QT_NO_DEBUG_STREAM
 
#if QT_CONFIG(vulkan) || defined(Q_QDOC)
 
void QWindow::setVulkanInstance(QVulkanInstance *instance)
{
    Q_D(QWindow);
    d->vulkanInstance = instance;
}
 
QVulkanInstance *QWindow::vulkanInstance() const
{
    Q_D(const QWindow);
    return d->vulkanInstance;
}
 
#endif // QT_CONFIG(vulkan)
 
QT_END_NAMESPACE
 
#include "moc_qwindow.cpp"