qwaylandqtshellchrome.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "qwaylandqtshellchrome.h"
#include "qwaylandqtshellchrome_p.h"
#include "qwaylandqtshell.h"
 
#include <QtWaylandCompositor/qwaylandquickshellsurfaceitem.h>
 
QT_BEGIN_NAMESPACE
 
QPointF QWaylandQtShellChromePrivate::constrainPoint(const QPointF &point) const
{
    float x0 = maximizedRect.left();
    float y0 = maximizedRect.top();
    float x1 = maximizedRect.right();
    float y1 = maximizedRect.bottom();
    return QPoint(qBound(x0, point.x(), x1),
                  qBound(y0, point.y(), y1));
}
 
void QWaylandQtShellChromePrivate::updateDecorationInteraction(quint8 flags,
                                                               const QQuickHandlerPoint &centroid)
{
    if (shellSurface == nullptr)
        return;
 
    if (decorationInteraction == quint8(DecorationInteraction::None)) {
        decorationInteraction = flags;
        decorationInteractionPosition = centroid.scenePressPosition();
        decorationInteractionGeometry = shellSurface->windowGeometry();
    }
 
    if (decorationInteraction != flags)
        return;
 
    QPointF position = constrainPoint(centroid.scenePosition());
    float dx = position.x() - decorationInteractionPosition.x();
    float dy = position.y() - decorationInteractionPosition.y();
 
    float minWidth = qMax(0, shellSurface->minimumSize().width());
    float minHeight = qMax(0, shellSurface->minimumSize().height());
 
    float maxWidth = shellSurface->maximumSize().width();
    float maxHeight = shellSurface->maximumSize().height();
 
    float minX = maxWidth >= 0.0f
            ? decorationInteractionGeometry.right() - maxWidth
            : -FLT_MAX;
    float minY = maxHeight >= 0.0f
            ? decorationInteractionGeometry.bottom() - maxHeight
            : -FLT_MAX;
    float maxX = maxWidth >= 0
            ? decorationInteractionGeometry.left() + maxWidth
            : FLT_MAX;
    float maxY = maxHeight >= 0.0f
            ? decorationInteractionGeometry.top() + maxHeight
            : FLT_MAX;
 
    float newLeft = decorationInteractionGeometry.left();
    if (flags & quint8(DecorationInteraction::WestBound)) {
        newLeft = qBound(minX,
                         newLeft + dx,
                         float(decorationInteractionGeometry.right() - minWidth));
    }
 
    float newTop = decorationInteractionGeometry.top();
    if (flags & quint8(DecorationInteraction::NorthBound)) {
        newTop = qBound(minY,
                        newTop + dy,
                        decorationInteractionGeometry.bottom() + minHeight);
    }
 
    float newRight = decorationInteractionGeometry.right();
    if (flags & quint8(DecorationInteraction::EastBound)) {
        newRight = qBound(decorationInteractionGeometry.left() + minWidth,
                          newRight + dx,
                          maxX);
    }
 
    float newBottom = decorationInteractionGeometry.bottom();
    if (flags & quint8(DecorationInteraction::SouthBound)) {
        newBottom = qBound(decorationInteractionGeometry.top() + minHeight,
                           newBottom + dy,
                           maxY);
    }
 
    shellSurface->requestWindowGeometry(shellSurface->windowState(),
                                        QRect(int(newLeft), int(newTop),
                                              int(newRight - newLeft), int(newBottom - newTop)));
}
 
QWaylandQtShellChrome::QWaylandQtShellChrome(QQuickItem *parent)
    : QQuickItem(*new QWaylandQtShellChromePrivate{}, parent)
{
    init();
}
 
QWaylandQtShellChrome::QWaylandQtShellChrome(QWaylandQtShellChromePrivate &dd,
                                             QQuickItem *parent)
    : QQuickItem(dd, parent)
{
    init();
}
 
QWaylandQtShellChrome::~QWaylandQtShellChrome()
{
    Q_D(QWaylandQtShellChrome);
    if (d->shell != nullptr)
        d->shell->unregisterChrome(this);
}
 
void QWaylandQtShellChrome::init()
{
    connect(this, &QWaylandQtShellChrome::currentWindowStateChanged,
            this, &QWaylandQtShellChrome::windowMetaInfoChanged);
 
    connect(this, &QWaylandQtShellChrome::currentWindowFlagsChanged,
            this, &QWaylandQtShellChrome::windowMetaInfoChanged);
 
    connect(this, &QWaylandQtShellChrome::windowMetaInfoChanged,
            this, &QWaylandQtShellChrome::updateDecorations);
 
    connect(this, &QWaylandQtShellChrome::leftResizeHandleChanged,
            this, &QWaylandQtShellChrome::updateDecorations);
 
    connect(this, &QWaylandQtShellChrome::rightResizeHandleChanged,
            this, &QWaylandQtShellChrome::updateDecorations);
 
    connect(this, &QWaylandQtShellChrome::topResizeHandleChanged,
            this, &QWaylandQtShellChrome::updateDecorations);
 
    connect(this, &QWaylandQtShellChrome::bottomResizeHandleChanged,
            this, &QWaylandQtShellChrome::updateDecorations);
 
    connect(this, &QWaylandQtShellChrome::topLeftResizeHandleChanged,
            this, &QWaylandQtShellChrome::updateDecorations);
 
    connect(this, &QWaylandQtShellChrome::bottomLeftResizeHandleChanged,
            this, &QWaylandQtShellChrome::updateDecorations);
 
    connect(this, &QWaylandQtShellChrome::topRightResizeHandleChanged,
            this, &QWaylandQtShellChrome::updateDecorations);
 
    connect(this, &QWaylandQtShellChrome::bottomRightResizeHandleChanged,
            this, &QWaylandQtShellChrome::updateDecorations);
}
 
