qdockwidget.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 "qdockwidget.h"
 
#include <qaction.h>
#include <qapplication.h>
#include <qdrawutil.h>
#include <qevent.h>
#include <qfontmetrics.h>
#include <qproxystyle.h>
#include <qwindow.h>
#include <qscreen.h>
#include <qmainwindow.h>
#include <qstylepainter.h>
#include <qtoolbutton.h>
#include <qdebug.h>
 
#include <private/qwidgetresizehandler_p.h>
#include <private/qstylesheetstyle_p.h>
#include <qpa/qplatformtheme.h>
 
#include <private/qhighdpiscaling_p.h>
#include "qdockwidget_p.h"
#include "qmainwindowlayout_p.h"
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
extern QString qt_setWindowTitle_helperHelper(const QString&, const QWidget*); // qwidget.cpp
 
// qmainwindow.cpp
extern QMainWindowLayout *qt_mainwindow_layout(const QMainWindow *window);
 
static const QMainWindow *mainwindow_from_dock(const QDockWidget *dock)
{
    for (const QWidget *p = dock->parentWidget(); p; p = p->parentWidget()) {
        if (const QMainWindow *window = qobject_cast<const QMainWindow*>(p))
            return window;
    }
    return nullptr;
}
 
static inline QMainWindowLayout *qt_mainwindow_layout_from_dock(const QDockWidget *dock)
{
    auto mainWindow = mainwindow_from_dock(dock);
    return mainWindow ? qt_mainwindow_layout(mainWindow) : nullptr;
}
 
static inline bool hasFeature(const QDockWidgetPrivate *priv, QDockWidget::DockWidgetFeature feature)
{ return (priv->features & feature) == feature; }
 
static inline bool hasFeature(const QDockWidget *dockwidget, QDockWidget::DockWidgetFeature feature)
{ return (dockwidget->features() & feature) == feature; }
 
 
/*
    A Dock Window:
 
    [+] is the float button
    [X] is the close button
 
    +-------------------------------+
    | Dock Window Title       [+][X]|
    +-------------------------------+
    |                               |
    | place to put the single       |
    | QDockWidget child (this space |
    | does not yet have a name)     |
    |                               |
    |                               |
    |                               |
    |                               |
    |                               |
    |                               |
    |                               |
    |                               |
    |                               |
    +-------------------------------+
 
*/
 
/******************************************************************************
** QDockWidgetTitleButton
*/
 
class QDockWidgetTitleButton : public QAbstractButton
{
    Q_OBJECT
 
public:
    QDockWidgetTitleButton(QDockWidget *dockWidget);
 
    QSize sizeHint() const override;
    QSize minimumSizeHint() const override
    { return sizeHint(); }
 
    void enterEvent(QEnterEvent *event) override;
    void leaveEvent(QEvent *event) override;
    void paintEvent(QPaintEvent *event) override;
 
protected:
    bool event(QEvent *event) override;
 
private:
    QSize dockButtonIconSize() const;
 
    mutable int m_iconSize = -1;
};
 
QDockWidgetTitleButton::QDockWidgetTitleButton(QDockWidget *dockWidget)
    : QAbstractButton(dockWidget)
{
    setFocusPolicy(Qt::NoFocus);
}
 
bool QDockWidgetTitleButton::event(QEvent *event)
{
    switch (event->type()) {
    case QEvent::StyleChange:
    case QEvent::DevicePixelRatioChange:
        m_iconSize = -1;
        break;
    default:
        break;
    }
    return QAbstractButton::event(event);
}
 
QSize QDockWidgetTitleButton::dockButtonIconSize() const
{
    if (m_iconSize < 0) {
        m_iconSize = style()->pixelMetric(QStyle::PM_SmallIconSize, nullptr, this);
        if (style()->styleHint(QStyle::SH_DockWidget_ButtonsHaveFrame, nullptr, this))
            m_iconSize = (m_iconSize * 5) / 8;  // 16 -> 10
    }
    return QSize(m_iconSize, m_iconSize);
}
 
QSize QDockWidgetTitleButton::sizeHint() const
{
    ensurePolished();
 
    int size = 2*style()->pixelMetric(QStyle::PM_DockWidgetTitleBarButtonMargin, nullptr, this);
    if (!icon().isNull()) {
        const QSize sz = icon().actualSize(dockButtonIconSize());
        size += qMax(sz.width(), sz.height());
    }
 
    return QSize(size, size);
}
 
void QDockWidgetTitleButton::enterEvent(QEnterEvent *event)
{
    if (isEnabled()) update();
    QAbstractButton::enterEvent(event);
}
 
void QDockWidgetTitleButton::leaveEvent(QEvent *event)
{
    if (isEnabled()) update();
    QAbstractButton::leaveEvent(event);
}
 
void QDockWidgetTitleButton::paintEvent(QPaintEvent *)
{
    QStylePainter p(this);
 
    QStyleOptionToolButton opt;
    opt.initFrom(this);
    opt.state |= QStyle::State_AutoRaise;
 
    if (style()->styleHint(QStyle::SH_DockWidget_ButtonsHaveFrame, nullptr, this)) {
        if (isEnabled() && underMouse() && !isChecked() && !isDown())
            opt.state |= QStyle::State_Raised;
        if (isChecked())
            opt.state |= QStyle::State_On;
        if (isDown())
            opt.state |= QStyle::State_Sunken;
        p.drawPrimitive(QStyle::PE_PanelButtonTool, opt);
    } else if (isDown() || isChecked()) {
        // no frame, but the icon might have explicit pixmaps for QIcon::On
        opt.state |= QStyle::State_On | QStyle::State_Sunken;
    }
 
    opt.icon = icon();
    opt.subControls = { };
    opt.activeSubControls = { };
    opt.features = QStyleOptionToolButton::None;
    opt.arrowType = Qt::NoArrow;
    opt.iconSize = dockButtonIconSize();
    p.drawComplexControl(QStyle::CC_ToolButton, opt);
}
 
/******************************************************************************
** QDockWidgetLayout
*/
 
QDockWidgetLayout::QDockWidgetLayout(QWidget *parent)
    : QLayout(parent), verticalTitleBar(false), item_list(RoleCount, 0)
{
}
 
QDockWidgetLayout::~QDockWidgetLayout()
{
    qDeleteAll(item_list);
}
 
bool QDockWidgetLayout::nativeWindowDeco() const
{
    bool floating = parentWidget()->isWindow();
#if QT_CONFIG(tabbar)
    if (auto groupWindow =
            qobject_cast<const QDockWidgetGroupWindow *>(parentWidget()->parentWidget()))
        floating = floating || groupWindow->tabLayoutInfo();
#endif
    return nativeWindowDeco(floating);
}
 
