diff options
Diffstat (limited to 'src/widgets/widgets/qdockwidget.cpp')
| -rw-r--r-- | src/widgets/widgets/qdockwidget.cpp | 1606 |
1 files changed, 1606 insertions, 0 deletions
diff --git a/src/widgets/widgets/qdockwidget.cpp b/src/widgets/widgets/qdockwidget.cpp new file mode 100644 index 0000000000..9d1a737cf1 --- /dev/null +++ b/src/widgets/widgets/qdockwidget.cpp @@ -0,0 +1,1606 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdockwidget.h" + +#ifndef QT_NO_DOCKWIDGET +#include <qaction.h> +#include <qapplication.h> +#include <qdesktopwidget.h> +#include <qdrawutil.h> +#include <qevent.h> +#include <qfontmetrics.h> +#include <qmainwindow.h> +#include <qrubberband.h> +#include <qstylepainter.h> +#include <qtoolbutton.h> +#include <qdebug.h> + +#include <private/qwidgetresizehandler_p.h> + +#include "qdockwidget_p.h" +#include "qmainwindowlayout_p.h" +#ifdef Q_WS_MAC +#include <private/qapplication_p.h> +#include <private/qt_mac_p.h> +#include <qmacstyle_mac.h> +#endif + +QT_BEGIN_NAMESPACE + +extern QString qt_setWindowTitle_helperHelper(const QString&, const QWidget*); // qwidget.cpp + +// qmainwindow.cpp +extern QMainWindowLayout *qt_mainwindow_layout(const QMainWindow *window); + +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; + inline QSize minimumSizeHint() const + { return sizeHint(); } + + void enterEvent(QEvent *event); + void leaveEvent(QEvent *event); + void paintEvent(QPaintEvent *event); +}; + + +QDockWidgetTitleButton::QDockWidgetTitleButton(QDockWidget *dockWidget) + : QAbstractButton(dockWidget) +{ + setFocusPolicy(Qt::NoFocus); +} + +QSize QDockWidgetTitleButton::sizeHint() const +{ + ensurePolished(); + + int size = 2*style()->pixelMetric(QStyle::PM_DockWidgetTitleBarButtonMargin, 0, this); + if (!icon().isNull()) { + int iconSize = style()->pixelMetric(QStyle::PM_SmallIconSize, 0, this); + QSize sz = icon().actualSize(QSize(iconSize, iconSize)); + size += qMax(sz.width(), sz.height()); + } + + return QSize(size, size); +} + +void QDockWidgetTitleButton::enterEvent(QEvent *event) +{ + if (isEnabled()) update(); + QAbstractButton::enterEvent(event); +} + +void QDockWidgetTitleButton::leaveEvent(QEvent *event) +{ + if (isEnabled()) update(); + QAbstractButton::leaveEvent(event); +} + +void QDockWidgetTitleButton::paintEvent(QPaintEvent *) +{ + QPainter p(this); + + QRect r = rect(); + QStyleOptionToolButton opt; + opt.init(this); + opt.state |= QStyle::State_AutoRaise; + + if (style()->styleHint(QStyle::SH_DockWidget_ButtonsHaveFrame, 0, 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; + style()->drawPrimitive(QStyle::PE_PanelButtonTool, &opt, &p, this); + } + + opt.icon = icon(); + opt.subControls = 0; + opt.activeSubControls = 0; + opt.features = QStyleOptionToolButton::None; + opt.arrowType = Qt::NoArrow; + int size = style()->pixelMetric(QStyle::PM_SmallIconSize, 0, this); + opt.iconSize = QSize(size, size); + style()->drawComplexControl(QStyle::CC_ToolButton, &opt, &p, this); +} + +/****************************************************************************** +** QDockWidgetLayout +*/ + +QDockWidgetLayout::QDockWidgetLayout(QWidget *parent) + : QLayout(parent), verticalTitleBar(false), item_list(RoleCount, 0) +{ +} + +QDockWidgetLayout::~QDockWidgetLayout() +{ + qDeleteAll(item_list); +} + +bool QDockWidgetLayout::nativeWindowDeco() const +{ + return nativeWindowDeco(parentWidget()->isWindow()); +} + +bool QDockWidgetLayout::nativeWindowDeco(bool floating) const +{ +#if defined(Q_WS_X11) || defined(Q_WS_QWS) || defined(Q_WS_WINCE) + Q_UNUSED(floating); + return false; +#else + return floating && item_list[QDockWidgetLayout::TitleBar] == 0; +#endif +} + + +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.count(); ++i) { + QLayoutItem *item = item_list.at(i); + if (item == 0) + continue; + if (index == cnt++) + return item; + } + return 0; +} + +QLayoutItem *QDockWidgetLayout::takeAt(int index) +{ + int j = 0; + for (int i = 0; i < item_list.count(); ++i) { + QLayoutItem *item = item_list.at(i); + if (item == 0) + continue; + if (index == j) { + item_list[i] = 0; + invalidate(); + return item; + } + ++j; + } + return 0; +} + +int QDockWidgetLayout::count() const +{ + int result = 0; + for (int i = 0; i < item_list.count(); ++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, 0, 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); + + int left, top, right, bottom; + w->getContentsMargins(&left, &top, &right, &bottom); + //we need to substract the contents margin (it will be added by the caller) + QSize min = w->minimumSize() - QSize(left + right, top + bottom); + QSize max = w->maximumSize() - QSize(left + right, top + bottom); + + /* 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 != 0) { + 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 == 0 ? 0 : 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 != 0) { + old->hide(); + removeWidget(old); + } + + if (w != 0) { + 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, 0, q); + int fw = q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, 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(); +#ifdef Q_WS_MAC + if (qobject_cast<QMacStyle *>(q->style())) { + //### this breaks on proxy styles. (But is this code still called?) + QFont font = qt_app_fonts_hash()->value("QToolButton", q->font()); + titleFontMetrics = QFontMetrics(font); + } +#endif + + int mw = q->style()->pixelMetric(QStyle::PM_DockWidgetTitleMargin, 0, 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, 0, 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 { + QStyleOptionDockWidgetV2 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(QLatin1String("qt_dockwidget_floatbutton")); + QObject::connect(button, SIGNAL(clicked()), q, SLOT(_q_toggleTopLevel())); + layout->setWidgetForRole(QDockWidgetLayout::FloatButton, button); + + button = new QDockWidgetTitleButton(q); + button->setObjectName(QLatin1String("qt_dockwidget_closebutton")); + QObject::connect(button, SIGNAL(clicked()), q, SLOT(close())); + layout->setWidgetForRole(QDockWidgetLayout::CloseButton, button); + + resizer = new QWidgetResizeHandler(q); + resizer->setMovingEnabled(false); + resizer->setActive(false); + +#ifndef QT_NO_ACTION + toggleViewAction = new QAction(q); + toggleViewAction->setCheckable(true); + fixedWindowTitle = qt_setWindowTitle_helperHelper(q->windowTitle(), q); + toggleViewAction->setText(fixedWindowTitle); + QObject::connect(toggleViewAction, SIGNAL(triggered(bool)), + q, SLOT(_q_toggleView(bool))); +#endif + + updateButtons(); +} + +/*! + Initialize \a option with the values from this QDockWidget. This method + is useful for subclasses when they need a QStyleOptionDockWidget, but don't want + to fill in all the information themselves. + + \sa QStyleOption::initFrom() +*/ +void QDockWidget::initStyleOption(QStyleOptionDockWidget *option) const +{ + Q_D(const QDockWidget); + + if (!option) + return; + QDockWidgetLayout *dwlayout = qobject_cast<QDockWidgetLayout*>(layout()); + + option->initFrom(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()); + QStyleOptionDockWidgetV2 *v2 + = qstyleoption_cast<QStyleOptionDockWidgetV2*>(option); + if (v2 != 0) + v2->verticalTitleBar = l->verticalTitleBar; +} + +void QDockWidgetPrivate::_q_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) != 0; + 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); + + button + = qobject_cast <QAbstractButton*>(dwLayout->widgetForRole(QDockWidgetLayout::CloseButton)); + button->setIcon(q->style()->standardIcon(QStyle::SP_TitleBarCloseButton, &opt, q)); + button->setVisible(canClose && !hideButtons); + + q->setAttribute(Qt::WA_ContentsPropagated, + (canFloat || canClose) && !hideButtons); + + layout->invalidate(); +} + +void QDockWidgetPrivate::_q_toggleTopLevel() +{ + Q_Q(QDockWidget); + q->setFloating(!q->isFloating()); +} + +void QDockWidgetPrivate::initDrag(const QPoint &pos, bool nca) +{ + if (state != 0) + return; + + QMainWindow *win = qobject_cast<QMainWindow*>(parent); + Q_ASSERT(win != 0); + QMainWindowLayout *layout = qt_mainwindow_layout(win); + Q_ASSERT(layout != 0); + if (layout->pluggingWidget != 0) // the main window is animating a docking operation + return; + + state = new QDockWidgetPrivate::DragState; + state->pressPos = pos; + state->dragging = false; + state->widgetItem = 0; + state->ownWidgetItem = false; + state->nca = nca; + state->ctrlDrag = false; +} + +void QDockWidgetPrivate::startDrag() +{ + Q_Q(QDockWidget); + + if (state == 0 || state->dragging) + return; + + QMainWindowLayout *layout = qt_mainwindow_layout(qobject_cast<QMainWindow *>(q->parentWidget())); + Q_ASSERT(layout != 0); + + state->widgetItem = layout->unplug(q); + if (state->widgetItem == 0) { + /* I have a QMainWindow parent, but I was never inserted with + QMainWindow::addDockWidget, so the QMainWindowLayout has no + widget item for me. :( I have to create it myself, and then + delete it if I don't get dropped into a dock area. */ + state->widgetItem = new QDockWidgetItem(q); + state->ownWidgetItem = true; + } + + if (state->ctrlDrag) + layout->restore(); + + state->dragging = true; +} + +void QDockWidgetPrivate::endDrag(bool abort) +{ + Q_Q(QDockWidget); + Q_ASSERT(state != 0); + + q->releaseMouse(); + + if (state->dragging) { + QMainWindowLayout *mwLayout = qt_mainwindow_layout(qobject_cast<QMainWindow *>(q->parentWidget())); + Q_ASSERT(mwLayout != 0); + + if (abort || !mwLayout->plug(state->widgetItem)) { + if (hasFeature(this, QDockWidget::DockWidgetFloatable)) { + if (state->ownWidgetItem) + delete state->widgetItem; + mwLayout->restore(); +#ifdef Q_WS_X11 + // get rid of the X11BypassWindowManager window flag and activate the resizer + Qt::WindowFlags flags = q->windowFlags(); + flags &= ~Qt::X11BypassWindowManagerHint; + q->setWindowFlags(flags); + resizer->setActive(QWidgetResizeHandler::Resize, true); + q->show(); +#else + QDockWidgetLayout *myLayout + = qobject_cast<QDockWidgetLayout*>(layout); + resizer->setActive(QWidgetResizeHandler::Resize, + myLayout->widgetForRole(QDockWidgetLayout::TitleBar) != 0); +#endif + undockedGeometry = q->geometry(); + q->activateWindow(); + } else { + mwLayout->revert(state->widgetItem); + } + } + } + delete state; + state = 0; +} + +bool QDockWidgetPrivate::isAnimating() const +{ + Q_Q(const QDockWidget); + + QMainWindow *mainWin = qobject_cast<QMainWindow*>(parent); + if (mainWin == 0) + return false; + + QMainWindowLayout *mainWinLayout = qt_mainwindow_layout(mainWin); + if (mainWinLayout == 0) + return false; + + return (void*)mainWinLayout->pluggingWidget == (void*)q; +} + +bool QDockWidgetPrivate::mousePressEvent(QMouseEvent *event) +{ +#if !defined(QT_NO_MAINWINDOW) + Q_Q(QDockWidget); + + QDockWidgetLayout *dwLayout + = qobject_cast<QDockWidgetLayout*>(layout); + + if (!dwLayout->nativeWindowDeco()) { + QRect titleArea = dwLayout->titleArea(); + + if (event->button() != Qt::LeftButton || + !titleArea.contains(event->pos()) || + // 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) == 0 || + isAnimating() || state != 0) { + return false; + } + + initDrag(event->pos(), false); + + if (state) + state->ctrlDrag = hasFeature(this, QDockWidget::DockWidgetFloatable) && event->modifiers() & Qt::ControlModifier; + + return true; + } + +#endif // !defined(QT_NO_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->pos()) && + hasFeature(this, QDockWidget::DockWidgetFloatable)) { + _q_toggleTopLevel(); + return true; + } + } + return false; +} + +bool QDockWidgetPrivate::mouseMoveEvent(QMouseEvent *event) +{ + bool ret = false; +#if !defined(QT_NO_MAINWINDOW) + Q_Q(QDockWidget); + + if (!state) + return ret; + + QDockWidgetLayout *dwlayout + = qobject_cast<QDockWidgetLayout *>(layout); + QMainWindowLayout *mwlayout = qt_mainwindow_layout(qobject_cast<QMainWindow *>(q->parentWidget())); + if (!dwlayout->nativeWindowDeco()) { + if (!state->dragging + && mwlayout->pluggingWidget == 0 + && (event->pos() - state->pressPos).manhattanLength() + > QApplication::startDragDistance()) { + startDrag(); +#ifdef Q_OS_WIN + grabMouseWhileInWindow(); +#else + q->grabMouse(); +#endif + ret = true; + } + } + + if (state->dragging && !state->nca) { + QPoint pos = event->globalPos() - state->pressPos; + q->move(pos); + + if (!state->ctrlDrag) + mwlayout->hover(state->widgetItem, event->globalPos()); + + ret = true; + } + +#endif // !defined(QT_NO_MAINWINDOW) + return ret; +} + +bool QDockWidgetPrivate::mouseReleaseEvent(QMouseEvent *event) +{ +#if !defined(QT_NO_MAINWINDOW) + + if (event->button() == Qt::LeftButton && state && !state->nca) { + endDrag(); + return true; //filter out the event + } + +#endif // !defined(QT_NO_MAINWINDOW) + return false; +} + +void QDockWidgetPrivate::nonClientAreaMouseEvent(QMouseEvent *event) +{ + Q_Q(QDockWidget); + + int fw = q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, q); + + QRect geo = q->geometry(); + QRect titleRect = q->frameGeometry(); +#ifdef Q_WS_MAC + if ((features & QDockWidget::DockWidgetVerticalTitleBar)) { + titleRect.setTop(geo.top()); + titleRect.setBottom(geo.bottom()); + titleRect.setRight(geo.left() - 1); + } else +#endif + { + 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->globalPos())) + break; + if (state != 0) + break; + if (qobject_cast<QMainWindow*>(parent) == 0) + break; + if (isAnimating()) + break; + initDrag(event->pos(), true); + if (state == 0) + break; +#ifdef Q_OS_WIN + // On Windows, NCA mouse events don't contain modifier info + state->ctrlDrag = GetKeyState(VK_CONTROL) & 0x8000; +#else + state->ctrlDrag = event->modifiers() & Qt::ControlModifier; +#endif + startDrag(); + break; + case QEvent::NonClientAreaMouseMove: + if (state == 0 || !state->dragging) + break; + if (state->nca) { + endDrag(); + } +#ifdef Q_OS_MAC + else { // workaround for lack of mouse-grab on Mac + QMainWindowLayout *layout = qt_mainwindow_layout(qobject_cast<QMainWindow *>(q->parentWidget())); + Q_ASSERT(layout != 0); + + q->move(event->globalPos() - state->pressPos); + if (!state->ctrlDrag) + layout->hover(state->widgetItem, event->globalPos()); + } +#endif + break; + case QEvent::NonClientAreaMouseButtonRelease: +#ifdef Q_OS_MAC + if (state) + endDrag(); +#endif + break; + case QEvent::NonClientAreaMouseButtonDblClick: + _q_toggleTopLevel(); + break; + default: + break; + } +} + +void QDockWidgetPrivate::moveEvent(QMoveEvent *event) +{ + Q_Q(QDockWidget); + + if (state == 0 || !state->dragging || !state->nca || !q->isWindow()) + 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(qobject_cast<QMainWindow *>(q->parentWidget())); + Q_ASSERT(layout != 0); + + 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(qobject_cast<QMainWindow *>(q->parentWidget())); + if (mwlayout && mwlayout->dockWidgetArea(q) == Qt::NoDockWidgetArea) + return; // this dockwidget can't be redocked + } + + bool wasFloating = q->isFloating(); + 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 (unplug) + flags |= Qt::X11BypassWindowManagerHint; + + q->setWindowFlags(flags); + +#if defined(Q_WS_MAC) && !defined(QT_MAC_USE_COCOA) + if (floating && nativeDeco && (q->features() & QDockWidget::DockWidgetVerticalTitleBar)) { + ChangeWindowAttributes(HIViewGetWindow(HIViewRef(q->winId())), kWindowSideTitlebarAttribute, 0); + } +#endif + + 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(qobject_cast<QMainWindow *>(q->parentWidget())); + if (mwlayout) + emit q->dockLocationChanged(mwlayout->dockWidgetArea(q)); + } + } + + resizer->setActive(QWidgetResizeHandler::Resize, !unplug && floating && !nativeDeco); +} + +/*! + \class QDockWidget + + \brief The QDockWidget class provides a widget that can be docked + inside a QMainWindow or floated as a top-level window on the + desktop. + + \ingroup mainwindow-classes + + QDockWidget provides the concept of dock widgets, also know as + tool palettes or utility windows. Dock windows are secondary + windows placed in the \e {dock widget area} around the + \l{QMainWindow::centralWidget()}{central widget} in a + QMainWindow. + + \image mainwindow-docks.png + + Dock windows can be moved inside their current area, moved into + new areas and floated (e.g., undocked) by the end-user. The + QDockWidget API allows the programmer to restrict the dock widgets + ability to move, float and close, as well as the areas in which + they can be placed. + + \section1 Appearance + + A QDockWidget consists of a title bar and the content area. The + title bar displays the dock widgets \link QWidget::windowTitle() + window title\endlink, a \e float button and a \e close button. + Depending on the state of the QDockWidget, the \e float and \e + close buttons may be either disabled or not shown at all. + + The visual appearance of the title bar and buttons is dependent + on the \l{QStyle}{style} in use. + + A QDockWidget acts as a wrapper for its child widget, set with setWidget(). + Custom size hints, minimum and maximum sizes and size policies should be + implemented in the child widget. QDockWidget will respect them, adjusting + its own constraints to include the frame and title. Size constraints + should not be set on the QDockWidget itself, because they change depending + on whether it is docked; a docked QDockWidget has no frame and a smaller title + bar. + + \sa QMainWindow, {Dock Widgets Example} +*/ + +/*! + \enum QDockWidget::DockWidgetFeature + + \value DockWidgetClosable The dock widget can be closed. On some systems the dock + widget always has a close button when it's floating + (for example on MacOS 10.5). + \value DockWidgetMovable The dock widget can be moved between docks + by the user. + \value DockWidgetFloatable The dock widget can be detached from the + main window, and floated as an independent + window. + \value DockWidgetVerticalTitleBar The dock widget displays a vertical title + bar on its left side. This can be used to + increase the amount of vertical space in + a QMainWindow. + \value AllDockWidgetFeatures (Deprecated) The dock widget can be closed, moved, + and floated. Since new features might be added in future + releases, the look and behavior of dock widgets might + change if you use this flag. Please specify individual + flags instead. + \value NoDockWidgetFeatures The dock widget cannot be closed, moved, + or floated. + + \omitvalue DockWidgetFeatureMask + \omitvalue Reserved +*/ + +/*! + \property QDockWidget::windowTitle + \brief the dock widget title (caption) + + By default, this property contains an empty string. +*/ + +/*! + Constructs a QDockWidget with parent \a parent and window flags \a + flags. The dock widget will be placed in the left dock widget + area. +*/ +QDockWidget::QDockWidget(QWidget *parent, Qt::WindowFlags flags) + : QWidget(*new QDockWidgetPrivate, parent, flags) +{ + Q_D(QDockWidget); + d->init(); +} + +/*! + Constructs a QDockWidget with parent \a parent and window flags \a + flags. The dock widget will be placed in the left dock widget + area. + + The window title is set to \a title. This title is used when the + QDockWidget is docked and undocked. It is also used in the context + menu provided by QMainWindow. + + \sa setWindowTitle() +*/ +QDockWidget::QDockWidget(const QString &title, QWidget *parent, Qt::WindowFlags flags) + : QWidget(*new QDockWidgetPrivate, parent, flags) +{ + Q_D(QDockWidget); + d->init(); + setWindowTitle(title); +} + +/*! + Destroys the dock widget. +*/ +QDockWidget::~QDockWidget() +{ } + +/*! + Returns the widget for the dock widget. This function returns zero + if the widget has not been set. + + \sa setWidget() +*/ +QWidget *QDockWidget::widget() const +{ + QDockWidgetLayout *layout = qobject_cast<QDockWidgetLayout*>(this->layout()); + return layout->widgetForRole(QDockWidgetLayout::Content); +} + +/*! + Sets the widget for the dock widget to \a widget. + + If the dock widget is visible when \a widget is added, you must + \l{QWidget::}{show()} it explicitly. + + Note that you must add the layout of the \a widget before you call + this function; if not, the \a widget will not be visible. + + \sa widget() +*/ +void QDockWidget::setWidget(QWidget *widget) +{ + QDockWidgetLayout *layout = qobject_cast<QDockWidgetLayout*>(this->layout()); + layout->setWidgetForRole(QDockWidgetLayout::Content, widget); +} + +/*! + \property QDockWidget::features + \brief whether the dock widget is movable, closable, and floatable + + By default, this property is set to a combination of DockWidgetClosable, + DockWidgetMovable and DockWidgetFloatable. + + \sa DockWidgetFeature +*/ + +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()) { + //this ensures the native decoration is drawn + d->setWindowState(true /*floating*/, true /*unplug*/); + } +} + +QDockWidget::DockWidgetFeatures QDockWidget::features() const +{ + Q_D(const QDockWidget); + return d->features; +} + +/*! + \property QDockWidget::floating + \brief whether the dock widget is floating + + A floating dock widget is presented to the user as an independent + window "on top" of its parent QMainWindow, instead of being + docked in the QMainWindow. + + By default, this property is true. + + \sa isWindow() +*/ +void QDockWidget::setFloating(bool floating) +{ + Q_D(QDockWidget); + + // the initial click of a double-click may have started a drag... + if (d->state != 0) + d->endDrag(true); + + QRect r = d->undockedGeometry; + + 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 + } +} + +/*! + \property QDockWidget::allowedAreas + \brief areas where the dock widget may be placed + + The default is Qt::AllDockWidgetAreas. + + \sa Qt::DockWidgetArea +*/ + +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; +} + +/*! + \fn bool QDockWidget::isAreaAllowed(Qt::DockWidgetArea area) const + + Returns true if this dock widget can be placed in the given \a area; + otherwise returns false. +*/ + +/*! \reimp */ +void QDockWidget::changeEvent(QEvent *event) +{ + Q_D(QDockWidget); + QDockWidgetLayout *layout = qobject_cast<QDockWidgetLayout*>(this->layout()); + + switch (event->type()) { + case QEvent::ModifiedChange: + case QEvent::WindowTitleChange: + update(layout->titleArea()); +#ifndef QT_NO_ACTION + d->fixedWindowTitle = qt_setWindowTitle_helperHelper(windowTitle(), this); + d->toggleViewAction->setText(d->fixedWindowTitle); +#endif +#ifndef QT_NO_TABBAR + { + QMainWindow *win = qobject_cast<QMainWindow*>(parentWidget()); + if (QMainWindowLayout *winLayout = qt_mainwindow_layout(win)) { + if (QDockAreaLayoutInfo *info = winLayout->layoutState.dockAreaLayout.info(this)) + info->updateTabBar(); + } + } +#endif // QT_NO_TABBAR + break; + default: + break; + } + QWidget::changeEvent(event); +} + +/*! \reimp */ +void QDockWidget::closeEvent(QCloseEvent *event) +{ + Q_D(QDockWidget); + if (d->state) + d->endDrag(true); + QWidget::closeEvent(event); +} + +/*! \reimp */ +void QDockWidget::paintEvent(QPaintEvent *event) +{ + Q_UNUSED(event) + + QDockWidgetLayout *layout + = qobject_cast<QDockWidgetLayout*>(this->layout()); + bool customTitleBar = layout->widgetForRole(QDockWidgetLayout::TitleBar) != 0; + 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.init(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. XP style) + QStyleOptionDockWidgetV2 titleOpt; + initStyleOption(&titleOpt); + p.drawControl(QStyle::CE_DockWidgetTitle, titleOpt); + } +} + +/*! \reimp */ +bool QDockWidget::event(QEvent *event) +{ + Q_D(QDockWidget); + + QMainWindow *win = qobject_cast<QMainWindow*>(parentWidget()); + QMainWindowLayout *layout = qt_mainwindow_layout(win); + + switch (event->type()) { +#ifndef QT_NO_ACTION + case QEvent::Hide: + if (layout != 0) + layout->keepSize(this); + d->toggleViewAction->setChecked(false); + emit visibilityChanged(false); + break; + case QEvent::Show: + d->toggleViewAction->setChecked(true); + emit visibilityChanged(geometry().right() >= 0 && geometry().bottom() >= 0); + 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 != 0) { + const QObjectList &siblings = win->children(); + onTop = siblings.count() > 0 && siblings.last() == (QObject*)this; + } + if (!isFloating() && layout != 0 && onTop) + layout->raise(this); + 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; +#ifdef Q_OS_WIN + case QEvent::Leave: + if (d->state != 0 && d->state->dragging && !d->state->nca) { + // This is a workaround for loosing the mouse on Vista. + QPoint pos = QCursor::pos(); + QMouseEvent fake(QEvent::MouseMove, mapFromGlobal(pos), pos, Qt::NoButton, + QApplication::mouseButtons(), QApplication::keyboardModifiers()); + d->mouseMoveEvent(&fake); + } + break; +#endif + 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 != 0 && layout->pluggingWidget != this) + d->undockedGeometry = geometry(); + break; + default: + break; + } + return QWidget::event(event); +} + +#ifndef QT_NO_ACTION +/*! + Returns a checkable action that can be used to show or close this + dock widget. + + The action's text is set to the dock widget's window title. + + \sa QAction::text QWidget::windowTitle + */ +QAction * QDockWidget::toggleViewAction() const +{ + Q_D(const QDockWidget); + return d->toggleViewAction; +} +#endif // QT_NO_ACTION + +/*! + \fn void QDockWidget::featuresChanged(QDockWidget::DockWidgetFeatures features) + + This signal is emitted when the \l features property changes. The + \a features parameter gives the new value of the property. +*/ + +/*! + \fn void QDockWidget::topLevelChanged(bool topLevel) + + This signal is emitted when the \l floating property changes. + The \a topLevel parameter is true if the dock widget is now floating; + otherwise it is false. + + \sa isWindow() +*/ + +/*! + \fn void QDockWidget::allowedAreasChanged(Qt::DockWidgetAreas allowedAreas) + + This signal is emitted when the \l allowedAreas property changes. The + \a allowedAreas parameter gives the new value of the property. +*/ + +/*! + \fn void QDockWidget::visibilityChanged(bool visible) + \since 4.3 + + This signal is emitted when the dock widget becomes \a visible (or + invisible). This happens when the widget is hidden or shown, as + well as when it is docked in a tabbed dock area and its tab + becomes selected or unselected. +*/ + +/*! + \fn void QDockWidget::dockLocationChanged(Qt::DockWidgetArea area) + \since 4.3 + + This signal is emitted when the dock widget is moved to another + dock \a area, or is moved to a different location in its current + dock area. This happens when the dock widget is moved + programmatically or is dragged to a new location by the user. +*/ + +/*! + \since 4.3 + + Sets an arbitrary \a widget as the dock widget's title bar. If \a widget + is 0, any custom title bar widget previously set on the dock widget is + removed, but not deleted, and the default title bar will be used + instead. + + If a title bar widget is set, QDockWidget will not use native window + decorations when it is floated. + + Here are some tips for implementing custom title bars: + + \list + \o Mouse events that are not explicitly handled by the title bar widget + must be ignored by calling QMouseEvent::ignore(). These events then + propagate to the QDockWidget parent, which handles them in the usual + manner, moving when the title bar is dragged, docking and undocking + when it is double-clicked, etc. + + \o When DockWidgetVerticalTitleBar is set on QDockWidget, the title + bar widget is repositioned accordingly. In resizeEvent(), the title + bar should check what orientation it should assume: + \snippet doc/src/snippets/code/src_gui_widgets_qdockwidget.cpp 0 + + \o The title bar widget must have a valid QWidget::sizeHint() and + QWidget::minimumSizeHint(). These functions should take into account + the current orientation of the title bar. + + \o It is not possible to remove a title bar from a dock widget. However, + a similar effect can be achieved by setting a default constructed + QWidget as the title bar widget. + \endlist + + Using qobject_cast() as shown above, the title bar widget has full access + to its parent QDockWidget. Hence it can perform such operations as docking + and hiding in response to user actions. + + \sa titleBarWidget() DockWidgetVerticalTitleBar +*/ + +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*/); + } +} + +/*! + \since 4.3 + Returns the custom title bar widget set on the QDockWidget, or 0 if no + custom title bar has been set. + + \sa setTitleBarWidget() +*/ + +QWidget *QDockWidget::titleBarWidget() const +{ + QDockWidgetLayout *layout + = qobject_cast<QDockWidgetLayout*>(this->layout()); + return layout->widgetForRole(QDockWidgetLayout::TitleBar); +} + +QT_END_NAMESPACE + +#include "qdockwidget.moc" +#include "moc_qdockwidget.cpp" + +#endif // QT_NO_DOCKWIDGET |