qmainwindow.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
 
//#define QT_EXPERIMENTAL_CLIENT_DECORATIONS
 
#include "qmainwindow.h"
#include "qmainwindowlayout_p.h"
 
#if QT_CONFIG(dockwidget)
#include "qdockwidget.h"
#endif
#if QT_CONFIG(toolbar)
#include "qtoolbar.h"
#endif
 
#include <qapplication.h>
#include <qmenu.h>
#if QT_CONFIG(menubar)
#include <qmenubar.h>
#endif
#if QT_CONFIG(statusbar)
#include <qstatusbar.h>
#endif
#include <qevent.h>
#include <qstyle.h>
#include <qdebug.h>
#include <qpainter.h>
#include <qmimedata.h>
 
#include <private/qwidget_p.h>
#if QT_CONFIG(toolbar)
#include "qtoolbar_p.h"
#endif
#include "qwidgetanimator_p.h"
#include <QtGui/qpa/qplatformwindow.h>
#include <QtGui/qpa/qplatformwindow_p.h>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
class QMainWindowPrivate : public QWidgetPrivate
{
    Q_DECLARE_PUBLIC(QMainWindow)
public:
    inline QMainWindowPrivate()
        : layout(nullptr), explicitIconSize(false), toolButtonStyle(Qt::ToolButtonIconOnly)
#ifdef Q_OS_MACOS
            , useUnifiedToolBar(false)
#endif
    { }
    QPointer<QMainWindowLayout> layout;
    QSize iconSize;
    bool explicitIconSize;
    Qt::ToolButtonStyle toolButtonStyle;
#ifdef Q_OS_MACOS
    bool useUnifiedToolBar;
#endif
    void init();
 
    static inline QMainWindowLayout *mainWindowLayout(const QMainWindow *mainWindow)
    {
        return mainWindow ? mainWindow->d_func()->layout.data() : static_cast<QMainWindowLayout *>(nullptr);
    }
};
 
QMainWindowLayout *qt_mainwindow_layout(const QMainWindow *mainWindow)
{
    return QMainWindowPrivate::mainWindowLayout(mainWindow);
}
 
#ifdef QT_EXPERIMENTAL_CLIENT_DECORATIONS
Q_WIDGETS_EXPORT void qt_setMainWindowTitleWidget(QMainWindow *mainWindow, Qt::DockWidgetArea area, QWidget *widget)
{
    QGridLayout *topLayout = qobject_cast<QGridLayout *>(mainWindow->layout());
    Q_ASSERT(topLayout);
 
    int row = 0;
    int column = 0;
 
    switch (area) {
    case Qt::LeftDockWidgetArea:
        row = 1;
        column = 0;
        break;
    case Qt::TopDockWidgetArea:
        row = 0;
        column = 1;
        break;
    case Qt::BottomDockWidgetArea:
        row = 2;
        column = 1;
        break;
    case Qt::RightDockWidgetArea:
        row = 1;
        column = 2;
        break;
    default:
        Q_ASSERT_X(false, "qt_setMainWindowTitleWidget", "Unknown area");
        return;
    }
 
    if (QLayoutItem *oldItem = topLayout->itemAtPosition(row, column))
        delete oldItem->widget();
    topLayout->addWidget(widget, row, column);
}
#endif
 
void QMainWindowPrivate::init()
{
    Q_Q(QMainWindow);
 
#ifdef QT_EXPERIMENTAL_CLIENT_DECORATIONS
    QGridLayout *topLayout = new QGridLayout(q);
    topLayout->setContentsMargins(0, 0, 0, 0);
 
    layout = new QMainWindowLayout(q, topLayout);
 
    topLayout->addItem(layout, 1, 1);
#else
    layout = new QMainWindowLayout(q, nullptr);
#endif
 
    const int metric = q->style()->pixelMetric(QStyle::PM_ToolBarIconSize, nullptr, q);
    iconSize = QSize(metric, metric);
    q->setAttribute(Qt::WA_Hover);
    q->setAcceptDrops(true);
}
 