void QWaylandQtShellChrome::toggleFullScreen()
{
    Q_D(QWaylandQtShellChrome);
    if (d->shellSurface == nullptr)
        return;
 
    uint newState;
    if ((d->shellSurface->windowState() & Qt::WindowFullScreen) == Qt::WindowFullScreen)
        newState = d->currentState & ~Qt::WindowFullScreen;
    else
        newState = d->currentState | Qt::WindowFullScreen;
 
    if ((newState & (Qt::WindowMinimized | Qt::WindowMaximized)) != 0)
        newState &= ~(Qt::WindowMinimized | Qt::WindowMaximized);
 
    setWindowState(newState);
}
 
void QWaylandQtShellChrome::toggleMaximized()
{
    Q_D(QWaylandQtShellChrome);
    if (d->shellSurface == nullptr)
        return;
 
    uint newState;
    if ((d->shellSurface->windowState() & Qt::WindowMaximized) == Qt::WindowMaximized)
        newState = d->currentState & ~Qt::WindowMaximized;
    else
        newState = d->currentState | Qt::WindowMaximized;
 
    if ((newState & Qt::WindowMinimized) == Qt::WindowMinimized)
        newState &= ~Qt::WindowMinimized;
 
    setWindowState(newState);
}
 
void QWaylandQtShellChrome::toggleMinimized()
{
    Q_D(QWaylandQtShellChrome);
    if (d->shellSurface == nullptr)
        return;
 
    uint newState;
    if ((d->shellSurface->windowState() & Qt::WindowMinimized) == Qt::WindowMinimized)
        newState = d->currentState & ~Qt::WindowMinimized;
    else
        newState = d->currentState | Qt::WindowMinimized;
 
    if ((newState & Qt::WindowMaximized) == Qt::WindowMaximized)
        newState &= ~Qt::WindowMaximized;
 
    setWindowState(newState);
}
 
void QWaylandQtShellChrome::setShellSurfaceItem(QWaylandQuickShellSurfaceItem *shellSurfaceItem)
{
    Q_D(QWaylandQtShellChrome);
    if (d->shellSurfaceItem == shellSurfaceItem)
        return;
 
    if (d->shellSurfaceItem != nullptr)
        d->shellSurfaceItem->disconnect(this);
 
    d->shellSurfaceItem = shellSurfaceItem;
 
    if (d->shellSurfaceItem != nullptr) {
        connect(d->shellSurfaceItem, &QWaylandQuickShellSurfaceItem::shellSurfaceChanged,
                this, &QWaylandQtShellChrome::updateShellSurface);
        connect(d->shellSurfaceItem, &QWaylandQuickShellSurfaceItem::surfaceDestroyed,
                this, &QWaylandQtShellChrome::clientDestroyed);
    }
 
    updateShellSurface();
    emit shellSurfaceItemChanged();
}
 
QWaylandQuickShellSurfaceItem *QWaylandQtShellChrome::shellSurfaceItem() const
{
    Q_D(const QWaylandQtShellChrome);
    return d->shellSurfaceItem;
}
 
void QWaylandQtShellChrome::stopGrab()
{
    Q_D(QWaylandQtShellChrome);
    d->decorationInteraction = quint8(QWaylandQtShellChromePrivate::DecorationInteraction::None);
}
 
void QWaylandQtShellChrome::leftResize()
{
    Q_D(QWaylandQtShellChrome);
    if (!d->leftResizeHandleHandler->active())
        return;
 
    d->updateDecorationInteraction(quint8(QWaylandQtShellChromePrivate::DecorationInteraction::WestBound),
                                   d->leftResizeHandleHandler->centroid());
}
 
void QWaylandQtShellChrome::rightResize()
{
    Q_D(QWaylandQtShellChrome);
    if (!d->rightResizeHandleHandler->active())
        return;
 
    d->updateDecorationInteraction(quint8(QWaylandQtShellChromePrivate::DecorationInteraction::EastBound),
                                   d->rightResizeHandleHandler->centroid());
}
 
void QWaylandQtShellChrome::topResize()
{
    Q_D(QWaylandQtShellChrome);
    if (!d->topResizeHandleHandler->active())
        return;
 
    d->updateDecorationInteraction(quint8(QWaylandQtShellChromePrivate::DecorationInteraction::NorthBound),
                                   d->topResizeHandleHandler->centroid());
}
 
void QWaylandQtShellChrome::bottomResize()
{
    Q_D(QWaylandQtShellChrome);
    if (!d->bottomResizeHandleHandler->active())
        return;
 
    d->updateDecorationInteraction(quint8(QWaylandQtShellChromePrivate::DecorationInteraction::SouthBound),
                                   d->bottomResizeHandleHandler->centroid());
}
 