bool QDockWidgetLayout::wmSupportsNativeWindowDeco()
{
#if defined(Q_OS_ANDROID)
    return false;
#else
    static const bool xcb = !QGuiApplication::platformName().compare("xcb"_L1, Qt::CaseInsensitive);
    static const bool wayland =
            QGuiApplication::platformName().startsWith("wayland"_L1, Qt::CaseInsensitive);
    return !(xcb || wayland);
#endif
}
 
bool QDockWidgetLayout::nativeWindowDeco(bool floating) const
{
    return wmSupportsNativeWindowDeco() && floating && item_list.at(QDockWidgetLayout::TitleBar) == nullptr;
}
 
 
void QDockWidgetLayout::addItem(QLayoutItem*)
{
    qWarning("QDockWidgetLayout::addItem(): please use QDockWidgetLayout::setWidget()");
    return;
}
 
QLayoutItem *QDockWidgetLayout::itemAt(int index) const
{
    int cnt = 0;
    for (int i = 0; i < item_list.size(); ++i) {
        QLayoutItem *item = item_list.at(i);
        if (item == nullptr)
            continue;
        if (index == cnt++)
            return item;
    }
    return nullptr;
}
 
QLayoutItem *QDockWidgetLayout::takeAt(int index)
{
    int j = 0;
    for (int i = 0; i < item_list.size(); ++i) {
        QLayoutItem *item = item_list.at(i);
        if (item == nullptr)
            continue;
        if (index == j) {
            item_list[i] = 0;
            invalidate();
            return item;
        }
        ++j;
    }
    return nullptr;
}
 
int QDockWidgetLayout::count() const
{
    int result = 0;
    for (int i = 0; i < item_list.size(); ++i) {
        if (item_list.at(i))
            ++result;
    }
    return result;
}
 
QSize QDockWidgetLayout::sizeFromContent(const QSize &content, bool floating) const
{
    QSize result = content;
 
    if (verticalTitleBar) {
        result.setHeight(qMax(result.height(), minimumTitleWidth()));
        result.setWidth(qMax(content.width(), 0));
    } else {
        result.setHeight(qMax(result.height(), 0));
        result.setWidth(qMax(content.width(), minimumTitleWidth()));
    }
 
    QDockWidget *w = qobject_cast<QDockWidget*>(parentWidget());
    const bool nativeDeco = nativeWindowDeco(floating);
 
    int fw = floating && !nativeDeco
            ? w->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, nullptr, w)
            : 0;
 
    const int th = titleHeight();
    if (!nativeDeco) {
        if (verticalTitleBar)
            result += QSize(th + 2*fw, 2*fw);
        else
            result += QSize(2*fw, th + 2*fw);
    }
 
    result.setHeight(qMin(result.height(), (int) QWIDGETSIZE_MAX));
    result.setWidth(qMin(result.width(), (int) QWIDGETSIZE_MAX));
 
    if (content.width() < 0)
        result.setWidth(-1);
    if (content.height() < 0)
        result.setHeight(-1);
 
    const QMargins margins = w->contentsMargins();
    //we need to subtract the contents margin (it will be added by the caller)
    QSize min = w->minimumSize().shrunkBy(margins);
    QSize max = w->maximumSize().shrunkBy(margins);
 
    /* A floating dockwidget will automatically get its minimumSize set to the layout's
       minimum size + deco. We're *not* interested in this, we only take minimumSize()
       into account if the user set it herself. Otherwise we end up expanding the result
       of a calculation for a non-floating dock widget to a floating dock widget's
       minimum size + window decorations. */
 
    uint explicitMin = 0;
    uint explicitMax = 0;
    if (w->d_func()->extra != nullptr) {
        explicitMin = w->d_func()->extra->explicitMinSize;
        explicitMax = w->d_func()->extra->explicitMaxSize;
    }
 
    if (!(explicitMin & Qt::Horizontal) || min.width() == 0)
        min.setWidth(-1);
    if (!(explicitMin & Qt::Vertical) || min.height() == 0)
        min.setHeight(-1);
 
    if (!(explicitMax & Qt::Horizontal))
        max.setWidth(QWIDGETSIZE_MAX);
    if (!(explicitMax & Qt::Vertical))
        max.setHeight(QWIDGETSIZE_MAX);
 
    return result.boundedTo(max).expandedTo(min);
}
 
QSize QDockWidgetLayout::sizeHint() const
{
    QDockWidget *w = qobject_cast<QDockWidget*>(parentWidget());
 
    QSize content(-1, -1);
    if (item_list[Content] != 0)
        content = item_list[Content]->sizeHint();
 
    return sizeFromContent(content, w->isFloating());
}
 
QSize QDockWidgetLayout::maximumSize() const
{
    if (item_list[Content] != 0) {
        const QSize content = item_list[Content]->maximumSize();
        return sizeFromContent(content, parentWidget()->isWindow());
    } else {
        return parentWidget()->maximumSize();
    }
 
}
 
QSize QDockWidgetLayout::minimumSize() const
{
    QDockWidget *w = qobject_cast<QDockWidget*>(parentWidget());
 
    QSize content(0, 0);
    if (item_list[Content] != 0)
        content = item_list[Content]->minimumSize();
 
    return sizeFromContent(content, w->isFloating());
}
 
QWidget *QDockWidgetLayout::widgetForRole(Role r) const
{
    QLayoutItem *item = item_list.at(r);
    return item == nullptr ? nullptr : item->widget();
}
 
QLayoutItem *QDockWidgetLayout::itemForRole(Role r) const
{
    return item_list.at(r);
}
 
void QDockWidgetLayout::setWidgetForRole(Role r, QWidget *w)
{
    QWidget *old = widgetForRole(r);
    if (old != nullptr) {
        old->hide();
        removeWidget(old);
    }
 
    if (w != nullptr) {
        addChildWidget(w);
        item_list[r] = new QWidgetItemV2(w);
        w->show();
    } else {
        item_list[r] = 0;
    }
 
    invalidate();
}
 
static inline int pick(bool vertical, const QSize &size)
{
    return vertical ? size.height() : size.width();
}
 
static inline int perp(bool vertical, const QSize &size)
{
    return vertical ? size.width() : size.height();
}
 
int QDockWidgetLayout::minimumTitleWidth() const
{
    QDockWidget *q = qobject_cast<QDockWidget*>(parentWidget());
 
    if (QWidget *title = widgetForRole(TitleBar))
        return pick(verticalTitleBar, title->minimumSizeHint());
 
    QSize closeSize(0, 0);
    QSize floatSize(0, 0);
    if (hasFeature(q, QDockWidget::DockWidgetClosable)) {
        if (QLayoutItem *item = item_list[CloseButton])
            closeSize = item->widget()->sizeHint();
    }
    if (hasFeature(q, QDockWidget::DockWidgetFloatable)) {
        if (QLayoutItem *item = item_list[FloatButton])
            floatSize = item->widget()->sizeHint();
    }
 
    int titleHeight = this->titleHeight();
 
    int mw = q->style()->pixelMetric(QStyle::PM_DockWidgetTitleMargin, nullptr, q);
    int fw = q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, nullptr, q);
 
    return pick(verticalTitleBar, closeSize)
            + pick(verticalTitleBar, floatSize)
            + titleHeight + 2*fw + 3*mw;
}
 
