Revision control
++ // Copyright (C) 2017 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #include "qwaylandquickshellsurfaceitem.h"
++ #include "qwaylandquickshellsurfaceitem_p.h"
++
++ #include <QtWaylandCompositor/QWaylandShellSurface>
++ #include <QGuiApplication>
++
++ QT_BEGIN_NAMESPACE
++
++ void QWaylandQuickShellSurfaceItemPrivate::setShellSurface(QWaylandShellSurface *shellSurface)
++ {
++ Q_Q(QWaylandQuickShellSurfaceItem);
++
++ if (m_shellSurface) {
++ QObject::disconnect(m_shellSurface, &QObject::destroyed, q, nullptr);
++ QObject::disconnect(m_shellSurface, &QWaylandShellSurface::modalChanged, q, nullptr);
++ }
++
++ m_shellSurface = shellSurface;
++
++ if (m_shellIntegration) {
++ q->removeEventFilter(m_shellIntegration);
++ delete m_shellIntegration;
++ m_shellIntegration = nullptr;
++ }
++
++ if (m_shellSurface) {
++ m_shellIntegration = m_shellSurface->createIntegration(q);
++ q->installEventFilter(m_shellIntegration);
++
++ QObject::connect(m_shellSurface, &QObject::destroyed,
++ q, [this]() {
++ setShellSurface(nullptr);
++ emit q_func()->shellSurfaceChanged();
++ });
++ QObject::connect(m_shellSurface, &QWaylandShellSurface::modalChanged,
++ q, [this]() {
++ if (m_shellSurface && m_shellSurface->isModal())
++ raise();
++ });
++ }
++ }
++
++ QWaylandQuickShellSurfaceItem *QWaylandQuickShellSurfaceItemPrivate::maybeCreateAutoPopup(QWaylandShellSurface* shellSurface)
++ {
++ if (!m_autoCreatePopupItems)
++ return nullptr;
++
++ Q_Q(QWaylandQuickShellSurfaceItem);
++ auto *popupItem = new QWaylandQuickShellSurfaceItem(q);
++ popupItem->setShellSurface(shellSurface);
++ popupItem->setAutoCreatePopupItems(true);
++ QObject::connect(popupItem, &QWaylandQuickShellSurfaceItem::surfaceDestroyed,
++ popupItem, &QObject::deleteLater);
++ return popupItem;
++ }
++
++ /*!
++ * \qmltype ShellSurfaceItem
++ * \nativetype QWaylandQuickShellSurfaceItem
++ * \inherits WaylandQuickItem
++ * \inqmlmodule QtWayland.Compositor
++ * \since 5.8
++ * \brief A Qt Quick item type for displaying and interacting with a ShellSurface.
++ *
++ * This type is used to render \c xdg_shell, \c ivi_application, \c wl_shell or \c qt_shell
++ * surfaces as part of a Qt Quick scene.
++ *
++ * \sa WaylandQuickItem, XdgSurface, IviSurface, QtShellSurface, WlShellSurface
++ */
++
++ /*!
++ * \class QWaylandQuickShellSurfaceItem
++ * \inmodule QtWaylandCompositor
++ * \since 5.8
++ * \brief The QWaylandQuickShellSurfaceItem class provides a Qt Quick item that represents a QWaylandShellSurface.
++ *
++ * This type is used to render \c xdg_shell, \c ivi_application, \c wl_shell or \c qt_shell
++ * surfaces as part of a Qt Quick scene.
++ *
++ * \sa QWaylandQuickItem, QWaylandXdgSurface, QWaylandIviSurface, QWaylandWlShellSurface
++ */
++
++ /*!
++ * Constructs a QWaylandQuickWlShellSurfaceItem with the given \a parent.
++ */
++ QWaylandQuickShellSurfaceItem::QWaylandQuickShellSurfaceItem(QQuickItem *parent)
++ : QWaylandQuickItem(*new QWaylandQuickShellSurfaceItemPrivate(), parent)
++ {
++ }
++
++ QWaylandQuickShellSurfaceItem::~QWaylandQuickShellSurfaceItem()
++ {
++ Q_D(QWaylandQuickShellSurfaceItem);
++
++ d->setShellSurface(nullptr);
++ }
++
++ /*!
++ * \internal
++ */
++ QWaylandQuickShellSurfaceItem::QWaylandQuickShellSurfaceItem(QWaylandQuickShellSurfaceItemPrivate &dd, QQuickItem *parent)
++ : QWaylandQuickItem(dd, parent)
++ {
++ }
++
++ /*!
++ * \qmlproperty ShellSurface QtWayland.Compositor::ShellSurfaceItem::shellSurface
++ *
++ * This property holds the ShellSurface rendered by this ShellSurfaceItem.
++ * It may either be an XdgSurfaceV5, WlShellSurface or IviSurface depending on which shell protocol
++ * is in use.
++ */
++
++ /*!
++ * \property QWaylandQuickShellSurfaceItem::shellSurface
++ *
++ * This property holds the QWaylandShellSurface rendered by this QWaylandQuickShellSurfaceItem.
++ * It may either be a QWaylandXdgSurfaceV5, QWaylandWlShellSurface or QWaylandIviSurface depending
++ * on which shell protocol is in use.
++ */
++ QWaylandShellSurface *QWaylandQuickShellSurfaceItem::shellSurface() const
++ {
++ Q_D(const QWaylandQuickShellSurfaceItem);
++ return d->m_shellSurface;
++ }
++
++ void QWaylandQuickShellSurfaceItem::setShellSurface(QWaylandShellSurface *shellSurface)
++ {
++ Q_D(QWaylandQuickShellSurfaceItem);
++ if (d->m_shellSurface == shellSurface)
++ return;
++
++ d->setShellSurface(shellSurface);
++
++ emit shellSurfaceChanged();
++ }
++
++ /*!
++ * \qmlproperty Item QtWayland.Compositor::ShellSurfaceItem::moveItem
++ *
++ * This property holds the move item for this ShellSurfaceItem. This is the item that will be moved
++ * when the clients request the ShellSurface to be moved, maximized, resized etc. This property is
++ * useful when implementing server-side decorations.
++ */
++
++ /*!
++ * \property QWaylandQuickShellSurfaceItem::moveItem
++ *
++ * This property holds the move item for this QWaylandQuickShellSurfaceItem. This is the item that
++ * will be moved when the clients request the QWaylandShellSurface to be moved, maximized, resized
++ * etc. This property is useful when implementing server-side decorations.
++ */
++ QQuickItem *QWaylandQuickShellSurfaceItem::moveItem() const
++ {
++ Q_D(const QWaylandQuickShellSurfaceItem);
++ return d->m_moveItem ? d->m_moveItem : const_cast<QWaylandQuickShellSurfaceItem *>(this);
++ }
++
++ void QWaylandQuickShellSurfaceItem::setMoveItem(QQuickItem *moveItem)
++ {
++ Q_D(QWaylandQuickShellSurfaceItem);
++ moveItem = moveItem ? moveItem : this;
++ if (this->moveItem() == moveItem)
++ return;
++ d->m_moveItem = moveItem;
++ moveItemChanged();
++ }
++
++ /*!
++ * \qmlproperty bool QtWayland.Compositor::ShellSurfaceItem::autoCreatePopupItems
++ * \default true
++ *
++ * This property holds whether ShellSurfaceItems for popups parented to the shell
++ * surface managed by this item should automatically be created.
++ */
++
++ /*!
++ * \property QWaylandQuickShellSurfaceItem::autoCreatePopupItems
++ *
++ * This property holds whether QWaylandQuickShellSurfaceItems for popups
++ * parented to the shell surface managed by this item should automatically be created.
++ */
++ bool QWaylandQuickShellSurfaceItem::autoCreatePopupItems()
++ {
++ Q_D(const QWaylandQuickShellSurfaceItem);
++ return d->m_autoCreatePopupItems;
++ }
++
++ void QWaylandQuickShellSurfaceItem::setAutoCreatePopupItems(bool enabled)
++ {
++ Q_D(QWaylandQuickShellSurfaceItem);
++
++ if (enabled == d->m_autoCreatePopupItems)
++ return;
++
++ d->m_autoCreatePopupItems = enabled;
++ emit autoCreatePopupItemsChanged();
++ }
++
++ /*!
++ \class QWaylandQuickShellEventFilter
++ \brief QWaylandQuickShellEventFilter implements a Wayland popup grab
++ \internal
++ */
++
++ void QWaylandQuickShellEventFilter::startFilter(QWaylandClient *client, CallbackFunction closePopups)
++ {
++ if (!self)
++ self = new QWaylandQuickShellEventFilter(qGuiApp);
++ if (!self->eventFilterInstalled) {
++ qGuiApp->installEventFilter(self);
++ self->eventFilterInstalled = true;
++ self->client = client;
++ self->closePopups = closePopups;
++ }
++ }
++
++ void QWaylandQuickShellEventFilter::cancelFilter()
++ {
++ if (!self)
++ return;
++ if (self->eventFilterInstalled && !self->waitForRelease)
++ self->stopFilter();
++ }
++
++ void QWaylandQuickShellEventFilter::stopFilter()
++ {
++ if (eventFilterInstalled) {
++ qGuiApp->removeEventFilter(this);
++ eventFilterInstalled = false;
++ }
++ }
++ QWaylandQuickShellEventFilter *QWaylandQuickShellEventFilter::self = nullptr;
++
++ QWaylandQuickShellEventFilter::QWaylandQuickShellEventFilter(QObject *parent)
++ : QObject(parent)
++ {
++ }
++
++ bool QWaylandQuickShellEventFilter::eventFilter(QObject *receiver, QEvent *e)
++ {
++ if (e->type() == QEvent::MouseButtonPress || e->type() == QEvent::MouseButtonRelease) {
++ bool press = e->type() == QEvent::MouseButtonPress;
++ if (press && !waitForRelease) {
++ // The user clicked something: we need to close popups unless this press is caught later
++ if (!mousePressTimeout.isActive())
++ mousePressTimeout.start(0, this);
++ }
++
++ QQuickItem *item = qobject_cast<QQuickItem*>(receiver);
++ if (!item)
++ return false;
++
++ QMouseEvent *event = static_cast<QMouseEvent*>(e);
++ QWaylandQuickShellSurfaceItem *shellSurfaceItem = qobject_cast<QWaylandQuickShellSurfaceItem*>(item);
++ bool finalRelease = (event->type() == QEvent::MouseButtonRelease) && (event->buttons() == Qt::NoButton);
++ bool popupClient = shellSurfaceItem && shellSurfaceItem->surface() && shellSurfaceItem->surface()->client() == client;
++
++ if (waitForRelease) {
++ // We are eating events until all mouse buttons are released
++ if (finalRelease) {
++ waitForRelease = false;
++ stopFilter();
++ }
++ return true;
++ }
++
++ if (finalRelease && mousePressTimeout.isActive()) {
++ // the user somehow managed to press and release the mouse button in 0 milliseconds
++ qWarning("Badly written autotest detected");
++ mousePressTimeout.stop();
++ stopFilter();
++ }
++
++ if (press && !shellSurfaceItem && !QQmlProperty(item, QStringLiteral("qtwayland_blocking_overlay")).isValid()) {
++ // the user clicked on something that's not blocking mouse events
++ e->ignore(); //propagate the event to items below
++ return true; // don't give the event to the item
++ }
++
++ mousePressTimeout.stop(); // we've got this
++
++ if (press && !popupClient) {
++ // The user clicked outside the active popup's client. The popups should
++ // be closed, but the event filter will stay to catch the release-
++ // event before removing itself.
++ waitForRelease = true;
++ closePopups();
++ return true;
++ }
++ }
++
++ return false;
++ }
++
++ void QWaylandQuickShellEventFilter::timerEvent(QTimerEvent *event)
++ {
++ if (event->timerId() == mousePressTimeout.timerId()) {
++ mousePressTimeout.stop();
++ closePopups();
++ stopFilter();
++ // Don't wait for release: Since the press wasn't accepted,
++ // the release won't be delivered.
++ }
++ }
++
++ static QWaylandQuickShellSurfaceItem *findSurfaceItemFromMoveItem(QQuickItem *moveItem)
++ {
++ if (Q_UNLIKELY(!moveItem))
++ return nullptr;
++ if (auto *surf = qobject_cast<QWaylandQuickShellSurfaceItem *>(moveItem))
++ return surf;
++
++ const auto childItems = moveItem->childItems();
++ for (auto *item : childItems) {
++ if (auto *surf = findSurfaceItemFromMoveItem(item))
++ return surf;
++ }
++ return nullptr;
++ }
++
++ static inline bool onTop(QWaylandQuickShellSurfaceItem *surf)
++ {
++ return surf->staysOnTop() || (surf->shellSurface() && surf->shellSurface()->isModal());
++ }
++
++ static inline bool onBottom(QWaylandQuickShellSurfaceItem *surf)
++ {
++ return surf->staysOnBottom() && !(surf->shellSurface() && surf->shellSurface()->isModal());
++ }
++
++ /*
++ To raise a surface, find the topmost suitable surface and place above that.
++ We start from the top and:
++ If we don't have staysOnTop, skip all surfaces with staysOnTop
++ If we have staysOnBottom, skip all surfaces that don't have staysOnBottom
++ A modal dialog is handled as if it had staysOnTop
++ */
++ void QWaylandQuickShellSurfaceItemPrivate::raise()
++ {
++ Q_Q(QWaylandQuickShellSurfaceItem);
++ auto *moveItem = q->moveItem();
++ QQuickItem *parent = moveItem->parentItem();
++ if (!parent || !m_shellSurface)
++ return;
++ const bool putOnTop = staysOnTop || m_shellSurface->isModal();
++ const bool putOnBottom = staysOnBottom && !m_shellSurface->isModal();
++
++ const QList<QQuickItem *> childItems = parent->childItems();
++ auto it = childItems.crbegin();
++ const auto end = childItems.crend();
++ auto skip = [putOnTop, putOnBottom](QQuickItem *item) {
++ if (auto *surf = findSurfaceItemFromMoveItem(item))
++ return (!putOnTop && onTop(surf)) || (putOnBottom && !onBottom(surf));
++ return true; // ignore any other Quick items that may be there
++ };
++ while (it != end && skip(*it))
++ ++it;
++ if (it != end) {
++ QQuickItem *top = *it;
++ if (moveItem != top)
++ moveItem->stackAfter(top);
++ }
++ }
++
++ /*
++ To lower a surface, find the lowest suitable surface and place below that.
++ We start from the bottom and:
++ If we don't have staysOnBottom, skip all surfaces with staysOnBottom
++ If we have staysOnTop, skip all surfaces that don't have staysOnTop
++ A modal dialog is handled as if it had staysOnTop
++ */
++ void QWaylandQuickShellSurfaceItemPrivate::lower()
++ {
++ Q_Q(QWaylandQuickShellSurfaceItem);
++ auto *moveItem = q->moveItem();
++ QQuickItem *parent = moveItem->parentItem();
++ if (!parent || !m_shellSurface)
++ return;
++ const bool putOnTop = staysOnTop || m_shellSurface->isModal();
++ const bool putOnBottom = staysOnBottom && !m_shellSurface->isModal();
++
++ const QList<QQuickItem *> childItems = parent->childItems();
++ auto it = childItems.cbegin();
++ auto skip = [putOnTop, putOnBottom](QQuickItem *item) {
++ if (auto *surf = findSurfaceItemFromMoveItem(item))
++ return (!putOnBottom && onBottom(surf)) || (putOnTop && !onTop(surf));
++ return true; // ignore any other Quick items that may be there
++ };
++ while (skip(*it))
++ ++it;
++
++ QQuickItem *bottom = *it;
++ if (moveItem != bottom)
++ moveItem->stackBefore(bottom);
++ }
++
++ /*!
++ * \property QWaylandQuickShellSurfaceItem::staysOnTop
++ *
++ * Keep this item above other Wayland surfaces
++ */
++ bool QWaylandQuickShellSurfaceItem::staysOnTop() const
++ {
++ Q_D(const QWaylandQuickShellSurfaceItem);
++ return d->staysOnTop;
++ }
++
++ void QWaylandQuickShellSurfaceItem::setStaysOnTop(bool onTop)
++ {
++ Q_D(QWaylandQuickShellSurfaceItem);
++ if (d->staysOnTop == onTop)
++ return;
++ d->staysOnTop = onTop;
++ if (d->staysOnBottom) {
++ d->staysOnBottom = false;
++ emit staysOnBottomChanged();
++ }
++ // We need to call raise() even if onTop is false, since we need to stack under any other
++ // staysOnTop surfaces in that case
++ raise();
++ emit staysOnTopChanged();
++ Q_ASSERT(!(d->staysOnTop && d->staysOnBottom));
++ }
++
++ /*!
++ * \property QWaylandQuickShellSurfaceItem::staysOnBottom
++ *
++ * Keep this item above other Wayland surfaces
++ */
++ bool QWaylandQuickShellSurfaceItem::staysOnBottom() const
++ {
++ Q_D(const QWaylandQuickShellSurfaceItem);
++ return d->staysOnBottom;
++ }
++
++ void QWaylandQuickShellSurfaceItem::setStaysOnBottom(bool onBottom)
++ {
++ Q_D(QWaylandQuickShellSurfaceItem);
++ if (d->staysOnBottom == onBottom)
++ return;
++ d->staysOnBottom = onBottom;
++ if (d->staysOnTop) {
++ d->staysOnTop = false;
++ emit staysOnTopChanged();
++ }
++ // We need to call lower() even if onBottom is false, since we need to stack over any other
++ // staysOnBottom surfaces in that case
++ lower();
++ emit staysOnBottomChanged();
++ Q_ASSERT(!(d->staysOnTop && d->staysOnBottom));
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qwaylandquickshellsurfaceitem_p.cpp"
++
++ #include "moc_qwaylandquickshellsurfaceitem.cpp"