void QWaylandQtShellChrome::topLeftResize()
{
    Q_D(QWaylandQtShellChrome);
    if (!d->topLeftResizeHandleHandler->active())
        return;
 
    d->updateDecorationInteraction(quint8(QWaylandQtShellChromePrivate::DecorationInteraction::WestBound)
                                   | quint8(QWaylandQtShellChromePrivate::DecorationInteraction::NorthBound),
                                   d->topLeftResizeHandleHandler->centroid());
}
 
void QWaylandQtShellChrome::topRightResize()
{
    Q_D(QWaylandQtShellChrome);
    if (!d->topRightResizeHandleHandler->active())
        return;
 
    d->updateDecorationInteraction(quint8(QWaylandQtShellChromePrivate::DecorationInteraction::EastBound)
                                   | quint8(QWaylandQtShellChromePrivate::DecorationInteraction::NorthBound),
                                   d->topRightResizeHandleHandler->centroid());
}
 
void QWaylandQtShellChrome::bottomLeftResize()
{
    Q_D(QWaylandQtShellChrome);
    if (!d->bottomLeftResizeHandleHandler->active())
        return;
 
    d->updateDecorationInteraction(quint8(QWaylandQtShellChromePrivate::DecorationInteraction::WestBound)
                                   | quint8(QWaylandQtShellChromePrivate::DecorationInteraction::SouthBound),
                                   d->bottomLeftResizeHandleHandler->centroid());
}
 
void QWaylandQtShellChrome::bottomRightResize()
{
    Q_D(QWaylandQtShellChrome);
    if (!d->bottomRightResizeHandleHandler->active())
        return;
 
    d->updateDecorationInteraction(quint8(QWaylandQtShellChromePrivate::DecorationInteraction::EastBound)
                                   | quint8(QWaylandQtShellChromePrivate::DecorationInteraction::SouthBound),
                                   d->bottomRightResizeHandleHandler->centroid());
}
 
void QWaylandQtShellChrome::titleBarMove()
{
    Q_D(QWaylandQtShellChrome);
    if (!d->titleBarHandler->active())
        return;
 
    quint8 flags = quint8(QWaylandQtShellChromePrivate::DecorationInteraction::TitleBar);
    QQuickHandlerPoint centroid = d->titleBarHandler->centroid();
    if (d->decorationInteraction == quint8(QWaylandQtShellChromePrivate::DecorationInteraction::None)) {
        d->decorationInteraction = flags;
        d->decorationInteractionPosition = d->shellSurface->windowPosition() - centroid.scenePressPosition();
 
        activate();
    }
 
    if (d->decorationInteraction != flags)
        return;
 
    QPointF position = d->constrainPoint(centroid.scenePosition());
    d->shellSurface->setWindowPosition((position + d->decorationInteractionPosition).toPoint());
}
 
QQuickItem *QWaylandQtShellChrome::titleBar() const
{
    Q_D(const QWaylandQtShellChrome);
    return d->titleBar;
}
 
void QWaylandQtShellChrome::setTitleBar(QQuickItem *item)
{
    Q_D(QWaylandQtShellChrome);
    if (d->titleBar == item)
        return;
 
    if (d->titleBar != nullptr) {
        d->titleBar->disconnect(this);
 
        delete d->titleBarHandler;
        d->titleBarHandler = nullptr;
    }
 
    d->titleBar = item;
 
    if (d->titleBar != nullptr) {
        connect(d->titleBar, &QQuickItem::heightChanged,
                this, &QWaylandQtShellChrome::updateDecorations);
 
        d->titleBarHandler = new QQuickDragHandler(d->titleBar);
        d->titleBarHandler->setTarget(nullptr);
 
        connect(d->titleBarHandler, &QQuickPointerHandler::grabChanged,
                this, &QWaylandQtShellChrome::stopGrab);
        connect(d->titleBarHandler, &QQuickPointerHandler::grabChanged,
                this, &QWaylandQtShellChrome::activateOnGrab);
        connect(d->titleBarHandler, &QQuickMultiPointHandler::centroidChanged,
                this, &QWaylandQtShellChrome::titleBarMove);
    }
 
    emit titleBarChanged();
}
 
QQuickItem *QWaylandQtShellChrome::leftResizeHandle() const
{
    Q_D(const QWaylandQtShellChrome);
    return d->leftResizeHandle;
}
 
void QWaylandQtShellChrome::setLeftResizeHandle(QQuickItem *item)
{
    Q_D(QWaylandQtShellChrome);
    if (d->leftResizeHandle == item)
        return;
 
    if (d->leftResizeHandle != nullptr) {
        d->leftResizeHandle->disconnect(this);
 
        delete d->leftResizeHandleHandler;
        d->leftResizeHandleHandler = nullptr;
    }
 
    d->leftResizeHandle = item;
 
    if (d->leftResizeHandle != nullptr) {
        connect(d->leftResizeHandle, &QQuickItem::widthChanged,
                this, &QWaylandQtShellChrome::updateDecorations);
 
        d->leftResizeHandleHandler = new QQuickDragHandler(d->leftResizeHandle);
        d->leftResizeHandleHandler->setCursorShape(Qt::SizeHorCursor);
        d->leftResizeHandleHandler->setTarget(nullptr);
 
        connect(d->leftResizeHandleHandler, &QQuickPointerHandler::grabChanged,
                this, &QWaylandQtShellChrome::stopGrab);
        connect(d->leftResizeHandleHandler, &QQuickMultiPointHandler::centroidChanged,
                this, &QWaylandQtShellChrome::leftResize);
    }
 
    emit leftResizeHandleChanged();
}
 