int QDockWidgetLayout::titleHeight() const
{
    QDockWidget *q = qobject_cast<QDockWidget*>(parentWidget());
 
    if (QWidget *title = widgetForRole(TitleBar))
        return perp(verticalTitleBar, title->sizeHint());
 
    QSize closeSize(0, 0);
    QSize floatSize(0, 0);
    if (QLayoutItem *item = item_list[CloseButton])
        closeSize = item->widget()->sizeHint();
    if (QLayoutItem *item = item_list[FloatButton])
        floatSize = item->widget()->sizeHint();
 
    int buttonHeight = qMax(perp(verticalTitleBar, closeSize),
                            perp(verticalTitleBar, floatSize));
 
    QFontMetrics titleFontMetrics = q->fontMetrics();
    int mw = q->style()->pixelMetric(QStyle::PM_DockWidgetTitleMargin, nullptr, q);
 
    return qMax(buttonHeight + 2, titleFontMetrics.height() + 2*mw);
}
 
void QDockWidgetLayout::setGeometry(const QRect &geometry)
{
    QDockWidget *q = qobject_cast<QDockWidget*>(parentWidget());
 
    bool nativeDeco = nativeWindowDeco();
 
    int fw = q->isFloating() && !nativeDeco
            ? q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, nullptr, q)
            : 0;
 
    if (nativeDeco) {
        if (QLayoutItem *item = item_list[Content])
            item->setGeometry(geometry);
    } else {
        int titleHeight = this->titleHeight();
 
        if (verticalTitleBar) {
            _titleArea = QRect(QPoint(fw, fw),
                                QSize(titleHeight, geometry.height() - (fw * 2)));
        } else {
            _titleArea = QRect(QPoint(fw, fw),
                                QSize(geometry.width() - (fw * 2), titleHeight));
        }
 
        if (QLayoutItem *item = item_list[TitleBar]) {
            item->setGeometry(_titleArea);
        } else {
            QStyleOptionDockWidget opt;
            q->initStyleOption(&opt);
 
            if (QLayoutItem *item = item_list[CloseButton]) {
                if (!item->isEmpty()) {
                    QRect r = q->style()
                        ->subElementRect(QStyle::SE_DockWidgetCloseButton,
                                            &opt, q);
                    if (!r.isNull())
                        item->setGeometry(r);
                }
            }
 
            if (QLayoutItem *item = item_list[FloatButton]) {
                if (!item->isEmpty()) {
                    QRect r = q->style()
                        ->subElementRect(QStyle::SE_DockWidgetFloatButton,
                                            &opt, q);
                    if (!r.isNull())
                        item->setGeometry(r);
                }
            }
        }
 
        if (QLayoutItem *item = item_list[Content]) {
            QRect r = geometry;
            if (verticalTitleBar) {
                r.setLeft(_titleArea.right() + 1);
                r.adjust(0, fw, -fw, -fw);
            } else {
                r.setTop(_titleArea.bottom() + 1);
                r.adjust(fw, 0, -fw, -fw);
            }
            item->setGeometry(r);
        }
    }
}
 
void QDockWidgetLayout::setVerticalTitleBar(bool b)
{
    if (b == verticalTitleBar)
        return;
    verticalTitleBar = b;
    invalidate();
    parentWidget()->update();
}
 
/******************************************************************************
** QDockWidgetItem
*/
 
QDockWidgetItem::QDockWidgetItem(QDockWidget *dockWidget)
    : QWidgetItem(dockWidget)
{
}
 
QSize QDockWidgetItem::minimumSize() const
{
    QSize widgetMin(0, 0);
    if (QLayoutItem *item = dockWidgetChildItem())
        widgetMin = item->minimumSize();
    return dockWidgetLayout()->sizeFromContent(widgetMin, false);
}
 
QSize QDockWidgetItem::maximumSize() const
{
    if (QLayoutItem *item = dockWidgetChildItem()) {
        return dockWidgetLayout()->sizeFromContent(item->maximumSize(), false);
    } else {
        return QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
    }
}
 
 
QSize QDockWidgetItem::sizeHint() const
{
    if (QLayoutItem *item = dockWidgetChildItem()) {
         return dockWidgetLayout()->sizeFromContent(item->sizeHint(), false);
    } else {
        return QWidgetItem::sizeHint();
    }
}
 
/******************************************************************************
** QDockWidgetPrivate
*/
 
void QDockWidgetPrivate::init()
{
    Q_Q(QDockWidget);
 
    QDockWidgetLayout *layout = new QDockWidgetLayout(q);
    layout->setSizeConstraint(QLayout::SetMinAndMaxSize);
 
    QAbstractButton *button = new QDockWidgetTitleButton(q);
    button->setObjectName("qt_dockwidget_floatbutton"_L1);
    QObjectPrivate::connect(button, &QAbstractButton::clicked,
                            this, &QDockWidgetPrivate::toggleTopLevel);
    layout->setWidgetForRole(QDockWidgetLayout::FloatButton, button);
 
    button = new QDockWidgetTitleButton(q);
    button->setObjectName("qt_dockwidget_closebutton"_L1);
    QObject::connect(button, &QAbstractButton::clicked, q, &QDockWidget::close);
    layout->setWidgetForRole(QDockWidgetLayout::CloseButton, button);
 
    font = QApplication::font("QDockWidgetTitle");
 
#ifndef QT_NO_ACTION
    toggleViewAction = new QAction(q);
    toggleViewAction->setCheckable(true);
    toggleViewAction->setMenuRole(QAction::NoRole);
    fixedWindowTitle = qt_setWindowTitle_helperHelper(q->windowTitle(), q);
    toggleViewAction->setText(fixedWindowTitle);
    QObjectPrivate::connect(toggleViewAction, &QAction::triggered,
                            this, &QDockWidgetPrivate::toggleView);
#endif
 
    updateButtons();
}
 
