qsizegrip.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qsizegrip.h"
 
#include "qapplication.h"
#include "qevent.h"
#include "qstylepainter.h"
#include "qwindow.h"
#include <qpa/qplatformwindow.h>
#include "qstyle.h"
#include "qstyleoption.h"
#include "qlayout.h"
#include "qdebug.h"
 
#include <private/qwidget_p.h>
#include "private/qapplication_p.h"
#include <qpa/qplatformtheme.h>
#include <QtWidgets/qabstractscrollarea.h>
 
QT_BEGIN_NAMESPACE
 
static QWidget *qt_sizegrip_topLevelWidget(QWidget* w)
{
    while (w && !w->isWindow() && w->windowType() != Qt::SubWindow)
        w = w->parentWidget();
    return w;
}
 
class QSizeGripPrivate : public QWidgetPrivate
{
    Q_DECLARE_PUBLIC(QSizeGrip)
public:
    QSizeGripPrivate();
    void init();
    QPoint p;
    QRect r;
    int d;
    int dxMax;
    int dyMax;
    Qt::Corner m_corner;
    bool gotMousePress;
    QPointer<QWidget> tlw;
 
    Qt::Corner corner() const;
    inline bool atBottom() const
    {
        return m_corner == Qt::BottomRightCorner || m_corner == Qt::BottomLeftCorner;
    }
 
    inline bool atLeft() const
    {
        return m_corner == Qt::BottomLeftCorner || m_corner == Qt::TopLeftCorner;
    }
 
    void updateTopLevelWidget()
    {
        Q_Q(QSizeGrip);
        QWidget *w = qt_sizegrip_topLevelWidget(q);
        if (tlw == w)
            return;
        if (tlw)
            tlw->removeEventFilter(q);
        tlw = w;
        if (tlw)
            tlw->installEventFilter(q);
    }
 
    // This slot is invoked by QLayout when the size grip is added to
    // a layout or reparented after the tlw is shown. This re-implementation is basically
    // the same as QWidgetPrivate::_q_showIfNotHidden except that it checks
    // for Qt::WindowFullScreen and Qt::WindowMaximized as well.
    void _q_showIfNotHidden()
    {
        Q_Q(QSizeGrip);
        bool showSizeGrip = !(q->isHidden() && q->testAttribute(Qt::WA_WState_ExplicitShowHide));
        updateTopLevelWidget();
        if (tlw && showSizeGrip) {
            Qt::WindowStates sizeGripNotVisibleState = Qt::WindowFullScreen;
            sizeGripNotVisibleState |= Qt::WindowMaximized;
            // Don't show the size grip if the tlw is maximized or in full screen mode.
            showSizeGrip = !(tlw->windowState() & sizeGripNotVisibleState);
        }
        if (showSizeGrip)
            q->setVisible(true);
    }
 
    bool m_platformSizeGrip;
};
 
QSizeGripPrivate::QSizeGripPrivate()
    : dxMax(0)
    , dyMax(0)
    , gotMousePress(false)
    , tlw(nullptr)
    , m_platformSizeGrip(false)
{
}
 
Qt::Corner QSizeGripPrivate::corner() const
{
    Q_Q(const QSizeGrip);
    QWidget *tlw = qt_sizegrip_topLevelWidget(const_cast<QSizeGrip *>(q));
    const QPoint sizeGripPos = q->mapTo(tlw, QPoint(0, 0));
    bool isAtBottom = sizeGripPos.y() >= tlw->height() / 2;
    bool isAtLeft = sizeGripPos.x() <= tlw->width() / 2;
    if (isAtLeft)
        return isAtBottom ? Qt::BottomLeftCorner : Qt::TopLeftCorner;
    else
        return isAtBottom ? Qt::BottomRightCorner : Qt::TopRightCorner;
}
 
QSizeGrip::QSizeGrip(QWidget * parent)
    : QWidget(*new QSizeGripPrivate, parent, { })
{
    Q_D(QSizeGrip);
    d->init();
}
 
 
void QSizeGripPrivate::init()
{
    Q_Q(QSizeGrip);
    m_corner = q->isLeftToRight() ? Qt::BottomRightCorner : Qt::BottomLeftCorner;
 
#if !defined(QT_NO_CURSOR)
    q->setCursor(m_corner == Qt::TopLeftCorner || m_corner == Qt::BottomRightCorner
                 ? Qt::SizeFDiagCursor : Qt::SizeBDiagCursor);
#endif
    q->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed));
    updateTopLevelWidget();
}
 
 
QSizeGrip::~QSizeGrip()
{
}
 