QQuickItem *QWaylandQtShellChrome::rightResizeHandle() const
{
    Q_D(const QWaylandQtShellChrome);
    return d->rightResizeHandle;
}
 
void QWaylandQtShellChrome::setRightResizeHandle(QQuickItem *item)
{
    Q_D(QWaylandQtShellChrome);
    if (d->rightResizeHandle == item)
        return;
 
    if (d->rightResizeHandle != nullptr) {
        d->rightResizeHandle->disconnect(this);
 
        delete d->rightResizeHandleHandler;
        d->rightResizeHandleHandler = nullptr;
    }
 
    d->rightResizeHandle = item;
 
    if (d->rightResizeHandle != nullptr) {
        connect(d->rightResizeHandle, &QQuickItem::widthChanged,
                this, &QWaylandQtShellChrome::updateDecorations);
 
        d->rightResizeHandleHandler = new QQuickDragHandler(d->rightResizeHandle);
        d->rightResizeHandleHandler->setCursorShape(Qt::SizeHorCursor);
        d->rightResizeHandleHandler->setTarget(nullptr);
 
        connect(d->rightResizeHandleHandler, &QQuickPointerHandler::grabChanged,
                this, &QWaylandQtShellChrome::stopGrab);
        connect(d->rightResizeHandleHandler, &QQuickMultiPointHandler::centroidChanged,
                this, &QWaylandQtShellChrome::rightResize);
    }
 
    emit rightResizeHandleChanged();
}
 
QQuickItem *QWaylandQtShellChrome::topResizeHandle() const
{
    Q_D(const QWaylandQtShellChrome);
    return d->topResizeHandle;
}
 
void QWaylandQtShellChrome::setTopResizeHandle(QQuickItem *item)
{
    Q_D(QWaylandQtShellChrome);
    if (d->topResizeHandle == item)
        return;
 
    if (d->topResizeHandle != nullptr) {
        d->topResizeHandle->disconnect(this);
 
        delete d->topResizeHandleHandler;
        d->topResizeHandleHandler = nullptr;
    }
 
    d->topResizeHandle = item;
 
    if (d->topResizeHandle != nullptr) {
        connect(d->topResizeHandle, &QQuickItem::heightChanged,
                this, &QWaylandQtShellChrome::updateDecorations);
 
        d->topResizeHandleHandler = new QQuickDragHandler(d->topResizeHandle);
        d->topResizeHandleHandler->setCursorShape(Qt::SizeVerCursor);
        d->topResizeHandleHandler->setTarget(nullptr);
 
        connect(d->topResizeHandleHandler, &QQuickPointerHandler::grabChanged,
                this, &QWaylandQtShellChrome::stopGrab);
        connect(d->topResizeHandleHandler, &QQuickMultiPointHandler::centroidChanged,
                this, &QWaylandQtShellChrome::topResize);
    }
 
    emit topResizeHandleChanged();
}
 
QQuickItem *QWaylandQtShellChrome::bottomResizeHandle() const
{
    Q_D(const QWaylandQtShellChrome);
    return d->bottomResizeHandle;
}
 
void QWaylandQtShellChrome::setBottomResizeHandle(QQuickItem *item)
{
    Q_D(QWaylandQtShellChrome);
    if (d->bottomResizeHandle == item)
        return;
 
    if (d->bottomResizeHandle != nullptr) {
        d->bottomResizeHandle->disconnect(this);
 
        delete d->bottomResizeHandleHandler;
        d->bottomResizeHandleHandler = nullptr;
    }
 
    d->bottomResizeHandle = item;
 
    if (d->bottomResizeHandle != nullptr) {
        connect(d->bottomResizeHandle, &QQuickItem::heightChanged,
                this, &QWaylandQtShellChrome::updateDecorations);
 
        d->bottomResizeHandleHandler = new QQuickDragHandler(d->bottomResizeHandle);
        d->bottomResizeHandleHandler->setCursorShape(Qt::SizeVerCursor);
        d->bottomResizeHandleHandler->setTarget(nullptr);
 
        connect(d->bottomResizeHandleHandler, &QQuickPointerHandler::grabChanged,
                this, &QWaylandQtShellChrome::stopGrab);
        connect(d->bottomResizeHandleHandler, &QQuickMultiPointHandler::centroidChanged,
                this, &QWaylandQtShellChrome::bottomResize);
 
    }
 
    emit bottomResizeHandleChanged();
}
 
QQuickItem *QWaylandQtShellChrome::topLeftResizeHandle() const
{
    Q_D(const QWaylandQtShellChrome);
    return d->topLeftResizeHandle;
}
 