void QDockWidget::initStyleOption(QStyleOptionDockWidget *option) const
{
    Q_D(const QDockWidget);
 
    if (!option)
        return;
    QDockWidgetLayout *dwlayout = qobject_cast<QDockWidgetLayout*>(layout());
 
    QDockWidgetGroupWindow *floatingTab = qobject_cast<QDockWidgetGroupWindow*>(parent());
    // If we are in a floating tab, init from the parent because the attributes and the geometry
    // of the title bar should be taken from the floating window.
    option->initFrom(floatingTab && !isFloating() ? parentWidget() : this);
    option->rect = dwlayout->titleArea();
    option->title = d->fixedWindowTitle;
    option->closable = hasFeature(this, QDockWidget::DockWidgetClosable);
    option->movable = hasFeature(this, QDockWidget::DockWidgetMovable);
    option->floatable = hasFeature(this, QDockWidget::DockWidgetFloatable);
 
    QDockWidgetLayout *l = qobject_cast<QDockWidgetLayout*>(layout());
    option->verticalTitleBar = l->verticalTitleBar;
}
 
void QDockWidgetPrivate::toggleView(bool b)
{
    Q_Q(QDockWidget);
    if (b == q->isHidden()) {
        if (b)
            q->show();
        else
            q->close();
    }
}
 
void QDockWidgetPrivate::updateButtons()
{
    Q_Q(QDockWidget);
    QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout);
 
    QStyleOptionDockWidget opt;
    q->initStyleOption(&opt);
 
    bool customTitleBar = dwLayout->widgetForRole(QDockWidgetLayout::TitleBar) != nullptr;
    bool nativeDeco = dwLayout->nativeWindowDeco();
    bool hideButtons = nativeDeco || customTitleBar;
 
    bool canClose = hasFeature(this, QDockWidget::DockWidgetClosable);
    bool canFloat = hasFeature(this, QDockWidget::DockWidgetFloatable);
 
    QAbstractButton *button
        = qobject_cast<QAbstractButton*>(dwLayout->widgetForRole(QDockWidgetLayout::FloatButton));
    button->setIcon(q->style()->standardIcon(QStyle::SP_TitleBarNormalButton, &opt, q));
    button->setVisible(canFloat && !hideButtons);
#if QT_CONFIG(accessibility)
    //: Accessible name for button undocking a dock widget (floating state)
    button->setAccessibleName(QDockWidget::tr("Float"));
    button->setAccessibleDescription(QDockWidget::tr("Undocks and re-attaches the dock widget"));
#endif
    button
        = qobject_cast <QAbstractButton*>(dwLayout->widgetForRole(QDockWidgetLayout::CloseButton));
    button->setIcon(q->style()->standardIcon(QStyle::SP_TitleBarCloseButton, &opt, q));
    button->setVisible(canClose && !hideButtons);
#if QT_CONFIG(accessibility)
    //: Accessible name for button closing a dock widget
    button->setAccessibleName(QDockWidget::tr("Close"));
    button->setAccessibleDescription(QDockWidget::tr("Closes the dock widget"));
#endif
 
    layout->invalidate();
}
 
void QDockWidgetPrivate::toggleTopLevel()
{
    Q_Q(QDockWidget);
    q->setFloating(!q->isFloating());
}
 
void QDockWidgetPrivate::initDrag(const QPoint &pos, bool nca)
{
    Q_Q(QDockWidget);
 
    if (state != nullptr)
        return;
 
    QMainWindowLayout *layout = qt_mainwindow_layout_from_dock(q);
    Q_ASSERT(layout != nullptr);
    if (layout->pluggingWidget != nullptr) // the main window is animating a docking operation
        return;
 
    state = new QDockWidgetPrivate::DragState;
    state->pressPos = pos;
    state->globalPressPos = q->mapToGlobal(pos);
    state->widgetInitialPos = q->isFloating() ? q->pos() : q->mapToGlobal(QPoint(0, 0));
    state->dragging = false;
    state->widgetItem = nullptr;
    state->ownWidgetItem = false;
    state->nca = nca;
    state->ctrlDrag = false;
}
 
void QDockWidgetPrivate::startDrag(DragScope scope)
{
    Q_Q(QDockWidget);
 
    if (state == nullptr || state->dragging)
        return;
 
    QMainWindowLayout *layout = qt_mainwindow_layout_from_dock(q);
    Q_ASSERT(layout != nullptr);
 
#if QT_CONFIG(draganddrop)
    bool wasFloating = q->isFloating();
#endif
 
    state->widgetItem = layout->unplug(q, scope);
    if (state->widgetItem == nullptr) {
        /*  Dock widget has a QMainWindow parent, but was never inserted with
            QMainWindow::addDockWidget, so the QMainWindowLayout has no
            widget item for it. It will be newly created and deleted if it doesn't
            get dropped into a dock area. */
        QDockWidgetGroupWindow *floatingTab = qobject_cast<QDockWidgetGroupWindow*>(parent);
        if (floatingTab && !q->isFloating())
            state->widgetItem = new QDockWidgetGroupWindowItem(floatingTab);
        else
            state->widgetItem = new QDockWidgetItem(q);
        state->ownWidgetItem = true;
    }
 
    if (state->ctrlDrag)
        layout->restore();
 
    state->dragging = true;
 
#if QT_CONFIG(draganddrop)
    if (QMainWindowLayout::needsPlatformDrag()) {
        Qt::DropAction result =
                layout->performPlatformWidgetDrag(state->widgetItem, state->pressPos);
        if (result == Qt::IgnoreAction && !wasFloating) {
            layout->revert(state->widgetItem);
            delete state;
            state = nullptr;
        } else {
            endDrag(QDockWidgetPrivate::EndDragMode::LocationChange);
        }
    }
#endif
}
 