QSize QSizeGrip::sizeHint() const
{
    QStyleOption opt(0);
    opt.initFrom(this);
    return style()->sizeFromContents(QStyle::CT_SizeGrip, &opt, QSize(13, 13), this);
}
 
void QSizeGrip::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    Q_D(QSizeGrip);
    QStylePainter painter(this);
    QStyleOptionSizeGrip opt;
    opt.initFrom(this);
    opt.corner = d->m_corner;
    painter.drawControl(QStyle::CE_SizeGrip, opt);
}
 
static Qt::Edges edgesFromCorner(Qt::Corner corner)
{
    switch (corner) {
    case Qt::TopLeftCorner: return Qt::TopEdge | Qt::LeftEdge;
    case Qt::TopRightCorner: return Qt::TopEdge | Qt::RightEdge;
    case Qt::BottomLeftCorner: return Qt::BottomEdge | Qt::LeftEdge;
    case Qt::BottomRightCorner: return Qt::BottomEdge | Qt::RightEdge;
    }
    return Qt::Edges{};
}
 
static bool usePlatformSizeGrip(const QWidget *tlw)
{
    const QString &platformName = QGuiApplication::platformName();
    if (platformName.contains(u"xcb")) // ### FIXME QTBUG-69716
        return false;
    if (tlw->testAttribute(Qt::WA_TranslucentBackground)
        && platformName == u"windows") {
        return false; // QTBUG-90628, flicker when using translucency
    }
    return true;
}
 
void QSizeGrip::mousePressEvent(QMouseEvent * e)
{
    if (e->button() != Qt::LeftButton) {
        QWidget::mousePressEvent(e);
        return;
    }
 
    Q_D(QSizeGrip);
    QWidget *tlw = qt_sizegrip_topLevelWidget(this);
    d->p = e->globalPosition().toPoint();
    d->gotMousePress = true;
    d->r = tlw->geometry();
 
    // Does the platform provide size grip support?
    d->m_platformSizeGrip = false;
    if (tlw->isWindow()
        && tlw->windowHandle()
        && !(tlw->windowFlags() & Qt::X11BypassWindowManagerHint)
        && !tlw->testAttribute(Qt::WA_DontShowOnScreen)
        && !tlw->hasHeightForWidth()
        && usePlatformSizeGrip(tlw)) {
        QPlatformWindow *platformWindow = tlw->windowHandle()->handle();
        const Qt::Edges edges = edgesFromCorner(d->m_corner);
        d->m_platformSizeGrip = platformWindow->startSystemResize(edges);
    }
 
    if (d->m_platformSizeGrip)
        return;
 
    // Find available desktop/workspace geometry.
    QRect availableGeometry;
    bool hasVerticalSizeConstraint = true;
    bool hasHorizontalSizeConstraint = true;
    if (tlw->isWindow()) {
        if (QGuiApplicationPrivate::platformTheme()->themeHint(QPlatformTheme::InteractiveResizeAcrossScreens).toBool())
            availableGeometry = tlw->screen()->availableVirtualGeometry();
        else
            availableGeometry = QWidgetPrivate::availableScreenGeometry(tlw);
    }
    else {
        const QWidget *tlwParent = tlw->parentWidget();
        // Check if tlw is inside QAbstractScrollArea/QScrollArea.
        // If that's the case tlw->parentWidget() will return the viewport
        // and tlw->parentWidget()->parentWidget() will return the scroll area.
#if QT_CONFIG(scrollarea)
        QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea *>(tlwParent->parentWidget());
        if (scrollArea) {
            hasHorizontalSizeConstraint = scrollArea->horizontalScrollBarPolicy() == Qt::ScrollBarAlwaysOff;
            hasVerticalSizeConstraint = scrollArea->verticalScrollBarPolicy() == Qt::ScrollBarAlwaysOff;
        }
#endif // QT_CONFIG(scrollarea)
        availableGeometry = tlwParent->contentsRect();
    }
 
    // Find frame geometries, title bar height, and decoration sizes.
    const QRect frameGeometry = tlw->frameGeometry();
    const int titleBarHeight = qMax(tlw->geometry().y() - frameGeometry.y(), 0);
    const int bottomDecoration = qMax(frameGeometry.height() - tlw->height() - titleBarHeight, 0);
    const int leftRightDecoration = qMax((frameGeometry.width() - tlw->width()) / 2, 0);
 
    // Determine dyMax depending on whether the sizegrip is at the bottom
    // of the widget or not.
    if (d->atBottom()) {
        if (hasVerticalSizeConstraint)
            d->dyMax = availableGeometry.bottom() - d->r.bottom() - bottomDecoration;
        else
            d->dyMax = INT_MAX;
    } else {
        if (hasVerticalSizeConstraint)
            d->dyMax = availableGeometry.y() - d->r.y() + titleBarHeight;
        else
            d->dyMax = -INT_MAX;
    }
 
    // In RTL mode, the size grip is to the left; find dxMax from the desktop/workspace
    // geometry, the size grip geometry and the width of the decoration.
    if (d->atLeft()) {
        if (hasHorizontalSizeConstraint)
            d->dxMax = availableGeometry.x() - d->r.x() + leftRightDecoration;
        else
            d->dxMax = -INT_MAX;
    } else {
        if (hasHorizontalSizeConstraint)
            d->dxMax = availableGeometry.right() - d->r.right() - leftRightDecoration;
        else
            d->dxMax = INT_MAX;
    }
}
 
 
void QSizeGrip::mouseMoveEvent(QMouseEvent * e)
{
    Q_D(QSizeGrip);
    if (e->buttons() != Qt::LeftButton || d->m_platformSizeGrip) {
        QWidget::mouseMoveEvent(e);
        return;
    }
 
    QWidget* tlw = qt_sizegrip_topLevelWidget(this);
    if (!d->gotMousePress || tlw->testAttribute(Qt::WA_WState_ConfigPending))
        return;
 
    QPoint np(e->globalPosition().toPoint());
 
    // Don't extend beyond the available geometry; bound to dyMax and dxMax.
    QSize ns;
    if (d->atBottom())
        ns.rheight() = d->r.height() + qMin(np.y() - d->p.y(), d->dyMax);
    else
        ns.rheight() = d->r.height() - qMax(np.y() - d->p.y(), d->dyMax);
 
    if (d->atLeft())
        ns.rwidth() = d->r.width() - qMax(np.x() - d->p.x(), d->dxMax);
    else
        ns.rwidth() = d->r.width() + qMin(np.x() - d->p.x(), d->dxMax);
 
    ns = QLayout::closestAcceptableSize(tlw, ns);
 
    QPoint p;
    QRect nr(p, ns);
    if (d->atBottom()) {
        if (d->atLeft())
            nr.moveTopRight(d->r.topRight());
        else
            nr.moveTopLeft(d->r.topLeft());
    } else {
        if (d->atLeft())
            nr.moveBottomRight(d->r.bottomRight());
        else
            nr.moveBottomLeft(d->r.bottomLeft());
    }
 
    tlw->setGeometry(nr);
}
 