void QWaylandQtShellChrome::setTopLeftResizeHandle(QQuickItem *item)
{
    Q_D(QWaylandQtShellChrome);
    if (d->topLeftResizeHandle == item)
        return;
 
    if (d->topLeftResizeHandle != nullptr) {
        delete d->topLeftResizeHandleHandler;
        d->topLeftResizeHandleHandler = nullptr;
    }
 
    d->topLeftResizeHandle = item;
 
    if (d->topLeftResizeHandle != nullptr) {
        d->topLeftResizeHandleHandler = new QQuickDragHandler(d->topLeftResizeHandle);
        d->topLeftResizeHandleHandler->setCursorShape(Qt::SizeFDiagCursor);
        d->topLeftResizeHandleHandler->setTarget(nullptr);
 
        connect(d->topLeftResizeHandleHandler, &QQuickPointerHandler::grabChanged,
                this, &QWaylandQtShellChrome::stopGrab);
        connect(d->topLeftResizeHandleHandler, &QQuickMultiPointHandler::centroidChanged,
                this, &QWaylandQtShellChrome::topLeftResize);
    }
 
    emit topLeftResizeHandleChanged();
}
 
QQuickItem *QWaylandQtShellChrome::bottomLeftResizeHandle() const
{
    Q_D(const QWaylandQtShellChrome);
    return d->bottomLeftResizeHandle;
}
 
void QWaylandQtShellChrome::setBottomLeftResizeHandle(QQuickItem *item)
{
    Q_D(QWaylandQtShellChrome);
    if (d->bottomLeftResizeHandle == item)
        return;
 
    if (d->bottomLeftResizeHandle != nullptr) {
        delete d->bottomLeftResizeHandleHandler;
        d->bottomLeftResizeHandleHandler = nullptr;
    }
 
    d->bottomLeftResizeHandle = item;
 
    if (d->bottomLeftResizeHandle != nullptr) {
        d->bottomLeftResizeHandleHandler = new QQuickDragHandler(d->bottomLeftResizeHandle);
        d->bottomLeftResizeHandleHandler->setCursorShape(Qt::SizeBDiagCursor);
        d->bottomLeftResizeHandleHandler->setTarget(nullptr);
 
        connect(d->bottomLeftResizeHandleHandler, &QQuickPointerHandler::grabChanged,
                this, &QWaylandQtShellChrome::stopGrab);
        connect(d->bottomLeftResizeHandleHandler, &QQuickMultiPointHandler::centroidChanged,
                this, &QWaylandQtShellChrome::bottomLeftResize);
    }
 
    emit bottomLeftResizeHandleChanged();
}
 
QQuickItem *QWaylandQtShellChrome::topRightResizeHandle() const
{
    Q_D(const QWaylandQtShellChrome);
    return d->topRightResizeHandle;
}
 
void QWaylandQtShellChrome::setTopRightResizeHandle(QQuickItem *item)
{
    Q_D(QWaylandQtShellChrome);
    if (d->topRightResizeHandle == item)
        return;
 
    if (d->topRightResizeHandle != nullptr) {
        delete d->topRightResizeHandleHandler;
        d->topRightResizeHandleHandler = nullptr;
    }
 
    d->topRightResizeHandle = item;
 
    if (d->topRightResizeHandle != nullptr) {
        d->topRightResizeHandleHandler = new QQuickDragHandler(d->topRightResizeHandle);
        d->topRightResizeHandleHandler->setCursorShape(Qt::SizeBDiagCursor);
        d->topRightResizeHandleHandler->setTarget(nullptr);
 
        connect(d->topRightResizeHandleHandler, &QQuickPointerHandler::grabChanged,
                this, &QWaylandQtShellChrome::stopGrab);
        connect(d->topRightResizeHandleHandler, &QQuickMultiPointHandler::centroidChanged,
                this, &QWaylandQtShellChrome::topRightResize);
    }
 
    emit topRightResizeHandleChanged();
}
 
QQuickItem *QWaylandQtShellChrome::bottomRightResizeHandle() const
{
    Q_D(const QWaylandQtShellChrome);
    return d->bottomRightResizeHandle;
}
 
void QWaylandQtShellChrome::setBottomRightResizeHandle(QQuickItem *item)
{
    Q_D(QWaylandQtShellChrome);
    if (d->bottomRightResizeHandle == item)
        return;
 
    if (d->bottomRightResizeHandle != nullptr) {
        delete d->bottomRightResizeHandleHandler;
        d->bottomRightResizeHandleHandler = nullptr;
    }
 
    d->bottomRightResizeHandle = item;
 
    if (d->bottomRightResizeHandle != nullptr) {
        d->bottomRightResizeHandleHandler = new QQuickDragHandler(d->bottomRightResizeHandle);
        d->bottomRightResizeHandleHandler->setCursorShape(Qt::SizeFDiagCursor);
        d->bottomRightResizeHandleHandler->setTarget(nullptr);
 
        connect(d->bottomRightResizeHandleHandler, &QQuickPointerHandler::grabChanged,
                this, &QWaylandQtShellChrome::stopGrab);
        connect(d->bottomRightResizeHandleHandler, &QQuickMultiPointHandler::centroidChanged,
                this, &QWaylandQtShellChrome::bottomRightResize);
    }
 
    emit bottomRightResizeHandleChanged();
}
 
void QWaylandQtShellChrome::setMaximizedRect(const QRect &rect)
{
    Q_D(QWaylandQtShellChrome);
    if (d->maximizedRect == rect)
        return;
 
    d->maximizedRect = rect;
    emit maximizedRectChanged();
}
 
QRect QWaylandQtShellChrome::maximizedRect() const
{
    Q_D(const QWaylandQtShellChrome);
    if (d->maximizedRect.isValid())
        return d->maximizedRect;
    else if (d->shellSurfaceItem != nullptr && d->shellSurfaceItem->output() != nullptr)
        return d->shellSurfaceItem->output()->geometry();
 
    return QRect{};
}
 