/*
    The Main Window:
 
    +----------------------------------------------------------+
    | Menu Bar                                                 |
    +----------------------------------------------------------+
    | Tool Bar Area                                            |
    |   +--------------------------------------------------+   |
    |   | Dock Window Area                                 |   |
    |   |   +------------------------------------------+   |   |
    |   |   |                                          |   |   |
    |   |   | Central Widget                           |   |   |
    |   |   |                                          |   |   |
    |   |   |                                          |   |   |
    |   |   |                                          |   |   |
    |   |   |                                          |   |   |
    |   |   |                                          |   |   |
    |   |   |                                          |   |   |
    |   |   |                                          |   |   |
    |   |   |                                          |   |   |
    |   |   |                                          |   |   |
    |   |   |                                          |   |   |
    |   |   +------------------------------------------+   |   |
    |   |                                                  |   |
    |   +--------------------------------------------------+   |
    |                                                          |
    +----------------------------------------------------------+
    | Status Bar                                               |
    +----------------------------------------------------------+
 
*/
 
#if QT_CONFIG(dockwidget)
#endif
 
QMainWindow::QMainWindow(QWidget *parent, Qt::WindowFlags flags)
    : QWidget(*(new QMainWindowPrivate()), parent, flags | Qt::Window)
{
    d_func()->init();
}
 
 
QMainWindow::~QMainWindow()
{ }
 
void QMainWindow::setDockOptions(DockOptions opt)
{
    Q_D(QMainWindow);
    d->layout->setDockOptions(opt);
}
 
QMainWindow::DockOptions QMainWindow::dockOptions() const
{
    Q_D(const QMainWindow);
    return d->layout->dockOptions;
}
 
QSize QMainWindow::iconSize() const
{ return d_func()->iconSize; }
 
void QMainWindow::setIconSize(const QSize &iconSize)
{
    Q_D(QMainWindow);
    QSize sz = iconSize;
    if (!sz.isValid()) {
        const int metric = style()->pixelMetric(QStyle::PM_ToolBarIconSize, nullptr, this);
        sz = QSize(metric, metric);
    }
    if (d->iconSize != sz) {
        d->iconSize = sz;
        emit iconSizeChanged(d->iconSize);
    }
    d->explicitIconSize = iconSize.isValid();
}
 
Qt::ToolButtonStyle QMainWindow::toolButtonStyle() const
{ return d_func()->toolButtonStyle; }
 
void QMainWindow::setToolButtonStyle(Qt::ToolButtonStyle toolButtonStyle)
{
    Q_D(QMainWindow);
    if (d->toolButtonStyle == toolButtonStyle)
        return;
    d->toolButtonStyle = toolButtonStyle;
    emit toolButtonStyleChanged(d->toolButtonStyle);
}
 
#if QT_CONFIG(menubar)
QMenuBar *QMainWindow::menuBar() const
{
    QMenuBar *menuBar = qobject_cast<QMenuBar *>(layout()->menuBar());
    if (!menuBar) {
        QMainWindow *self = const_cast<QMainWindow *>(this);
        menuBar = new QMenuBar(self);
        self->setMenuBar(menuBar);
    }
    return menuBar;
}
 
void QMainWindow::setMenuBar(QMenuBar *menuBar)
{
    QLayout *topLayout = layout();
 
    if (QWidget *existingMenuBar = topLayout->menuBar(); existingMenuBar && existingMenuBar != menuBar) {
        // Reparent corner widgets before we delete the old menu bar.
        QMenuBar *oldMenuBar = qobject_cast<QMenuBar *>(existingMenuBar);
        if (oldMenuBar && menuBar) {
            // TopLeftCorner widget.
            QWidget *cornerWidget = oldMenuBar->cornerWidget(Qt::TopLeftCorner);
            if (cornerWidget)
                menuBar->setCornerWidget(cornerWidget, Qt::TopLeftCorner);
            // TopRightCorner widget.
            cornerWidget = oldMenuBar->cornerWidget(Qt::TopRightCorner);
            if (cornerWidget)
                menuBar->setCornerWidget(cornerWidget, Qt::TopRightCorner);
        }
 
        existingMenuBar->hide();
        existingMenuBar->setParent(nullptr);
        existingMenuBar->deleteLater();
    }
    topLayout->setMenuBar(menuBar);
}
 
QWidget *QMainWindow::menuWidget() const
{
    QWidget *menuBar = d_func()->layout->menuBar();
    return menuBar;
}
 