void QSizeGrip::mouseReleaseEvent(QMouseEvent *mouseEvent)
{
    if (mouseEvent->button() == Qt::LeftButton) {
        Q_D(QSizeGrip);
        d->gotMousePress = false;
        d->p = QPoint();
    } else {
        QWidget::mouseReleaseEvent(mouseEvent);
    }
}
 
void QSizeGrip::moveEvent(QMoveEvent * /*moveEvent*/)
{
    Q_D(QSizeGrip);
    // We're inside a resize operation; no update necessary.
    if (!d->p.isNull())
        return;
 
    d->m_corner = d->corner();
#if !defined(QT_NO_CURSOR)
    setCursor(d->m_corner == Qt::TopLeftCorner || d->m_corner == Qt::BottomRightCorner
              ? Qt::SizeFDiagCursor : Qt::SizeBDiagCursor);
#endif
}
 
void QSizeGrip::showEvent(QShowEvent *showEvent)
{
    QWidget::showEvent(showEvent);
}
 
void QSizeGrip::hideEvent(QHideEvent *hideEvent)
{
    QWidget::hideEvent(hideEvent);
}
 
void QSizeGrip::setVisible(bool visible)
{
    QWidget::setVisible(visible);
}
 
bool QSizeGrip::eventFilter(QObject *o, QEvent *e)
{
    Q_D(QSizeGrip);
    if ((isHidden() && testAttribute(Qt::WA_WState_ExplicitShowHide))
        || e->type() != QEvent::WindowStateChange
        || o != d->tlw) {
        return QWidget::eventFilter(o, e);
    }
    Qt::WindowStates sizeGripNotVisibleState = Qt::WindowFullScreen;
    sizeGripNotVisibleState |= Qt::WindowMaximized;
    // Don't show the size grip if the tlw is maximized or in full screen mode.
    setVisible(!(d->tlw->windowState() & sizeGripNotVisibleState));
    setAttribute(Qt::WA_WState_ExplicitShowHide, false);
    return QWidget::eventFilter(o, e);
}
 
bool QSizeGrip::event(QEvent *event)
{
    return QWidget::event(event);
}
 
QT_END_NAMESPACE
 
#include "moc_qsizegrip.cpp"