void QWaylandQtShellChrome::updateDecorations()
{
    Q_D(QWaylandQtShellChrome);
    if (d->shellSurface == nullptr)
        return;
 
    bool decorations = hasDecorations();
    bool titleBarShowing = hasTitleBar();
 
    QMargins margins;
    if (d->automaticFrameMargins) {
        if (d->leftResizeHandle != nullptr && decorations)
            margins.setLeft(d->leftResizeHandle->width());
        if (d->rightResizeHandle != nullptr && decorations)
            margins.setRight(d->rightResizeHandle->width());
        if (d->bottomResizeHandle != nullptr && decorations)
            margins.setBottom(d->bottomResizeHandle->height());
 
        margins.setTop((decorations && d->topResizeHandle != nullptr ? d->topResizeHandle->height() : 0)
                    + (titleBarShowing && d->titleBar != nullptr ? d->titleBar->height() : 0));
    } else {
        margins = d->explicitFrameMargins;
    }
    d->shellSurface->setFrameMargins(margins);
 
    if (d->titleBar != nullptr)
        d->titleBar->setVisible(titleBarShowing);
    if (d->leftResizeHandle != nullptr)
        d->leftResizeHandle->setVisible(decorations);
    if (d->rightResizeHandle != nullptr)
        d->rightResizeHandle->setVisible(decorations);
    if (d->topResizeHandle != nullptr)
        d->topResizeHandle->setVisible(decorations);
    if (d->bottomResizeHandle != nullptr)
        d->bottomResizeHandle->setVisible(decorations);
    if (d->bottomLeftResizeHandle != nullptr)
        d->bottomLeftResizeHandle->setVisible(decorations);
    if (d->topLeftResizeHandle != nullptr)
        d->topLeftResizeHandle->setVisible(decorations);
    if (d->bottomRightResizeHandle != nullptr)
        d->bottomRightResizeHandle->setVisible(decorations);
    if (d->topRightResizeHandle != nullptr)
        d->topRightResizeHandle->setVisible(decorations);
 
    bool minimizedOrMaximized = (d->currentState & (Qt::WindowMaximized|Qt::WindowMinimized)) != 0;
    if (d->leftResizeHandleHandler != nullptr)
        d->leftResizeHandleHandler->setEnabled(decorations && !minimizedOrMaximized);
    if (d->rightResizeHandleHandler != nullptr)
        d->rightResizeHandleHandler->setEnabled(decorations && !minimizedOrMaximized);
    if (d->bottomResizeHandleHandler != nullptr)
        d->bottomResizeHandleHandler->setEnabled(decorations && !minimizedOrMaximized);
    if (d->topResizeHandleHandler != nullptr)
        d->topResizeHandleHandler->setEnabled(decorations && !minimizedOrMaximized);
    if (d->bottomLeftResizeHandleHandler != nullptr)
        d->bottomLeftResizeHandleHandler->setEnabled(decorations && !minimizedOrMaximized);
    if (d->bottomRightResizeHandleHandler != nullptr)
        d->bottomRightResizeHandleHandler->setEnabled(decorations && !minimizedOrMaximized);
    if (d->topLeftResizeHandleHandler != nullptr)
        d->topLeftResizeHandleHandler->setEnabled(decorations && !minimizedOrMaximized);
    if (d->topRightResizeHandleHandler != nullptr)
        d->topRightResizeHandleHandler->setEnabled(decorations && !minimizedOrMaximized);
    if (d->titleBarHandler != nullptr)
        d->titleBarHandler->setEnabled(titleBarShowing && !minimizedOrMaximized);
}
 
void QWaylandQtShellChrome::updateGeometry()
{
    Q_D(QWaylandQtShellChrome);
    if (d->shellSurface == nullptr)
        return;
 
    QRect windowGeometry = d->shellSurface->windowGeometry();
 
    QPointF position = windowGeometry.topLeft();
    position.rx() -= d->shellSurface->frameMarginLeft();
    position.ry() -= d->shellSurface->frameMarginTop();
 
    QSizeF size = windowGeometry.size();
    size.rwidth() += d->shellSurface->frameMarginLeft() + d->shellSurface->frameMarginRight();
    size.rheight() += d->shellSurface->frameMarginTop() + d->shellSurface->frameMarginBottom();
 
    setPosition(position);
    setSize(size);
}
 
void QWaylandQtShellChrome::updateSurface()
{
    Q_D(QWaylandQtShellChrome);
    QWaylandSurface *surface = d->shellSurface != nullptr ? d->shellSurface->surface() : nullptr;
    if (d->surface == surface)
        return;
 
    if (d->surface != nullptr)
        d->surface->disconnect(this);
 
    d->surface = surface;
 
    if (d->surface != nullptr) {
        connect(d->surface, &QWaylandSurface::hasContentChanged,
                this, &QWaylandQtShellChrome::updateAutomaticPosition);
    }
}
 
