qwaylandwindow.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
// Qt-Security score:significant reason:default
 
#include "qwaylandsessionmanager_p.h"
#include "qwaylandwindow_p.h"
 
#include "qwaylandbuffer_p.h"
#include "qwaylandcursor_p.h"
#include "qwaylandcutouts_p.h"
#include "qwaylanddisplay_p.h"
#include "qwaylandsurface_p.h"
#include "qwaylandinputdevice_p.h"
#include "qwaylandfractionalscale_p.h"
#include "qwaylandscreen_p.h"
#include "qwaylandshellsurface_p.h"
#include "qwaylandsubsurface_p.h"
#include "qwaylandabstractdecoration_p.h"
#include "qwaylandplatformservices_p.h"
#include "qwaylandnativeinterface_p.h"
#include "qwaylandshmbackingstore_p.h"
#include "qwaylandshellintegration_p.h"
#include "qwaylandviewport_p.h"
#include "qwaylandcolormanagement_p.h"
#include "qwaylanddecorationhandler_p.h"
 
#include <QtCore/QFileInfo>
#include <QtCore/QPointer>
#include <QtCore/QRegularExpression>
#include <QtGui/QWindow>
 
#include <QGuiApplication>
#include <qpa/qwindowsysteminterface.h>
#include <QtGui/private/qguiapplication_p.h>
#include <QtGui/private/qwindow_p.h>
 
#include <QtCore/QDebug>
#include <QtCore/QThread>
 