void QMainWindow::setMenuWidget(QWidget *menuBar)
{
    Q_D(QMainWindow);
    if (d->layout->menuBar() && d->layout->menuBar() != menuBar) {
        d->layout->menuBar()->hide();
        d->layout->menuBar()->deleteLater();
    }
    d->layout->setMenuBar(menuBar);
}
#endif // QT_CONFIG(menubar)
 
#if QT_CONFIG(statusbar)
QStatusBar *QMainWindow::statusBar() const
{
    QStatusBar *statusbar = d_func()->layout->statusBar();
    if (!statusbar) {
        QMainWindow *self = const_cast<QMainWindow *>(this);
        statusbar = new QStatusBar(self);
        statusbar->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
        self->setStatusBar(statusbar);
    }
    return statusbar;
}
 
void QMainWindow::setStatusBar(QStatusBar *statusbar)
{
    Q_D(QMainWindow);
    if (d->layout->statusBar() && d->layout->statusBar() != statusbar) {
        d->layout->statusBar()->hide();
        d->layout->statusBar()->deleteLater();
    }
    d->layout->setStatusBar(statusbar);
}
#endif // QT_CONFIG(statusbar)
 
QWidget *QMainWindow::centralWidget() const
{ return d_func()->layout->centralWidget(); }
 
void QMainWindow::setCentralWidget(QWidget *widget)
{
    Q_D(QMainWindow);
    if (d->layout->centralWidget() && d->layout->centralWidget() != widget) {
        d->layout->centralWidget()->hide();
        d->layout->centralWidget()->deleteLater();
    }
    d->layout->setCentralWidget(widget);
}
 
QWidget *QMainWindow::takeCentralWidget()
{
    Q_D(QMainWindow);
    QWidget *oldcentralwidget = d->layout->centralWidget();
    if (oldcentralwidget) {
        oldcentralwidget->setParent(nullptr);
        d->layout->setCentralWidget(nullptr);
    }
    return oldcentralwidget;
}
 
#if QT_CONFIG(dockwidget)
void QMainWindow::setCorner(Qt::Corner corner, Qt::DockWidgetArea area)
{
    bool valid = false;
    switch (corner) {
    case Qt::TopLeftCorner:
        valid = (area == Qt::TopDockWidgetArea || area == Qt::LeftDockWidgetArea);
        break;
    case Qt::TopRightCorner:
        valid = (area == Qt::TopDockWidgetArea || area == Qt::RightDockWidgetArea);
        break;
    case Qt::BottomLeftCorner:
        valid = (area == Qt::BottomDockWidgetArea || area == Qt::LeftDockWidgetArea);
        break;
    case Qt::BottomRightCorner:
        valid = (area == Qt::BottomDockWidgetArea || area == Qt::RightDockWidgetArea);
        break;
    }
    if (Q_UNLIKELY(!valid))
        qWarning("QMainWindow::setCorner(): 'area' is not valid for 'corner'");
    else
        d_func()->layout->setCorner(corner, area);
}
 
Qt::DockWidgetArea QMainWindow::corner(Qt::Corner corner) const
{ return d_func()->layout->corner(corner); }
#endif
 
#if QT_CONFIG(toolbar)
 
static bool checkToolBarArea(Qt::ToolBarArea area, const char *where)
{
    switch (area) {
    case Qt::LeftToolBarArea:
    case Qt::RightToolBarArea:
    case Qt::TopToolBarArea:
    case Qt::BottomToolBarArea:
        return true;
    default:
        break;
    }
    qWarning("%s: invalid 'area' argument", where);
    return false;
}
 
void QMainWindow::addToolBarBreak(Qt::ToolBarArea area)
{
    if (!checkToolBarArea(area, "QMainWindow::addToolBarBreak"))
        return;
    d_func()->layout->addToolBarBreak(area);
}
 
void QMainWindow::insertToolBarBreak(QToolBar *before)
{ d_func()->layout->insertToolBarBreak(before); }
 
void QMainWindow::removeToolBarBreak(QToolBar *before)
{
    Q_D(QMainWindow);
    d->layout->removeToolBarBreak(before);
}
 
