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

     2 **

     3 ** Copyright (C) 2009 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 Qt3Support 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 "q3dockwindow.h"

    43 

    44 #ifndef QT_NO_MAINWINDOW

    45 #include "qapplication.h"

    46 #include "qcursor.h"

    47 #include "qdesktopwidget.h"

    48 #include "q3dockarea.h"

    49 #include "qevent.h"

    50 #include "qlayout.h"

    51 #include "q3mainwindow.h"

    52 #include "qpainter.h"

    53 #include "qpointer.h"

    54 #include "qstyle.h"

    55 #include "qstyleoption.h"

    56 #include "qtimer.h"

    57 #include "q3toolbar.h"

    58 #include "qtoolbutton.h"

    59 #include "qtooltip.h"

    60 #include <private/q3titlebar_p.h>

    61 #include <private/qwidgetresizehandler_p.h>

    62 #include <qrubberband.h>

    63 #include <qdebug.h>

    64 

    65 QT_BEGIN_NAMESPACE

    66 

    67 #ifdef Q_WS_MAC

    68 static bool default_opaque = true;

    69 #else

    70 static bool default_opaque = false;

    71 #endif

    72 

    73 class Q3DockWindowPrivate

    74 {

    75 };

    76 

    77 class Q3DockWindowResizeHandle : public QWidget

    78 {

    79     Q_OBJECT

    80 

    81 public:

    82     Q3DockWindowResizeHandle(Qt::Orientation o, QWidget *parent, Q3DockWindow *w, const char* /*name*/=0);

    83     void setOrientation(Qt::Orientation o);

    84     Qt::Orientation orientation() const { return orient; }

    85 

    86     QSize sizeHint() const;

    87 

    88 protected:

    89     void paintEvent(QPaintEvent *);

    90     void mouseMoveEvent(QMouseEvent *);

    91     void mousePressEvent(QMouseEvent *);

    92     void mouseReleaseEvent(QMouseEvent *);

    93     bool event(QEvent *event);

    94 

    95 private:

    96     void startLineDraw();

    97     void endLineDraw();

    98     void drawLine(const QPoint &globalPos);

    99 

   100 private:

   101     Qt::Orientation orient;

   102     bool mousePressed;

   103     QRubberBand *rubberBand;

   104     QPoint lastPos, firstPos;

   105     Q3DockWindow *dockWindow;

   106     bool mouseOver;

   107 };

   108 

   109 Q3DockWindowResizeHandle::Q3DockWindowResizeHandle(Qt::Orientation o, QWidget *parent,

   110                                                   Q3DockWindow *w, const char *)

   111     : QWidget(parent, "qt_dockwidget_internal"), mousePressed(false), rubberBand(0), dockWindow(w),

   112       mouseOver(false)

   113 {

   114     setOrientation(o);

   115 }

   116 

   117 QSize Q3DockWindowResizeHandle::sizeHint() const

   118 {

   119     QStyleOptionQ3DockWindow opt;

   120     opt.init(this);

   121     if (!dockWindow->area() || dockWindow->area()->orientation() == Qt::Horizontal)

   122         opt.state |= QStyle::State_Horizontal;

   123 

   124     opt.rect = rect();

   125     opt.docked = dockWindow->area();

   126     opt.closeEnabled = dockWindow->isCloseEnabled();

   127     int sw = 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, &opt, this) / 3;

   128     return (style()->sizeFromContents(QStyle::CT_Q3DockWindow, &opt, QSize(sw, sw), this).expandedTo(QApplication::globalStrut()));

   129 }

   130 

   131 void Q3DockWindowResizeHandle::setOrientation(Qt::Orientation o)

   132 {

   133     orient = o;

   134     if (o == Qt::Horizontal) {

   135 #ifndef QT_NO_CURSOR

   136         setCursor(Qt::splitVCursor);

   137 #endif

   138         setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));

   139     } else {

   140 #ifndef QT_NO_CURSOR

   141         setCursor(Qt::splitHCursor);

   142 #endif

   143         setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding));

   144     }

   145 }

   146 

   147 void Q3DockWindowResizeHandle::mousePressEvent(QMouseEvent *e)

   148 {

   149     e->ignore();

   150     if (e->button() != Qt::LeftButton)

   151         return;

   152     e->accept();

   153     mousePressed = true;

   154     if (!dockWindow->opaqueMoving())

   155         startLineDraw();

   156     lastPos = firstPos = e->globalPos();

   157     if (!dockWindow->opaqueMoving())

   158         drawLine(e->globalPos());

   159 }

   160 

   161 void Q3DockWindowResizeHandle::mouseMoveEvent(QMouseEvent *e)

   162 {

   163     if (!mousePressed)

   164         return;

   165     if (!dockWindow->opaqueMoving()) {

   166         if (orientation() != dockWindow->area()->orientation()) {

   167             if (orientation() == Qt::Horizontal) {

   168                 int minpos = dockWindow->area()->mapToGlobal(QPoint(0, 0)).y();

   169                 int maxpos = dockWindow->area()->mapToGlobal(QPoint(0, 0)).y() + dockWindow->area()->height();

   170                 if (e->globalPos().y() < minpos || e->globalPos().y() > maxpos)

   171                     return;

   172             } else {

   173                 int minpos = dockWindow->area()->mapToGlobal(QPoint(0, 0)).x();

   174                 int maxpos = dockWindow->area()->mapToGlobal(QPoint(0, 0)).x() + dockWindow->area()->width();

   175                 if (e->globalPos().x() < minpos || e->globalPos().x() > maxpos)

   176                     return;

   177             }

   178         } else {

   179             QWidget *w = dockWindow->area()->window();

   180             if (w) {

   181                 if (orientation() == Qt::Horizontal) {

   182                     int minpos = w->mapToGlobal(QPoint(0, 0)).y();

   183                     int maxpos = w->mapToGlobal(QPoint(0, 0)).y() + w->height();

   184                     if (e->globalPos().y() < minpos || e->globalPos().y() > maxpos)

   185                         return;

   186                 } else {

   187                     int minpos = w->mapToGlobal(QPoint(0, 0)).x();

   188                     int maxpos = w->mapToGlobal(QPoint(0, 0)).x() + w->width();

   189                     if (e->globalPos().x() < minpos || e->globalPos().x() > maxpos)

   190                         return;

   191                 }

   192             }

   193         }

   194     }

   195 

   196     if (!dockWindow->opaqueMoving())

   197         drawLine(lastPos);

   198     lastPos = e->globalPos();

   199     if (dockWindow->opaqueMoving()) {

   200         mouseReleaseEvent(e);

   201         mousePressed = true;

   202         firstPos = e->globalPos();

   203     }

   204     if (!dockWindow->opaqueMoving())

   205         drawLine(e->globalPos());

   206 }

   207 

   208 void Q3DockWindowResizeHandle::mouseReleaseEvent(QMouseEvent *e)

   209 {

   210     if (mousePressed) {

   211         if (!dockWindow->opaqueMoving()) {

   212             drawLine(lastPos);

   213             endLineDraw();

   214         }

   215         if (orientation() != dockWindow->area()->orientation())

   216             dockWindow->area()->invalidNextOffset(dockWindow);

   217         if (orientation() == Qt::Horizontal) {

   218             int dy;

   219             if (dockWindow->area()->handlePosition() == Q3DockArea::Normal || orientation() != dockWindow->area()->orientation())

   220                 dy = e->globalPos().y() - firstPos.y();

   221             else

   222                 dy =  firstPos.y() - e->globalPos().y();

   223             int d = dockWindow->height() + dy;

   224             if (orientation() != dockWindow->area()->orientation()) {

   225                 dockWindow->setFixedExtentHeight(-1);

   226                 d = qMax(d, dockWindow->minimumHeight());

   227                 int ms = dockWindow->area()->maxSpace(d, dockWindow);

   228                 d = qMin(d, ms);

   229                 dockWindow->setFixedExtentHeight(d);

   230             } else {

   231                 dockWindow->area()->setFixedExtent(d, dockWindow);

   232             }

   233         } else {

   234             int dx;

   235             if (dockWindow->area()->handlePosition() == Q3DockArea::Normal || orientation() != dockWindow->area()->orientation())

   236                 dx = e->globalPos().x() - firstPos.x();

   237             else

   238                 dx = firstPos.x() - e->globalPos().x();

   239             int d = dockWindow->width() + dx;

   240             if (orientation() != dockWindow->area()->orientation()) {

   241                 dockWindow->setFixedExtentWidth(-1);

   242                 d = qMax(d, dockWindow->minimumWidth());

   243                 int ms = dockWindow->area()->maxSpace(d, dockWindow);

   244                 d = qMin(d, ms);

   245                 dockWindow->setFixedExtentWidth(d);

   246             } else {

   247                 dockWindow->area()->setFixedExtent(d, dockWindow);

   248             }

   249         }

   250     }

   251 

   252     QApplication::postEvent(dockWindow->area(), new QEvent(QEvent::LayoutHint));

   253     mousePressed = false;

   254 }

   255 

   256 bool Q3DockWindowResizeHandle::event(QEvent *event)

   257 {

   258     switch (event->type()) {

   259     case QEvent::HoverEnter:

   260         if (!mouseOver) {

   261             mouseOver = true;

   262             update();

   263         }

   264         break;

   265     case QEvent::HoverLeave:

   266         if (mouseOver) {

   267             mouseOver = false;

   268             update();

   269         }

   270         break;

   271     default:

   272         break;

   273     }

   274     return QWidget::event(event);

   275 }

   276 

   277 void Q3DockWindowResizeHandle::paintEvent(QPaintEvent *)

   278 {

   279     QPainter p(this);

   280     QStyleOption opt(0);

   281     opt.init(this);

   282     if (orientation() == Qt::Horizontal)

   283         opt.state |= QStyle::State_Horizontal;

   284     style()->drawPrimitive(QStyle::PE_IndicatorDockWidgetResizeHandle, &opt, &p, this);

   285 }

   286 

   287 void Q3DockWindowResizeHandle::startLineDraw()

   288 {

   289     if (rubberBand)

   290         endLineDraw();

   291     rubberBand = new QRubberBand(QRubberBand::Line);

   292     rubberBand->setGeometry(-1, -1, 1, 1);

   293     rubberBand->show();

   294 }

   295 

   296 void Q3DockWindowResizeHandle::endLineDraw()

   297 {

   298     delete rubberBand;

   299     rubberBand = 0;

   300 }

   301 

   302 void Q3DockWindowResizeHandle::drawLine(const QPoint &globalPos)

   303 {

   304     QPoint start = mapToGlobal(QPoint(0, 0));

   305     QPoint starta = dockWindow->area()->mapToGlobal(QPoint(0, 0));

   306     QPoint end = globalPos;

   307     if (orientation() == Qt::Horizontal) {

   308         if (orientation() == dockWindow->orientation())

   309             rubberBand->setGeometry(starta.x(), end.y(), dockWindow->area()->width(), height());

   310         else

   311             rubberBand->setGeometry(start.x(), end.y(), width(), height());

   312     } else {

   313         if (orientation() == dockWindow->orientation())

   314             rubberBand->setGeometry(end.x(), starta.y(), width(), dockWindow->area()->height());

   315         else

   316             rubberBand->setGeometry(end.x(), start.y(), width(), height());

   317     }

   318 }

   319 

   320 static QPoint realWidgetPos(Q3DockWindow *w)

   321 {

   322     if (!w->parentWidget() || w->place() == Q3DockWindow::OutsideDock)

   323         return w->pos();

   324     return w->parentWidget()->mapToGlobal(w->geometry().topLeft());

   325 }

   326 

   327 class Q3DockWindowHandle : public QWidget

   328 {

   329     Q_OBJECT

   330     Q_PROPERTY(QString windowTitle READ windowTitle)

   331     friend class Q3DockWindow;

   332     friend class Q3DockWindowTitleBar;

   333 

   334 public:

   335     Q3DockWindowHandle(Q3DockWindow *dw);

   336     void updateGui();

   337 

   338     QSize minimumSizeHint() const;

   339     QSize minimumSize() const { return minimumSizeHint(); }

   340     QSize sizeHint() const { return minimumSize(); }

   341     void setOpaqueMoving(bool b) { opaque = b; }

   342 

   343     QString windowTitle() const { return dockWindow->windowTitle(); }

   344 

   345 signals:

   346     void doubleClicked();

   347 

   348 protected:

   349     void paintEvent(QPaintEvent *e);

   350     void resizeEvent(QResizeEvent *e);

   351     void mousePressEvent(QMouseEvent *e);

   352     void mouseMoveEvent(QMouseEvent *e);

   353     void mouseReleaseEvent(QMouseEvent *e);

   354     void mouseDoubleClickEvent(QMouseEvent *e);

   355     void keyPressEvent(QKeyEvent *e);

   356     void keyReleaseEvent(QKeyEvent *e);

   357     void changeEvent(QEvent *);

   358 

   359 private slots:

   360     void minimize();

   361 

   362 private:

   363     Q3DockWindow *dockWindow;

   364     QPoint offset;

   365     QToolButton *closeButton;

   366     QTimer *timer;

   367     uint opaque                : 1;

   368     uint mousePressed        : 1;

   369     uint hadDblClick        : 1;

   370     uint ctrlDown : 1;

   371     QPointer<QWidget> oldFocus;

   372 };

   373 

   374 class Q3DockWindowTitleBar : public Q3TitleBar

   375 {

   376     Q_OBJECT

   377     friend class Q3DockWindow;

   378     friend class Q3DockWindowHandle;

   379 

   380 public:

   381     Q3DockWindowTitleBar(Q3DockWindow *dw);

   382     void updateGui();

   383     void setOpaqueMoving(bool b) { opaque = b; }

   384 

   385 protected:

   386     void resizeEvent(QResizeEvent *e);

   387     void mousePressEvent(QMouseEvent *e);

   388     void mouseMoveEvent(QMouseEvent *e);

   389     void mouseReleaseEvent(QMouseEvent *e);

   390     void mouseDoubleClickEvent(QMouseEvent *e);

   391     void keyPressEvent(QKeyEvent *e);

   392     void keyReleaseEvent(QKeyEvent *e);

   393 

   394 private:

   395     Q3DockWindow *dockWindow;

   396     QPoint offset;

   397     uint mousePressed : 1;

   398     uint hadDblClick : 1;

   399     uint opaque : 1;

   400     uint ctrlDown : 1;

   401     QPointer<QWidget> oldFocus;

   402 

   403 };

   404 

   405 Q3DockWindowHandle::Q3DockWindowHandle(Q3DockWindow *dw)

   406     : QWidget(dw, "qt_dockwidget_internal"), dockWindow(dw),

   407       closeButton(0), opaque(default_opaque), mousePressed(false)

   408 {

   409     ctrlDown = false;

   410     timer = new QTimer(this);

   411     connect(timer, SIGNAL(timeout()), this, SLOT(minimize()));

   412 #ifdef Q_WS_WIN

   413     setCursor(Qt::SizeAllCursor);

   414 #endif

   415 }

   416 

   417 void Q3DockWindowHandle::paintEvent(QPaintEvent *e)

   418 {

   419     if (!dockWindow->dockArea && !opaque)

   420         return;

   421     QPainter p(this);

   422     QStyleOptionQ3DockWindow opt;

   423     opt.init(this);

   424     if (!dockWindow->area() || dockWindow->area()->orientation() == Qt::Horizontal)

   425         opt.state |= QStyle::State_Horizontal;

   426 

   427     opt.rect = rect();

   428     opt.docked = dockWindow->area();

   429     opt.closeEnabled = dockWindow->isCloseEnabled();

   430     opt.rect = QStyle::visualRect(opt.direction, opt.rect,

   431                                   style()->subElementRect(QStyle::SE_Q3DockWindowHandleRect, &opt, this));

   432     style()->drawPrimitive(QStyle::PE_IndicatorToolBarHandle, &opt, &p, this);

   433     QWidget::paintEvent(e);

   434 }

   435 

   436 void Q3DockWindowHandle::keyPressEvent(QKeyEvent *e)

   437 {

   438     if (!mousePressed)

   439         return;

   440     if (e->key() == Qt::Key_Control) {

   441         ctrlDown = true;

   442         dockWindow->handleMove(mapFromGlobal(QCursor::pos()) - offset, QCursor::pos(), !opaque);

   443     }

   444 }

   445 

   446 void Q3DockWindowHandle::keyReleaseEvent(QKeyEvent *e)

   447 {

   448     if (!mousePressed)

   449         return;

   450     if (e->key() == Qt::Key_Control) {

   451         ctrlDown = false;

   452         dockWindow->handleMove(mapFromGlobal(QCursor::pos()) - offset, QCursor::pos(), !opaque);

   453     }

   454 }

   455 

   456 void Q3DockWindowHandle::mousePressEvent(QMouseEvent *e)

   457 {

   458     if (!dockWindow->dockArea)

   459         return;

   460     ctrlDown = (e->state() & Qt::ControlButton) == Qt::ControlButton;

   461     oldFocus = qApp->focusWidget();

   462     setFocus();

   463     e->ignore();

   464     if (e->button() != Qt::LeftButton)

   465         return;

   466     e->accept();

   467     hadDblClick = false;

   468     mousePressed = true;

   469     offset = e->pos();

   470     dockWindow->startRectDraw(mapToGlobal(e->pos()), !opaque);

   471     if (!opaque)

   472         qApp->installEventFilter(dockWindow);

   473 }

   474 

   475 void Q3DockWindowHandle::mouseMoveEvent(QMouseEvent *e)

   476 {

   477     if (!mousePressed || e->pos() == offset)

   478         return;

   479     ctrlDown = (e->state() & Qt::ControlButton) == Qt::ControlButton;

   480     dockWindow->handleMove(e->pos() - offset, e->globalPos(), !opaque);

   481     if (opaque)

   482         dockWindow->updatePosition(e->globalPos());

   483 }

   484 

   485 void Q3DockWindowHandle::mouseReleaseEvent(QMouseEvent *e)

   486 {

   487     ctrlDown = false;

   488     qApp->removeEventFilter(dockWindow);

   489     if (oldFocus)

   490         oldFocus->setFocus();

   491     if (!mousePressed)

   492         return;

   493     dockWindow->endRectDraw(!opaque);

   494     mousePressed = false;

   495 #ifdef Q_WS_MAC

   496     releaseMouse();

   497 #endif

   498     if (!hadDblClick && offset == e->pos()) {

   499         timer->start(QApplication::doubleClickInterval(), true);

   500     } else if (!hadDblClick) {

   501         dockWindow->updatePosition(e->globalPos());

   502     }

   503     if (opaque)

   504         dockWindow->titleBar->mousePressed = false;

   505     if (dockWindow->parentWidget())

   506         QApplication::postEvent(dockWindow->parentWidget(), new QEvent(QEvent::LayoutHint));

   507 }

   508 

   509 void Q3DockWindowHandle::minimize()

   510 {

   511     if (!dockWindow->area())

   512         return;

   513 

   514     Q3MainWindow *mw = qobject_cast<Q3MainWindow*>(dockWindow->area()->parentWidget());

   515     if (mw && mw->isDockEnabled(dockWindow, Qt::DockMinimized))

   516         mw->moveDockWindow(dockWindow, Qt::DockMinimized);

   517 }

   518 

   519 void Q3DockWindowHandle::resizeEvent(QResizeEvent *)

   520 {

   521     updateGui();

   522 }

   523 

   524 void Q3DockWindowHandle::updateGui()

   525 {

   526     updateGeometry();

   527 

   528     if (!closeButton) {

   529         closeButton = new QToolButton(this, "qt_close_button1");

   530 #ifndef QT_NO_CURSOR

   531         closeButton->setCursor(Qt::ArrowCursor);

   532 #endif

   533         QStyleOption opt(0);

   534         opt.init(closeButton);

   535         closeButton->setIcon(style()->standardIcon(QStyle::SP_DockWidgetCloseButton, &opt,

   536                                                     closeButton));

   537         closeButton->setFixedSize(12, 12);

   538         connect(closeButton, SIGNAL(clicked()),

   539                  dockWindow, SLOT(hide()));

   540     }

   541 

   542     if (dockWindow->isCloseEnabled() && dockWindow->area())

   543         closeButton->show();

   544     else

   545         closeButton->hide();

   546 

   547     if (!dockWindow->area())

   548         return;

   549 

   550     if (dockWindow->area()->orientation() == Qt::Horizontal) {

   551         int off = (width() - closeButton->width() - 1) / 2;

   552         closeButton->move(off, 2);

   553     } else {

   554         int off = (height() - closeButton->height() - 1) / 2;

   555         int x = QApplication::reverseLayout() ? 2 : width() - closeButton->width() - 2;

   556         closeButton->move(x, off);

   557     }

   558 }

   559 

   560 void Q3DockWindowHandle::changeEvent(QEvent *ev)

   561 {

   562     if(ev->type() == QEvent::StyleChange) {

   563         if (closeButton) {

   564             QStyleOption opt(0);

   565             opt.init(closeButton);

   566             closeButton->setIcon(style()->standardIcon(QStyle::SP_DockWidgetCloseButton,

   567                                                         &opt, closeButton));

   568         }

   569     }

   570     QWidget::changeEvent(ev);

   571 }

   572 

   573 QSize Q3DockWindowHandle::minimumSizeHint() const

   574 {

   575     if (!dockWindow->dockArea)

   576         return QSize(0, 0);

   577     int wh = dockWindow->isCloseEnabled() ? 17 : style()->pixelMetric(QStyle::PM_ToolBarHandleExtent, 0, this);

   578     if (dockWindow->orientation() == Qt::Horizontal)

   579         return QSize(wh, 0);

   580     return QSize(0, wh);

   581 }

   582 

   583 void Q3DockWindowHandle::mouseDoubleClickEvent(QMouseEvent *e)

   584 {

   585     e->ignore();

   586     if (e->button() != Qt::LeftButton)

   587         return;

   588     e->accept();

   589     timer->stop();

   590     emit doubleClicked();

   591     hadDblClick = true;

   592     if (dockWindow->parentWidget())

   593         QApplication::postEvent(dockWindow->parentWidget(), new QEvent(QEvent::LayoutHint));

   594 }

   595 

   596 Q3DockWindowTitleBar::Q3DockWindowTitleBar(Q3DockWindow *dw)

   597     : Q3TitleBar(0, dw), dockWindow(dw),

   598       mousePressed(false), hadDblClick(false), opaque(default_opaque)

   599 {

   600     setObjectName(QLatin1String("qt_dockwidget_internal"));

   601     ctrlDown = false;

   602     setMouseTracking(true);

   603     QStyleOptionTitleBar opt = getStyleOption();

   604     setFixedHeight(style()->pixelMetric(QStyle::PM_TitleBarHeight, &opt, this));

   605     connect(this, SIGNAL(doClose()), dockWindow, SLOT(hide()));

   606 }

   607 

   608 void Q3DockWindowTitleBar::keyPressEvent(QKeyEvent *e)

   609 {

   610     if (!mousePressed)

   611         return;

   612     if (e->key() == Qt::Key_Control) {

   613         ctrlDown = true;

   614         dockWindow->handleMove(mapFromGlobal(QCursor::pos()) - offset, QCursor::pos(), !opaque);

   615     }

   616 }

   617 

   618 void Q3DockWindowTitleBar::keyReleaseEvent(QKeyEvent *e)

   619 {

   620     if (!mousePressed)

   621         return;

   622     if (e->key() == Qt::Key_Control) {

   623         ctrlDown = false;

   624         dockWindow->handleMove(mapFromGlobal(QCursor::pos()) - offset, QCursor::pos(), !opaque);

   625     }

   626 }

   627 

   628 void Q3DockWindowTitleBar::mousePressEvent(QMouseEvent *e)

   629 {

   630     QStyleOptionTitleBar opt;

   631     opt.init(this);

   632     opt.subControls = QStyle::SC_All;

   633     opt.activeSubControls = QStyle::SC_None;

   634     opt.text = windowTitle();

   635     //################

   636     QIcon icon = windowIcon();

   637     QSize s = icon.actualSize(QSize(64, 64));

   638     opt.icon = icon.pixmap(s);

   639     opt.titleBarState = window() ? window()->windowState() : static_cast<Qt::WindowStates>(Qt::WindowNoState);

   640     opt.titleBarFlags = fakeWindowFlags();

   641     QStyle::SubControl tbctrl = style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt,

   642                                                                e->pos(), this);

   643 

   644     if (tbctrl < QStyle::SC_TitleBarLabel && tbctrl != QStyle::SC_None) {

   645         Q3TitleBar::mousePressEvent(e);

   646         return;

   647     }

   648 

   649     ctrlDown = (e->state() & Qt::ControlButton) == Qt::ControlButton;

   650     oldFocus = qApp->focusWidget();

   651 // setFocus activates the window, which deactivates the main window

   652 // not what we want, and not required anyway on Windows

   653 #ifndef Q_WS_WIN

   654     setFocus();

   655 #endif

   656 

   657     e->ignore();

   658     if (e->button() != Qt::LeftButton)

   659         return;

   660     if (e->y() < 3 && dockWindow->isResizeEnabled())

   661         return;

   662 

   663     e->accept();

   664     bool oldPressed = mousePressed;

   665     mousePressed = true;

   666     hadDblClick = false;

   667     offset = e->pos();

   668     dockWindow->startRectDraw(mapToGlobal(e->pos()), !opaque);

   669 // grabMouse resets the Windows mouse press count, so we never receive a double click on Windows

   670 // not required on Windows, and did work on X11, too, but no problem there in the first place

   671 #ifndef Q_WS_WIN

   672     if(!oldPressed && dockWindow->opaqueMoving())

   673         grabMouse();

   674 #else

   675     Q_UNUSED(oldPressed);

   676 #endif

   677 }

   678 

   679 void Q3DockWindowTitleBar::mouseMoveEvent(QMouseEvent *e)

   680 {

   681     if (!mousePressed) {

   682         Q3TitleBar::mouseMoveEvent(e);

   683         return;

   684     }

   685 

   686     ctrlDown = (e->state() & Qt::ControlButton) == Qt::ControlButton;

   687     e->accept();

   688     dockWindow->handleMove(e->pos() - offset, e->globalPos(), !opaque);

   689 }

   690 

   691 void Q3DockWindowTitleBar::mouseReleaseEvent(QMouseEvent *e)

   692 {

   693     if (!mousePressed) {

   694         Q3TitleBar::mouseReleaseEvent(e);

   695         return;

   696     }

   697 

   698     ctrlDown = false;

   699     qApp->removeEventFilter(dockWindow);

   700     if (oldFocus)

   701         oldFocus->setFocus();

   702 

   703     if (dockWindow->place() == Q3DockWindow::OutsideDock)

   704         dockWindow->raise();

   705 

   706     if(dockWindow->opaqueMoving())

   707         releaseMouse();

   708     if (!mousePressed)

   709         return;

   710     dockWindow->endRectDraw(!opaque);

   711     mousePressed = false;

   712     if (!hadDblClick)

   713         dockWindow->updatePosition(e->globalPos());

   714     if (opaque) {

   715         dockWindow->horHandle->mousePressed = false;

   716         dockWindow->verHandle->mousePressed = false;

   717     }

   718     if (dockWindow->parentWidget())

   719         QApplication::postEvent(dockWindow->parentWidget(), new QEvent(QEvent::LayoutHint));

   720 }

   721 

   722 void Q3DockWindowTitleBar::resizeEvent(QResizeEvent *e)

   723 {

   724     updateGui();

   725     Q3TitleBar::resizeEvent(e);

   726 }

   727 

   728 void Q3DockWindowTitleBar::updateGui()

   729 {

   730     if (dockWindow->isCloseEnabled()) {

   731         setFakeWindowFlags(fakeWindowFlags() | Qt::WStyle_SysMenu);

   732     } else {

   733         setFakeWindowFlags(fakeWindowFlags() & ~Qt::WStyle_SysMenu);

   734     }

   735 }

   736 

   737 void Q3DockWindowTitleBar::mouseDoubleClickEvent(QMouseEvent *)

   738 {

   739     emit doubleClicked();

   740     hadDblClick = true;

   741     if (dockWindow->parentWidget())

   742         QApplication::postEvent(dockWindow->parentWidget(), new QEvent(QEvent::LayoutHint));

   743 }

   744 

   745 /*!

   746     \class Q3DockWindow

   747     \brief The Q3DockWindow class provides a widget which can be docked

   748     inside a Q3DockArea or floated as a top level window on the

   749     desktop.

   750 

   751     \compat

   752 

   753     This class handles moving, resizing, docking and undocking dock

   754     windows. Q3ToolBar is a subclass of Q3DockWindow so the

   755     functionality provided for dock windows is available with the same

   756     API for toolbars.

   757 

   758     \img qmainwindow-qdockareas.png Q3DockWindows in a Q3DockArea

   759     \caption Two Q3DockWindows (\l{Q3ToolBar}s) in a \l Q3DockArea

   760 

   761     \img qdockwindow.png A Q3DockWindow

   762     \caption A Floating Q3DockWindow

   763 

   764     If the user drags the dock window into the dock area the dock

   765     window will be docked. If the user drags the dock area outside any

   766     dock areas the dock window will be undocked (floated) and will

   767     become a top level window. Double clicking a floating dock

   768     window's title bar will dock the dock window to the last dock area

   769     it was docked in. Double clicking a docked dock window's handle

   770     will undock (float) the dock window.

   771     \omit

   772     Single clicking a docked dock window's handle will minimize the

   773     dock window (only its handle will appear, below the menu bar).

   774     Single clicking the minimized handle will restore the dock window

   775     to the last dock area that it was docked in.

   776     \endomit

   777     If the user clicks the close button (which appears on floating

   778     dock windows by default) the dock window will disappear. You can

   779     control whether or not a dock window has a close button with

   780     setCloseMode().

   781 

   782     Q3MainWindow provides four dock areas (top, left, right and bottom)

   783     which can be used by dock windows. For many applications using the

   784     dock areas provided by Q3MainWindow is sufficient. (See the \l

   785     Q3DockArea documentation if you want to create your own dock

   786     areas.) In Q3MainWindow a right-click popup menu (the dock window

   787     menu) is available which lists dock windows and can be used to

   788     show or hide them. (The popup menu only lists dock windows that

   789     have a \link QWidget::setWindowTitle() caption\endlink.)

   790 

   791     When you construct a dock window you \e must pass it a Q3DockArea

   792     or a Q3MainWindow as its parent if you want it docked. Pass 0 for

   793     the parent if you want it floated.

   794 

   795     \snippet doc/src/snippets/code/src_qt3support_widgets_q3dockwindow.cpp 0

   796 

   797     In the example above we create a new Q3ToolBar in the constructor

   798     of a Q3MainWindow subclass (so that the \e this pointer points to

   799     the Q3MainWindow). By default the toolbar will be added to the \c

   800     Top dock area, but we've moved it to the \c Left dock area.

   801 

   802     A dock window is often used to contain a single widget. In these

   803     cases the widget can be set by calling setWidget(). If you're

   804     constructing a dock window that contains multiple widgets, e.g. a

   805     toolbar, arrange the widgets within a box layout inside the dock

   806     window. To do this use the boxLayout() function to get a pointer

   807     to the dock window's box layout, then add widgets to the layout

   808     using the box layout's QBoxLayout::addWidget() function. The dock

   809     window will dynamically set the orientation of the layout to be

   810     vertical or horizontal as necessary, although you can control this

   811     yourself with setOrientation().

   812 

   813     Although a common use of dock windows is for toolbars, they can be

   814     used with any widgets. When using larger

   815     widgets it may make sense for the dock window to be resizable by

   816     calling setResizeEnabled(). Resizable dock windows are given

   817     splitter-like handles to allow the user to resize them within

   818     their dock area. When resizable dock windows are undocked they

   819     become top level windows and can be resized like any other top

   820     level windows, e.g. by dragging a corner or edge.

   821 

   822     Qt::Dock windows can be docked and undocked using dock() and undock().

   823     A dock window's orientation can be set with setOrientation(). You

   824     can also use Q3DockArea::moveDockWindow(). If you're using a

   825     Q3MainWindow, Q3MainWindow::moveDockWindow() and

   826     Q3MainWindow::removeDockWindow() are available.

   827 

   828     A dock window can have some preferred settings, for example, you

   829     can set a preferred offset from the left edge (or top edge for

   830     vertical dock areas) of the dock area using setOffset(). If you'd

   831     prefer a dock window to start on a new line when it is docked use

   832     setNewLine(). The setFixedExtentWidth() and setFixedExtentHeight()

   833     functions can be used to define the dock window's preferred size,

   834     and the setHorizontallyStretchable() and setVerticallyStretchable()

   835     functions set whether the dock window can be stretched or not.

   836     Dock windows can be moved by default, but this can be changed with

   837     setMovingEnabled(). When a dock window is moved it is shown as a

   838     rectangular outline, but it can be shown normally using

   839     setOpaqueMoving().

   840 

   841     When a dock window's visibility changes, i.e. it is shown or

   842     hidden, the visibilityChanged() signal is emitted. When a dock

   843     window is docked, undocked or moved inside the dock area the

   844     placeChanged() signal is emitted.

   845 */

   846 

   847 /*!

   848     \enum Q3DockWindow::Place

   849 

   850     This enum specifies the possible locations for a Q3DockWindow:

   851 

   852     \value InDock  Inside a Q3DockArea.

   853     \value OutsideDock  Floating as a top level window on the desktop.

   854 */

   855 

   856 /*!

   857     \enum Q3DockWindow::CloseMode

   858 

   859     This enum type specifies when (if ever) a dock window has a close

   860     button.

   861 

   862     \value Never  The dock window never has a close button and cannot

   863     be closed by the user.

   864     \value Docked  The dock window has a close button only when

   865     docked.

   866     \value Undocked  The dock window has a close button only when

   867     floating.

   868     \value Always The dock window always has a close button.

   869     \omit

   870     Note that dock windows can always be minimized if the user clicks

   871     their dock window handle when they are docked.

   872     \endomit

   873 */

   874 

   875 /*!

   876     \fn void Q3DockWindow::setHorizontalStretchable(bool b)

   877 

   878     If \a b is true the dock window is set to be horizontally

   879     stretchable.

   880 */

   881 /*!

   882     \fn void Q3DockWindow::setVerticalStretchable(bool b)

   883 

   884     If \a b is true the dock window is set to be vertically

   885     stretchable.

   886 */

   887 /*!

   888     \fn bool Q3DockWindow::isHorizontalStretchable() const

   889 

   890     Returns true if the dock window can be stretched horizontally;

   891     otherwise returns false.

   892 */

   893 /*!

   894     \fn bool Q3DockWindow::isVerticalStretchable() const

   895 

   896     Returns true if the dock window can be stretched vertically;

   897     otherwise returns false.

   898 */

   899 /*!

   900     \fn void Q3DockWindow::orientationChanged(Qt::Orientation o)

   901 

   902     This signal is emitted when the orientation of the dock window is

   903     changed. The new orientation is \a o.

   904 */

   905 

   906 /*!

   907     \fn void Q3DockWindow::placeChanged(Q3DockWindow::Place p)

   908 

   909     This signal is emitted when the dock window is docked (\a p is \c

   910     InDock), undocked (\a p is \c OutsideDock) or moved inside the

   911     the dock area.

   912 

   913     \sa Q3DockArea::moveDockWindow(), Q3DockArea::removeDockWindow(),

   914     Q3MainWindow::moveDockWindow(), Q3MainWindow::removeDockWindow()

   915 */

   916 

   917 /*!

   918     \fn void Q3DockWindow::visibilityChanged(bool visible)

   919 

   920     This signal is emitted when the visibility of the dock window

   921     relatively to its dock area is changed. If \a visible is true, the

   922     Q3DockWindow is now visible to the dock area, otherwise it has been

   923     hidden.

   924 

   925     A dock window can be hidden if it has a close button which the

   926     user has clicked. In the case of a Q3MainWindow a dock window can

   927     have its visibility changed (hidden or shown) by clicking its name

   928     in the dock window menu that lists the Q3MainWindow's dock windows.

   929 */

   930 

   931 /*!

   932     \fn Q3DockArea *Q3DockWindow::area() const

   933 

   934     Returns the dock area in which this dock window is docked, or 0 if

   935     the dock window is floating.

   936 */

   937 

   938 /*!

   939     \property Q3DockWindow::place

   940     \brief the location where the dock window is placed

   941 

   942     This is either \c InDock or \c OutsideDock.

   943 

   944     \sa Q3DockArea::moveDockWindow(), Q3DockArea::removeDockWindow(),

   945         Q3MainWindow::moveDockWindow(), Q3MainWindow::removeDockWindow()

   946 */

   947 

   948 /*!

   949     Constructs a Q3DockWindow with parent \a parent, called \a name and

   950     with widget flags \a f.

   951 */

   952 

   953 Q3DockWindow::Q3DockWindow(QWidget* parent, const char* name, Qt::WindowFlags f)

   954     : Q3Frame(parent, name, f | Qt::WType_Dialog | Qt::WStyle_Customize | Qt::WStyle_NoBorder)

   955 {

   956     curPlace = InDock;

   957     isToolbar = false;

   958     init();

   959 }

   960 

   961 /*!

   962     Constructs a Q3DockWindow with parent \a parent, called \a name and

   963     with widget flags \a f.

   964 

   965     If \a p is \c InDock, the dock window is docked into a dock area

   966     and \a parent \e must be a Q3DockArea or a Q3MainWindow. If the \a

   967     parent is a Q3MainWindow the dock window will be docked in the main

   968     window's \c Top dock area.

   969 

   970     If \a p is \c OutsideDock, the dock window is created as a floating

   971     window.

   972 

   973     We recommend creating the dock area \c InDock with a Q3MainWindow

   974     as parent then calling Q3MainWindow::moveDockWindow() to move the

   975     dock window where you want it.

   976 */

   977 

   978 Q3DockWindow::Q3DockWindow(Place p, QWidget *parent, const char *name, Qt::WindowFlags f)

   979     : Q3Frame(parent, name, f | Qt::WType_Dialog | Qt::WStyle_Customize | Qt::WStyle_NoBorder)

   980 {

   981     curPlace = p;

   982     isToolbar = false;

   983     init();

   984 }

   985 

   986 /*! \internal

   987 */

   988 

   989 Q3DockWindow::Q3DockWindow(Place p, QWidget *parent, const char *name, Qt::WindowFlags f, bool toolbar)

   990     : Q3Frame(parent, name, f | Qt::WType_Dialog | Qt::WStyle_Customize | Qt::WStyle_NoBorder)

   991 {

   992     curPlace = p;

   993     isToolbar = toolbar;

   994     init();

   995 }

   996 

   997 class Q3DockWindowGridLayout : public QGridLayout

   998 {

   999 public:

  1000     Q3DockWindowGridLayout(QWidget *parent, int nRows, int nCols)

  1001         : QGridLayout(parent, nRows, nCols) {};

  1002 

  1003     Qt::Orientations expandingDirections() const

  1004     {

  1005         return 0;

  1006     }

  1007 };

  1008 

  1009 void Q3DockWindow::init()

  1010 {

  1011     wid = 0;

  1012     rubberBand = 0;

  1013     dockArea = 0;

  1014     tmpDockArea = 0;

  1015     resizeEnabled = false;

  1016     moveEnabled = true;

  1017     nl = false;

  1018     opaque = default_opaque;

  1019     cMode = Never;

  1020     offs = 0;

  1021     fExtent = QSize(-1, -1);

  1022     dockWindowData = 0;

  1023     lastPos = QPoint(-1, -1);

  1024     lastSize = QSize(-1, -1);

  1025     stretchable[Qt::Horizontal] = false;

  1026     stretchable[Qt::Vertical] = false;

  1027 

  1028     widgetResizeHandler = new QWidgetResizeHandler(this);

  1029     widgetResizeHandler->setMovingEnabled(false);

  1030 

  1031     titleBar      = new Q3DockWindowTitleBar(this);

  1032     verHandle     = new Q3DockWindowHandle(this);

  1033     verHandle->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred));

  1034     horHandle     = new Q3DockWindowHandle(this);

  1035     horHandle->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));

  1036 

  1037     vHandleLeft   = new Q3DockWindowResizeHandle(Qt::Vertical, this, this, "vert. handle");

  1038     vHandleRight  = new Q3DockWindowResizeHandle(Qt::Vertical, this, this, "vert. handle");

  1039     hHandleTop    = new Q3DockWindowResizeHandle(Qt::Horizontal, this, this, "horz. handle");

  1040     hHandleBottom = new Q3DockWindowResizeHandle(Qt::Horizontal, this, this, "horz. handle");

  1041 

  1042     // Creating inner layout

  1043     hbox          = new QVBoxLayout();

  1044     vbox          = new QHBoxLayout();

  1045     childBox          = new QBoxLayout(QBoxLayout::LeftToRight);

  1046     vbox->addSpacing(2);

  1047     vbox->addWidget(verHandle);

  1048     vbox->addStretch(0);

  1049     vbox->addLayout(childBox, 1);

  1050     vbox->addStretch(0);

  1051 

  1052     hbox->setResizeMode(QLayout::FreeResize);

  1053     hbox->setMargin(isResizeEnabled() || curPlace == OutsideDock ? 2 : 0);

  1054     hbox->setSpacing(1);

  1055     hbox->addWidget(titleBar);

  1056     hbox->addWidget(horHandle);

  1057     hbox->addLayout(vbox);

  1058 

  1059     // Set up the initial handle layout for Qt::Vertical

  1060     // Handle layout will change on calls to setOrienation()

  1061     QGridLayout *glayout = new Q3DockWindowGridLayout(this, 3, 3);

  1062     glayout->setResizeMode(QLayout::Minimum);

  1063     glayout->addMultiCellWidget(hHandleTop,    0, 0, 1, 1);

  1064     glayout->addMultiCellWidget(hHandleBottom, 2, 2, 1, 1);

  1065     glayout->addMultiCellWidget(vHandleLeft,   0, 2, 0, 0);

  1066     glayout->addMultiCellWidget(vHandleRight,  0, 2, 2, 2);

  1067     glayout->addLayout(hbox, 1, 1);

  1068     glayout->setRowStretch(1, 1);

  1069     glayout->setColStretch(1, 1);

  1070 

  1071     hHandleBottom->hide();

  1072     vHandleRight->hide();

  1073     hHandleTop->hide();

  1074     vHandleLeft->hide();

  1075     setFrameStyle(Q3Frame::StyledPanel | Q3Frame::Raised);

  1076     setLineWidth(2);

  1077 

  1078     if (parentWidget())

  1079         parentWidget()->installEventFilter(this);

  1080     QWidget *mw = parentWidget();

  1081     Q3DockArea *da = qobject_cast<Q3DockArea*>(parentWidget());

  1082     if (da) {

  1083         if (curPlace == InDock)

  1084             da->moveDockWindow(this);

  1085         mw = da->parentWidget();

  1086     }

  1087     if (qobject_cast<Q3MainWindow*>(mw)) {

  1088         if (place() == InDock) {

  1089             Qt::Dock myDock = Qt::DockTop;

  1090             // make sure we put the window in the correct dock.

  1091             if (dockArea) {

  1092                 Q3MainWindow *mainw = (Q3MainWindow*)mw;

  1093                 // I'm not checking if it matches the top because I've

  1094                 // done the assignment to it above.

  1095                 if (dockArea == mainw->leftDock())

  1096                     myDock = Qt::DockLeft;

  1097                 else if (dockArea == mainw->rightDock())

  1098                     myDock = Qt::DockRight;

  1099                 else if (dockArea == mainw->bottomDock())

  1100                     myDock = Qt::DockBottom;

  1101             }

  1102             ((Q3MainWindow*)mw)->addDockWindow(this, myDock);

  1103         }

  1104         moveEnabled = ((Q3MainWindow*)mw)->dockWindowsMovable();

  1105         opaque = ((Q3MainWindow*)mw)->opaqueMoving();

  1106     }

  1107 

  1108     updateGui();

  1109 

  1110     connect(titleBar, SIGNAL(doubleClicked()), this, SLOT(dock()));

  1111     connect(verHandle, SIGNAL(doubleClicked()), this, SLOT(undock()));

  1112     connect(horHandle, SIGNAL(doubleClicked()), this, SLOT(undock()));

  1113     connect(this, SIGNAL(orientationChanged(Qt::Orientation)),

  1114              this, SLOT(setOrientation(Qt::Orientation)));

  1115 }

  1116 

  1117 /*!

  1118     Sets the orientation of the dock window to \a o. The orientation

  1119     is propagated to the layout boxLayout().

  1120 

  1121     \warning All undocked Q3ToolBars will always have a horizontal orientation.

  1122 */

  1123 

  1124 void Q3DockWindow::setOrientation(Qt::Orientation o)

  1125 {

  1126     QGridLayout *glayout = (QGridLayout*)layout();

  1127     glayout->removeWidget(hHandleTop);

  1128     glayout->removeWidget(hHandleBottom);

  1129     glayout->removeWidget(vHandleLeft);

  1130     glayout->removeWidget(vHandleRight);

  1131 

  1132     if (o == Qt::Horizontal) {

  1133         // Set up the new layout as

  1134         //   3 3 3      1 = vHandleLeft   4 = hHandleBottom