1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qdockwidget.h"

    43 

    44 #ifndef QT_NO_DOCKWIDGET

    45 #include <qaction.h>

    46 #include <qapplication.h>

    47 #include <qdesktopwidget.h>

    48 #include <qdrawutil.h>

    49 #include <qevent.h>

    50 #include <qfontmetrics.h>

    51 #include <qmainwindow.h>

    52 #include <qrubberband.h>

    53 #include <qstylepainter.h>

    54 #include <qtoolbutton.h>

    55 #include <qdebug.h>

    56 

    57 #include <private/qwidgetresizehandler_p.h>

    58 

    59 #include "qdockwidget_p.h"

    60 #include "qmainwindowlayout_p.h"

    61 #ifdef Q_WS_MAC

    62 #include <private/qapplication_p.h>

    63 #include <private/qt_mac_p.h>

    64 #include <qmacstyle_mac.h>

    65 #endif

    66 

    67 QT_BEGIN_NAMESPACE

    68 

    69 extern QString qt_setWindowTitle_helperHelper(const QString&, const QWidget*); // qwidget.cpp

    70 

    71 static inline bool hasFeature(const QDockWidgetPrivate *priv, QDockWidget::DockWidgetFeature feature)

    72 { return (priv->features & feature) == feature; }

    73 

    74 static inline bool hasFeature(const QDockWidget *dockwidget, QDockWidget::DockWidgetFeature feature)

    75 { return (dockwidget->features() & feature) == feature; }

    76 

    77 

    78 /*

    79     A Dock Window:

    80 

    81     [+] is the float button

    82     [X] is the close button

    83 

    84     +-------------------------------+

    85     | Dock Window Title       [+][X]|

    86     +-------------------------------+

    87     |                               |

    88     | place to put the single       |

    89     | QDockWidget child (this space |

    90     | does not yet have a name)     |

    91     |                               |

    92     |                               |

    93     |                               |

    94     |                               |

    95     |                               |

    96     |                               |

    97     |                               |

    98     |                               |

    99     |                               |

   100     +-------------------------------+

   101 

   102 */

   103 

   104 /******************************************************************************

   105 ** QDockWidgetTitleButton

   106 */

   107 

   108 class QDockWidgetTitleButton : public QAbstractButton

   109 {

   110     Q_OBJECT

   111 

   112 public:

   113     QDockWidgetTitleButton(QDockWidget *dockWidget);

   114 

   115     QSize sizeHint() const;

   116     inline QSize minimumSizeHint() const

   117     { return sizeHint(); }

   118 

   119     void enterEvent(QEvent *event);

   120     void leaveEvent(QEvent *event);

   121     void paintEvent(QPaintEvent *event);

   122 };

   123 

   124 

   125 QDockWidgetTitleButton::QDockWidgetTitleButton(QDockWidget *dockWidget)

   126     : QAbstractButton(dockWidget)

   127 {

   128     setFocusPolicy(Qt::NoFocus);

   129 }

   130 

   131 QSize QDockWidgetTitleButton::sizeHint() const

   132 {

   133     ensurePolished();

   134 

   135     int size = 2*style()->pixelMetric(QStyle::PM_DockWidgetTitleBarButtonMargin, 0, this);

   136     if (!icon().isNull()) {

   137         int iconSize = style()->pixelMetric(QStyle::PM_SmallIconSize, 0, this);

   138         QSize sz = icon().actualSize(QSize(iconSize, iconSize));

   139         size += qMax(sz.width(), sz.height());

   140     }

   141 

   142     return QSize(size, size);

   143 }

   144 

   145 void QDockWidgetTitleButton::enterEvent(QEvent *event)

   146 {

   147     if (isEnabled()) update();

   148     QAbstractButton::enterEvent(event);

   149 }

   150 

   151 void QDockWidgetTitleButton::leaveEvent(QEvent *event)

   152 {

   153     if (isEnabled()) update();

   154     QAbstractButton::leaveEvent(event);

   155 }

   156 

   157 void QDockWidgetTitleButton::paintEvent(QPaintEvent *)

   158 {

   159     QPainter p(this);

   160 

   161     QRect r = rect();

   162     QStyleOptionToolButton opt;

   163     opt.init(this);

   164     opt.state |= QStyle::State_AutoRaise;

   165 

   166     if (style()->styleHint(QStyle::SH_DockWidget_ButtonsHaveFrame, 0, this))

   167     {

   168         if (isEnabled() && underMouse() && !isChecked() && !isDown())

   169             opt.state |= QStyle::State_Raised;

   170         if (isChecked())

   171             opt.state |= QStyle::State_On;

   172         if (isDown())

   173             opt.state |= QStyle::State_Sunken;

   174         style()->drawPrimitive(QStyle::PE_PanelButtonTool, &opt, &p, this);

   175     }

   176 

   177     opt.icon = icon();

   178     opt.subControls = 0;

   179     opt.activeSubControls = 0;

   180     opt.features = QStyleOptionToolButton::None;

   181     opt.arrowType = Qt::NoArrow;

   182     int size = style()->pixelMetric(QStyle::PM_SmallIconSize, 0, this);

   183     opt.iconSize = QSize(size, size);

   184     style()->drawComplexControl(QStyle::CC_ToolButton, &opt, &p, this);

   185 }

   186 

   187 /******************************************************************************

   188 ** QDockWidgetLayout

   189 */

   190 

   191 QDockWidgetLayout::QDockWidgetLayout(QWidget *parent)

   192     : QLayout(parent), verticalTitleBar(false), item_list(RoleCount, 0)

   193 {

   194 }

   195 

   196 QDockWidgetLayout::~QDockWidgetLayout()

   197 {

   198     qDeleteAll(item_list);

   199 }

   200 

   201 bool QDockWidgetLayout::nativeWindowDeco() const

   202 {

   203     return nativeWindowDeco(parentWidget()->isWindow());

   204 }

   205 

   206 bool QDockWidgetLayout::nativeWindowDeco(bool floating) const

   207 {

   208 #if defined(Q_WS_X11) || defined(Q_WS_QWS) || defined(Q_WS_WINCE)

   209     Q_UNUSED(floating);

   210     return false;

   211 #else

   212     return floating && item_list[QDockWidgetLayout::TitleBar] == 0;

   213 #endif

   214 }

   215 

   216 

   217 void QDockWidgetLayout::addItem(QLayoutItem*)

   218 {

   219     qWarning() << "QDockWidgetLayout::addItem(): please use QDockWidgetLayout::setWidget()";

   220     return;

   221 }

   222 

   223 QLayoutItem *QDockWidgetLayout::itemAt(int index) const

   224 {

   225     int cnt = 0;

   226     for (int i = 0; i < item_list.count(); ++i) {

   227         QLayoutItem *item = item_list.at(i);

   228         if (item == 0)

   229             continue;

   230         if (index == cnt++)

   231             return item;

   232     }

   233     return 0;

   234 }

   235 

   236 QLayoutItem *QDockWidgetLayout::takeAt(int index)

   237 {

   238     int j = 0;

   239     for (int i = 0; i < item_list.count(); ++i) {

   240         QLayoutItem *item = item_list.at(i);

   241         if (item == 0)

   242             continue;

   243         if (index == j) {

   244             item_list[i] = 0;

   245             invalidate();

   246             return item;

   247         }

   248         ++j;

   249     }

   250     return 0;

   251 }

   252 

   253 int QDockWidgetLayout::count() const

   254 {

   255     int result = 0;

   256     for (int i = 0; i < item_list.count(); ++i) {

   257         if (item_list.at(i))

   258             ++result;

   259     }

   260     return result;

   261 }

   262 

   263 QSize QDockWidgetLayout::sizeFromContent(const QSize &content, bool floating) const

   264 {

   265     QSize result = content;

   266 

   267     if (verticalTitleBar) {

   268         result.setHeight(qMax(result.height(), minimumTitleWidth()));

   269         result.setWidth(qMax(content.width(), 0));

   270     } else {

   271         result.setHeight(qMax(result.height(), 0));

   272         result.setWidth(qMax(content.width(), minimumTitleWidth()));

   273     }

   274 

   275     QDockWidget *w = qobject_cast<QDockWidget*>(parentWidget());

   276     const bool nativeDeco = nativeWindowDeco(floating);

   277 

   278     int fw = floating && !nativeDeco

   279             ? w->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, w)

   280             : 0;

   281 

   282     const int th = titleHeight();

   283     if (!nativeDeco) {

   284         if (verticalTitleBar)

   285             result += QSize(th + 2*fw, 2*fw);

   286         else

   287             result += QSize(2*fw, th + 2*fw);

   288     }

   289 

   290     result.setHeight(qMin(result.height(), (int) QWIDGETSIZE_MAX));

   291     result.setWidth(qMin(result.width(), (int) QWIDGETSIZE_MAX));

   292 

   293     if (content.width() < 0)

   294         result.setWidth(-1);

   295     if (content.height() < 0)

   296         result.setHeight(-1);

   297 

   298     int left, top, right, bottom;

   299     w->getContentsMargins(&left, &top, &right, &bottom);

   300     //we need to substract the contents margin (it will be added by the caller)

   301     QSize min = w->minimumSize() - QSize(left + right, top + bottom);

   302     QSize max = w->maximumSize() - QSize(left + right, top + bottom);

   303 

   304     /* A floating dockwidget will automatically get its minimumSize set to the layout's

   305        minimum size + deco. We're *not* interested in this, we only take minimumSize()

   306        into account if the user set it herself. Otherwise we end up expanding the result

   307        of a calculation for a non-floating dock widget to a floating dock widget's

   308        minimum size + window decorations. */

   309 

   310     uint explicitMin = 0;

   311     uint explicitMax = 0;

   312     if (w->d_func()->extra != 0) {

   313         explicitMin = w->d_func()->extra->explicitMinSize;

   314         explicitMax = w->d_func()->extra->explicitMaxSize;

   315     }

   316 

   317     if (!(explicitMin & Qt::Horizontal) || min.width() == 0)

   318         min.setWidth(-1);

   319     if (!(explicitMin & Qt::Vertical) || min.height() == 0)

   320         min.setHeight(-1);

   321 

   322     if (!(explicitMax & Qt::Horizontal))

   323         max.setWidth(QWIDGETSIZE_MAX);

   324     if (!(explicitMax & Qt::Vertical))

   325         max.setHeight(QWIDGETSIZE_MAX);

   326 

   327     return result.boundedTo(max).expandedTo(min);

   328 }

   329 

   330 QSize QDockWidgetLayout::sizeHint() const

   331 {

   332     QDockWidget *w = qobject_cast<QDockWidget*>(parentWidget());

   333 

   334     QSize content(-1, -1);

   335     if (item_list[Content] != 0)

   336         content = item_list[Content]->sizeHint();

   337 

   338     return sizeFromContent(content, w->isFloating());

   339 }

   340 

   341 QSize QDockWidgetLayout::maximumSize() const

   342 {

   343     if (item_list[Content] != 0) {

   344         const QSize content = item_list[Content]->maximumSize();

   345         return sizeFromContent(content, parentWidget()->isWindow());

   346     } else {

   347         return parentWidget()->maximumSize();

   348     }

   349 

   350 }

   351 

   352 QSize QDockWidgetLayout::minimumSize() const

   353 {

   354     QDockWidget *w = qobject_cast<QDockWidget*>(parentWidget());

   355 

   356     QSize content(0, 0);

   357     if (item_list[Content] != 0)

   358         content = item_list[Content]->minimumSize();

   359 

   360     return sizeFromContent(content, w->isFloating());

   361 }

   362 

   363 QWidget *QDockWidgetLayout::widgetForRole(Role r) const

   364 {

   365     QLayoutItem *item = item_list.at(r);

   366     return item == 0 ? 0 : item->widget();

   367 }

   368 

   369 QLayoutItem *QDockWidgetLayout::itemForRole(Role r) const

   370 {

   371     return item_list.at(r);

   372 }

   373 

   374 void QDockWidgetLayout::setWidgetForRole(Role r, QWidget *w)

   375 {

   376     QWidget *old = widgetForRole(r);

   377     if (old != 0) {

   378         old->hide();

   379         removeWidget(old);

   380     }

   381 

   382     if (w != 0) {

   383         addChildWidget(w);

   384         item_list[r] = new QWidgetItemV2(w);

   385         w->show();

   386     } else {

   387         item_list[r] = 0;

   388     }

   389 

   390     invalidate();

   391 }

   392 

   393 static inline int pick(bool vertical, const QSize &size)

   394 {

   395     return vertical ? size.height() : size.width();

   396 }

   397 

   398 static inline int perp(bool vertical, const QSize &size)

   399 {

   400     return vertical ? size.width() : size.height();

   401 }

   402 

   403 int QDockWidgetLayout::minimumTitleWidth() const

   404 {

   405     QDockWidget *q = qobject_cast<QDockWidget*>(parentWidget());

   406 

   407     if (QWidget *title = widgetForRole(TitleBar))

   408         return pick(verticalTitleBar, title->minimumSizeHint());

   409 

   410     QSize closeSize(0, 0);

   411     QSize floatSize(0, 0);

   412     if (hasFeature(q, QDockWidget::DockWidgetClosable)) {

   413         if (QLayoutItem *item = item_list[CloseButton])

   414             closeSize = item->widget()->sizeHint();

   415     }

   416     if (hasFeature(q, QDockWidget::DockWidgetFloatable)) {

   417         if (QLayoutItem *item = item_list[FloatButton])

   418             floatSize = item->widget()->sizeHint();

   419     }

   420 

   421     int titleHeight = this->titleHeight();

   422 

   423     int mw = q->style()->pixelMetric(QStyle::PM_DockWidgetTitleMargin, 0, q);

   424     int fw = q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, q);

   425 

   426     return pick(verticalTitleBar, closeSize)

   427             + pick(verticalTitleBar, floatSize)

   428             + titleHeight + 2*fw + 3*mw;

   429 }

   430 

   431 int QDockWidgetLayout::titleHeight() const

   432 {

   433     QDockWidget *q = qobject_cast<QDockWidget*>(parentWidget());

   434 

   435     if (QWidget *title = widgetForRole(TitleBar))

   436         return perp(verticalTitleBar, title->sizeHint());

   437 

   438     QSize closeSize(0, 0);

   439     QSize floatSize(0, 0);

   440     if (QLayoutItem *item = item_list[CloseButton])

   441         closeSize = item->widget()->sizeHint();

   442     if (QLayoutItem *item = item_list[FloatButton])

   443         floatSize = item->widget()->sizeHint();

   444 

   445     int buttonHeight = qMax(perp(verticalTitleBar, closeSize),

   446                             perp(verticalTitleBar, floatSize));

   447 

   448     QFontMetrics titleFontMetrics = q->fontMetrics();

   449 #ifdef Q_WS_MAC

   450     if (qobject_cast<QMacStyle *>(q->style())) {

   451         //### this breaks on proxy styles.  (But is this code still called?)

   452         QFont font = qt_app_fonts_hash()->value("QToolButton", q->font());

   453         titleFontMetrics = QFontMetrics(font);

   454     }

   455 #endif

   456 

   457     int mw = q->style()->pixelMetric(QStyle::PM_DockWidgetTitleMargin, 0, q);

   458 

   459     return qMax(buttonHeight + 2, titleFontMetrics.height() + 2*mw);

   460 }

   461 

   462 void QDockWidgetLayout::setGeometry(const QRect &geometry)

   463 {

   464     QDockWidget *q = qobject_cast<QDockWidget*>(parentWidget());

   465 

   466     bool nativeDeco = nativeWindowDeco();

   467 

   468     int fw = q->isFloating() && !nativeDeco

   469             ? q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, q)

   470             : 0;

   471 

   472     if (nativeDeco) {

   473         if (QLayoutItem *item = item_list[Content])

   474             item->setGeometry(geometry);

   475     } else {

   476         int titleHeight = this->titleHeight();

   477 

   478         if (verticalTitleBar) {

   479             _titleArea = QRect(QPoint(fw, fw),

   480                                 QSize(titleHeight, geometry.height() - (fw * 2)));

   481         } else {

   482             _titleArea = QRect(QPoint(fw, fw),

   483                                 QSize(geometry.width() - (fw * 2), titleHeight));

   484         }

   485 

   486         if (QLayoutItem *item = item_list[TitleBar]) {

   487             item->setGeometry(_titleArea);

   488         } else {

   489             QStyleOptionDockWidgetV2 opt;

   490             q->initStyleOption(&opt);

   491 

   492             if (QLayoutItem *item = item_list[CloseButton]) {

   493                 if (!item->isEmpty()) {

   494                     QRect r = q->style()

   495                         ->subElementRect(QStyle::SE_DockWidgetCloseButton,

   496                                             &opt, q);

   497                     if (!r.isNull())

   498                         item->setGeometry(r);

   499                 }

   500             }

   501 

   502             if (QLayoutItem *item = item_list[FloatButton]) {

   503                 if (!item->isEmpty()) {

   504                     QRect r = q->style()

   505                         ->subElementRect(QStyle::SE_DockWidgetFloatButton,

   506                                             &opt, q);

   507                     if (!r.isNull())

   508                         item->setGeometry(r);

   509                 }

   510             }

   511         }

   512 

   513         if (QLayoutItem *item = item_list[Content]) {

   514             QRect r = geometry;

   515             if (verticalTitleBar) {

   516                 r.setLeft(_titleArea.right() + 1);

   517                 r.adjust(0, fw, -fw, -fw);

   518             } else {

   519                 r.setTop(_titleArea.bottom() + 1);

   520                 r.adjust(fw, 0, -fw, -fw);

   521             }

   522             item->setGeometry(r);

   523         }

   524     }

   525 }

   526 

   527 void QDockWidgetLayout::setVerticalTitleBar(bool b)

   528 {

   529     if (b == verticalTitleBar)

   530         return;

   531     verticalTitleBar = b;

   532     invalidate();

   533     parentWidget()->update();

   534 }

   535 

   536 /******************************************************************************

   537 ** QDockWidgetItem

   538 */

   539 

   540 QDockWidgetItem::QDockWidgetItem(QDockWidget *dockWidget)

   541     : QWidgetItem(dockWidget)

   542 {

   543 }

   544 

   545 QSize QDockWidgetItem::minimumSize() const

   546 {

   547     QSize widgetMin(0, 0);

   548     if (QLayoutItem *item = dockWidgetChildItem())

   549         widgetMin = item->minimumSize();

   550     return dockWidgetLayout()->sizeFromContent(widgetMin, false);

   551 }

   552 

   553 QSize QDockWidgetItem::maximumSize() const

   554 {

   555     if (QLayoutItem *item = dockWidgetChildItem()) {

   556         return dockWidgetLayout()->sizeFromContent(item->maximumSize(), false);

   557     } else {

   558         return QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);

   559     }

   560 }

   561 

   562 

   563 QSize QDockWidgetItem::sizeHint() const

   564 {

   565     if (QLayoutItem *item = dockWidgetChildItem()) {

   566          return dockWidgetLayout()->sizeFromContent(item->sizeHint(), false);

   567     } else {

   568         return QWidgetItem::sizeHint();

   569     }

   570 }

   571 

   572 /******************************************************************************

   573 ** QDockWidgetPrivate

   574 */

   575 

   576 void QDockWidgetPrivate::init()

   577 {

   578     Q_Q(QDockWidget);

   579 

   580     QDockWidgetLayout *layout = new QDockWidgetLayout(q);

   581     layout->setSizeConstraint(QLayout::SetMinAndMaxSize);

   582 

   583     QAbstractButton *button = new QDockWidgetTitleButton(q);

   584     button->setObjectName(QLatin1String("qt_dockwidget_floatbutton"));

   585     QObject::connect(button, SIGNAL(clicked()), q, SLOT(_q_toggleTopLevel()));

   586     layout->setWidgetForRole(QDockWidgetLayout::FloatButton, button);

   587 

   588     button = new QDockWidgetTitleButton(q);

   589     button->setObjectName(QLatin1String("qt_dockwidget_closebutton"));

   590     QObject::connect(button, SIGNAL(clicked()), q, SLOT(close()));

   591     layout->setWidgetForRole(QDockWidgetLayout::CloseButton, button);

   592 

   593     resizer = new QWidgetResizeHandler(q);

   594     resizer->setMovingEnabled(false);

   595     resizer->setActive(false);

   596 

   597 #ifndef QT_NO_ACTION

   598     toggleViewAction = new QAction(q);

   599     toggleViewAction->setCheckable(true);

   600     fixedWindowTitle = qt_setWindowTitle_helperHelper(q->windowTitle(), q);

   601     toggleViewAction->setText(fixedWindowTitle);

   602     QObject::connect(toggleViewAction, SIGNAL(triggered(bool)),

   603                         q, SLOT(_q_toggleView(bool)));

   604 #endif

   605 

   606     updateButtons();

   607 }

   608 

   609 /*!

   610     Initialize \a option with the values from this QDockWidget. This method

   611     is useful for subclasses when they need a QStyleOptionDockWidget, but don't want

   612     to fill in all the information themselves.

   613 

   614     \sa QStyleOption::initFrom()

   615 */

   616 void QDockWidget::initStyleOption(QStyleOptionDockWidget *option) const

   617 {

   618     Q_D(const QDockWidget);

   619 

   620     if (!option)

   621         return;

   622     QDockWidgetLayout *dwlayout = qobject_cast<QDockWidgetLayout*>(layout());

   623 

   624     option->initFrom(this);

   625     option->rect = dwlayout->titleArea();

   626     option->title = d->fixedWindowTitle;

   627     option->closable = hasFeature(this, QDockWidget::DockWidgetClosable);

   628     option->movable = hasFeature(this, QDockWidget::DockWidgetMovable);

   629     option->floatable = hasFeature(this, QDockWidget::DockWidgetFloatable);

   630 

   631     QDockWidgetLayout *l = qobject_cast<QDockWidgetLayout*>(layout());

   632     QStyleOptionDockWidgetV2 *v2

   633         = qstyleoption_cast<QStyleOptionDockWidgetV2*>(option);

   634     if (v2 != 0)

   635         v2->verticalTitleBar = l->verticalTitleBar;

   636 }

   637 

   638 void QDockWidgetPrivate::_q_toggleView(bool b)

   639 {

   640     Q_Q(QDockWidget);

   641     if (b == q->isHidden()) {

   642         if (b)

   643             q->show();

   644         else

   645             q->close();

   646     }

   647 }

   648 

   649 void QDockWidgetPrivate::updateButtons()

   650 {

   651     Q_Q(QDockWidget);

   652     QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout);

   653 

   654     QStyleOptionDockWidget opt;

   655     q->initStyleOption(&opt);

   656 

   657     bool customTitleBar = dwLayout->widgetForRole(QDockWidgetLayout::TitleBar) != 0;

   658     bool nativeDeco = dwLayout->nativeWindowDeco();

   659     bool hideButtons = nativeDeco || customTitleBar;

   660 

   661     bool canClose = hasFeature(this, QDockWidget::DockWidgetClosable);

   662     bool canFloat = hasFeature(this, QDockWidget::DockWidgetFloatable);

   663 

   664     QAbstractButton *button

   665         = qobject_cast<QAbstractButton*>(dwLayout->widgetForRole(QDockWidgetLayout::FloatButton));

   666     button->setIcon(q->style()->standardIcon(QStyle::SP_TitleBarNormalButton, &opt, q));

   667     button->setVisible(canFloat && !hideButtons);

   668 

   669     button

   670         = qobject_cast <QAbstractButton*>(dwLayout->widgetForRole(QDockWidgetLayout::CloseButton));

   671     button->setIcon(q->style()->standardIcon(QStyle::SP_TitleBarCloseButton, &opt, q));

   672     button->setVisible(canClose && !hideButtons);

   673 

   674     q->setAttribute(Qt::WA_ContentsPropagated,

   675                     (canFloat || canClose) && !hideButtons);

   676 

   677     layout->invalidate();

   678 }

   679 

   680 void QDockWidgetPrivate::_q_toggleTopLevel()

   681 {

   682     Q_Q(QDockWidget);

   683     q->setFloating(!q->isFloating());

   684 }

   685 

   686 void QDockWidgetPrivate::initDrag(const QPoint &pos, bool nca)

   687 {

   688     if (state != 0)

   689         return;

   690 

   691     QMainWindow *win = qobject_cast<QMainWindow*>(parent);

   692     Q_ASSERT(win != 0);

   693     QMainWindowLayout *layout = qobject_cast<QMainWindowLayout*>(win->layout());

   694     Q_ASSERT(layout != 0);

   695     if (layout->pluggingWidget != 0) // the main window is animating a docking operation

   696         return;

   697 

   698     state = new QDockWidgetPrivate::DragState;

   699     state->pressPos = pos;

   700     state->dragging = false;

   701     state->widgetItem = 0;

   702     state->ownWidgetItem = false;

   703     state->nca = nca;

   704     state->ctrlDrag = false;

   705 }

   706 

   707 void QDockWidgetPrivate::startDrag()

   708 {

   709     Q_Q(QDockWidget);

   710 

   711     if (state == 0 || state->dragging)

   712         return;

   713 

   714     QMainWindowLayout *layout

   715         = qobject_cast<QMainWindowLayout *>(q->parentWidget()->layout());

   716     Q_ASSERT(layout != 0);

   717 

   718     state->widgetItem = layout->unplug(q);

   719     if (state->widgetItem == 0) {

   720         /* I have a QMainWindow parent, but I was never inserted with

   721             QMainWindow::addDockWidget, so the QMainWindowLayout has no

   722             widget item for me. :( I have to create it myself, and then

   723             delete it if I don't get dropped into a dock area. */

   724         state->widgetItem = new QDockWidgetItem(q);

   725         state->ownWidgetItem = true;

   726     }

   727 

   728     if (state->ctrlDrag)

   729         layout->restore();

   730 

   731     state->dragging = true;

   732 }

   733 

   734 void QDockWidgetPrivate::endDrag(bool abort)

   735 {

   736     Q_Q(QDockWidget);

   737     Q_ASSERT(state != 0);

   738 

   739     q->releaseMouse();

   740 

   741     if (state->dragging) {

   742         QMainWindowLayout *mwLayout =

   743             qobject_cast<QMainWindowLayout *>(q->parentWidget()->layout());

   744         Q_ASSERT(mwLayout != 0);

   745 

   746         if (abort || !mwLayout->plug(state->widgetItem)) {

   747             if (hasFeature(this, QDockWidget::DockWidgetFloatable)) {

   748                 if (state->ownWidgetItem)

   749                     delete state->widgetItem;

   750                 mwLayout->restore();

   751 #ifdef Q_WS_X11

   752                 // get rid of the X11BypassWindowManager window flag and activate the resizer

   753                 Qt::WindowFlags flags = q->windowFlags();

   754                 flags &= ~Qt::X11BypassWindowManagerHint;

   755                 q->setWindowFlags(flags);

   756                 resizer->setActive(QWidgetResizeHandler::Resize, true);

   757                 q->show();

   758 #else

   759                 QDockWidgetLayout *myLayout

   760                     = qobject_cast<QDockWidgetLayout*>(layout);

   761                 resizer->setActive(QWidgetResizeHandler::Resize,

   762                                     myLayout->widgetForRole(QDockWidgetLayout::TitleBar) != 0);

   763 #endif

   764                 undockedGeometry = q->geometry();

   765                 q->activateWindow();

   766             } else {

   767                 mwLayout->revert(state->widgetItem);

   768             }

   769         }

   770     }

   771     delete state;

   772     state = 0;

   773 }

   774 

   775 bool QDockWidgetPrivate::isAnimating() const

   776 {

   777     Q_Q(const QDockWidget);

   778 

   779     QMainWindow *mainWin = qobject_cast<QMainWindow*>(parent);

   780     if (mainWin == 0)

   781         return false;

   782 

   783     QMainWindowLayout *mainWinLayout

   784         = qobject_cast<QMainWindowLayout*>(mainWin->layout());

   785     if (mainWinLayout == 0)

   786         return false;

   787 

   788     return (void*)mainWinLayout->pluggingWidget == (void*)q;

   789 }

   790 

   791 bool QDockWidgetPrivate::mousePressEvent(QMouseEvent *event)

   792 {

   793 #if !defined(QT_NO_MAINWINDOW)

   794     Q_Q(QDockWidget);

   795 

   796     QDockWidgetLayout *dwLayout

   797         = qobject_cast<QDockWidgetLayout*>(layout);

   798 

   799     if (!dwLayout->nativeWindowDeco()) {

   800         QRect titleArea = dwLayout->titleArea();

   801 

   802         if (event->button() != Qt::LeftButton ||

   803             !titleArea.contains(event->pos()) ||

   804             // check if the tool window is movable... do nothing if it

   805             // is not (but allow moving if the window is floating)

   806             (!hasFeature(this, QDockWidget::DockWidgetMovable) && !q->isFloating()) ||

   807             qobject_cast<QMainWindow*>(parent) == 0 ||

   808             isAnimating() || state != 0) {

   809             return false;

   810         }

   811 

   812         initDrag(event->pos(), false);

   813 

   814         if (state)

   815             state->ctrlDrag = hasFeature(this, QDockWidget::DockWidgetFloatable) && event->modifiers() & Qt::ControlModifier;

   816 

   817         return true;

   818     }

   819 

   820 #endif // !defined(QT_NO_MAINWINDOW)

   821     return false;

   822 }

   823 

   824 bool QDockWidgetPrivate::mouseDoubleClickEvent(QMouseEvent *event)

   825 {

   826     QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout);

   827 

   828     if (!dwLayout->nativeWindowDeco()) {

   829         QRect titleArea = dwLayout->titleArea();

   830 

   831         if (event->button() == Qt::LeftButton && titleArea.contains(event->pos()) &&

   832             hasFeature(this, QDockWidget::DockWidgetFloatable)) {

   833             _q_toggleTopLevel();

   834             return true;

   835         }

   836     }

   837     return false;

   838 }

   839 

   840 bool QDockWidgetPrivate::mouseMoveEvent(QMouseEvent *event)

   841 {

   842     bool ret = false;

   843 #if !defined(QT_NO_MAINWINDOW)

   844     Q_Q(QDockWidget);

   845 

   846     if (!state)

   847         return ret;

   848 

   849     QDockWidgetLayout *dwlayout

   850         = qobject_cast<QDockWidgetLayout*>(layout);

   851     QMainWindowLayout *mwlayout

   852         = qobject_cast<QMainWindowLayout*>(q->parentWidget()->layout());

   853     if (!dwlayout->nativeWindowDeco()) {

   854         if (!state->dragging

   855             && mwlayout->pluggingWidget == 0

   856             && (event->pos() - state->pressPos).manhattanLength()

   857                 > QApplication::startDragDistance()) {

   858             startDrag();

   859 #ifdef Q_OS_WIN

   860             grabMouseWhileInWindow();

   861 #else

   862             q->grabMouse();

   863 #endif

   864             ret = true;

   865         }

   866     }

   867 

   868     if (state->dragging && !state->nca) {

   869         QPoint pos = event->globalPos() - state->pressPos;

   870         q->move(pos);

   871 

   872         if (!state->ctrlDrag)

   873             mwlayout->hover(state->widgetItem, event->globalPos());

   874 

   875         ret = true;

   876     }

   877 

   878 #endif // !defined(QT_NO_MAINWINDOW)

   879     return ret;

   880 }

   881 

   882 bool QDockWidgetPrivate::mouseReleaseEvent(QMouseEvent *event)

   883 {

   884 #if !defined(QT_NO_MAINWINDOW)

   885 

   886     if (event->button() == Qt::LeftButton && state && !state->nca) {

   887         endDrag();

   888         return true; //filter out the event

   889     }

   890 

   891 #endif // !defined(QT_NO_MAINWINDOW)

   892     return false;

   893 }

   894 

   895 void QDockWidgetPrivate::nonClientAreaMouseEvent(QMouseEvent *event)

   896 {

   897     Q_Q(QDockWidget);

   898 

   899     int fw = q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, q);

   900 

   901     QRect geo = q->geometry();

   902     QRect titleRect = q->frameGeometry();

   903 #ifdef Q_WS_MAC

   904     if ((features & QDockWidget::DockWidgetVerticalTitleBar)) {

   905         titleRect.setTop(geo.top());

   906         titleRect.setBottom(geo.bottom());

   907         titleRect.setRight(geo.left() - 1);

   908     } else

   909 #endif

   910     {

   911         titleRect.setLeft(geo.left());

   912         titleRect.setRight(geo.right());

   913         titleRect.setBottom(geo.top() - 1);

   914         titleRect.adjust(0, fw, 0, 0);

   915     }

   916 

   917     switch (event->type()) {

   918         case QEvent::NonClientAreaMouseButtonPress:

   919             if (!titleRect.contains(event->globalPos()))

   920                 break;

   921             if (state != 0)

   922                 break;

   923             if (qobject_cast<QMainWindow*>(parent) == 0)

   924                 break;

   925             if (isAnimating())

   926                 break;

   927             initDrag(event->pos(), true);

   928             if (state == 0)

   929                 break;

   930 #ifdef Q_OS_WIN

   931             // On Windows, NCA mouse events don't contain modifier info

   932             state->ctrlDrag = GetKeyState(VK_CONTROL) & 0x8000;

   933 #else

   934             state->ctrlDrag = event->modifiers() & Qt::ControlModifier;

   935 #endif

   936             startDrag();

   937             break;

   938         case QEvent::NonClientAreaMouseMove:

   939             if (state == 0 || !state->dragging)

   940                 break;

   941             if (state->nca) {

   942                 endDrag();

   943             }

   944 #ifdef Q_OS_MAC

   945             else { // workaround for lack of mouse-grab on Mac

   946                 QMainWindowLayout *layout

   947                     = qobject_cast<QMainWindowLayout *>(q->parentWidget()->layout());

   948                 Q_ASSERT(layout != 0);

   949 

   950                 q->move(event->globalPos() - state->pressPos);

   951                 if (!state->ctrlDrag)

   952                     layout->hover(state->widgetItem, event->globalPos());

   953             }

   954 #endif

   955             break;

   956         case QEvent::NonClientAreaMouseButtonRelease:

   957 #ifdef Q_OS_MAC

   958                         if (state)

   959                                 endDrag();

   960 #endif

   961                         break;

   962         case QEvent::NonClientAreaMouseButtonDblClick:

   963             _q_toggleTopLevel();

   964             break;

   965         default:

   966             break;

   967     }

   968 }

   969 

   970 void QDockWidgetPrivate::moveEvent(QMoveEvent *event)

   971 {

   972     Q_Q(QDockWidget);

   973 

   974     if (state == 0 || !state->dragging || !state->nca || !q->isWindow())

   975         return;

   976 

   977     // When the native window frame is being dragged, all we get is these mouse

   978     // move events.

   979 

   980     if (state->ctrlDrag)

   981         return;

   982 

   983     QMainWindowLayout *layout

   984         = qobject_cast<QMainWindowLayout *>(q->parentWidget()->layout());

   985     Q_ASSERT(layout != 0);

   986 

   987     QPoint globalMousePos = event->pos() + state->pressPos;

   988     layout->hover(state->widgetItem, globalMousePos);

   989 }

   990 

   991 void QDockWidgetPrivate::unplug(const QRect &rect)

   992 {

   993     Q_Q(QDockWidget);

   994     QRect r = rect;

   995     r.moveTopLeft(q->mapToGlobal(QPoint(0, 0)));

   996     QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout);

   997     if (dwLayout->nativeWindowDeco(true))

   998         r.adjust(0, dwLayout->titleHeight(), 0, 0);

   999     setWindowState(true, true, r);

  1000 }

  1001 

  1002 void QDockWidgetPrivate::plug(const QRect &rect)

  1003 {

  1004     setWindowState(false, false, rect);

  1005 }

  1006 

  1007 void QDockWidgetPrivate::setWindowState(bool floating, bool unplug, const QRect &rect)

  1008 {

  1009     Q_Q(QDockWidget);

  1010 

  1011     if (!floating && parent) {

  1012         QMainWindowLayout *mwlayout = qobject_cast<QMainWindowLayout *>(q->parentWidget()->layout());

  1013         if (!mwlayout || mwlayout->dockWidgetArea(q) == Qt::NoDockWidgetArea)

  1014             return; // this dockwidget can't be redocked

  1015     }

  1016 

  1017     bool wasFloating = q->isFloating();

  1018     bool hidden = q->isHidden();

  1019 

  1020     if (q->isVisible())

  1021         q->hide();

  1022 

  1023     Qt::WindowFlags flags = floating ? Qt::Tool : Qt::Widget;

  1024 

  1025     QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout);

  1026     const bool nativeDeco = dwLayout->nativeWindowDeco(floating);

  1027 

  1028     if (nativeDeco) {

  1029         flags |= Qt::CustomizeWindowHint | Qt::WindowTitleHint;

  1030         if (hasFeature(this, QDockWidget::DockWidgetClosable))

  1031             flags |= Qt::WindowCloseButtonHint;

  1032     } else {

  1033         flags |= Qt::FramelessWindowHint;

  1034     }

  1035 

  1036     if (unplug)

  1037         flags |= Qt::X11BypassWindowManagerHint;

  1038 

  1039     q->setWindowFlags(flags);

  1040 

  1041 #if defined(Q_WS_MAC) && !defined(QT_MAC_USE_COCOA)

  1042     if (floating && nativeDeco && (q->features() & QDockWidget::DockWidgetVerticalTitleBar)) {

  1043         ChangeWindowAttributes(HIViewGetWindow(HIViewRef(q->winId())), kWindowSideTitlebarAttribute, 0);

  1044     }

  1045 #endif

  1046 

  1047     if (!rect.isNull())

  1048         q->setGeometry(rect);

  1049 

  1050     updateButtons();

  1051 

  1052     if (!hidden)

  1053         q->show();

  1054 

  1055     if (floating != wasFloating) {

  1056         emit q->topLevelChanged(floating);

  1057         if (!floating && parent) {

  1058             QMainWindowLayout *mwlayout = qobject_cast<QMainWindowLayout *>(q->parentWidget()->layout());

  1059             if (mwlayout)

  1060                 emit q->dockLocationChanged(mwlayout->dockWidgetArea(q));

  1061         }

  1062     }

  1063 

  1064     resizer->setActive(QWidgetResizeHandler::Resize, !unplug && floating && !nativeDeco);

  1065 }

  1066 

  1067 /*!

  1068     \class QDockWidget

  1069 

  1070     \brief The QDockWidget class provides a widget that can be docked

  1071     inside a QMainWindow or floated as a top-level window on the

  1072     desktop.

  1073 

  1074     \ingroup mainwindow-classes

  1075 

  1076     QDockWidget provides the concept of dock widgets, also know as

  1077     tool palettes or utility windows.  Dock windows are secondary

  1078     windows placed in the \e {dock widget area} around the

  1079     \l{QMainWindow::centralWidget()}{central widget} in a

  1080     QMainWindow.

  1081 

  1082     \image mainwindow-docks.png

  1083 

  1084     Dock windows can be moved inside their current area, moved into

  1085     new areas and floated (e.g., undocked) by the end-user.  The

  1086     QDockWidget API allows the programmer to restrict the dock widgets

  1087     ability to move, float and close, as well as the areas in which

  1088     they can be placed.

  1089 

  1090     \section1 Appearance

  1091 

  1092     A QDockWidget consists of a title bar and the content area.  The

  1093     title bar displays the dock widgets \link QWidget::windowTitle()

  1094     window title\endlink, a \e float button and a \e close button.

  1095     Depending on the state of the QDockWidget, the \e float and \e

  1096     close buttons may be either disabled or not shown at all.

  1097 

  1098     The visual appearance of the title bar and buttons is dependent

  1099     on the \l{QStyle}{style} in use.

  1100 

  1101     A QDockWidget acts as a wrapper for its child widget, set with setWidget().

  1102     Custom size hints, minimum and maximum sizes and size policies should be

  1103     implemented in the child widget. QDockWidget will respect them, adjusting

  1104     its own constraints to include the frame and title. Size constraints

  1105     should not be set on the QDockWidget itself, because they change depending

  1106     on whether it is docked; a docked QDockWidget has no frame and a smaller title

  1107     bar.

  1108 

  1109     \sa QMainWindow, {Dock Widgets Example}

  1110 */

  1111 

  1112 /*!

  1113     \enum QDockWidget::DockWidgetFeature

  1114 

  1115     \value DockWidgetClosable   The dock widget can be closed. On some systems the dock

  1116 	                            widget always has a close button when it's floating

  1117 								(for example on MacOS 10.5).

  1118     \value DockWidgetMovable    The dock widget can be moved between docks

  1119                                 by the user.

  1120     \value DockWidgetFloatable  The dock widget can be detached from the

  1121                                 main window, and floated as an independent

  1122                                 window.

  1123     \value DockWidgetVerticalTitleBar The dock widget displays a vertical title

  1124                                   bar on its left side. This can be used to

  1125                                   increase the amount of vertical space in

  1126                                   a QMainWindow.

  1127     \value AllDockWidgetFeatures  (Deprecated) The dock widget can be closed, moved,

  1128                                   and floated. Since new features might be added in future

  1129                                   releases, the look and behavior of dock widgets might

  1130                                   change if you use this flag. Please specify individual

  1131                                   flags instead.

  1132     \value NoDockWidgetFeatures   The dock widget cannot be closed, moved,

  1133                                   or floated.

  1134 

  1135     \omitvalue DockWidgetFeatureMask