#include <QtWaylandClient/private/qwayland-fractional-scale-v1.h>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
namespace QtWaylandClient {
 
Q_LOGGING_CATEGORY(lcWaylandBackingstore, "qt.qpa.wayland.backingstore")
 
QWaylandWindow *QWaylandWindow::mMouseGrab = nullptr;
QWaylandWindow *QWaylandWindow::mTopPopup = nullptr;
 
/*!
    \class QtWaylandClient::QWaylandWindow
    \internal
*/
QWaylandWindow::QWaylandWindow(QWindow *window, QWaylandDisplay *display)
    : QPlatformWindow(window)
    , mDisplay(display)
    , mSurfaceLock(QReadWriteLock::Recursive)
    , mShellIntegration(display->shellIntegration())
    , mSurfaceFormat(window->requestedFormat())
{
    {
        bool ok;
        int frameCallbackTimeout = qEnvironmentVariableIntValue("QT_WAYLAND_FRAME_CALLBACK_TIMEOUT", &ok);
        if (ok)
            mFrameCallbackTimeout = frameCallbackTimeout;
    }
    mSurfaceFormat.setColorSpace(QColorSpace{});
    initializeWlSurface();
    mWindowDecorationHandler.reset(new QWaylandDecorationHandler(this));
 
    mFlags = window->flags();
 
    setWindowIcon(window->icon());
 
    connect(this, &QWaylandWindow::wlSurfaceCreated, this,
            &QNativeInterface::Private::QWaylandWindow::surfaceCreated);
    connect(this, &QWaylandWindow::wlSurfaceDestroyed, this,
            &QNativeInterface::Private::QWaylandWindow::surfaceDestroyed);
}
 
QWaylandWindow::~QWaylandWindow()
{
    reset();
 
    const QWindow *parent = window();
    const auto tlw = QGuiApplication::topLevelWindows();
    for (QWindow *w : tlw) {
        if (w->transientParent() == parent)
            QWindowSystemInterface::handleCloseEvent(w);
    }
 
    if (mMouseGrab == this) {
        mMouseGrab = nullptr;
    }
}
 
void QWaylandWindow::ensureSize()
{
    if (mBackingStore) {
        setBackingStore(mBackingStore);
        mBackingStore->recreateBackBufferIfNeeded();
    }
}
 
void QWaylandWindow::initWindow()
{
    resetFrameCallback();
 
    if (shouldCreateSubSurface()) {
        Q_ASSERT(!mSubSurfaceWindow);
 
        auto *parent = static_cast<QWaylandWindow *>(QPlatformWindow::parent());
        if (!parent->mSurface)
            parent->initializeWlSurface();
        if (parent->wlSurface()) {
            if (::wl_subsurface *subsurface = mDisplay->createSubSurface(waylandSurface(), parent->waylandSurface()))
                mSubSurfaceWindow = new QWaylandSubSurface(this, parent, subsurface);
        }
    } else if (shouldCreateShellSurface()) {
        Q_ASSERT(!mShellSurface);
        Q_ASSERT(mShellIntegration);
        mTransientParent = guessTransientParent();
        if (mTransientParent) {
            if (window()->type() == Qt::Popup) {
                if (mTopPopup && mTopPopup != mTransientParent) {
                    qCWarning(lcQpaWayland) << "Creating a popup with a parent," << mTransientParent->window()
                                            << "which does not match the current topmost grabbing popup,"
                                            << mTopPopup->window() << "With some shell surface protocols, this"
                                            << "is not allowed. The wayland QPA plugin is currently handling"
                                            << "it by setting the parent to the topmost grabbing popup."
                                            << "Note, however, that this may cause positioning errors and"
                                            << "popups closing unxpectedly. Please fix the transient parent of the popup.";
                    mTransientParent = mTopPopup;
                }
                mTopPopup = this;
            }
        }
 
        mShellSurface = mShellIntegration->createShellSurface(this);
        if (mShellSurface) {
            if (mTransientParent) {
                if (window()->type() == Qt::ToolTip || window()->type() == Qt::Popup || window()->type() == Qt::Tool)
                    mTransientParent->addChildPopup(this);
            }
 
            // Set initial surface title
            setWindowTitle(window()->title());
            mShellSurface->setIcon(mWindowIcon);
 
            // The appId is the desktop entry identifier that should follow the
            // reverse DNS convention (see
            // http://standards.freedesktop.org/desktop-entry-spec/latest/ar01s02.html). According
            // to xdg-shell the appId is only the name, without the .desktop suffix.
            //
            // If the application specifies the desktop file name use that,
            // otherwise fall back to the executable name and prepend the
            // reversed organization domain when available.
            if (!QGuiApplication::desktopFileName().isEmpty()) {
                mShellSurface->setAppId(QGuiApplication::desktopFileName());
            } else {
                QFileInfo fi = QFileInfo(QCoreApplication::instance()->applicationFilePath());
                QStringList domainName =
                        QCoreApplication::instance()->organizationDomain().split(QLatin1Char('.'),
                                                                                 Qt::SkipEmptyParts);
 
                if (domainName.isEmpty()) {
                    mShellSurface->setAppId(fi.baseName());
                } else {
                    QString appId;
                    for (int i = 0; i < domainName.size(); ++i)
                        appId.prepend(QLatin1Char('.')).prepend(domainName.at(i));
                    appId.append(fi.baseName());
                    mShellSurface->setAppId(appId);
                }
            }
            // the user may have already set some window properties, so make sure to send them out
            for (auto it = m_properties.cbegin(); it != m_properties.cend(); ++it)
                mShellSurface->sendProperty(it.key(), it.value());
 
            emit surfaceRoleCreated();
        } else {
            qWarning("Could not create a shell surface object.");
        }
    }
 
    updateNeedsDecoration();
    updateInputRegion();
 
    // Enable high-dpi rendering. Scale() returns the screen scale factor and will
    // typically be integer 1 (normal-dpi) or 2 (high-dpi). Call set_buffer_scale()
    // to inform the compositor that high-resolution buffers will be provided.
    if (mViewport)
        updateViewport();
    else if (mSurface->version() >= 3)
        mSurface->set_buffer_scale(std::ceil(scale()));
 
    QRect geometry = windowGeometry();
    QRect defaultGeometry = this->defaultGeometry();
    if (geometry.width() <= 0)
        geometry.setWidth(defaultGeometry.width());
    if (geometry.height() <= 0)
        geometry.setHeight(defaultGeometry.height());
 
    setGeometry_helper(geometry);
    setMask(window()->mask());
    if (mShellSurface) {
        mShellSurface->requestWindowStates(window()->windowStates());
        mShellSurface->setWindowFlags(mFlags);
    }
    handleContentOrientationChange(window()->contentOrientation());
 
    if (mShellSurface && mShellSurface->commitSurfaceRole())
        mSurface->commit();
 
    if (!QPlatformWindow::parent() && window()->flags().testFlag(Qt::ExpandedClientAreaHint) && mDisplay->cutoutsManager()) {
        m_cutouts = std::make_unique<QtWaylandClient::Cutouts>(mDisplay->cutoutsManager()->get_cutouts(surface()), this);
    }
}
 
void QWaylandWindow::setPendingImageDescription()
{
    mColorManagementSurface->setImageDescription(mPendingImageDescription.get());
}
 
void QWaylandWindow::initializeWlSurface(bool colorSpace)
{
    Q_ASSERT(!mSurface);
    {
        QWriteLocker lock(&mSurfaceLock);
        mSurface.reset(new QWaylandSurface(mDisplay));
        connect(mSurface.get(), &QWaylandSurface::screensChanged,
                this, &QWaylandWindow::handleScreensChanged);
        connect(mSurface.get(), &QWaylandSurface::preferredBufferScaleChanged,
                this, &QWaylandWindow::updateScale);
        connect(mSurface.get(), &QWaylandSurface::preferredBufferTransformChanged,
                this, &QWaylandWindow::updateBufferTransform);
        mSurface->m_container = this;
    }
    emit wlSurfaceCreated();
 
    if (mDisplay->fractionalScaleManager() && qApp->highDpiScaleFactorRoundingPolicy() == Qt::HighDpiScaleFactorRoundingPolicy::PassThrough) {
        mFractionalScale.reset(new QWaylandFractionalScale(mDisplay->fractionalScaleManager()->get_fractional_scale(mSurface->object())));
 
        connect(mFractionalScale.get(), &QWaylandFractionalScale::preferredScaleChanged,
                this, &QWaylandWindow::updateScale);
    }
    // The fractional scale manager check is needed to work around Gnome < 36 where viewports don't work
    // Right now viewports are only necessary when a fractional scale manager is used
    if (display()->viewporter() && display()->fractionalScaleManager()) {
        mViewport.reset(new QWaylandViewport(display()->createViewport(mSurface.get())));
    }
 
    if (colorSpace) {
        initializeColorSpace();
    }
}
 
void QWaylandWindow::initializeColorSpace()
{
    QColorSpace requestedColorSpace = window()->requestedFormat().colorSpace();
    if (requestedColorSpace != QColorSpace{} && mDisplay->colorManager()) {
        // TODO try a similar (same primaries + supported transfer function) color space if this fails?
        mPendingImageDescription = mDisplay->colorManager()->createImageDescription(requestedColorSpace);
        if (mPendingImageDescription) {
            if (!mColorManagementSurface)
                mColorManagementSurface = std::make_unique<ColorManagementSurface>(mDisplay->colorManager()->get_surface(surface()));
            connect(mPendingImageDescription.get(), &ImageDescription::ready, this, &QWaylandWindow::setPendingImageDescription, Qt::SingleShotConnection);
            mSurfaceFormat.setColorSpace(requestedColorSpace);
        } else {
            qCWarning(lcQpaWayland) << "couldn't create image description for requested color space" << requestedColorSpace;
        }
    }
}
 
void QWaylandWindow::setFormat(const QSurfaceFormat &format)
{
    const auto colorSpace = mSurfaceFormat.colorSpace();
    mSurfaceFormat = format;
    mSurfaceFormat.setColorSpace(colorSpace);
}
 
void QWaylandWindow::setShellIntegration(QWaylandShellIntegration *shellIntegration)
{
    Q_ASSERT(shellIntegration);
    if (mShellSurface) {
        qCWarning(lcQpaWayland) << "Cannot set shell integration while there's already a shell surface created";
        return;
    }
    mShellIntegration = shellIntegration;
}
 
bool QWaylandWindow::shouldCreateShellSurface() const
{
    if (!shellIntegration())
        return false;
 
    if (shouldCreateSubSurface())
        return false;
 
    if (window()->inherits("QShapedPixmapWindow"))
        return false;
 
    if (qEnvironmentVariableIsSet("QT_WAYLAND_USE_BYPASSWINDOWMANAGERHINT"))
        return !(window()->flags() & Qt::BypassWindowManagerHint);
 
    return true;
}
 
bool QWaylandWindow::shouldCreateSubSurface() const
{
    return QPlatformWindow::parent() != nullptr;
}
 
void QWaylandWindow::beginFrame()
{
    mSurfaceLock.lockForRead();
    mInFrameRender = true;
}
 
void QWaylandWindow::endFrame()
{
    mSurfaceLock.unlock();
    mInFrameRender = false;
}
 
void QWaylandWindow::reset()
{
    resetSurfaceRole();
 
    m_cutouts.reset();
    m_safeAreaMargins = {};
 
    if (mSurface) {
        {
            QWriteLocker lock(&mSurfaceLock);
            invalidateSurface();
            mColorManagementSurface.reset();
            mPendingImageDescription.reset();
            mFractionalScale.reset();
            mViewport.reset();
 
            // Destroy surface last.
            // Some compositors (e.g. ChromeOS Sommelier) crash if they receive
            // destroy requests for these objects after the associated surface
            // has already been destroyed.
            mSurface.reset();
        }
        emit wlSurfaceDestroyed();
    }
 
    mScale = std::nullopt;
    mOpaqueArea = QRegion();
    mMask = QRegion();
 
    mInputRegion = QRegion();
    mTransparentInputRegion = false;
    mWindowDecorationHandler->reset();
 
    mDisplay->handleWindowDestroyed(this);
}
 
void QWaylandWindow::resetSurfaceRole()
{
     // Old Reset
    closeChildPopups();
 
    if (mTopPopup == this)
        mTopPopup = mTransientParent && (mTransientParent->window()->type() == Qt::Popup) ? mTransientParent : nullptr;
    if (mTransientParent)
        mTransientParent->removeChildPopup(this);
    mTransientParent = nullptr;
    delete std::exchange(mShellSurface, nullptr);
    delete std::exchange(mSubSurfaceWindow, nullptr);
    emit surfaceRoleDestroyed();
 
    resetFrameCallback();
    mInFrameRender = false;
    mWaitingToApplyConfigure = false;
    mExposed = false;
}
 
void QWaylandWindow::resetFrameCallback()
{
    {
        QMutexLocker lock(&mFrameSyncMutex);
        if (mFrameCallback) {
            wl_callback_destroy(mFrameCallback);
            mFrameCallback = nullptr;
        }
        mFrameCallbackElapsedTimer.invalidate();
        mFrameSyncWait.wakeAll();
    }
    if (mFrameCallbackCheckIntervalTimerId != -1) {
        killTimer(mFrameCallbackCheckIntervalTimerId);
        mFrameCallbackCheckIntervalTimerId = -1;
    }
    mFrameCallbackTimedOut = false;
}
 
QWaylandWindow *QWaylandWindow::fromWlSurface(::wl_surface *surface)
{
    if (auto *s = QWaylandSurface::fromWlSurface(surface))
        return s->waylandWindow();
    return nullptr;
}
WId QWaylandWindow::winId() const
{
    return reinterpret_cast<WId>(wlSurface());
}
 
void QWaylandWindow::setParent(const QPlatformWindow *parent)
{
    if (lastParent == parent)
        return;
 
    if (mSubSurfaceWindow && parent) { // new parent, but we were a subsurface already
        delete mSubSurfaceWindow;
        QWaylandWindow *p = const_cast<QWaylandWindow *>(static_cast<const QWaylandWindow *>(parent));
        mSubSurfaceWindow = new QWaylandSubSurface(this, p, mDisplay->createSubSurface(waylandSurface(), p->waylandSurface()));
    } else if ((!lastParent && parent) || (lastParent && !parent)) {
        // we're changing role, need to make a new wl_surface
        reset();
        initializeWlSurface();
        if (window()->isVisible()) {
            initWindow();
        }
    }
    lastParent = parent;
}
 
QString QWaylandWindow::windowTitle() const
{
    return mWindowTitle;
}
 
void QWaylandWindow::setWindowTitle(const QString &title)
{
    const QString separator = QString::fromUtf8(" \xe2\x80\x94 "); // unicode character U+2014, EM DASH
    const QString formatted = formatWindowTitle(title, separator);
 
    const int libwaylandMaxBufferSize = 4096;
    // Some parts of the buffer is used for metadata, so subtract 100 to be on the safe side.
    // Also, QString is in utf-16, which means that in the worst case each character will be
    // three bytes when converted to utf-8 (which is what libwayland uses), so divide by three.
    const int maxLength = libwaylandMaxBufferSize / 3 - 100;
 
    auto truncated = QStringView{formatted}.left(maxLength);
    if (truncated.size() < formatted.size()) {
        qCWarning(lcQpaWayland) << "Window titles longer than" << maxLength << "characters are not supported."
                                << "Truncating window title (from" << formatted.size() << "chars)";
    }
 
    mWindowTitle = truncated.toString();
 
    if (mShellSurface)
        mShellSurface->setTitle(mWindowTitle);
 
    if (auto *dec = decoration(); dec && window()->isVisible())
        dec->update();
}
 
void QWaylandWindow::setWindowIcon(const QIcon &icon)
{
    mWindowIcon = icon;
 
    if (auto *dec = decoration(); dec && window()->isVisible())
        dec->update();
    if (mShellSurface)
        mShellSurface->setIcon(icon);
}
 
QRect QWaylandWindow::defaultGeometry() const
{
    return QRect(QPoint(), QSize(500,500));
}
 
void QWaylandWindow::setGeometry_helper(const QRect &rect)
{
    QPlatformWindow::setGeometry(rect);
    if (mViewport)
        updateViewport();
 
    if (mSubSurfaceWindow) {
        mSubSurfaceWindow->set_position(rect.x(), rect.y());
 
        QWaylandWindow *parentWindow = mSubSurfaceWindow->parent();
        if (parentWindow)
            parentWindow->requestForcedUpdate();
    }
}
 
void QWaylandWindow::setGeometry(const QRect &r)
{
    auto rect = r;
    if (fixedToplevelPositions && !QPlatformWindow::parent() && window()->type() != Qt::Popup
        && window()->type() != Qt::ToolTip && window()->type() != Qt::Tool) {
        rect.moveTo(screen()->geometry().topLeft());
    }
    setGeometry_helper(rect);
 
    if (mShellSurface && !mInResizeFromApplyConfigure) {
        const QRect frameGeometry = r.marginsRemoved(windowContentMargins());
        if (qt_window_private(window())->positionAutomatic || m_popupInfo.parentControlGeometry.isValid())
            mShellSurface->setWindowSize(frameGeometry.size());
        else
            mShellSurface->setWindowGeometry(frameGeometry);
    }
 
    if (mShellSurface)
        mShellSurface->setContentGeometry(windowContentGeometry());
 
    if (isOpaque() && mMask.isEmpty())
        setOpaqueArea(QRect(QPoint(0, 0), rect.size()));
 
 
    if (window()->isVisible() && rect.isValid()) {
        ensureSize();
        if (auto *dec = decoration())
            dec->update();
 
        QWindowSystemInterface::handleGeometryChange<QWindowSystemInterface::SynchronousDelivery>(window(), geometry());
    }
 
    // Wayland has no concept of areas being exposed or not, only the entire window, when our geometry changes, we need to flag the new area as exposed
    // On other platforms (X11) the expose event would be received deferred from the X server
    // we want our behaviour to match, and only run after control has returned to the event loop
    QMetaObject::invokeMethod(this, &QWaylandWindow::synthesizeExposeOnGeometryChange, Qt::QueuedConnection);
}
 
void QWaylandWindow::synthesizeExposeOnGeometryChange()
{
    if (!isExposed())
        return;
    QRect exposeGeometry(QPoint(), geometry().size());
    if (exposeGeometry == mLastExposeGeometry)
        return;
 
    sendExposeEvent(exposeGeometry);
}
 
void QWaylandWindow::updateInputRegion()
{
    if (!mSurface)
        return;
 
    const bool transparentInputRegion = mFlags.testFlag(Qt::WindowTransparentForInput);
 
    QRegion inputRegion;
    if (!transparentInputRegion)
        inputRegion = mMask;
 
    if (mInputRegion == inputRegion && mTransparentInputRegion == transparentInputRegion)
        return;
 
    mInputRegion = inputRegion;
    mTransparentInputRegion = transparentInputRegion;
 
    if (mInputRegion.isEmpty() && !mTransparentInputRegion) {
        mSurface->set_input_region(nullptr);
    } else {
        struct ::wl_region *region = mDisplay->createRegion(mInputRegion);
        mSurface->set_input_region(region);
        wl_region_destroy(region);
    }
}
 
void QWaylandWindow::updateViewport()
{
    const QSize size = geometry().size();
    if (!size.isEmpty())
        mViewport->setDestination(size);
}
 
void QWaylandWindow::setGeometryFromApplyConfigure(const QPoint &globalPosition, const QSize &sizeWithMargins)
{
    QMargins margins = clientSideMargins();
 
    QPoint positionWithoutMargins = globalPosition + QPoint(margins.left(), margins.top());
    int widthWithoutMargins = qMax(sizeWithMargins.width() - (margins.left() + margins.right()), 1);
    int heightWithoutMargins = qMax(sizeWithMargins.height() - (margins.top() + margins.bottom()), 1);
 
    QRect geometry(positionWithoutMargins, QSize(widthWithoutMargins, heightWithoutMargins));
 
    mInResizeFromApplyConfigure = true;
    setGeometry(geometry);
    mInResizeFromApplyConfigure = false;
}
 
void QWaylandWindow::repositionFromApplyConfigure(const QPoint &globalPosition)
{
    QMargins margins = clientSideMargins();
    QPoint positionWithoutMargins = globalPosition + QPoint(margins.left(), margins.top());
 
    QRect geometry(positionWithoutMargins, windowGeometry().size());
    mInResizeFromApplyConfigure = true;
    setGeometry(geometry);
    mInResizeFromApplyConfigure = false;
}
 
void QWaylandWindow::resizeFromApplyConfigure(const QSize &sizeWithMargins, const QPoint &offset)
{
    QMargins margins = clientSideMargins();
    int widthWithoutMargins = qMax(sizeWithMargins.width() - (margins.left() + margins.right()), 1);
    int heightWithoutMargins = qMax(sizeWithMargins.height() - (margins.top() + margins.bottom()), 1);
    QRect geometry(windowGeometry().topLeft(), QSize(widthWithoutMargins, heightWithoutMargins));
 
    mOffset += offset;
    mInResizeFromApplyConfigure = true;
    setGeometry(geometry);
    mInResizeFromApplyConfigure = false;
}
 
void QWaylandWindow::sendExposeEvent(const QRect &rect)
{
    static bool sQtTestMode = qEnvironmentVariableIsSet("QT_QTESTLIB_RUNNING");
    mLastExposeGeometry = rect;
 
    if (decoration())
        mWindowDecorationHandler->update();
 
    if (sQtTestMode) {
        mExposeEventNeedsAttachedBuffer = true;
    }
    QWindowSystemInterface::handleExposeEvent<QWindowSystemInterface::SynchronousDelivery>(window(), rect);
 
    /**
      *  If an expose is not handled by application code, explicitly attach a buffer
      *  This primarily is a workaround for Qt unit tests using QWindow directly and
      *  wanting focus.
    */
    if (mExposed && mExposeEventNeedsAttachedBuffer && !rect.isNull()) {
        QWaylandShmBuffer buffer(mDisplay, rect.size(), QImage::Format_ARGB32);
        buffer.image()->fill(Qt::transparent);
        commit(&buffer, QRegion());
    }
}
 
QPlatformScreen *QWaylandWindow::calculateScreenFromSurfaceEvents() const
{
    QReadLocker lock(&mSurfaceLock);
    if (mSurface) {
        if (auto *screen = mSurface->oldestEnteredScreen())
            return screen;
    }
    return QPlatformWindow::screen();
}
 
void QWaylandWindow::setVisible(bool visible)
{
    // Workaround for issue where setVisible may be called with the same value twice
    if (lastVisible == visible)
        return;
    lastVisible = visible;
 
    if (visible) {
        setGeometry(windowGeometry());
        initWindow();
        updateExposure();
        if (mShellSurface)
            mShellSurface->requestActivateOnShow();
    } else {
        // make sure isExposed is false during the next event dispatch
        mExposed = false;
        sendExposeEvent(QRect());
        resetSurfaceRole();
        mSurface->attach(nullptr, 0, 0);
        mSurface->commit();
    }
}
 
 
void QWaylandWindow::raise()
{
    if (mShellSurface)
        mShellSurface->raise();
}
 
 
void QWaylandWindow::lower()
{
    if (mShellSurface)
        mShellSurface->lower();
}
 
void QWaylandWindow::setMask(const QRegion &mask)
{
    QReadLocker locker(&mSurfaceLock);
    if (!mSurface)
        return;
 
    if (mMask == mask)
        return;
 
    mMask = mask;
 
    updateInputRegion();
 
    if (isOpaque()) {
        if (mMask.isEmpty())
            setOpaqueArea(QRect(QPoint(0, 0), geometry().size()));
        else
            setOpaqueArea(mMask);
    }
}
 
void QWaylandWindow::setAlertState(bool enabled)
{
    if (mShellSurface)
        mShellSurface->setAlertState(enabled);
}
 
bool QWaylandWindow::isAlertState() const
{
    if (mShellSurface)
        return mShellSurface->isAlertState();
 
    return false;
}
 
void QWaylandWindow::applyConfigureWhenPossible()
{
    if (!mWaitingToApplyConfigure) {
        mWaitingToApplyConfigure = true;
        QMetaObject::invokeMethod(this, &QWaylandWindow::applyConfigure, Qt::QueuedConnection);
    }
}
 
void QWaylandWindow::applyConfigure()
{
    if (!mWaitingToApplyConfigure)
        return;
 
    Q_ASSERT_X(QThread::isMainThread(),
               "QWaylandWindow::applyConfigure", "not called from main thread");
 
    // If we're mid paint, use an exposeEvent to flush the current frame.
    // When this completes we know that no other frames will be rendering.
    // This could be improved in future as we 're blocking for not just the frame to finish but one additional extra frame.
    if (mInFrameRender)
        QWindowSystemInterface::handleExposeEvent<QWindowSystemInterface::SynchronousDelivery>(window(), QRect(QPoint(0, 0), geometry().size()));
    if (mShellSurface)
        mShellSurface->applyConfigure();
 
    mWaitingToApplyConfigure = false;
    if (mExposed)
        sendExposeEvent(QRect(QPoint(), geometry().size()));
    else
        // we still need to commit the configured ack for a hidden surface
        commit();
}
 
void QWaylandWindow::attach(QWaylandBuffer *buffer, int x, int y)
{
    QReadLocker locker(&mSurfaceLock);
    if (mSurface == nullptr)
        return;
 
    if (buffer) {
        Q_ASSERT(!buffer->committed());
        handleUpdate();
        buffer->setBusy(true);
        if (mSurface->version() >= WL_SURFACE_OFFSET_SINCE_VERSION) {
            mSurface->offset(x, y);
            mSurface->attach(buffer->buffer(), 0, 0);
        } else {
            mSurface->attach(buffer->buffer(), x, y);
        }
    } else {
        mSurface->attach(nullptr, 0, 0);
    }
}
 
void QWaylandWindow::attachOffset(QWaylandBuffer *buffer)
{
    attach(buffer, mOffset.x(), mOffset.y());
    mOffset = QPoint();
}
 
void QWaylandWindow::damage(const QRect &rect)
{
    QReadLocker locker(&mSurfaceLock);
    if (mSurface == nullptr)
        return;
 
    const qreal s = scale();
    if (mSurface->version() >= 4) {
        const QRect bufferRect =
                QRectF(s * rect.x(), s * rect.y(), s * rect.width(), s * rect.height())
                        .toAlignedRect();
        mSurface->damage_buffer(bufferRect.x(), bufferRect.y(), bufferRect.width(),
                                bufferRect.height());
    } else {
        mSurface->damage(rect.x(), rect.y(), rect.width(), rect.height());
    }
}
 
void QWaylandWindow::safeCommit(QWaylandBuffer *buffer, const QRegion &damage)
{
    if (isExposed()) {
        commit(buffer, damage);
    } else if (!buffer->committed()) {
        buffer->setBusy(false);
    }
}
 
bool QWaylandWindow::allowsIndependentThreadedRendering() const
{
    return !mWaitingToApplyConfigure;
}
 
void QWaylandWindow::commit(QWaylandBuffer *buffer, const QRegion &damage)
{
    Q_ASSERT(isExposed());
 
    QReadLocker locker(&mSurfaceLock);
    if (buffer->committed()) {
        mSurface->commit();
        qCDebug(lcWaylandBackingstore) << "Buffer already committed, not attaching.";
        return;
    }
 
    if (!mSurface)
        return;
 
    attachOffset(buffer);
    if (mSurface->version() >= 4) {
        const qreal s = scale();
        for (const QRect &rect : damage) {
            const QRect bufferRect =
                    QRectF(s * rect.x(), s * rect.y(), s * rect.width(), s * rect.height())
                            .toAlignedRect();
            mSurface->damage_buffer(bufferRect.x(), bufferRect.y(), bufferRect.width(),
                                    bufferRect.height());
        }
    } else {
        for (const QRect &rect: damage)
            mSurface->damage(rect.x(), rect.y(), rect.width(), rect.height());
    }
    Q_ASSERT(!buffer->committed());
    buffer->setCommitted();
    mSurface->commit();
}
 
void QWaylandWindow::commit()
{
    QReadLocker locker(&mSurfaceLock);
    if (mSurface != nullptr)
        mSurface->commit();
}
 
const wl_callback_listener QWaylandWindow::callbackListener = {
    [](void *data, wl_callback *callback, uint32_t time) {
        Q_UNUSED(time);
        auto *window = static_cast<QWaylandWindow*>(data);
        window->handleFrameCallback(callback);
    }
};
 
void QWaylandWindow::handleFrameCallback(wl_callback* callback)
{
    QMutexLocker locker(&mFrameSyncMutex);
    if (mFrameCallback != callback) {
        // This means the callback is already unset by QWaylandWindow::reset.
        // The wl_callback object will be destroyed there too.
        return;
    }
    wl_callback_destroy(mFrameCallback);
    mFrameCallback = nullptr;
    mFrameCallbackElapsedTimer.invalidate();
 
    // The rest can wait until we can run it on the correct thread
    if (mWaitingForUpdateDelivery.testAndSetAcquire(false, true)) {
        // Queued connection, to make sure we don't call handleUpdate() from inside waitForFrameSync()
        // in the single-threaded case.
        QMetaObject::invokeMethod(this, &QWaylandWindow::doHandleFrameCallback, Qt::QueuedConnection);
    }
    mFrameSyncWait.notify_all();
}
 
void QWaylandWindow::doHandleFrameCallback()
{
    mWaitingForUpdateDelivery.storeRelease(false);
    bool wasExposed = isExposed();
    mFrameCallbackTimedOut = false;
    // Did setting mFrameCallbackTimedOut make the window exposed?
    updateExposure();
    if (wasExposed && hasPendingUpdateRequest())
        deliverUpdateRequest();
 
}
 
bool QWaylandWindow::waitForFrameSync(int timeout)
{
    QMutexLocker locker(&mFrameSyncMutex);
 
    QDeadlineTimer deadline(timeout);
    while (mFrameCallback && mFrameSyncWait.wait(&mFrameSyncMutex, deadline)) { }
 
    if (mFrameCallback) {
        qCDebug(lcWaylandBackingstore) << "Didn't receive frame callback in time, window should now be inexposed";
        mFrameCallbackTimedOut = true;
        QMetaObject::invokeMethod(this, &QWaylandWindow::updateExposure, Qt::QueuedConnection);
    }
 
    return !mFrameCallback;
}
 
QMargins QWaylandWindow::frameMargins() const
{
    if (auto *dec = decoration())
        return dec->margins();
    else if (mShellSurface)
        return mShellSurface->serverSideFrameMargins();
    else
        return QPlatformWindow::frameMargins();
}
 
QMargins QWaylandWindow::clientSideMargins() const
{
    if (auto *dec = decoration())
        return dec->margins();
    return QMargins{};
}
 
void QWaylandWindow::setCustomMargins(const QMargins &margins) {
    const QMargins oldMargins = mCustomMargins;
    mCustomMargins = margins;
    propagateSizeHints();
    setGeometry(geometry().marginsRemoved(oldMargins).marginsAdded(margins));
}
 
QMargins QWaylandWindow::windowContentMargins() const
{
    QMargins shadowMargins;
 
    if (auto *dec = decoration())
        shadowMargins = dec->margins(QWaylandAbstractDecoration::ShadowsOnly);
 
    if (!mCustomMargins.isNull())
        shadowMargins += mCustomMargins;
 
    return shadowMargins;
}
 
/*!
 * Window geometry as defined by the xdg-shell spec (in wl_surface coordinates)
 * topLeft is where the shadow stops and the decorations border start.
 */
QRect QWaylandWindow::windowContentGeometry() const
{
    return QRect(QPoint(), geometry().size())
        .marginsAdded(clientSideMargins())
        .marginsRemoved(windowContentMargins());
}
 
QMargins QWaylandWindow::safeAreaMargins() const
{
    return m_safeAreaMargins;
}
 
void QWaylandWindow::setSafeAreaMargins(const QMargins &margins)
{
    m_safeAreaMargins = margins;
    QWindowSystemInterface::handleSafeAreaMarginsChanged(window());
}
 
wl_surface *QWaylandWindow::wlSurface() const
{
    QReadLocker locker(&mSurfaceLock);
    return mSurface ? mSurface->object() : nullptr;
}
 
QWaylandShellSurface *QWaylandWindow::shellSurface() const
{
    return mShellSurface;
}
 
std::any QWaylandWindow::_surfaceRole() const
{
    if (mSubSurfaceWindow)
        return mSubSurfaceWindow->object();
    if (mShellSurface)
        return mShellSurface->surfaceRole();
    return {};
}
 
QWaylandSubSurface *QWaylandWindow::subSurfaceWindow() const
{
    return mSubSurfaceWindow;
}
 
QWaylandScreen *QWaylandWindow::waylandScreen() const
{
    auto *platformScreen = QPlatformWindow::screen();
    Q_ASSERT(platformScreen);
    if (platformScreen->isPlaceholder())
        return nullptr;
    return static_cast<QWaylandScreen *>(platformScreen);
}
 
void QWaylandWindow::handleContentOrientationChange(Qt::ScreenOrientation orientation)
{
    mLastReportedContentOrientation = orientation;
    updateBufferTransform();
}
 
void QWaylandWindow::updateBufferTransform()
{
    QReadLocker locker(&mSurfaceLock);
    if (mSurface == nullptr || mSurface->version() < 2)
        return;
 
    wl_output_transform transform;
    Qt::ScreenOrientation screenOrientation = Qt::PrimaryOrientation;
 
    if (mSurface->version() >= 6) {
        const auto transform = mSurface->preferredBufferTransform().value_or(WL_OUTPUT_TRANSFORM_NORMAL);
        if (auto screen = waylandScreen())
            screenOrientation = screen->toScreenOrientation(transform, Qt::PrimaryOrientation);
    } else {
        if (auto screen = window()->screen())
            screenOrientation = screen->primaryOrientation();
    }
 
    const bool isPortrait = (screenOrientation == Qt::PortraitOrientation);
 
    switch (mLastReportedContentOrientation) {
    case Qt::PrimaryOrientation:
        transform = WL_OUTPUT_TRANSFORM_NORMAL;
        break;
    case Qt::LandscapeOrientation:
        transform = isPortrait ? WL_OUTPUT_TRANSFORM_270 : WL_OUTPUT_TRANSFORM_NORMAL;
        break;
    case Qt::PortraitOrientation:
        transform = isPortrait ? WL_OUTPUT_TRANSFORM_NORMAL : WL_OUTPUT_TRANSFORM_90;
        break;
    case Qt::InvertedLandscapeOrientation:
        transform = isPortrait ? WL_OUTPUT_TRANSFORM_90 : WL_OUTPUT_TRANSFORM_180;
        break;
    case Qt::InvertedPortraitOrientation:
        transform = isPortrait ? WL_OUTPUT_TRANSFORM_180 : WL_OUTPUT_TRANSFORM_270;
        break;
    default:
        Q_UNREACHABLE();
    }
    mSurface->set_buffer_transform(transform);
}
 
void QWaylandWindow::setOrientationMask(Qt::ScreenOrientations mask)
{
    if (mShellSurface)
        mShellSurface->setContentOrientationMask(mask);
}
 
void QWaylandWindow::setWindowState(Qt::WindowStates states)
{
    if (mShellSurface)
        mShellSurface->requestWindowStates(states);
}
 
void QWaylandWindow::setWindowFlags(Qt::WindowFlags flags)
{
    const bool wasPopup = mFlags.testFlag(Qt::Popup);
    const bool isPopup = flags.testFlag(Qt::Popup);
 
    mFlags = flags;
    // changing role is not allowed on XdgShell on the same wl_surface
    if (wasPopup != isPopup) {
        reset();
        initializeWlSurface();
        if (window()->isVisible()) {
            initWindow();
        }
    } else {
        if (mShellSurface)
            mShellSurface->setWindowFlags(flags);
    }
 
    updateNeedsDecoration();
 
    if (!m_cutouts && !QPlatformWindow::parent() && flags.testFlag(Qt::ExpandedClientAreaHint) && mDisplay->cutoutsManager()) {
        m_cutouts = std::make_unique<QtWaylandClient::Cutouts>(mDisplay->cutoutsManager()->get_cutouts(surface()), this);
    } else if (m_cutouts && !flags.testFlag(Qt::ExpandedClientAreaHint)) {
        m_cutouts.reset();
        setSafeAreaMargins({});
    }
 
    QReadLocker locker(&mSurfaceLock);
    updateInputRegion();
}
 
Qt::WindowFlags QWaylandWindow::windowFlags() const
{
    return mFlags;
}
 
void QWaylandWindow::updateNeedsDecoration()
{
    const bool hadDecoration = mWindowDecorationHandler->decoration() != nullptr;
    mWindowDecorationHandler->updateNeedsDecoration();
    const bool hasDecoration = mWindowDecorationHandler->decoration() != nullptr;
    if (hadDecoration != hasDecoration) {
        requestForcedUpdate();
        propagateSizeHints();
    }
}
 
QWaylandAbstractDecoration *QWaylandWindow::decoration() const
{
    return mWindowDecorationHandler->decoration();
}
 
static QWaylandWindow *closestShellSurfaceWindow(QWindow *window)
{
    while (window) {
        auto w = static_cast<QWaylandWindow *>(window->handle());
        if (w && w->shellSurface())
            return w;
        window = window->transientParent() ? window->transientParent() : window->parent();
    }
    return nullptr;
}
 
QWaylandWindow *QWaylandWindow::transientParent() const
{
    return mTransientParent;
}
 
QWaylandWindow *QWaylandWindow::guessTransientParent() const
{
    // Take the closest window with a shell surface, since the transient parent may be a
    // QWidgetWindow or some other window without a shell surface, which is then not able to
    // get mouse events.
    if (auto transientParent = closestShellSurfaceWindow(window()->transientParent()))
        return transientParent;
 
    if (window()->type() == Qt::Popup) {
        if (mTopPopup)
            return mTopPopup;
    }
 
    if (window()->type() == Qt::ToolTip || window()->type() == Qt::Popup) {
        if (auto lastInputWindow = display()->lastInputWindow())
            return closestShellSurfaceWindow(lastInputWindow->window());
    }
 
    return nullptr;
}
 
void QWaylandWindow::handleMouse(QWaylandInputDevice *inputDevice, const QWaylandPointerEvent &e)
{
    // There's currently no way to get info about the actual hardware device in use.
    // At least we get the correct seat.
    const QPointingDevice *device = QPointingDevice::primaryPointingDevice(inputDevice->seatname());
    if (e.type == QEvent::Leave) {
        QWindowSystemInterface::handleLeaveEvent(window());
#if QT_CONFIG(cursor)
        restoreMouseCursor(inputDevice);
#endif
        return;
    }
 
#if QT_CONFIG(cursor)
    if (e.type == QEvent::Enter) {
        restoreMouseCursor(inputDevice);
    }
#endif
 
    switch (e.type) {
    case QEvent::Enter:
        QWindowSystemInterface::handleEnterEvent(window(), e.local, e.global);
#if QT_CONFIG(cursor)
        mDisplay->waylandCursor()->setPosFromEnterEvent(e.global.toPoint());
#endif
        break;
    case QEvent::MouseButtonPress:
    case QEvent::MouseButtonRelease:
    case QEvent::MouseMove:
        QWindowSystemInterface::handleMouseEvent(window(), e.timestamp, device, e.local, e.global, e.buttons, e.button, e.type, e.modifiers);
        break;
    case QEvent::Wheel:
        QWindowSystemInterface::handleWheelEvent(window(), e.timestamp, device, e.local, e.global,
                                                 e.pixelDelta, e.angleDelta, e.modifiers,
                                                 e.phase, e.source, e.inverted);
        break;
    default:
        Q_UNREACHABLE();
    }
 
}
 
#ifndef QT_NO_GESTURES
void QWaylandWindow::handleSwipeGesture(QWaylandInputDevice *inputDevice,
                                        const QWaylandPointerGestureSwipeEvent &e)
{
    switch (e.state) {
        case Qt::GestureStarted:
            if (mGestureState != GestureNotActive)
                qCWarning(lcQpaWaylandInput) << "Unexpected GestureStarted while already active";
 
 
            mGestureState = GestureActiveInContentArea;
            QWindowSystemInterface::handleGestureEvent(window(), e.timestamp,
                                                       inputDevice->mTouchPadDevice,
                                                       Qt::BeginNativeGesture,
                                                       e.local, e.global, e.fingers);
            break;
        case Qt::GestureUpdated:
            if (mGestureState != GestureActiveInContentArea)
                return;
 
            if (!e.delta.isNull()) {
                QWindowSystemInterface::handleGestureEventWithValueAndDelta(
                            window(), e.timestamp, inputDevice->mTouchPadDevice,
                            Qt::PanNativeGesture,
                            0, e.delta, e.local, e.global, e.fingers);
            }
            break;
        case Qt::GestureFinished:
        case Qt::GestureCanceled:
 
            if (mGestureState != GestureActiveInContentArea)
                qCWarning(lcQpaWaylandInput) << "Unexpected" << (e.state == Qt::GestureFinished ? "GestureFinished" : "GestureCanceled");
 
            mGestureState = GestureNotActive;
 
            // There's currently no way to expose cancelled gestures to the rest of Qt, so
            // this part of information is lost.
            QWindowSystemInterface::handleGestureEvent(window(), e.timestamp,
                                                       inputDevice->mTouchPadDevice,
                                                       Qt::EndNativeGesture,
                                                       e.local, e.global, e.fingers);
            break;
        default:
            break;
    }
}
 
void QWaylandWindow::handlePinchGesture(QWaylandInputDevice *inputDevice,
                                        const QWaylandPointerGesturePinchEvent &e)
{
    switch (e.state) {
        case Qt::GestureStarted:
            if (mGestureState != GestureNotActive)
                qCWarning(lcQpaWaylandInput) << "Unexpected GestureStarted while already active";
 
            mGestureState = GestureActiveInContentArea;
            QWindowSystemInterface::handleGestureEvent(window(), e.timestamp,
                                                       inputDevice->mTouchPadDevice,
                                                       Qt::BeginNativeGesture,
                                                       e.local, e.global, e.fingers);
            break;
        case Qt::GestureUpdated:
            if (mGestureState != GestureActiveInContentArea)
                return;
 
            if (!e.delta.isNull()) {
                QWindowSystemInterface::handleGestureEventWithValueAndDelta(
                            window(), e.timestamp, inputDevice->mTouchPadDevice,
                            Qt::PanNativeGesture,
                            0, e.delta, e.local, e.global, e.fingers);
            }
            if (e.rotation_delta != 0) {
                QWindowSystemInterface::handleGestureEventWithRealValue(window(), e.timestamp,
                                                                        inputDevice->mTouchPadDevice,
                                                                        Qt::RotateNativeGesture,
                                                                        e.rotation_delta,
                                                                        e.local, e.global, e.fingers);
            }
            if (e.scale_delta != 0) {
                QWindowSystemInterface::handleGestureEventWithRealValue(window(), e.timestamp,
                                                                        inputDevice->mTouchPadDevice,
                                                                        Qt::ZoomNativeGesture,
                                                                        e.scale_delta,
                                                                        e.local, e.global, e.fingers);
            }
            break;
        case Qt::GestureFinished:
        case Qt::GestureCanceled:
            if (mGestureState != GestureActiveInContentArea)
                qCWarning(lcQpaWaylandInput) << "Unexpected" << (e.state == Qt::GestureFinished ? "GestureFinished" : "GestureCanceled");
 
            mGestureState = GestureNotActive;
 
            // There's currently no way to expose cancelled gestures to the rest of Qt, so
            // this part of information is lost.
            QWindowSystemInterface::handleGestureEvent(window(), e.timestamp,
                                                       inputDevice->mTouchPadDevice,
                                                       Qt::EndNativeGesture,
                                                       e.local, e.global, e.fingers);
            break;
        default:
            break;
    }
}
 
#endif // #ifndef QT_NO_GESTURES
 
 
QPointF QWaylandWindow::mapInputToGlobal(const QPointF &pointIn)
{
    return mapToGlobalF(pointIn);
}
 
void QWaylandWindow::handleScreensChanged()
{
    QPlatformScreen *newScreen = calculateScreenFromSurfaceEvents();
 
    if (!newScreen || newScreen->screen() == window()->screen())
        return;
 
    QWindowSystemInterface::handleWindowScreenChanged<QWindowSystemInterface::SynchronousDelivery>(window(), newScreen->QPlatformScreen::screen());
 
    if (fixedToplevelPositions && !QPlatformWindow::parent() && window()->type() != Qt::Popup
        && window()->type() != Qt::ToolTip && window()->type() != Qt::Tool
        && geometry().topLeft() != newScreen->geometry().topLeft()) {
        auto geometry = this->geometry();
        geometry.moveTo(newScreen->geometry().topLeft());
        setGeometry(geometry);
    }
 
    updateScale();
    updateBufferTransform();
}
 
void QWaylandWindow::updateScale()
{
    if (mFractionalScale) {
        qreal preferredScale = mFractionalScale->preferredScale().value_or(1.0);
        preferredScale = std::max<qreal>(1.0, preferredScale);
        Q_ASSERT(mViewport);
        setScale(preferredScale);
        return;
    }
 
    if (mSurface && mSurface->version() >= 6) {
        auto preferredScale = mSurface->preferredBufferScale().value_or(1);
        preferredScale = std::max(1, preferredScale);
        setScale(preferredScale);
        return;
    }
 
    int scale = screen()->isPlaceholder() ? 1 : static_cast<QWaylandScreen *>(screen())->scale();
    setScale(scale);
}
 
void QWaylandWindow::setScale(qreal newScale)
{
    if (mScale.has_value() && qFuzzyCompare(mScale.value(), newScale))
        return;
    mScale = newScale;
 
    if (mSurface) {
        if (mViewport)
            updateViewport();
        else if (mSurface->version() >= 3)
            mSurface->set_buffer_scale(std::ceil(newScale));
    }
    ensureSize();
 
    QWindowSystemInterface::handleWindowDevicePixelRatioChanged<QWindowSystemInterface::SynchronousDelivery>(window());
    if (isExposed()) {
        // redraw at the new DPR
        window()->requestUpdate();
        sendExposeEvent(QRect(QPoint(), geometry().size()));
    }
}
 
#if QT_CONFIG(cursor)
void QWaylandWindow::restoreMouseCursor(QWaylandInputDevice *device)
{
    if (const QCursor *overrideCursor = QGuiApplication::overrideCursor()) {
        applyCursor(device, *overrideCursor);
    } else if (mHasStoredCursor) {
        applyCursor(device, mStoredCursor);
    } else {
        applyCursor(device, QCursor(Qt::ArrowCursor));
    }
}
 
void QWaylandWindow::resetStoredCursor()
{
    mHasStoredCursor = false;
}
 
// Keep track of application set cursors on each window
void QWaylandWindow::setStoredCursor(const QCursor &cursor) {
    mStoredCursor = cursor;
    mHasStoredCursor = true;
}
 
void QWaylandWindow::applyCursor(QWaylandInputDevice *device, const QCursor &cursor) {
    if (!device || !device->pointer() || device->pointer()->focusSurface() != waylandSurface())
        return;
 
    int fallbackBufferScale = qCeil(devicePixelRatio());
    device->setCursor(&cursor, {}, fallbackBufferScale);
}
#endif
 
void QWaylandWindow::requestActivateWindow()
{
    QWaylandWindow *toplevel = this;
    while (auto parent = static_cast<QWaylandWindow *>(toplevel->QPlatformWindow::parent()))
        toplevel = parent;
 
    if (toplevel != this) {
        if (window()->isVisible() && mDisplay->isWindowActivated(toplevel))
            mDisplay->setActiveSubSurface(this);
        return;
    }
 
    if (QWaylandWindow *sub = mDisplay->activeSubSurface();
        sub && window()->isAncestorOf(sub->window(), QWindow::ExcludeTransients)) {
        mDisplay->setActiveSubSurface(nullptr);
        return;
    }
 
    if (mShellSurface)
        mShellSurface->requestActivate();
}
 
bool QWaylandWindow::calculateExposure() const
{
    if (!window()->isVisible())
        return false;
 
    if (mFrameCallbackTimedOut)
        return false;
 
    if (mShellSurface)
        return mShellSurface->isExposed();
 
    if (mSubSurfaceWindow)
        return mSubSurfaceWindow->parent()->isExposed();
 
    return !(shouldCreateShellSurface() || shouldCreateSubSurface());
}
 
void QWaylandWindow::updateExposure()
{
    bool exposed = calculateExposure();
    if (exposed == mExposed)
        return;
 
    mExposed = exposed;
 
    if (!exposed)
        sendExposeEvent(QRect());
    else
        sendExposeEvent(QRect(QPoint(), geometry().size()));
 
    for (QWaylandSubSurface *subSurface : std::as_const(mChildren)) {
        auto subWindow = subSurface->window();
        subWindow->updateExposure();
    }
}
 
bool QWaylandWindow::isExposed() const
{
    return mExposed;
}
 
bool QWaylandWindow::isActive() const
{
    return mDisplay->isWindowActivated(this);
}
 
qreal QWaylandWindow::scale() const
{
    return devicePixelRatio();
}
 
qreal QWaylandWindow::devicePixelRatio() const
{
    return mScale.value_or(waylandScreen() ? waylandScreen()->scale() : 1);
}
 
bool QWaylandWindow::setMouseGrabEnabled(bool grab)
{
    if (window()->type() != Qt::Popup) {
        qWarning("This plugin supports grabbing the mouse only for popup windows");
        return false;
    }
 
    mMouseGrab = grab ? this : nullptr;
    return true;
}
 
QWaylandWindow::ToplevelWindowTilingStates QWaylandWindow::toplevelWindowTilingStates() const
{
    return mLastReportedToplevelWindowTilingStates;
}
 
void QWaylandWindow::handleToplevelWindowTilingStatesChanged(ToplevelWindowTilingStates states)
{
    mLastReportedToplevelWindowTilingStates = states;
}
 
Qt::WindowStates QWaylandWindow::windowStates() const
{
    return mLastReportedWindowStates;
}
 
void QWaylandWindow::handleWindowStatesChanged(Qt::WindowStates states)
{
    updateNeedsDecoration();
    Qt::WindowStates statesWithoutActive = states & ~Qt::WindowActive;
    Qt::WindowStates lastStatesWithoutActive = mLastReportedWindowStates & ~Qt::WindowActive;
    QWindowSystemInterface::handleWindowStateChanged(window(), statesWithoutActive,
                                                     lastStatesWithoutActive);
    mLastReportedWindowStates = states;
}
 
void QWaylandWindow::sendProperty(const QString &name, const QVariant &value)
{
    m_properties.insert(name, value);
    QWaylandNativeInterface *nativeInterface = static_cast<QWaylandNativeInterface *>(
                QGuiApplication::platformNativeInterface());
    nativeInterface->emitWindowPropertyChanged(this, name);
    if (mShellSurface)
        mShellSurface->sendProperty(name, value);
}
 
void QWaylandWindow::setProperty(const QString &name, const QVariant &value)
{
    m_properties.insert(name, value);
    QWaylandNativeInterface *nativeInterface = static_cast<QWaylandNativeInterface *>(
                QGuiApplication::platformNativeInterface());
    nativeInterface->emitWindowPropertyChanged(this, name);
}
 
QVariantMap QWaylandWindow::properties() const
{
    return m_properties;
}
 
QVariant QWaylandWindow::property(const QString &name)
{
    return m_properties.value(name);
}
 
QVariant QWaylandWindow::property(const QString &name, const QVariant &defaultValue)
{
    return m_properties.value(name, defaultValue);
}
 
#ifdef QT_PLATFORM_WINDOW_HAS_VIRTUAL_SET_BACKING_STORE
void QWaylandWindow::setBackingStore(QPlatformBackingStore *store)
{
    mBackingStore = dynamic_cast<QWaylandShmBackingStore *>(store);
}
#endif
 
void QWaylandWindow::timerEvent(QTimerEvent *event)
{
    if (event->timerId() != mFrameCallbackCheckIntervalTimerId)
        return;
 
    {
        QMutexLocker lock(&mFrameSyncMutex);
 
        const bool callbackTimerValid = mFrameCallbackElapsedTimer.isValid();
        const bool callbackTimerExpired = callbackTimerValid && mFrameCallbackElapsedTimer.hasExpired(mFrameCallbackTimeout);
        if (!callbackTimerValid || callbackTimerExpired) {
            killTimer(mFrameCallbackCheckIntervalTimerId);
            mFrameCallbackCheckIntervalTimerId = -1;
        }
        if (!callbackTimerValid || !callbackTimerExpired) {
            return;
        }
        mFrameCallbackElapsedTimer.invalidate();
    }
 
    qCDebug(lcWaylandBackingstore) << "Didn't receive frame callback in time, window should now be inexposed";
    mFrameCallbackTimedOut = true;
    updateExposure();
}
 
void QWaylandWindow::requestUpdate()
{
    qCDebug(lcWaylandBackingstore) << "requestUpdate";
    Q_ASSERT(hasPendingUpdateRequest()); // should be set by QPA
 
    // If we have a frame callback all is good and will be taken care of there
    {
        QMutexLocker locker(&mFrameSyncMutex);
        if (mFrameCallback)
            return;
    }
 
    // Some applications (such as Qt Quick) depend on updates being delivered asynchronously,
    // so use invokeMethod to delay the delivery a bit.
    QMetaObject::invokeMethod(this, [this] {
        // Things might have changed in the meantime
        {
            QMutexLocker locker(&mFrameSyncMutex);
            if (mFrameCallback)
                return;
        }
        if (hasPendingUpdateRequest())
            deliverUpdateRequest();
    }, Qt::QueuedConnection);
}
 
// Should be called whenever we commit a buffer (directly through wl_surface.commit or indirectly
// with eglSwapBuffers) to know when it's time to commit the next one.
// Can be called from the render thread (without locking anything) so make sure to not make races in this method.
void QWaylandWindow::handleUpdate()
{
    mExposeEventNeedsAttachedBuffer = false;
    qCDebug(lcWaylandBackingstore) << "handleUpdate" << QThread::currentThread();
 
    // TODO: Should sync subsurfaces avoid requesting frame callbacks?
    QReadLocker lock(&mSurfaceLock);
    if (!mSurface)
        return;
 
    QMutexLocker locker(&mFrameSyncMutex);
    if (mFrameCallback)
        return;
 
    struct ::wl_surface *wrappedSurface = reinterpret_cast<struct ::wl_surface *>(wl_proxy_create_wrapper(mSurface->object()));
    wl_proxy_set_queue(reinterpret_cast<wl_proxy *>(wrappedSurface), mDisplay->frameEventQueue());
    mFrameCallback = wl_surface_frame(wrappedSurface);
    wl_proxy_wrapper_destroy(wrappedSurface);
    wl_callback_add_listener(mFrameCallback, &QWaylandWindow::callbackListener, this);
 
    // Start a timer for handling the case when the compositor stops sending frame callbacks.
    if (mFrameCallbackTimeout > 0) {
        QMetaObject::invokeMethod(this, [this] {
            QMutexLocker locker(&mFrameSyncMutex);
 
            if (mFrameCallback) {
                if (mFrameCallbackCheckIntervalTimerId < 0)
                    mFrameCallbackCheckIntervalTimerId = startTimer(mFrameCallbackTimeout);
                mFrameCallbackElapsedTimer.start();
            }
        }, Qt::QueuedConnection);
    }
}
 
void QWaylandWindow::requestForcedUpdate()
{
    mPendingForcedUpdate = true;
    window()->requestUpdate();
}
 
void QWaylandWindow::deliverUpdateRequest()
{
    qCDebug(lcWaylandBackingstore) << "deliverUpdateRequest";
    if (decoration())
        mWindowDecorationHandler->update();
    QPlatformWindow::deliverUpdateRequest();
 
    // an update request doesn't always force a commit if the window isn't damaged, so also force it
    if (mPendingForcedUpdate) {
        mPendingForcedUpdate = false;
        QRect exposeGeometry(QPoint(), geometry().size());
        QWindowSystemInterface::handleExposeEvent<QWindowSystemInterface::SynchronousDelivery>(window(), exposeGeometry);
    }
}
 
void QWaylandWindow::addAttachOffset(const QPoint point)
{
    mOffset += point;
}
 
void QWaylandWindow::propagateSizeHints()
{
    if (mShellSurface)
        mShellSurface->propagateSizeHints();
}
 
bool QWaylandWindow::startSystemResize(Qt::Edges edges)
{
    if (auto *seat = display()->lastInputDevice()) {
        bool rc = mShellSurface && mShellSurface->resize(seat, edges);
        seat->handleEndDrag();
        return rc;
    }
    return false;
}
 
bool QtWaylandClient::QWaylandWindow::startSystemMove()
{
    if (auto seat = display()->lastInputDevice()) {
        bool rc = mShellSurface && mShellSurface->move(seat);
        seat->handleEndDrag();
        return rc;
    }
    return false;
}
 
bool QWaylandWindow::isOpaque() const
{
    return window()->requestedFormat().alphaBufferSize() <= 0;
}
 
void QWaylandWindow::setOpaqueArea(const QRegion &opaqueArea)
{
    if (opaqueArea == mOpaqueArea || !mSurface)
        return;
 
    mOpaqueArea = opaqueArea;
 
    struct ::wl_region *region = mDisplay->createRegion(opaqueArea);
    mSurface->set_opaque_region(region);
    wl_region_destroy(region);
}
 
void QWaylandWindow::requestXdgActivationToken(uint serial)
{
    if (!mShellSurface) {
        qCWarning(lcQpaWayland) << "requestXdgActivationToken is called with no surface role created, emitting synthetic signal";
        Q_EMIT xdgActivationTokenCreated({});
        return;
    }
    mShellSurface->requestXdgActivationToken(serial);
}
 
void QWaylandWindow::setXdgActivationToken(const QString &token)
{
    if (mShellSurface)
        mShellSurface->setXdgActivationToken(token);
    else
        qCWarning(lcQpaWayland) << "setXdgActivationToken is called with no surface role created, token" << token << "discarded";
}
 
void QWaylandWindow::addChildPopup(QWaylandWindow *child)
{
    if (mShellSurface)
        mShellSurface->attachPopup(child->shellSurface());
    mChildPopups.append(child);
}
 
void QWaylandWindow::removeChildPopup(QWaylandWindow *child)
{
    if (mShellSurface)
        mShellSurface->detachPopup(child->shellSurface());
    mChildPopups.removeAll(child);
}
 
void QWaylandWindow::closeChildPopups() {
    while (!mChildPopups.isEmpty()) {
        auto popup = mChildPopups.takeLast();
        popup->resetSurfaceRole();
    }
}
 
void QWaylandWindow::reinit()
{
    if (window()->isVisible()) {
        initWindow();
        if (hasPendingUpdateRequest())
            deliverUpdateRequest();
    }
}
 
bool QWaylandWindow::windowEvent(QEvent *event)
{
    if (event->type() == QEvent::ApplicationPaletteChange
        || event->type() == QEvent::ApplicationFontChange) {
        if (auto *dec = decoration(); dec && window()->isVisible())
            dec->update();
    } else if (event->type() == QEvent::WindowUnblocked) {
        // QtGui sends leave event to window under cursor when modal window opens, so we have
        // to send enter event when modal closes and window has cursor and gets unblocked.
        if (auto *inputDevice = mDisplay->lastInputDevice(); inputDevice && inputDevice->pointerFocus() == this) {
            const auto pos = mDisplay->waylandCursor()->pos();
            QWindowSystemInterface::handleEnterEvent(window(), mapFromGlobalF(pos), pos);
        }
    }
 
    return QPlatformWindow::windowEvent(event);
}
 
QSurfaceFormat QWaylandWindow::format() const
{
    return mSurfaceFormat;
}
 
void QWaylandWindow::setSessionRestoreId(const QString &role)
{
    mSessionRestoreId = role;
}
 
QString QWaylandWindow::sessionRestoreId() const
{
    return mSessionRestoreId;
}
 
void QWaylandWindow::setExtendedWindowType(QNativeInterface::Private::QWaylandWindow::WindowType windowType) {
    m_popupInfo.extendedWindowType = windowType;
}
 
QNativeInterface::Private::QWaylandWindow::WindowType QWaylandWindow::extendedWindowType() const
{
    return m_popupInfo.extendedWindowType;
}
 
void QWaylandWindow::setParentControlGeometry(const QRect &parentControlGeometry) {
    m_popupInfo.parentControlGeometry = parentControlGeometry;
    if (mExposed) {
        mShellSurface->setWindowPosition(window()->position());
    }
}
 
QRect QWaylandWindow::parentControlGeometry() const
{
    return m_popupInfo.parentControlGeometry;
}
 
void QWaylandWindow::handleMousePressActivation()
{
    if (!window() || window()->flags() & Qt::WindowDoesNotAcceptFocus)
        return;
 
    const QWaylandWindow *currentActiveSubSurface = mDisplay->activeSubSurface();
    const bool isSubsurface = !!subSurfaceWindow();
 
    auto toplevelIsActive = [&](QWaylandWindow *w) -> bool {
        while (w && w->subSurfaceWindow())
            w = static_cast<QWaylandWindow *>(w->QPlatformWindow::parent());
        return mDisplay->isWindowActivated(w);
    };
 
    if (isSubsurface && currentActiveSubSurface != this && toplevelIsActive(this))
        mDisplay->setActiveSubSurface(this);
    else if (!isSubsurface && currentActiveSubSurface)
        mDisplay->setActiveSubSurface(nullptr);
}
 
}
 
QT_END_NAMESPACE
 
#include "moc_qwaylandwindow_p.cpp"