void QDockWidgetPrivate::endDrag(EndDragMode mode)
{
    Q_Q(QDockWidget);
    Q_ASSERT(state != nullptr);
 
    q->releaseMouse();
 
    if (state->dragging) {
        const QMainWindow *mainWindow = mainwindow_from_dock(q);
        Q_ASSERT(mainWindow != nullptr);
        QMainWindowLayout *mwLayout = qt_mainwindow_layout(mainWindow);
 
        // if mainWindow is being deleted in an ongoing drag, make it a no-op instead of crashing
        if (!mwLayout)
            return;
 
        if (mode == EndDragMode::Abort || !mwLayout->plug(state->widgetItem)) {
            if (hasFeature(this, QDockWidget::DockWidgetFloatable)) {
                // This QDockWidget will now stay in the floating state.
                if (state->ownWidgetItem) {
                    delete state->widgetItem;
                    state->widgetItem = nullptr;
                }
                mwLayout->restore();
                QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout);
                if (!dwLayout->nativeWindowDeco()) {
                    // get rid of the X11BypassWindowManager window flag and activate the resizer
                    Qt::WindowFlags flags = q->windowFlags();
                    flags &= ~Qt::X11BypassWindowManagerHint;
                    q->setWindowFlags(flags);
                    setResizerActive(q->isFloating());
                    q->show();
                } else {
                    setResizerActive(false);
                }
                if (q->isFloating()) { // Might not be floating when dragging a QDockWidgetGroupWindow
                    undockedGeometry = q->geometry();
#if QT_CONFIG(tabwidget)
                    // is the widget located within the mainwindow?
                    const Qt::DockWidgetArea area = mainWindow->dockWidgetArea(q);
                    if (area != Qt::NoDockWidgetArea) {
                        tabPosition = mwLayout->tabPosition(area);
                    } else if (auto dwgw = qobject_cast<QDockWidgetGroupWindow *>(q->parent())) {
                        // DockWidget wasn't found in one of the docks within mainwindow
                        // => derive tabPosition from parent
                        tabPosition = mwLayout->tabPosition(toDockWidgetArea(dwgw->layoutInfo()->dockPos));
                    }
#endif
                    // Reparent, if the drag was out of a dock widget group window
                    if (mode == EndDragMode::LocationChange) {
                        if (auto *groupWindow = qobject_cast<QDockWidgetGroupWindow *>(q->parentWidget()))
                            groupWindow->reparent(q);
                    }
                }
                q->activateWindow();
            } else {
                // The tab was not plugged back in the QMainWindow but the QDockWidget cannot
                // stay floating, revert to the previous state.
                mwLayout->revert(state->widgetItem);
            }
        }
    }
    delete state;
    state = nullptr;
}
 
Qt::DockWidgetArea QDockWidgetPrivate::toDockWidgetArea(QInternal::DockPosition pos)
{
    switch (pos) {
    case QInternal::LeftDock:   return Qt::LeftDockWidgetArea;
    case QInternal::RightDock:  return Qt::RightDockWidgetArea;
    case QInternal::TopDock:    return Qt::TopDockWidgetArea;
    case QInternal::BottomDock: return Qt::BottomDockWidgetArea;
    default: break;
    }
    return Qt::NoDockWidgetArea;
}
 
void QDockWidgetPrivate::setResizerActive(bool active)
{
    Q_Q(QDockWidget);
    const auto *dwLayout = qobject_cast<QDockWidgetLayout *>(layout);
    if (dwLayout->nativeWindowDeco(q->isFloating()))
        return;
 
    if (active && !resizer)
        resizer = new QWidgetResizeHandler(q);
    if (resizer)
        resizer->setEnabled(active);
}
 
bool QDockWidgetPrivate::isAnimating() const
{
    Q_Q(const QDockWidget);
 
    QMainWindowLayout *mainWinLayout = qt_mainwindow_layout_from_dock(q);
    if (mainWinLayout == nullptr)
        return false;
 
    return (const void*)mainWinLayout->pluggingWidget == (const void*)q;
}
 
bool QDockWidgetPrivate::mousePressEvent(QMouseEvent *event)
{
#if QT_CONFIG(mainwindow)
    Q_Q(QDockWidget);
 
    QDockWidgetLayout *dwLayout
        = qobject_cast<QDockWidgetLayout*>(layout);
 
    if (!dwLayout->nativeWindowDeco()) {
        QRect titleArea = dwLayout->titleArea();
 
        QDockWidgetGroupWindow *floatingTab = qobject_cast<QDockWidgetGroupWindow*>(parent);
 
        if (event->button() != Qt::LeftButton ||
            !titleArea.contains(event->position().toPoint()) ||
            // check if the tool window is movable... do nothing if it
            // is not (but allow moving if the window is floating)
            (!hasFeature(this, QDockWidget::DockWidgetMovable) && !q->isFloating()) ||
            (qobject_cast<QMainWindow*>(parent) == nullptr && !floatingTab) ||
            isAnimating() || state != nullptr) {
            return false;
        }
 
        initDrag(event->position().toPoint(), false);
 
        if (state)
            state->ctrlDrag = (hasFeature(this, QDockWidget::DockWidgetFloatable) && event->modifiers() & Qt::ControlModifier) ||
                              (!hasFeature(this, QDockWidget::DockWidgetMovable) && q->isFloating());
 
        return true;
    }
 
#endif // QT_CONFIG(mainwindow)
    return false;
}
 
bool QDockWidgetPrivate::mouseDoubleClickEvent(QMouseEvent *event)
{
    QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout);
 
    if (!dwLayout->nativeWindowDeco()) {
        QRect titleArea = dwLayout->titleArea();
 
        if (event->button() == Qt::LeftButton && titleArea.contains(event->position().toPoint()) &&
            hasFeature(this, QDockWidget::DockWidgetFloatable)) {
            toggleTopLevel();
            return true;
        }
    }
    return false;
}
 
bool QDockWidgetPrivate::isTabbed() const
{
    Q_Q(const QDockWidget);
    QDockWidget *that = const_cast<QDockWidget *>(q);
    auto *mwLayout = qt_mainwindow_layout_from_dock(that);
    Q_ASSERT(mwLayout);
    return mwLayout->isDockWidgetTabbed(q);
}
 