void QWaylandQtShellChrome::updateShellSurface()
{
    Q_D(QWaylandQtShellChrome);
    QWaylandQtShellSurface *sf = d->shellSurfaceItem != nullptr
            ? qobject_cast<QWaylandQtShellSurface *>(d->shellSurfaceItem->shellSurface())
            : nullptr;
    if (d->shellSurface == sf)
        return;
 
    if (d->shellSurface != nullptr) {
        d->shellSurface->disconnect(this);
        if (d->shell != nullptr)
            d->shell->unregisterChrome(this);
        d->shell = nullptr;
    }
 
    d->shellSurface = sf;
    if (d->shellSurface != nullptr) {
        d->shell = d->shellSurface->shell();
        if (d->shell != nullptr)
            d->shell->registerChrome(this);
 
        updateWindowFlags();
        connect(d->shellSurface, &QWaylandQtShellSurface::windowFlagsChanged,
                this, &QWaylandQtShellChrome::updateWindowFlags);
        connect(d->shellSurface, &QWaylandQtShellSurface::windowStateChanged,
                this, &QWaylandQtShellChrome::updateWindowState);
        connect(d->shellSurface, &QWaylandQtShellSurface::frameMarginChanged,
                this, &QWaylandQtShellChrome::updateGeometry);
        connect(d->shellSurface, &QWaylandQtShellSurface::windowGeometryChanged,
                this, &QWaylandQtShellChrome::updateGeometry);
        connect(d->shellSurface, &QWaylandQtShellSurface::raiseRequested,
                this, &QWaylandQtShellChrome::raise);
        connect(d->shellSurface, &QWaylandQtShellSurface::lowerRequested,
                this, &QWaylandQtShellChrome::lower);
        connect(d->shellSurface, &QWaylandQtShellSurface::activeChanged,
                this, &QWaylandQtShellChrome::updateActiveState);
        connect(d->shellSurface, &QWaylandQtShellSurface::surfaceChanged,
                this, &QWaylandQtShellChrome::updateSurface);
    }
 
    updateDecorations();
    updateSurface();
}
 
void QWaylandQtShellChrome::updateWindowState()
{
    Q_D(QWaylandQtShellChrome);
    if (d->shellSurface == nullptr)
        return;
 
    setWindowState(d->shellSurface->windowState());
}
 
void QWaylandQtShellChrome::updateWindowFlags()
{
    Q_D(QWaylandQtShellChrome);
 
    uint nextFlags = d->shellSurface == nullptr || d->shellSurface->windowFlags() == Qt::Window
            ? d->defaultFlags
            : d->shellSurface->windowFlags();
 
    if (d->currentFlags != nextFlags) {
        d->currentFlags = nextFlags;
        emit currentWindowFlagsChanged();
    }
}
 
uint QWaylandQtShellChrome::currentWindowFlags() const
{
    Q_D(const QWaylandQtShellChrome);
    return d->currentFlags;
}
 
uint QWaylandQtShellChrome::currentWindowState() const
{
    Q_D(const QWaylandQtShellChrome);
    return d->currentState;
}
 
bool QWaylandQtShellChrome::hasTitleBar() const
{
    Q_D(const QWaylandQtShellChrome);
 
    bool frameless = (d->currentFlags & Qt::FramelessWindowHint) == Qt::FramelessWindowHint
            || ((d->currentFlags & Qt::Popup) == Qt::Popup
                && (d->currentFlags & Qt::Tool) != Qt::Tool)
            || (d->currentState & Qt::WindowFullScreen) == Qt::WindowFullScreen;
    return !frameless;
}
 
bool QWaylandQtShellChrome::hasDecorations() const
{
    Q_D(const QWaylandQtShellChrome);
 
    return hasTitleBar() && (d->currentFlags & Qt::Window) == Qt::Window;
}
 
QRect QWaylandQtShellChrome::maxContentRect() const
{
    Q_D(const QWaylandQtShellChrome);
    if (d->shellSurface == nullptr)
        return QRect{};
 
    int x0 = d->maximizedRect.x() + d->shellSurface->frameMarginLeft();
    int x1 = d->maximizedRect.x() + d->maximizedRect.width() - d->shellSurface->frameMarginRight();
    int y0 = d->maximizedRect.y() + d->shellSurface->frameMarginTop();
    int y1 = d->maximizedRect.y() + d->maximizedRect.height() - d->shellSurface->frameMarginBottom();
 
    return QRect(x0, y0, x1 - x0, y1 - y0);
}
 
static int randomPos(int windowSize, int screenSize)
{
    return (windowSize >= screenSize) ? 0 : rand() % (screenSize - windowSize);
}
 
void QWaylandQtShellChrome::setWindowState(uint nextState)
{
    Q_D(QWaylandQtShellChrome);
 
    if (d->currentState == nextState)
        return;
 
    if (d->shellSurface == nullptr || d->shellSurfaceItem == nullptr)
        return;
 
    QWaylandOutput *output = d->shellSurfaceItem->output();
    if (output == nullptr)
        return;
 
    if ((d->currentState & (Qt::WindowMinimized | Qt::WindowMaximized | Qt::WindowFullScreen)) == 0) {
        d->restoreGeometry = d->shellSurface->windowGeometry();
    }
 
    d->currentState = nextState;
    emit currentWindowStateChanged();
 
    if ((nextState & Qt::WindowMinimized) != 0) {
        d->shellSurface->requestWindowGeometry(nextState, QRect(0, 0, 1, 1));
        d->shellSurfaceItem->setVisible(false);
        deactivate();
    } else if ((nextState & Qt::WindowFullScreen) != 0) {
        d->shellSurfaceItem->setVisible(true);
        d->shellSurface->requestWindowGeometry(nextState, QRect(QPoint(0, 0), output->window()->size()));
        activate();
    } else if ((nextState & Qt::WindowMaximized) != 0) {
        d->shellSurfaceItem->setVisible(true);
        d->shellSurface->requestWindowGeometry(nextState, maxContentRect());
        activate();
    } else {
        d->shellSurfaceItem->setVisible(true);
        d->shellSurface->requestWindowGeometry(nextState, d->restoreGeometry);
        activate();
    }
}
 