void QMainWindow::addToolBar(Qt::ToolBarArea area, QToolBar *toolbar)
{
    if (!checkToolBarArea(area, "QMainWindow::addToolBar"))
        return;
 
    Q_D(QMainWindow);
 
    disconnect(this, SIGNAL(iconSizeChanged(QSize)),
               toolbar, SLOT(_q_updateIconSize(QSize)));
    disconnect(this, SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle)),
               toolbar, SLOT(_q_updateToolButtonStyle(Qt::ToolButtonStyle)));
 
    if (toolbar->d_func()->state && toolbar->d_func()->state->dragging) {
        //removing a toolbar which is dragging will cause crash
#if QT_CONFIG(dockwidget)
        bool animated = isAnimated();
        setAnimated(false);
#endif
        toolbar->d_func()->endDrag();
#if QT_CONFIG(dockwidget)
        setAnimated(animated);
#endif
    }
 
    d->layout->removeToolBar(toolbar);
 
    toolbar->d_func()->_q_updateIconSize(d->iconSize);
    toolbar->d_func()->_q_updateToolButtonStyle(d->toolButtonStyle);
    connect(this, SIGNAL(iconSizeChanged(QSize)),
            toolbar, SLOT(_q_updateIconSize(QSize)));
    connect(this, SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle)),
            toolbar, SLOT(_q_updateToolButtonStyle(Qt::ToolButtonStyle)));
 
    d->layout->addToolBar(area, toolbar);
}
 
void QMainWindow::addToolBar(QToolBar *toolbar)
{ addToolBar(Qt::TopToolBarArea, toolbar); }
 
QToolBar *QMainWindow::addToolBar(const QString &title)
{
    QToolBar *toolBar = new QToolBar(this);
    toolBar->setWindowTitle(title);
    addToolBar(toolBar);
    return toolBar;
}
 
void QMainWindow::insertToolBar(QToolBar *before, QToolBar *toolbar)
{
    Q_D(QMainWindow);
 
    d->layout->removeToolBar(toolbar);
 
    toolbar->d_func()->_q_updateIconSize(d->iconSize);
    toolbar->d_func()->_q_updateToolButtonStyle(d->toolButtonStyle);
    connect(this, SIGNAL(iconSizeChanged(QSize)),
            toolbar, SLOT(_q_updateIconSize(QSize)));
    connect(this, SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle)),
            toolbar, SLOT(_q_updateToolButtonStyle(Qt::ToolButtonStyle)));
 
    d->layout->insertToolBar(before, toolbar);
}
 
void QMainWindow::removeToolBar(QToolBar *toolbar)
{
    if (toolbar) {
        d_func()->layout->removeToolBar(toolbar);
        toolbar->hide();
    }
}
 
Qt::ToolBarArea QMainWindow::toolBarArea(const QToolBar *toolbar) const
{ return d_func()->layout->toolBarArea(toolbar); }
 
bool QMainWindow::toolBarBreak(QToolBar *toolbar) const
{
    return d_func()->layout->toolBarBreak(toolbar);
}
 
#endif // QT_CONFIG(toolbar)
 
#if QT_CONFIG(dockwidget)
 
bool QMainWindow::isAnimated() const
{
    Q_D(const QMainWindow);
    return d->layout->dockOptions & AnimatedDocks;
}
 
void QMainWindow::setAnimated(bool enabled)
{
    Q_D(QMainWindow);
 
    DockOptions opts = d->layout->dockOptions;
    opts.setFlag(AnimatedDocks, enabled);
 
    d->layout->setDockOptions(opts);
}
 
bool QMainWindow::isDockNestingEnabled() const
{
    Q_D(const QMainWindow);
    return d->layout->dockOptions & AllowNestedDocks;
}
 
void QMainWindow::setDockNestingEnabled(bool enabled)
{
    Q_D(QMainWindow);
 
    DockOptions opts = d->layout->dockOptions;
    opts.setFlag(AllowNestedDocks, enabled);
 
    d->layout->setDockOptions(opts);
}
 
#if 0
// If added back in, add the '!' to the qdoc comment marker as well.
/*
    \property QMainWindow::verticalTabsEnabled
    \brief whether left and right dock areas use vertical tabs
    \since 4.2
 
    If this property is set to false, dock areas containing tabbed dock widgets
    display horizontal tabs, similar to Visual Studio.
 
    If this property is set to true, then the right and left dock areas display vertical
    tabs, similar to KDevelop.
 
    This property should be set before any dock widgets are added to the main window.
*/
 