bool QDockWidgetPrivate::mouseMoveEvent(QMouseEvent *event)
{
    bool ret = false;
#if QT_CONFIG(mainwindow)
    Q_Q(QDockWidget);
 
    if (!state)
        return ret;
 
    QDockWidgetLayout *dwlayout
        = qobject_cast<QDockWidgetLayout *>(layout);
    QMainWindowLayout *mwlayout = qt_mainwindow_layout_from_dock(q);
    if (!dwlayout->nativeWindowDeco()) {
        if (!state->dragging
            && mwlayout->pluggingWidget == nullptr
            && (event->position().toPoint() - state->pressPos).manhattanLength()
                > QApplication::startDragDistance()) {
 
#ifdef Q_OS_MACOS
            if (windowHandle() && !q->isFloating()) {
                // When using native widgets on mac, we have not yet been successful in
                // starting a drag on an NSView that belongs to one window (QMainWindow),
                // but continue the drag on another (QDockWidget). This is what happens if
                // we try to make this widget floating during a drag. So as a fall back
                // solution, we simply make this widget floating instead, when we would
                // otherwise start a drag.
                q->setFloating(true);
            } else
#endif
            {
                const DragScope scope = isTabbed() ? DragScope::Group : DragScope::Widget;
                startDrag(scope);
                q->grabMouse();
                ret = true;
            }
        }
    }
 
    if (state && state->dragging && !state->nca) {
        QMargins windowMargins = q->window()->windowHandle()->frameMargins();
        QPoint windowMarginOffset = QPoint(windowMargins.left(), windowMargins.top());
 
        // TODO maybe use QScreen API (if/when available) to simplify the below code.
        const QScreen *orgWdgScreen = QGuiApplication::screenAt(state->widgetInitialPos);
        const QScreen *screenFrom = QGuiApplication::screenAt(state->globalPressPos);
        const QScreen *screenTo = QGuiApplication::screenAt(event->globalPosition().toPoint());
        const QScreen *wdgScreen = q->screen();
 
        QPoint pos;
        if (Q_LIKELY(screenFrom && screenTo && wdgScreen && orgWdgScreen)) {
            const QPoint nativeWdgOrgPos = QHighDpiScaling::mapPositionToNative(
                    state->widgetInitialPos, orgWdgScreen->handle());
            const QPoint nativeTo = QHighDpiScaling::mapPositionToNative(
                    event->globalPosition().toPoint(), screenTo->handle());
            const QPoint nativeFrom = QHighDpiScaling::mapPositionToNative(state->globalPressPos,
                                                                           screenFrom->handle());
 
            // Calculate new nativePos based on startPos + mouse delta move.
            const QPoint nativeNewPos = nativeWdgOrgPos + (nativeTo - nativeFrom);
            pos = QHighDpiScaling::mapPositionFromNative(nativeNewPos, wdgScreen->handle())
                    - windowMarginOffset;
        } else {
            // Fallback in the unlikely case that source and target screens could not be established
            qCDebug(lcQpaDockWidgets)
                    << "QDockWidget failed to find relevant screen info. screenFrom:" << screenFrom
                    << "screenTo:" << screenTo << " wdgScreen:" << wdgScreen << "orgWdgScreen"
                    << orgWdgScreen;
            pos = event->globalPosition().toPoint() - state->pressPos - windowMarginOffset;
        }
 
        // If the newly floating dock widget has got a native title bar,
        // offset the position by the native title bar's height or width
        const int dx = q->geometry().x() - q->x();
        const int dy = q->geometry().y() - q->y();
        pos.rx() += dx;
        pos.ry() += dy;
 
        QDockWidgetGroupWindow *floatingTab = qobject_cast<QDockWidgetGroupWindow*>(parent);
        if (floatingTab && !q->isFloating())
            floatingTab->move(pos);
        else
            q->move(pos);
        if (state && !state->ctrlDrag)
            mwlayout->hover(state->widgetItem, event->globalPosition().toPoint());
 
        ret = true;
    }
 
#endif // QT_CONFIG(mainwindow)
    return ret;
}
 
bool QDockWidgetPrivate::mouseReleaseEvent(QMouseEvent *event)
{
#if QT_CONFIG(mainwindow)
#if QT_CONFIG(draganddrop)
    // if we are peforming a platform drag ignore the release here and end the drag when the actual
    // drag ends.
    if (QMainWindowLayout::needsPlatformDrag())
        return false;
#endif
 
    if (event->button() == Qt::LeftButton && state && !state->nca) {
        endDrag(EndDragMode::LocationChange);
        return true; //filter out the event
    }
 
#endif // QT_CONFIG(mainwindow)
    return false;
}
 
void QDockWidgetPrivate::nonClientAreaMouseEvent(QMouseEvent *event)
{
    Q_Q(QDockWidget);
 
    int fw = q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, nullptr, q);
 
    QWidget *tl = q->topLevelWidget();
    QRect geo = tl->geometry();
    QRect titleRect = tl->frameGeometry();
    {
        titleRect.setLeft(geo.left());
        titleRect.setRight(geo.right());
        titleRect.setBottom(geo.top() - 1);
        titleRect.adjust(0, fw, 0, 0);
    }
 
    switch (event->type()) {
        case QEvent::NonClientAreaMouseButtonPress:
            if (!titleRect.contains(event->globalPosition().toPoint()))
                break;
            if (state != nullptr)
                break;
            if (qobject_cast<QMainWindow*>(parent) == nullptr && qobject_cast<QDockWidgetGroupWindow*>(parent) == nullptr)
                break;
            if (isAnimating())
                break;
            initDrag(event->position().toPoint(), true);
            if (state == nullptr)
                break;
            state->ctrlDrag = (event->modifiers() & Qt::ControlModifier) ||
                              (!hasFeature(this, QDockWidget::DockWidgetMovable) && q->isFloating());
            startDrag(DragScope::Group);
            break;
        case QEvent::NonClientAreaMouseMove:
            if (state == nullptr || !state->dragging)
                break;
 
#if !defined(Q_OS_MAC) && !defined(Q_OS_WASM)
            if (state->nca)
                endDrag(EndDragMode::LocationChange);
#endif
            break;
        case QEvent::NonClientAreaMouseButtonRelease:
#if defined(Q_OS_MAC) || defined(Q_OS_WASM)
                        if (state)
                            endDrag(EndDragMode::LocationChange);
#endif
                        break;
        case QEvent::NonClientAreaMouseButtonDblClick:
            toggleTopLevel();
            break;
        default:
            break;
    }
}
 
void QDockWidgetPrivate::recalculatePressPos(QResizeEvent *event)
{
    qreal ratio = event->oldSize().width() / (1.0 * event->size().width());
    state->pressPos.setX(state->pressPos.x() / ratio);
}
 
void QDockWidgetPrivate::moveEvent(QMoveEvent *event)
{
    Q_Q(QDockWidget);
 
    if (state == nullptr || !state->dragging || !state->nca)
        return;
 
    if (!q->isWindow() && qobject_cast<QDockWidgetGroupWindow*>(parent) == nullptr)
        return;
 
    // When the native window frame is being dragged, all we get is these mouse
    // move events.
 
    if (state->ctrlDrag)
        return;
 
    QMainWindowLayout *layout = qt_mainwindow_layout_from_dock(q);
    Q_ASSERT(layout != nullptr);
 
    QPoint globalMousePos = event->pos() + state->pressPos;
    layout->hover(state->widgetItem, globalMousePos);
}
 
void QDockWidgetPrivate::unplug(const QRect &rect)
{
    Q_Q(QDockWidget);
    QRect r = rect;
    r.moveTopLeft(q->mapToGlobal(QPoint(0, 0)));
    QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout);
    if (dwLayout->nativeWindowDeco(true))
        r.adjust(0, dwLayout->titleHeight(), 0, 0);
    setWindowState(true, true, r);
}
 
void QDockWidgetPrivate::plug(const QRect &rect)
{
    setWindowState(false, false, rect);
}
 