void QWaylandQtShellChrome::updateAutomaticPosition()
{
    Q_D(QWaylandQtShellChrome);
    if (!d->positionSet && d->shellSurface != nullptr) {
        bool randomize = d->shellSurface->positionAutomatic();
        QRect rect = d->shellSurface->windowGeometry();
        QRect space = maxContentRect();
 
        int xpos = randomize ? randomPos(rect.width(), space.width()) + space.x()
                             : qMax(rect.x(), space.x());
        int ypos = randomize ? randomPos(rect.height(), space.height()) + space.y()
                             : qMax(rect.y(), space.y());
 
        d->shellSurface->setWindowPosition(QPoint(xpos, ypos));
        d->positionSet = true;
    }
}
 
void QWaylandQtShellChrome::deactivate()
{
    Q_D(QWaylandQtShellChrome);
    if (d->shellSurface != nullptr)
        d->shellSurface->setActive(false);
}
 
void QWaylandQtShellChrome::activateOnGrab(QPointingDevice::GrabTransition transition)
{
    Q_D(QWaylandQtShellChrome);
    if (d->titleBarHandler != nullptr) {
        switch (transition) {
        case QPointingDevice::GrabPassive:
        case QPointingDevice::OverrideGrabPassive:
        case QPointingDevice::GrabExclusive:
            activate();
            break;
        default:
            break;
        }
    }
}
 
void QWaylandQtShellChrome::activate()
{
    Q_D(QWaylandQtShellChrome);
    if (d->shellSurface != nullptr)
        d->shellSurface->setActive(true);
    raise();
}
 
void QWaylandQtShellChrome::raise()
{
    Q_D(QWaylandQtShellChrome);
    if (d->shellSurfaceItem != nullptr)
        d->shellSurfaceItem->raise();
}
 
void QWaylandQtShellChrome::lower()
{
    Q_D(QWaylandQtShellChrome);
    if (d->shellSurfaceItem != nullptr)
        d->shellSurfaceItem->lower();
}
 
void QWaylandQtShellChrome::updateActiveState()
{
    Q_D(QWaylandQtShellChrome);
    if (d->shellSurface == nullptr)
        return;
 
    if (d->shellSurface->active()) {
        raise();
        emit activated();
    } else {
        emit deactivated();
    }
}
 
void QWaylandQtShellChrome::setFrameMarginLeft(int left)
{
    Q_D(QWaylandQtShellChrome);
    if (d->explicitFrameMargins.left() == left)
        return;
 
    d->explicitFrameMargins.setLeft(left);
    d->automaticFrameMargins = false;
    updateDecorations();
 
    emit frameMarginChanged();
}
 
int QWaylandQtShellChrome::frameMarginLeft() const
{
    Q_D(const QWaylandQtShellChrome);
    if (d->shellSurface == nullptr)
        return 0;
    return d->shellSurface->frameMarginLeft();
}
 
void QWaylandQtShellChrome::setFrameMarginRight(int right)
{
    Q_D(QWaylandQtShellChrome);
    if (d->explicitFrameMargins.right() == right)
        return;
 
    d->explicitFrameMargins.setRight(right);
    d->automaticFrameMargins = false;
    updateDecorations();
 
    emit frameMarginChanged();
}
 
int QWaylandQtShellChrome::frameMarginRight() const
{
    Q_D(const QWaylandQtShellChrome);
    if (d->shellSurface == nullptr)
        return 0;
    return d->shellSurface->frameMarginRight();
}
 
void QWaylandQtShellChrome::setFrameMarginTop(int top)
{
    Q_D(QWaylandQtShellChrome);
    if (d->explicitFrameMargins.top() == top)
        return;
    d->explicitFrameMargins.setTop(top);
    d->automaticFrameMargins = false;
    updateDecorations();
 
    emit frameMarginChanged();
}
 
int QWaylandQtShellChrome::frameMarginTop() const
{
    Q_D(const QWaylandQtShellChrome);
    if (d->shellSurface == nullptr)
        return 0;
    return d->shellSurface->frameMarginTop();
}
 
void QWaylandQtShellChrome::setFrameMarginBottom(int bottom)
{
    Q_D(QWaylandQtShellChrome);
    if (d->explicitFrameMargins.bottom() == bottom)
        return;
    d->explicitFrameMargins.setBottom(bottom);
    d->automaticFrameMargins = false;
    updateDecorations();
 
    emit frameMarginChanged();
}
 
int QWaylandQtShellChrome::frameMarginBottom() const
{
    Q_D(const QWaylandQtShellChrome);
    if (d->shellSurface == nullptr)
        return 0;
    return d->shellSurface->frameMarginBottom();
}
 
QT_END_NAMESPACE
 
#include "moc_qwaylandqtshellchrome.cpp"