bool QMainWindow::verticalTabsEnabled() const
{
    return d_func()->layout->verticalTabsEnabled();
}
 
void QMainWindow::setVerticalTabsEnabled(bool enabled)
{
    d_func()->layout->setVerticalTabsEnabled(enabled);
}
#endif
 
static bool checkDockWidgetArea(Qt::DockWidgetArea area, const char *where)
{
    switch (area) {
    case Qt::LeftDockWidgetArea:
    case Qt::RightDockWidgetArea:
    case Qt::TopDockWidgetArea:
    case Qt::BottomDockWidgetArea:
        return true;
    default:
        break;
    }
    qWarning("%s: invalid 'area' argument", where);
    return false;
}
 
#if QT_CONFIG(tabbar)
bool QMainWindow::documentMode() const
{
    return d_func()->layout->documentMode();
}
 
void QMainWindow::setDocumentMode(bool enabled)
{
    d_func()->layout->setDocumentMode(enabled);
}
#endif // QT_CONFIG(tabbar)
 
#if QT_CONFIG(tabwidget)
QTabWidget::TabShape QMainWindow::tabShape() const
{
    return d_func()->layout->tabShape();
}
 
void QMainWindow::setTabShape(QTabWidget::TabShape tabShape)
{
    d_func()->layout->setTabShape(tabShape);
}
 
QTabWidget::TabPosition QMainWindow::tabPosition(Qt::DockWidgetArea area) const
{
    if (!checkDockWidgetArea(area, "QMainWindow::tabPosition"))
        return QTabWidget::South;
    return d_func()->layout->tabPosition(area);
}
 
void QMainWindow::setTabPosition(Qt::DockWidgetAreas areas, QTabWidget::TabPosition tabPosition)
{
    d_func()->layout->setTabPosition(areas, tabPosition);
}
#endif // QT_CONFIG(tabwidget)
 
void QMainWindow::addDockWidget(Qt::DockWidgetArea area, QDockWidget *dockwidget)
{
    if (!checkDockWidgetArea(area, "QMainWindow::addDockWidget"))
        return;
 
    Qt::Orientation orientation = Qt::Vertical;
    switch (area) {
    case Qt::TopDockWidgetArea:
    case Qt::BottomDockWidgetArea:
        orientation = Qt::Horizontal;
        break;
    default:
        break;
    }
    d_func()->layout->removeWidget(dockwidget); // in case it was already in here
    addDockWidget(area, dockwidget, orientation);
}
 
bool QMainWindow::restoreDockWidget(QDockWidget *dockwidget)
{
    return d_func()->layout->restoreDockWidget(dockwidget);
}
 
void QMainWindow::addDockWidget(Qt::DockWidgetArea area, QDockWidget *dockwidget,
                                Qt::Orientation orientation)
{
    if (!checkDockWidgetArea(area, "QMainWindow::addDockWidget"))
        return;
 
    // add a window to an area, placing done relative to the previous
    d_func()->layout->addDockWidget(area, dockwidget, orientation);
}
 
void QMainWindow::splitDockWidget(QDockWidget *after, QDockWidget *dockwidget,
                                  Qt::Orientation orientation)
{
    d_func()->layout->splitDockWidget(after, dockwidget, orientation);
}
 
#if QT_CONFIG(tabbar)
void QMainWindow::tabifyDockWidget(QDockWidget *first, QDockWidget *second)
{
    d_func()->layout->tabifyDockWidget(first, second);
}
 
 
QList<QDockWidget*> QMainWindow::tabifiedDockWidgets(QDockWidget *dockwidget) const
{
    Q_D(const QMainWindow);
    return d->layout ? d->layout->tabifiedDockWidgets(dockwidget) : QList<QDockWidget *>();
}
#endif // QT_CONFIG(tabbar)
 
 
void QMainWindow::removeDockWidget(QDockWidget *dockwidget)
{
    if (dockwidget) {
        d_func()->layout->removeWidget(dockwidget);
        dockwidget->hide();
    }
}
 