void QDockWidgetPrivate::setWindowState(bool floating, bool unplug, const QRect &rect)
{
    Q_Q(QDockWidget);
 
    if (!floating && parent) {
        QMainWindowLayout *mwlayout = qt_mainwindow_layout_from_dock(q);
        if (mwlayout && mwlayout->dockWidgetArea(q) == Qt::NoDockWidgetArea
                && !qobject_cast<QDockWidgetGroupWindow *>(parent))
            return; // this dockwidget can't be redocked
    }
 
    const bool wasFloating = q->isFloating();
    if (wasFloating) // Prevent repetitive unplugging from nested invocations (QTBUG-42818)
        unplug = false;
    const bool hidden = q->isHidden();
 
    if (q->isVisible())
        q->hide();
 
    Qt::WindowFlags flags = floating ? Qt::Tool : Qt::Widget;
 
    QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout);
    const bool nativeDeco = dwLayout->nativeWindowDeco(floating);
 
    if (nativeDeco) {
        flags |= Qt::CustomizeWindowHint | Qt::WindowTitleHint;
        if (hasFeature(this, QDockWidget::DockWidgetClosable))
            flags |= Qt::WindowCloseButtonHint;
    } else {
        flags |= Qt::FramelessWindowHint;
    }
 
#if QT_CONFIG(draganddrop)
    // If we are performing a platform drag the flag is not needed and we want to avoid recreating
    // the platform window when it would be removed later
    if (unplug && !QMainWindowLayout::needsPlatformDrag())
        flags |= Qt::X11BypassWindowManagerHint;
#endif
 
    q->setWindowFlags(flags);
 
 
    if (!rect.isNull())
            q->setGeometry(rect);
 
    updateButtons();
 
    if (!hidden)
        q->show();
 
    if (floating != wasFloating) {
        emit q->topLevelChanged(floating);
        if (!floating && parent) {
            QMainWindowLayout *mwlayout = qt_mainwindow_layout_from_dock(q);
            if (mwlayout)
                emit q->dockLocationChanged(mwlayout->dockWidgetArea(q));
        } else {
            emit q->dockLocationChanged(Qt::NoDockWidgetArea);
        }
    }
 
    setResizerActive(!unplug && floating && !nativeDeco);
}
 
QDockWidget::QDockWidget(QWidget *parent, Qt::WindowFlags flags)
    : QWidget(*new QDockWidgetPrivate, parent, flags)
{
    Q_D(QDockWidget);
    d->init();
}
 
QDockWidget::QDockWidget(const QString &title, QWidget *parent, Qt::WindowFlags flags)
    : QDockWidget(parent, flags)
{
    setWindowTitle(title);
}
 
QDockWidget::~QDockWidget()
{ }
 
QWidget *QDockWidget::widget() const
{
    QDockWidgetLayout *layout = qobject_cast<QDockWidgetLayout*>(this->layout());
    return layout->widgetForRole(QDockWidgetLayout::Content);
}
 
void QDockWidget::setWidget(QWidget *widget)
{
    QDockWidgetLayout *layout = qobject_cast<QDockWidgetLayout*>(this->layout());
    layout->setWidgetForRole(QDockWidgetLayout::Content, widget);
}
 
void QDockWidget::setFeatures(QDockWidget::DockWidgetFeatures features)
{
    Q_D(QDockWidget);
    features &= DockWidgetFeatureMask;
    if (d->features == features)
        return;
    const bool closableChanged = (d->features ^ features) & DockWidgetClosable;
    d->features = features;
    QDockWidgetLayout *layout
        = qobject_cast<QDockWidgetLayout*>(this->layout());
    layout->setVerticalTitleBar(features & DockWidgetVerticalTitleBar);
    d->updateButtons();
    d->toggleViewAction->setEnabled((d->features & DockWidgetClosable) == DockWidgetClosable);
    emit featuresChanged(d->features);
    update();
    if (closableChanged && layout->nativeWindowDeco()) {
        QDockWidgetGroupWindow *floatingTab = qobject_cast<QDockWidgetGroupWindow *>(parent());
        if (floatingTab && !isFloating())
            floatingTab->adjustFlags();
        else
            d->setWindowState(true /*floating*/, true /*unplug*/);  //this ensures the native decoration is drawn
    }
}
 
QDockWidget::DockWidgetFeatures QDockWidget::features() const
{
    Q_D(const QDockWidget);
    return d->features;
}
 
void QDockWidget::setFloating(bool floating)
{
    Q_D(QDockWidget);
 
    // the initial click of a double-click may have started a drag...
    if (d->state != nullptr)
        d->endDrag(QDockWidgetPrivate::EndDragMode::Abort);
 
    QRect r = d->undockedGeometry;
    // Keep position when undocking for the first time.
    if (floating && isVisible() && !r.isValid())
        r = QRect(mapToGlobal(QPoint(0, 0)), size());
 
    d->setWindowState(floating, false, floating ? r : QRect());
 
    if (floating && r.isNull()) {
        if (x() < 0 || y() < 0) //may happen if we have been hidden
            move(QPoint());
        setAttribute(Qt::WA_Moved, false); //we want it at the default position
    }
}
 
void QDockWidget::setAllowedAreas(Qt::DockWidgetAreas areas)
{
    Q_D(QDockWidget);
    areas &= Qt::DockWidgetArea_Mask;
    if (areas == d->allowedAreas)
        return;
    d->allowedAreas = areas;
    emit allowedAreasChanged(d->allowedAreas);
}
 
Qt::DockWidgetAreas QDockWidget::allowedAreas() const
{
    Q_D(const QDockWidget);
    return d->allowedAreas;
}
 
void QDockWidget::changeEvent(QEvent *event)
{
    Q_D(QDockWidget);
    QDockWidgetLayout *layout = qobject_cast<QDockWidgetLayout*>(this->layout());
 
    switch (event->type()) {
    case QEvent::WindowTitleChange:
        if (isFloating() && windowHandle() && d->topData() && windowHandle()->isVisible()) {
            // From QWidget::setWindowTitle(): Propagate window title without signal emission
            d->topData()->caption = windowHandle()->title();
            d->setWindowTitle_helper(windowHandle()->title());
        }
        Q_FALLTHROUGH();
    case QEvent::ModifiedChange:
        update(layout->titleArea());
#ifndef QT_NO_ACTION
        d->fixedWindowTitle = qt_setWindowTitle_helperHelper(windowTitle(), this);
        d->toggleViewAction->setText(d->fixedWindowTitle);
#endif
#if QT_CONFIG(tabbar)
        {
            if (QMainWindowLayout *winLayout = qt_mainwindow_layout_from_dock(this)) {
                if (QDockAreaLayoutInfo *info = winLayout->layoutState.dockAreaLayout.info(this))
                    info->updateTabBar();
            }
        }
#endif // QT_CONFIG(tabbar)
        break;
    default:
        break;
    }
    QWidget::changeEvent(event);
}
 
void QDockWidget::closeEvent(QCloseEvent *event)
{
    Q_D(QDockWidget);
    if (d->state)
        d->endDrag(QDockWidgetPrivate::EndDragMode::Abort);
 
    // For non-closable widgets, don't allow closing, except when the mainwindow
    // is hidden, as otherwise an application wouldn't be able to be shut down.
    const QMainWindow *win = qobject_cast<QMainWindow*>(parentWidget());
    const bool canClose = (d->features & DockWidgetClosable)
                       || (!win || !win->isVisible());
    event->setAccepted(canClose);
}
 