Qt::DockWidgetArea QMainWindow::dockWidgetArea(QDockWidget *dockwidget) const
{ return d_func()->layout->dockWidgetArea(dockwidget); }
 
 
void QMainWindow::resizeDocks(const QList<QDockWidget *> &docks,
                              const QList<int> &sizes, Qt::Orientation orientation)
{
    d_func()->layout->layoutState.dockAreaLayout.resizeDocks(docks, sizes, orientation);
    d_func()->layout->invalidate();
}
 
 
#endif // QT_CONFIG(dockwidget)
 
QByteArray QMainWindow::saveState(int version) const
{
    QByteArray data;
    QDataStream stream(&data, QIODevice::WriteOnly);
    stream.setVersion(QDataStream::Qt_5_0);
    stream << QMainWindowLayout::VersionMarker;
    stream << version;
    d_func()->layout->saveState(stream);
    return data;
}
 
bool QMainWindow::restoreState(const QByteArray &state, int version)
{
    if (state.isEmpty())
        return false;
    QByteArray sd = state;
    QDataStream stream(&sd, QIODevice::ReadOnly);
    stream.setVersion(QDataStream::Qt_5_0);
    int marker, v;
    stream >> marker;
    stream >> v;
    if (stream.status() != QDataStream::Ok || marker != QMainWindowLayout::VersionMarker || v != version)
        return false;
    bool restored = d_func()->layout->restoreState(stream);
    return restored;
}
 
bool QMainWindow::event(QEvent *event)
{
    Q_D(QMainWindow);
 
#if QT_CONFIG(dockwidget)
    if (d->layout && d->layout->windowEvent(event))
        return true;
#endif
 
    switch (event->type()) {
 
#if QT_CONFIG(toolbar)
        case QEvent::ToolBarChange: {
            Q_ASSERT(d->layout);
            d->layout->toggleToolBarsVisible();
            return true;
        }
#endif
 
#if QT_CONFIG(statustip)
        case QEvent::StatusTip:
#if QT_CONFIG(statusbar)
            Q_ASSERT(d->layout);
            if (QStatusBar *sb = d->layout->statusBar())
                sb->showMessage(static_cast<QStatusTipEvent*>(event)->tip());
            else
#endif
                static_cast<QStatusTipEvent*>(event)->ignore();
            return true;
#endif // QT_CONFIG(statustip)
 
        case QEvent::StyleChange:
#if QT_CONFIG(dockwidget)
            Q_ASSERT(d->layout);
            d->layout->layoutState.dockAreaLayout.styleChangedEvent();
#endif
            if (!d->explicitIconSize)
                setIconSize(QSize());
            break;
#if QT_CONFIG(draganddrop)
        case QEvent::DragEnter:
        case QEvent::Drop:
            if (!d->layout->draggingWidget)
                break;
            event->accept();
            return true;
        case QEvent::DragMove: {
            if (!d->layout->draggingWidget)
                break;
            auto dragMoveEvent = static_cast<QDragMoveEvent *>(event);
            d->layout->hover(d->layout->draggingWidget,
                             mapToGlobal(dragMoveEvent->position()).toPoint());
            event->accept();
            return true;
        }
        case QEvent::DragLeave:
            if (!d->layout->draggingWidget)
                break;
            d->layout->hover(d->layout->draggingWidget, pos() - QPoint(-1, -1));
            return true;
#endif
        default:
            break;
    }
 
    return QWidget::event(event);
}
 
#if QT_CONFIG(toolbar)
 
void QMainWindow::setUnifiedTitleAndToolBarOnMac(bool enabled)
{
#ifdef Q_OS_MACOS
    if (!isWindow())
        return;
 
    Q_D(QMainWindow);
    d->useUnifiedToolBar = enabled;
 
    // The unified toolbar is drawn by the macOS style with a transparent background.
    // To ensure a suitable surface format is used we need to first create backing
    // QWindow so we have something to update the surface format on, and then let
    // QWidget know about the translucency, which it will propagate to the surface.
    setAttribute(Qt::WA_NativeWindow);
    setAttribute(Qt::WA_TranslucentBackground, enabled);
 
    d->create(); // Create first, before querying the platform window
    using namespace QNativeInterface::Private;
    if (auto *platformWindow = dynamic_cast<QCocoaWindow*>(window()->windowHandle()->handle()))
        platformWindow->setContentBorderEnabled(enabled);
 
    update();
#else
    Q_UNUSED(enabled);
#endif
}
 
bool QMainWindow::unifiedTitleAndToolBarOnMac() const
{
#ifdef Q_OS_MACOS
    return d_func()->useUnifiedToolBar;
#endif
    return false;
}
 
#endif // QT_CONFIG(toolbar)
 
bool QMainWindow::isSeparator(const QPoint &pos) const
{
#if QT_CONFIG(dockwidget)
    Q_D(const QMainWindow);
    return !d->layout->layoutState.dockAreaLayout.findSeparator(pos).isEmpty();
#else
    Q_UNUSED(pos);
    return false;
#endif
}
 
#ifndef QT_NO_CONTEXTMENU
void QMainWindow::contextMenuEvent(QContextMenuEvent *event)
{
    event->ignore();
    // only show the context menu for direct QDockWidget and QToolBar
    // children and for the menu bar as well
    QWidget *child = childAt(event->pos());
    while (child && child != this) {
#if QT_CONFIG(menubar)
        if (QMenuBar *mb = qobject_cast<QMenuBar *>(child)) {
            if (mb->parentWidget() != this)
                return;
            break;
        }
#endif
#if QT_CONFIG(dockwidget)
        if (QDockWidget *dw = qobject_cast<QDockWidget *>(child)) {
            if (dw->parentWidget() != this)
                return;
            if (dw->widget()
                && dw->widget()->geometry().contains(child->mapFrom(this, event->pos()))) {
                // ignore the event if the mouse is over the QDockWidget contents
                return;
            }
            break;
        }
#endif // QT_CONFIG(dockwidget)
#if QT_CONFIG(toolbar)
        if (QToolBar *tb = qobject_cast<QToolBar *>(child)) {
            if (tb->parentWidget() != this)
                return;
            break;
        }
#endif
        child = child->parentWidget();
    }
    if (child == this)
        return;
 
#if QT_CONFIG(menu)
    QMenu *popup = createPopupMenu();
    if (popup) {
        if (!popup->isEmpty()) {
            popup->setAttribute(Qt::WA_DeleteOnClose);
            popup->popup(event->globalPos());
            event->accept();
        } else {
            delete popup;
        }
    }
#endif
}
#endif // QT_NO_CONTEXTMENU
 
#if QT_CONFIG(menu)
QMenu *QMainWindow::createPopupMenu()
{
    Q_D(QMainWindow);
    QMenu *menu = nullptr;
#if QT_CONFIG(dockwidget)
    QList<QDockWidget *> dockwidgets = findChildren<QDockWidget *>();
    if (dockwidgets.size()) {
        menu = new QMenu(this);
        for (int i = 0; i < dockwidgets.size(); ++i) {
            QDockWidget *dockWidget = dockwidgets.at(i);
            // filter to find out if we own this QDockWidget
            if (dockWidget->parentWidget() == this) {
                if (d->layout->layoutState.dockAreaLayout.indexOf(dockWidget).isEmpty())
                    continue;
            } else if (QDockWidgetGroupWindow *dwgw =
                           qobject_cast<QDockWidgetGroupWindow *>(dockWidget->parentWidget())) {
                if (dwgw->parentWidget() != this)
                    continue;
                if (dwgw->layoutInfo()->indexOf(dockWidget).isEmpty())
                    continue;
            } else {
                continue;
            }
            menu->addAction(dockwidgets.at(i)->toggleViewAction());
        }
        menu->addSeparator();
    }
#endif // QT_CONFIG(dockwidget)
#if QT_CONFIG(toolbar)
    QList<QToolBar *> toolbars = findChildren<QToolBar *>();
    if (toolbars.size()) {
        if (!menu)
            menu = new QMenu(this);
        for (int i = 0; i < toolbars.size(); ++i) {
            QToolBar *toolBar = toolbars.at(i);
            if (toolBar->parentWidget() == this
                && (!d->layout->layoutState.toolBarAreaLayout.indexOf(toolBar).isEmpty())) {
                menu->addAction(toolbars.at(i)->toggleViewAction());
            }
        }
    }
#endif
    Q_UNUSED(d);
    return menu;
}
#endif // QT_CONFIG(menu)
 
QT_END_NAMESPACE
 
#include "moc_qmainwindow.cpp"