void QDockWidget::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    Q_D(QDockWidget);
 
    QDockWidgetLayout *layout
        = qobject_cast<QDockWidgetLayout*>(this->layout());
    bool customTitleBar = layout->widgetForRole(QDockWidgetLayout::TitleBar) != nullptr;
    bool nativeDeco = layout->nativeWindowDeco();
 
    if (!nativeDeco && !customTitleBar) {
        QStylePainter p(this);
        // ### Add PixelMetric to change spacers, so style may show border
        // when not floating.
        if (isFloating()) {
            QStyleOptionFrame framOpt;
            framOpt.initFrom(this);
            p.drawPrimitive(QStyle::PE_FrameDockWidget, framOpt);
        }
 
        // Title must be painted after the frame, since the areas overlap, and
        // the title may wish to extend out to all sides (eg. Vista style)
        QStyleOptionDockWidget titleOpt;
        initStyleOption(&titleOpt);
        if (font() == QApplication::font("QDockWidget")) {
            titleOpt.fontMetrics = QFontMetrics(d->font);
            p.setFont(d->font);
        }
 
        p.drawControl(QStyle::CE_DockWidgetTitle, titleOpt);
    }
}
 
bool QDockWidget::event(QEvent *event)
{
    Q_D(QDockWidget);
 
    QMainWindow *win = qobject_cast<QMainWindow*>(parentWidget());
    QMainWindowLayout *layout = qt_mainwindow_layout_from_dock(this);
 
    switch (event->type()) {
#ifndef QT_NO_ACTION
    case QEvent::Hide:
        if (layout != nullptr)
            layout->keepSize(this);
        d->toggleViewAction->setChecked(false);
        emit visibilityChanged(false);
        break;
    case QEvent::Show: {
        d->toggleViewAction->setChecked(true);
        QPoint parentTopLeft(0, 0);
        if (isWindow()) {
            const QScreen *screen = d->associatedScreen();
            parentTopLeft = screen
                ? screen->availableVirtualGeometry().topLeft()
                : QGuiApplication::primaryScreen()->availableVirtualGeometry().topLeft();
        }
        emit visibilityChanged(geometry().right() >= parentTopLeft.x() && geometry().bottom() >= parentTopLeft.y());
}
        break;
#endif
    case QEvent::ApplicationLayoutDirectionChange:
    case QEvent::LayoutDirectionChange:
    case QEvent::StyleChange:
    case QEvent::ParentChange:
        d->updateButtons();
        break;
    case QEvent::ZOrderChange: {
        bool onTop = false;
        if (win != nullptr) {
            const QObjectList &siblings = win->children();
            onTop = siblings.size() > 0 && siblings.last() == (QObject*)this;
        }
#if QT_CONFIG(tabbar)
        if (!isFloating() && layout != nullptr && onTop)
            layout->raise(this);
#endif
        break;
    }
    case QEvent::WindowActivate:
    case QEvent::WindowDeactivate:
        update(qobject_cast<QDockWidgetLayout *>(this->layout())->titleArea());
        break;
    case QEvent::ContextMenu:
        if (d->state) {
            event->accept();
            return true;
        }
        break;
        // return true after calling the handler since we don't want
        // them to be passed onto the default handlers
    case QEvent::MouseButtonPress:
        if (d->mousePressEvent(static_cast<QMouseEvent *>(event)))
            return true;
        break;
    case QEvent::MouseButtonDblClick:
        if (d->mouseDoubleClickEvent(static_cast<QMouseEvent *>(event)))
            return true;
        break;
    case QEvent::MouseMove:
        if (d->mouseMoveEvent(static_cast<QMouseEvent *>(event)))
            return true;
        break;
    case QEvent::MouseButtonRelease:
        if (d->mouseReleaseEvent(static_cast<QMouseEvent *>(event)))
            return true;
        break;
    case QEvent::NonClientAreaMouseMove:
    case QEvent::NonClientAreaMouseButtonPress:
    case QEvent::NonClientAreaMouseButtonRelease:
    case QEvent::NonClientAreaMouseButtonDblClick:
        d->nonClientAreaMouseEvent(static_cast<QMouseEvent*>(event));
        return true;
    case QEvent::Move:
        d->moveEvent(static_cast<QMoveEvent*>(event));
        break;
    case QEvent::Resize:
        // if the mainwindow is plugging us, we don't want to update undocked geometry
        if (isFloating() && layout != nullptr && layout->pluggingWidget != this)
            d->undockedGeometry = geometry();
 
        // Usually the window won't get resized while it's being moved, but it can happen,
        // for example on Windows when moving to a screen with bigger scale factor
        // If that happens we should update state->pressPos, otherwise it will be outside
        // the window when the window shrinks.
        if (d->state && d->state->dragging)
            d->recalculatePressPos(static_cast<QResizeEvent*>(event));
        break;
    default:
        break;
    }
    return QWidget::event(event);
}
 
#ifndef QT_NO_ACTION
QAction * QDockWidget::toggleViewAction() const
{
    Q_D(const QDockWidget);
    return d->toggleViewAction;
}
#endif // QT_NO_ACTION
 
void QDockWidget::setTitleBarWidget(QWidget *widget)
{
    Q_D(QDockWidget);
    QDockWidgetLayout *layout
        = qobject_cast<QDockWidgetLayout*>(this->layout());
    layout->setWidgetForRole(QDockWidgetLayout::TitleBar, widget);
    d->updateButtons();
    if (isWindow()) {
        //this ensures the native decoration is drawn
        d->setWindowState(true /*floating*/, true /*unplug*/);
    }
}
 
QWidget *QDockWidget::titleBarWidget() const
{
    QDockWidgetLayout *layout
        = qobject_cast<QDockWidgetLayout*>(this->layout());
    return layout->widgetForRole(QDockWidgetLayout::TitleBar);
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QDockWidget *dockWidget)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace();
 
    if (!dockWidget) {
        dbg << "QDockWidget(0x0)";
        return dbg;
    }
 
    dbg << "QDockWidget(" << static_cast<const void *>(dockWidget);
    dbg << "->(ObjectName=" << dockWidget->objectName();
    dbg << "; floating=" << dockWidget->isFloating();
    dbg << "; features=" << dockWidget->features();
    dbg << ";))";
    return dbg;
}
#endif // QT_NO_DEBUG_STREAM
 
QT_END_NAMESPACE
 
#include "qdockwidget.moc"
#include "moc_qdockwidget.cpp"
#include "moc_qdockwidget_p.cpp"