/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt3Support 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 "q3dockwindow.h"
#ifndef QT_NO_MAINWINDOW
#include "qapplication.h"
#include "qcursor.h"
#include "qdesktopwidget.h"
#include "q3dockarea.h"
#include "qevent.h"
#include "qlayout.h"
#include "q3mainwindow.h"
#include "qpainter.h"
#include "qpointer.h"
#include "qstyle.h"
#include "qstyleoption.h"
#include "qtimer.h"
#include "q3toolbar.h"
#include "qtoolbutton.h"
#include "qtooltip.h"
#include <private/q3titlebar_p.h>
#include <private/qwidgetresizehandler_p.h>
#include <qrubberband.h>
#include <qdebug.h>
QT_BEGIN_NAMESPACE
#ifdef Q_WS_MAC
static bool default_opaque = true;
#else
static bool default_opaque = false;
#endif
class Q3DockWindowPrivate
{
};
class Q3DockWindowResizeHandle : public QWidget
{
Q_OBJECT
public:
Q3DockWindowResizeHandle(Qt::Orientation o, QWidget *parent, Q3DockWindow *w, const char* /*name*/=0);
void setOrientation(Qt::Orientation o);
Qt::Orientation orientation() const { return orient; }
QSize sizeHint() const;
protected:
void paintEvent(QPaintEvent *);
void mouseMoveEvent(QMouseEvent *);
void mousePressEvent(QMouseEvent *);
void mouseReleaseEvent(QMouseEvent *);
bool event(QEvent *event);
private:
void startLineDraw();
void endLineDraw();
void drawLine(const QPoint &globalPos);
private:
Qt::Orientation orient;
bool mousePressed;
QRubberBand *rubberBand;
QPoint lastPos, firstPos;
Q3DockWindow *dockWindow;
bool mouseOver;
};
Q3DockWindowResizeHandle::Q3DockWindowResizeHandle(Qt::Orientation o, QWidget *parent,
Q3DockWindow *w, const char *)
: QWidget(parent, "qt_dockwidget_internal"), mousePressed(false), rubberBand(0), dockWindow(w),
mouseOver(false)
{
setOrientation(o);
}
QSize Q3DockWindowResizeHandle::sizeHint() const
{
QStyleOptionQ3DockWindow opt;
opt.init(this);
if (!dockWindow->area() || dockWindow->area()->orientation() == Qt::Horizontal)
opt.state |= QStyle::State_Horizontal;
opt.rect = rect();
opt.docked = dockWindow->area();
opt.closeEnabled = dockWindow->isCloseEnabled();
int sw = 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, &opt, this) / 3;
return (style()->sizeFromContents(QStyle::CT_Q3DockWindow, &opt, QSize(sw, sw), this).expandedTo(QApplication::globalStrut()));
}
void Q3DockWindowResizeHandle::setOrientation(Qt::Orientation o)
{
orient = o;
if (o == Qt::Horizontal) {
#ifndef QT_NO_CURSOR
setCursor(Qt::splitVCursor);
#endif
setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
} else {
#ifndef QT_NO_CURSOR
setCursor(Qt::splitHCursor);
#endif
setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding));
}
}
void Q3DockWindowResizeHandle::mousePressEvent(QMouseEvent *e)
{
e->ignore();
if (e->button() != Qt::LeftButton)
return;
e->accept();
mousePressed = true;
if (!dockWindow->opaqueMoving())
startLineDraw();
lastPos = firstPos = e->globalPos();
if (!dockWindow->opaqueMoving())
drawLine(e->globalPos());
}
void Q3DockWindowResizeHandle::mouseMoveEvent(QMouseEvent *e)
{
if (!mousePressed)
return;
if (!dockWindow->opaqueMoving()) {
if (orientation() != dockWindow->area()->orientation()) {
if (orientation() == Qt::Horizontal) {
int minpos = dockWindow->area()->mapToGlobal(QPoint(0, 0)).y();
int maxpos = dockWindow->area()->mapToGlobal(QPoint(0, 0)).y() + dockWindow->area()->height();
if (e->globalPos().y() < minpos || e->globalPos().y() > maxpos)
return;
} else {
int minpos = dockWindow->area()->mapToGlobal(QPoint(0, 0)).x();
int maxpos = dockWindow->area()->mapToGlobal(QPoint(0, 0)).x() + dockWindow->area()->width();
if (e->globalPos().x() < minpos || e->globalPos().x() > maxpos)
return;
}
} else {
QWidget *w = dockWindow->area()->window();
if (w) {
if (orientation() == Qt::Horizontal) {
int minpos = w->mapToGlobal(QPoint(0, 0)).y();
int maxpos = w->mapToGlobal(QPoint(0, 0)).y() + w->height();
if (e->globalPos().y() < minpos || e->globalPos().y() > maxpos)
return;
} else {
int minpos = w->mapToGlobal(QPoint(0, 0)).x();
int maxpos = w->mapToGlobal(QPoint(0, 0)).x() + w->width();
if (e->globalPos().x() < minpos || e->globalPos().x() > maxpos)
return;
}
}
}
}
if (!dockWindow->opaqueMoving())
drawLine(lastPos);
lastPos = e->globalPos();
if (dockWindow->opaqueMoving()) {
mouseReleaseEvent(e);
mousePressed = true;
firstPos = e->globalPos();
}
if (!dockWindow->opaqueMoving())
drawLine(e->globalPos());
}
void Q3DockWindowResizeHandle::mouseReleaseEvent(QMouseEvent *e)
{
if (mousePressed) {
if (!dockWindow->opaqueMoving()) {
drawLine(lastPos);
endLineDraw();
}
if (orientation() != dockWindow->area()->orientation())
dockWindow->area()->invalidNextOffset(dockWindow);
if (orientation() == Qt::Horizontal) {
int dy;
if (dockWindow->area()->handlePosition() == Q3DockArea::Normal || orientation() != dockWindow->area()->orientation())
dy = e->globalPos().y() - firstPos.y();
else
dy = firstPos.y() - e->globalPos().y();
int d = dockWindow->height() + dy;
if (orientation() != dockWindow->area()->orientation()) {
dockWindow->setFixedExtentHeight(-1);
d = qMax(d, dockWindow->minimumHeight());
int ms = dockWindow->area()->maxSpace(d, dockWindow);
d = qMin(d, ms);
dockWindow->setFixedExtentHeight(d);
} else {
dockWindow->area()->setFixedExtent(d, dockWindow);
}
} else {
int dx;
if (dockWindow->area()->handlePosition() == Q3DockArea::Normal || orientation() != dockWindow->area()->orientation())
dx = e->globalPos().x() - firstPos.x();
else
dx = firstPos.x() - e->globalPos().x();
int d = dockWindow->width() + dx;
if (orientation() != dockWindow->area()->orientation()) {
dockWindow->setFixedExtentWidth(-1);
d = qMax(d, dockWindow->minimumWidth());
int ms = dockWindow->area()->maxSpace(d, dockWindow);
d = qMin(d, ms);
dockWindow->setFixedExtentWidth(d);
} else {
dockWindow->area()->setFixedExtent(d, dockWindow);
}
}
}
QApplication::postEvent(dockWindow->area(), new QEvent(QEvent::LayoutHint));
mousePressed = false;
}
bool Q3DockWindowResizeHandle::event(QEvent *event)
{
switch (event->type()) {
case QEvent::HoverEnter:
if (!mouseOver) {
mouseOver = true;
update();
}
break;
case QEvent::HoverLeave:
if (mouseOver) {
mouseOver = false;
update();
}
break;
default:
break;
}
return QWidget::event(event);
}
void Q3DockWindowResizeHandle::paintEvent(QPaintEvent *)
{
QPainter p(this);
QStyleOption opt(0);
opt.init(this);
if (orientation() == Qt::Horizontal)
opt.state |= QStyle::State_Horizontal;
style()->drawPrimitive(QStyle::PE_IndicatorDockWidgetResizeHandle, &opt, &p, this);
}
void Q3DockWindowResizeHandle::startLineDraw()
{
if (rubberBand)
endLineDraw();
rubberBand = new QRubberBand(QRubberBand::Line);
rubberBand->setGeometry(-1, -1, 1, 1);
rubberBand->show();
}
void Q3DockWindowResizeHandle::endLineDraw()
{
delete rubberBand;
rubberBand = 0;
}
void Q3DockWindowResizeHandle::drawLine(const QPoint &globalPos)
{
QPoint start = mapToGlobal(QPoint(0, 0));
QPoint starta = dockWindow->area()->mapToGlobal(QPoint(0, 0));
QPoint end = globalPos;
if (orientation() == Qt::Horizontal) {
if (orientation() == dockWindow->orientation())
rubberBand->setGeometry(starta.x(), end.y(), dockWindow->area()->width(), height());
else
rubberBand->setGeometry(start.x(), end.y(), width(), height());
} else {
if (orientation() == dockWindow->orientation())
rubberBand->setGeometry(end.x(), starta.y(), width(), dockWindow->area()->height());
else
rubberBand->setGeometry(end.x(), start.y(), width(), height());
}
}
static QPoint realWidgetPos(Q3DockWindow *w)
{
if (!w->parentWidget() || w->place() == Q3DockWindow::OutsideDock)
return w->pos();
return w->parentWidget()->mapToGlobal(w->geometry().topLeft());
}
class Q3DockWindowHandle : public QWidget
{
Q_OBJECT
Q_PROPERTY(QString windowTitle READ windowTitle)
friend class Q3DockWindow;
friend class Q3DockWindowTitleBar;
public:
Q3DockWindowHandle(Q3DockWindow *dw);
void updateGui();
QSize minimumSizeHint() const;
QSize minimumSize() const { return minimumSizeHint(); }
QSize sizeHint() const { return minimumSize(); }
void setOpaqueMoving(bool b) { opaque = b; }
QString windowTitle() const { return dockWindow->windowTitle(); }
signals:
void doubleClicked();
protected:
void paintEvent(QPaintEvent *e);
void resizeEvent(QResizeEvent *e);
void mousePressEvent(QMouseEvent *e);
void mouseMoveEvent(QMouseEvent *e);
void mouseReleaseEvent(QMouseEvent *e);
void mouseDoubleClickEvent(QMouseEvent *e);
void keyPressEvent(QKeyEvent *e);
void keyReleaseEvent(QKeyEvent *e);
void changeEvent(QEvent *);
private slots:
void minimize();
private:
Q3DockWindow *dockWindow;
QPoint offset;
QToolButton *closeButton;
QTimer *timer;
uint opaque : 1;
uint mousePressed : 1;
uint hadDblClick : 1;
uint ctrlDown : 1;
QPointer<QWidget> oldFocus;
};
class Q3DockWindowTitleBar : public Q3TitleBar
{
Q_OBJECT
friend class Q3DockWindow;
friend class Q3DockWindowHandle;
public:
Q3DockWindowTitleBar(Q3DockWindow *dw);
void updateGui();
void setOpaqueMoving(bool b) { opaque = b; }
protected:
void resizeEvent(QResizeEvent *e);
void mousePressEvent(QMouseEvent *e);
void mouseMoveEvent(QMouseEvent *e);
void mouseReleaseEvent(QMouseEvent *e);
void mouseDoubleClickEvent(QMouseEvent *e);
void keyPressEvent(QKeyEvent *e);
void keyReleaseEvent(QKeyEvent *e);
private:
Q3DockWindow *dockWindow;
QPoint offset;
uint mousePressed : 1;
uint hadDblClick : 1;
uint opaque : 1;
uint ctrlDown : 1;
QPointer<QWidget> oldFocus;
};
Q3DockWindowHandle::Q3DockWindowHandle(Q3DockWindow *dw)
: QWidget(dw, "qt_dockwidget_internal"), dockWindow(dw),
closeButton(0), opaque(default_opaque), mousePressed(false)
{
ctrlDown = false;
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(minimize()));
#if defined(Q_WS_WIN) && !defined(QT_NO_CURSOR)
setCursor(Qt::SizeAllCursor);
#endif
}
void Q3DockWindowHandle::paintEvent(QPaintEvent *e)
{
if (!dockWindow->dockArea && !opaque)
return;
QPainter p(this);
QStyleOptionQ3DockWindow opt;
opt.init(this);
if (!dockWindow->area() || dockWindow->area()->orientation() == Qt::Horizontal)
opt.state |= QStyle::State_Horizontal;
opt.rect = rect();
opt.docked = dockWindow->area();
opt.closeEnabled = dockWindow->isCloseEnabled();
opt.rect = QStyle::visualRect(opt.direction, opt.rect,
style()->subElementRect(QStyle::SE_Q3DockWindowHandleRect, &opt, this));
style()->drawPrimitive(QStyle::PE_IndicatorToolBarHandle, &opt, &p, this);
QWidget::paintEvent(e);
}
void Q3DockWindowHandle::keyPressEvent(QKeyEvent *e)
{
if (!mousePressed)
return;
if (e->key() == Qt::Key_Control) {
ctrlDown = true;
dockWindow->handleMove(mapFromGlobal(QCursor::pos()) - offset, QCursor::pos(), !opaque);
}
}
void Q3DockWindowHandle::keyReleaseEvent(QKeyEvent *e)
{
if (!mousePressed)
return;
if (e->key() == Qt::Key_Control) {
ctrlDown = false;
dockWindow->handleMove(mapFromGlobal(QCursor::pos()) - offset, QCursor::pos(), !opaque);
}
}
void Q3DockWindowHandle::mousePressEvent(QMouseEvent *e)
{
if (!dockWindow->dockArea)
return;
ctrlDown = (e->state() & Qt::ControlButton) == Qt::ControlButton;
oldFocus = qApp->focusWidget();
setFocus();
e->ignore();
if (e->button() != Qt::LeftButton)
return;
e->accept();
hadDblClick = false;
mousePressed = true;
offset = e->pos();
dockWindow->startRectDraw(mapToGlobal(e->pos()), !opaque);
if (!opaque)
qApp->installEventFilter(dockWindow);
}
void Q3DockWindowHandle::mouseMoveEvent(QMouseEvent *e)
{
if (!mousePressed || e->pos() == offset)
return;
ctrlDown = (e->state() & Qt::ControlButton) == Qt::ControlButton;
dockWindow->handleMove(e->pos() - offset, e->globalPos(), !opaque);
if (opaque)
dockWindow->updatePosition(e->globalPos());
}
void Q3DockWindowHandle::mouseReleaseEvent(QMouseEvent *e)
{
ctrlDown = false;
qApp->removeEventFilter(dockWindow);
if (oldFocus)
oldFocus->setFocus();
if (!mousePressed)
return;
dockWindow->endRectDraw(!opaque);
mousePressed = false;
#ifdef Q_WS_MAC
releaseMouse();
#endif
if (!hadDblClick && offset == e->pos()) {
timer->start(QApplication::doubleClickInterval(), true);
} else if (!hadDblClick) {
dockWindow->updatePosition(e->globalPos());
}
if (opaque)
dockWindow->titleBar->mousePressed = false;
if (dockWindow->parentWidget())
QApplication::postEvent(dockWindow->parentWidget(), new QEvent(QEvent::LayoutHint));
}
void Q3DockWindowHandle::minimize()
{
if (!dockWindow->area())
return;
Q3MainWindow *mw = qobject_cast<Q3MainWindow*>(dockWindow->area()->parentWidget());
if (mw && mw->isDockEnabled(dockWindow, Qt::DockMinimized))
mw->moveDockWindow(dockWindow, Qt::DockMinimized);
}
void Q3DockWindowHandle::resizeEvent(QResizeEvent *)
{
updateGui();
}
void Q3DockWindowHandle::updateGui()
{
updateGeometry();
if (!closeButton) {
closeButton = new QToolButton(this, "qt_close_button1");
#ifndef QT_NO_CURSOR
closeButton->setCursor(Qt::ArrowCursor);
#endif
QStyleOption opt(0);
opt.init(closeButton);
closeButton->setIcon(style()->standardIcon(QStyle::SP_DockWidgetCloseButton, &opt,
closeButton));
closeButton->setFixedSize(12, 12);
connect(closeButton, SIGNAL(clicked()),
dockWindow, SLOT(hide()));
}
if (dockWindow->isCloseEnabled() && dockWindow->area())
closeButton->show();
else
closeButton->hide();
if (!dockWindow->area())
return;
if (dockWindow->area()->orientation() == Qt::Horizontal) {
int off = (width() - closeButton->width() - 1) / 2;
closeButton->move(off, 2);
} else {
int off = (height() - closeButton->height() - 1) / 2;
int x = QApplication::reverseLayout() ? 2 : width() - closeButton->width() - 2;
closeButton->move(x, off);
}
}
void Q3DockWindowHandle::changeEvent(QEvent *ev)
{
if(ev->type() == QEvent::StyleChange) {
if (closeButton) {
QStyleOption opt(0);
opt.init(closeButton);
closeButton->setIcon(style()->standardIcon(QStyle::SP_DockWidgetCloseButton,
&opt, closeButton));
}
}
QWidget::changeEvent(ev);
}
QSize Q3DockWindowHandle::minimumSizeHint() const
{
if (!dockWindow->dockArea)
return QSize(0, 0);
int wh = dockWindow->isCloseEnabled() ? 17 : style()->pixelMetric(QStyle::PM_ToolBarHandleExtent, 0, this);
if (dockWindow->orientation() == Qt::Horizontal)
return QSize(wh, 0);
return QSize(0, wh);
}
void Q3DockWindowHandle::mouseDoubleClickEvent(QMouseEvent *e)
{
e->ignore();
if (e->button() != Qt::LeftButton)
return;
e->accept();
timer->stop();
emit doubleClicked();
hadDblClick = true;
if (dockWindow->parentWidget())
QApplication::postEvent(dockWindow->parentWidget(), new QEvent(QEvent::LayoutHint));
}
Q3DockWindowTitleBar::Q3DockWindowTitleBar(Q3DockWindow *dw)
: Q3TitleBar(0, dw), dockWindow(dw),
mousePressed(false), hadDblClick(false), opaque(default_opaque)
{
setObjectName(QLatin1String("qt_dockwidget_internal"));
ctrlDown = false;
setMouseTracking(true);
QStyleOptionTitleBar opt = getStyleOption();
setFixedHeight(style()->pixelMetric(QStyle::PM_TitleBarHeight, &opt, this));
connect(this, SIGNAL(doClose()), dockWindow, SLOT(hide()));
}
void Q3DockWindowTitleBar::keyPressEvent(QKeyEvent *e)
{
if (!mousePressed)
return;
if (e->key() == Qt::Key_Control) {
ctrlDown = true;
dockWindow->handleMove(mapFromGlobal(QCursor::pos()) - offset, QCursor::pos(), !opaque);
}
}
void Q3DockWindowTitleBar::keyReleaseEvent(QKeyEvent *e)
{
if (!mousePressed)
return;
if (e->key() == Qt::Key_Control) {
ctrlDown = false;
dockWindow->handleMove(mapFromGlobal(QCursor::pos()) - offset, QCursor::pos(), !opaque);
}
}
void Q3DockWindowTitleBar::mousePressEvent(QMouseEvent *e)
{
QStyleOptionTitleBar opt;
opt.init(this);
opt.subControls = QStyle::SC_All;
opt.activeSubControls = QStyle::SC_None;
opt.text = windowTitle();
//################
QIcon icon = windowIcon();
QSize s = icon.actualSize(QSize(64, 64));
opt.icon = icon.pixmap(s);
opt.titleBarState = window() ? window()->windowState() : static_cast<Qt::WindowStates>(Qt::WindowNoState);
opt.titleBarFlags = fakeWindowFlags();
QStyle::SubControl tbctrl = style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt,
e->pos(), this);
if (tbctrl < QStyle::SC_TitleBarLabel && tbctrl != QStyle::SC_None) {
Q3TitleBar::mousePressEvent(e);
return;
}
ctrlDown = (e->state() & Qt::ControlButton) == Qt::ControlButton;
oldFocus = qApp->focusWidget();
// setFocus activates the window, which deactivates the main window
// not what we want, and not required anyway on Windows
#ifndef Q_WS_WIN
setFocus();
#endif
e->ignore();
if (e->button() != Qt::LeftButton)
return;
if (e->y() < 3 && dockWindow->isResizeEnabled())
return;
e->accept();
bool oldPressed = mousePressed;
mousePressed = true;
hadDblClick = false;
offset = e->pos();
dockWindow->startRectDraw(mapToGlobal(e->pos()), !opaque);
// grabMouse resets the Windows mouse press count, so we never receive a double click on Windows
// not required on Windows, and did work on X11, too, but no problem there in the first place
#ifndef Q_WS_WIN
if(!oldPressed && dockWindow->opaqueMoving())
grabMouse();
#else
Q_UNUSED(oldPressed);
#endif
}
void Q3DockWindowTitleBar::mouseMoveEvent(QMouseEvent *e)
{
if (!mousePressed) {
Q3TitleBar::mouseMoveEvent(e);
return;
}
ctrlDown = (e->state() & Qt::ControlButton) == Qt::ControlButton;
e->accept();
dockWindow->handleMove(e->pos() - offset, e->globalPos(), !opaque);
}
void Q3DockWindowTitleBar::mouseReleaseEvent(QMouseEvent *e)
{
if (!mousePressed) {
Q3TitleBar::mouseReleaseEvent(e);
return;
}
ctrlDown = false;
qApp->removeEventFilter(dockWindow);
if (oldFocus)
oldFocus->setFocus();
if (dockWindow->place() == Q3DockWindow::OutsideDock)
dockWindow->raise();
if(dockWindow->opaqueMoving())
releaseMouse();
if (!mousePressed)
return;
dockWindow->endRectDraw(!opaque);
mousePressed = false;
if (!hadDblClick)
dockWindow->updatePosition(e->globalPos());
if (opaque) {
dockWindow->horHandle->mousePressed = false;
dockWindow->verHandle->mousePressed = false;
}
if (dockWindow->parentWidget())
QApplication::postEvent(dockWindow->parentWidget(), new QEvent(QEvent::LayoutHint));
}
void Q3DockWindowTitleBar::resizeEvent(QResizeEvent *e)
{
updateGui();
Q3TitleBar::resizeEvent(e);
}
void Q3DockWindowTitleBar::updateGui()
{
if (dockWindow->isCloseEnabled()) {
setFakeWindowFlags(fakeWindowFlags() | Qt::WStyle_SysMenu);
} else {
setFakeWindowFlags(fakeWindowFlags() & ~Qt::WStyle_SysMenu);
}
}
void Q3DockWindowTitleBar::mouseDoubleClickEvent(QMouseEvent *)
{
emit doubleClicked();
hadDblClick = true;
if (dockWindow->parentWidget())
QApplication::postEvent(dockWindow->parentWidget(), new QEvent(QEvent::LayoutHint));
}
/*!
\class Q3DockWindow
\brief The Q3DockWindow class provides a widget which can be docked
inside a Q3DockArea or floated as a top level window on the
desktop.
\compat
This class handles moving, resizing, docking and undocking dock
windows. Q3ToolBar is a subclass of Q3DockWindow so the
functionality provided for dock windows is available with the same
API for toolbars.
\img qmainwindow-qdockareas.png Q3DockWindows in a Q3DockArea
\caption Two Q3DockWindows (\l{Q3ToolBar}s) in a \l Q3DockArea
\img qdockwindow.png A Q3DockWindow
\caption A Floating Q3DockWindow
If the user drags the dock window into the dock area the dock
window will be docked. If the user drags the dock area outside any
dock areas the dock window will be undocked (floated) and will
become a top level window. Double clicking a floating dock
window's title bar will dock the dock window to the last dock area
it was docked in. Double clicking a docked dock window's handle
will undock (float) the dock window.
\omit
Single clicking a docked dock window's handle will minimize the
dock window (only its handle will appear, below the menu bar).
Single clicking the minimized handle will restore the dock window
to the last dock area that it was docked in.
\endomit
If the user clicks the close button (which appears on floating
dock windows by default) the dock window will disappear. You can
control whether or not a dock window has a close button with
setCloseMode().
Q3MainWindow provides four dock areas (top, left, right and bottom)
which can be used by dock windows. For many applications using the
dock areas provided by Q3MainWindow is sufficient. (See the \l
Q3DockArea documentation if you want to create your own dock
areas.) In Q3MainWindow a right-click popup menu (the dock window
menu) is available which lists dock windows and can be used to
show or hide them. (The popup menu only lists dock windows that
have a \link QWidget::setWindowTitle() caption\endlink.)
When you construct a dock window you \e must pass it a Q3DockArea
or a Q3MainWindow as its parent if you want it docked. Pass 0 for
the parent if you want it floated.
\snippet doc/src/snippets/code/src_qt3support_widgets_q3dockwindow.cpp 0
In the example above we create a new Q3ToolBar in the constructor
of a Q3MainWindow subclass (so that the \e this pointer points to
the Q3MainWindow). By default the toolbar will be added to the \c
Top dock area, but we've moved it to the \c Left dock area.
A dock window is often used to contain a single widget. In these
cases the widget can be set by calling setWidget(). If you're
constructing a dock window that contains multiple widgets, e.g. a
toolbar, arrange the widgets within a box layout inside the dock
window. To do this use the boxLayout() function to get a pointer
to the dock window's box layout, then add widgets to the layout
using the box layout's QBoxLayout::addWidget() function. The dock
window will dynamically set the orientation of the layout to be
vertical or horizontal as necessary, although you can control this
yourself with setOrientation().
Although a common use of dock windows is for toolbars, they can be
used with any widgets. When using larger
widgets it may make sense for the dock window to be resizable by
calling setResizeEnabled(). Resizable dock windows are given
splitter-like handles to allow the user to resize them within
their dock area. When resizable dock windows are undocked they
become top level windows and can be resized like any other top
level windows, e.g. by dragging a corner or edge.
Qt::Dock windows can be docked and undocked using dock() and undock().
A dock window's orientation can be set with setOrientation(). You
can also use Q3DockArea::moveDockWindow(). If you're using a
Q3MainWindow, Q3MainWindow::moveDockWindow() and
Q3MainWindow::removeDockWindow() are available.
A dock window can have some preferred settings, for example, you
can set a preferred offset from the left edge (or top edge for
vertical dock areas) of the dock area using setOffset(). If you'd
prefer a dock window to start on a new line when it is docked use
setNewLine(). The setFixedExtentWidth() and setFixedExtentHeight()
functions can be used to define the dock window's preferred size,
and the setHorizontallyStretchable() and setVerticallyStretchable()
functions set whether the dock window can be stretched or not.
Dock windows can be moved by default, but this can be changed with
setMovingEnabled(). When a dock window is moved it is shown as a
rectangular outline, but it can be shown normally using
setOpaqueMoving().
When a dock window's visibility changes, i.e. it is shown or
hidden, the visibilityChanged() signal is emitted. When a dock
window is docked, undocked or moved inside the dock area the
placeChanged() signal is emitted.
*/
/*!
\enum Q3DockWindow::Place
This enum specifies the possible locations for a Q3DockWindow:
\value InDock Inside a Q3DockArea.
\value OutsideDock Floating as a top level window on the desktop.
*/
/*!
\enum Q3DockWindow::CloseMode
This enum type specifies when (if ever) a dock window has a close
button.
\value Never The dock window never has a close button and cannot
be closed by the user.
\value Docked The dock window has a close button only when
docked.
\value Undocked The dock window has a close button only when
floating.
\value Always The dock window always has a close button.
\omit
Note that dock windows can always be minimized if the user clicks
their dock window handle when they are docked.
\endomit
*/
/*!
\fn void Q3DockWindow::setHorizontalStretchable(bool b)
If \a b is true the dock window is set to be horizontally
stretchable.
*/
/*!
\fn void Q3DockWindow::setVerticalStretchable(bool b)
If \a b is true the dock window is set to be vertically
stretchable.
*/
/*!
\fn bool Q3DockWindow::isHorizontalStretchable() const
Returns true if the dock window can be stretched horizontally;
otherwise returns false.
*/
/*!
\fn bool Q3DockWindow::isVerticalStretchable() const
Returns true if the dock window can be stretched vertically;
otherwise returns false.
*/
/*!
\fn void Q3DockWindow::orientationChanged(Qt::Orientation o)
This signal is emitted when the orientation of the dock window is
changed. The new orientation is \a o.
*/
/*!
\fn void Q3DockWindow::placeChanged(Q3DockWindow::Place p)
This signal is emitted when the dock window is docked (\a p is \c
InDock), undocked (\a p is \c OutsideDock) or moved inside the
the dock area.
\sa Q3DockArea::moveDockWindow(), Q3DockArea::removeDockWindow(),
Q3MainWindow::moveDockWindow(), Q3MainWindow::removeDockWindow()
*/
/*!
\fn void Q3DockWindow::visibilityChanged(bool visible)
This signal is emitted when the visibility of the dock window
relatively to its dock area is changed. If \a visible is true, the
Q3DockWindow is now visible to the dock area, otherwise it has been
hidden.
A dock window can be hidden if it has a close button which the
user has clicked. In the case of a Q3MainWindow a dock window can
have its visibility changed (hidden or shown) by clicking its name
in the dock window menu that lists the Q3MainWindow's dock windows.
*/
/*!
\fn Q3DockArea *Q3DockWindow::area() const
Returns the dock area in which this dock window is docked, or 0 if
the dock window is floating.
*/
/*!
\property Q3DockWindow::place
\brief the location where the dock window is placed
This is either \c InDock or \c OutsideDock.
\sa Q3DockArea::moveDockWindow(), Q3DockArea::removeDockWindow(),
Q3MainWindow::moveDockWindow(), Q3MainWindow::removeDockWindow()
*/
/*!
Constructs a Q3DockWindow with parent \a parent, called \a name and
with widget flags \a f.
*/
Q3DockWindow::Q3DockWindow(QWidget* parent, const char* name, Qt::WindowFlags f)
: Q3Frame(parent, name, f | Qt::WType_Dialog | Qt::WStyle_Customize | Qt::WStyle_NoBorder)
{
curPlace = InDock;
isToolbar = false;
init();
}
/*!
Constructs a Q3DockWindow with parent \a parent, called \a name and
with widget flags \a f.
If \a p is \c InDock, the dock window is docked into a dock area
and \a parent \e must be a Q3DockArea or a Q3MainWindow. If the \a
parent is a Q3MainWindow the dock window will be docked in the main
window's \c Top dock area.
If \a p is \c OutsideDock, the dock window is created as a floating
window.
We recommend creating the dock area \c InDock with a Q3MainWindow
as parent then calling Q3MainWindow::moveDockWindow() to move the
dock window where you want it.
*/
Q3DockWindow::Q3DockWindow(Place p, QWidget *parent, const char *name, Qt::WindowFlags f)
: Q3Frame(parent, name, f | Qt::WType_Dialog | Qt::WStyle_Customize | Qt::WStyle_NoBorder)
{
curPlace = p;
isToolbar = false;
init();
}
/*! \internal
*/
Q3DockWindow::Q3DockWindow(Place p, QWidget *parent, const char *name, Qt::WindowFlags f, bool toolbar)
: Q3Frame(parent, name, f | Qt::WType_Dialog | Qt::WStyle_Customize | Qt::WStyle_NoBorder)
{
curPlace = p;
isToolbar = toolbar;
init();
}
class Q3DockWindowGridLayout : public QGridLayout
{
public:
Q3DockWindowGridLayout(QWidget *parent, int nRows, int nCols)
: QGridLayout(parent, nRows, nCols) {};
Qt::Orientations expandingDirections() const
{
return 0;
}
};
void Q3DockWindow::init()
{
wid = 0;
rubberBand = 0;
dockArea = 0;
tmpDockArea = 0;
resizeEnabled = false;
moveEnabled = true;
nl = false;
opaque = default_opaque;
cMode = Never;
offs = 0;
fExtent = QSize(-1, -1);
dockWindowData = 0;
lastPos = QPoint(-1, -1);
lastSize = QSize(-1, -1);
stretchable[Qt::Horizontal] = false;
stretchable[Qt::Vertical] = false;
widgetResizeHandler = new QWidgetResizeHandler(this);
widgetResizeHandler->setMovingEnabled(false);
titleBar = new Q3DockWindowTitleBar(this);
verHandle = new Q3DockWindowHandle(this);
verHandle->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred));
horHandle = new Q3DockWindowHandle(this);
horHandle->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));
vHandleLeft = new Q3DockWindowResizeHandle(Qt::Vertical, this, this, "vert. handle");
vHandleRight = new Q3DockWindowResizeHandle(Qt::Vertical, this, this, "vert. handle");
hHandleTop = new Q3DockWindowResizeHandle(Qt::Horizontal, this, this, "horz. handle");
hHandleBottom = new Q3DockWindowResizeHandle(Qt::Horizontal, this, this, "horz. handle");
// Creating inner layout
hbox = new QVBoxLayout();
vbox = new QHBoxLayout();
childBox = new QBoxLayout(QBoxLayout::LeftToRight);
vbox->addSpacing(2);
vbox->addWidget(verHandle);
vbox->addStretch(0);
vbox->addLayout(childBox, 1);
vbox->addStretch(0);
hbox->setResizeMode(QLayout::FreeResize);
hbox->setMargin(isResizeEnabled() || curPlace == OutsideDock ? 2 : 0);
hbox->setSpacing(1);
hbox->addWidget(titleBar);
hbox->addWidget(horHandle);
hbox->addLayout(vbox);
// Set up the initial handle layout for Qt::Vertical
// Handle layout will change on calls to setOrienation()
QGridLayout *glayout = new Q3DockWindowGridLayout(this, 3, 3);
glayout->setResizeMode(QLayout::Minimum);
glayout->addMultiCellWidget(hHandleTop, 0, 0, 1, 1);
glayout->addMultiCellWidget(hHandleBottom, 2, 2, 1, 1);
glayout->addMultiCellWidget(vHandleLeft, 0, 2, 0, 0);
glayout->addMultiCellWidget(vHandleRight, 0, 2, 2, 2);
glayout->addLayout(hbox, 1, 1);
glayout->setRowStretch(1, 1);
glayout->setColStretch(1, 1);
hHandleBottom->hide();
vHandleRight->hide();
hHandleTop->hide();
vHandleLeft->hide();
setFrameStyle(Q3Frame::StyledPanel | Q3Frame::Raised);
setLineWidth(2);
if (parentWidget())
parentWidget()->installEventFilter(this);
QWidget *mw = parentWidget();
Q3DockArea *da = qobject_cast<Q3DockArea*>(parentWidget());
if (da) {
if (curPlace == InDock)
da->moveDockWindow(this);
mw = da->parentWidget();
}
if (qobject_cast<Q3MainWindow*>(mw)) {
if (place() == InDock) {
Qt::Dock myDock = Qt::DockTop;
// make sure we put the window in the correct dock.
if (dockArea) {
Q3MainWindow *mainw = (Q3MainWindow*)mw;
// I'm not checking if it matches the top because I've
// done the assignment to it above.
if (dockArea == mainw->leftDock())
myDock = Qt::DockLeft;
else if (dockArea == mainw->rightDock())
myDock = Qt::DockRight;
else if (dockArea == mainw->bottomDock())
myDock = Qt::DockBottom;
}
((Q3MainWindow*)mw)->addDockWindow(this, myDock);
}
moveEnabled = ((Q3MainWindow*)mw)->dockWindowsMovable();
opaque = ((Q3MainWindow*)mw)->opaqueMoving();
}
updateGui();
connect(titleBar, SIGNAL(doubleClicked()), this, SLOT(dock()));
connect(verHandle, SIGNAL(doubleClicked()), this, SLOT(undock()));
connect(horHandle, SIGNAL(doubleClicked()), this, SLOT(undock()));
connect(this, SIGNAL(orientationChanged(Qt::Orientation)),
this, SLOT(setOrientation(Qt::Orientation)));
}
/*!
Sets the orientation of the dock window to \a o. The orientation
is propagated to the layout boxLayout().
\warning All undocked Q3ToolBars will always have a horizontal orientation.
*/
void Q3DockWindow::setOrientation(Qt::Orientation o)
{
QGridLayout *glayout = (QGridLayout*)layout();
glayout->removeWidget(hHandleTop);
glayout->removeWidget(hHandleBottom);
glayout->removeWidget(vHandleLeft);
glayout->removeWidget(vHandleRight);
if (o == Qt::Horizontal) {
// Set up the new layout as
// 3 3 3 1 = vHandleLeft 4 = hHandleBottom
// 1 X 2 2 = vHandleRight X = Inner Layout
// 4 4 4 3 = hHandleTop
glayout->addMultiCellWidget(hHandleTop, 0, 0, 0, 2);
glayout->addMultiCellWidget(hHandleBottom, 2, 2, 0, 2);
glayout->addMultiCellWidget(vHandleLeft, 1, 1, 0, 0);
glayout->addMultiCellWidget(vHandleRight, 1, 1, 2, 2);
} else {
// Set up the new layout as
// 1 3 2 1 = vHandleLeft 4 = hHandleBottom
// 1 X 2 2 = vHandleRight X = Inner Layout
// 1 4 2 3 = hHandleTop
glayout->addMultiCellWidget(hHandleTop, 0, 0, 1, 1);
glayout->addMultiCellWidget(hHandleBottom, 2, 2, 1, 1);
glayout->addMultiCellWidget(vHandleLeft, 0, 2, 0, 0);
glayout->addMultiCellWidget(vHandleRight, 0, 2, 2, 2);
}
boxLayout()->setDirection(o == Qt::Horizontal ? QBoxLayout::LeftToRight : QBoxLayout::TopToBottom);
QApplication::sendPostedEvents(this, QEvent::LayoutHint);
QEvent *e = new QEvent(QEvent::LayoutHint);
QApplication::postEvent(this, e);
}
/*!
Destroys the dock window and its child widgets.
*/
Q3DockWindow::~Q3DockWindow()
{
qApp->removeEventFilter(this);
if (area())
area()->removeDockWindow(this, false, false);
Q3DockArea *a = area();
if (!a && dockWindowData)
a = ((Q3DockArea::DockWindowData*)dockWindowData)->area;
Q3MainWindow *mw = a ? qobject_cast<Q3MainWindow*>(a->parentWidget()) : 0;
if (mw)
mw->removeDockWindow(this);
delete (Q3DockArea::DockWindowData*)dockWindowData;
}
/*! \reimp
*/
void Q3DockWindow::resizeEvent(QResizeEvent *e)
{
Q3Frame::resizeEvent(e);
updateGui();
}
void Q3DockWindow::swapRect(QRect &r, Qt::Orientation o, const QPoint &offset, Q3DockArea *)
{
r.setSize(QSize(r.height(), r.width()));
bool reverse = QApplication::reverseLayout();
if (o == Qt::Horizontal)
r.moveBy(-r.width()/2, 0);
else
r.moveBy(reverse ? - r.width() : 0, -r.height() / 2 );
r.moveBy(offset.x(), offset.y());
}
QWidget *Q3DockWindow::areaAt(const QPoint &gp)
{
QWidget *w = qApp->widgetAt(gp);
if (w && (w == this || w == titleBar) && parentWidget())
w = parentWidget()->childAt(parentWidget()->mapFromGlobal(gp));
while (w) {
if (qobject_cast<Q3DockArea*>(w)) {
Q3DockArea *a = (Q3DockArea*)w;
if (a->isDockWindowAccepted(this))
return w;
}
if (qobject_cast<Q3MainWindow*>(w)) {
Q3MainWindow *mw = (Q3MainWindow*)w;
Q3DockArea *a = mw->dockingArea(mw->mapFromGlobal(gp));
if (a && a->isDockWindowAccepted(this))
return a;
}
w = w->isWindow() ? 0 : (QWidget *)w->parent();
}
return 0;
}
void Q3DockWindow::handleMove(const QPoint &pos, const QPoint &gp, bool drawRect)
{
if (!rubberBand)
return;
currRect = QRect(realWidgetPos(this), size());
QWidget *w = areaAt(gp);
if (titleBar->ctrlDown || horHandle->ctrlDown || verHandle->ctrlDown)
w = 0;
currRect.moveBy(pos.x(), pos.y());
if (!qobject_cast<Q3DockArea*>(w)) {
if (startOrientation != Qt::Horizontal && qobject_cast<Q3ToolBar*>(this))
swapRect(currRect, Qt::Horizontal, startOffset, (Q3DockArea*)w);
if (drawRect) {
rubberBand->setGeometry(currRect);
} else {
QPoint mp(mapToGlobal(pos));
if(place() == InDock) {
undock();
if(titleBar) {
mp = QPoint(titleBar->width() / 2, titleBar->height() / 2);
QMouseEvent me(QEvent::MouseButtonPress, mp, Qt::LeftButton, 0);
QApplication::sendEvent(titleBar, &me);
mp = titleBar->mapToGlobal(mp);
}
}
move(mp);
}
state = OutsideDock;
return;
}
Q3DockArea *area = (Q3DockArea*)w;
if(area->isVisible()) {
state = InDock;
Qt::Orientation o = (area ? area->orientation() :
(boxLayout()->direction() == QBoxLayout::LeftToRight ||
boxLayout()->direction() == QBoxLayout::RightToLeft ?
Qt::Horizontal : Qt::Vertical));
if (startOrientation != o)
swapRect(currRect, o, startOffset, area);
if (drawRect) {
rubberBand->setGeometry(currRect);
}
tmpDockArea = area;
}
}
void Q3DockWindow::updateGui()
{
if (curPlace == OutsideDock) {
hbox->setMargin(2);
horHandle->hide();
verHandle->hide();
if (moveEnabled)
titleBar->show();
else
titleBar->hide();
titleBar->updateGui();
hHandleTop->hide();
vHandleLeft->hide();
hHandleBottom->hide();
vHandleRight->hide();
setLineWidth(2);
widgetResizeHandler->setActive(isResizeEnabled());
} else {
hbox->setMargin(0);
titleBar->hide();
if (orientation() == Qt::Horizontal) {
horHandle->hide();
if (moveEnabled)
verHandle->show();
else
verHandle->hide();
#ifdef Q_WS_MAC
if(horHandle->mousePressed) {
horHandle->mousePressed = false;
verHandle->mousePressed = true;
verHandle->grabMouse();
}
#endif
verHandle->updateGui();
} else {
if (moveEnabled)
horHandle->show();
else
horHandle->hide();
horHandle->updateGui();
#ifdef Q_WS_MAC
if(verHandle->mousePressed) {
verHandle->mousePressed = false;
horHandle->mousePressed = true;
horHandle->grabMouse();
}
#endif
verHandle->hide();
}
if (isResizeEnabled()) {
if (orientation() == Qt::Horizontal) {
hHandleBottom->raise();
hHandleTop->raise();
} else {
vHandleRight->raise();
vHandleLeft->raise();
}
if (area()) {
if (orientation() == Qt::Horizontal) {
if (area()->handlePosition() == Q3DockArea::Normal) {
hHandleBottom->show();
hHandleTop->hide();
} else {
hHandleTop->show();
hHandleBottom->hide();
}
if (!area()->isLastDockWindow(this))
vHandleRight->show();
else
vHandleRight->hide();
vHandleLeft->hide();
} else {
if ((area()->handlePosition() == Q3DockArea::Normal) != QApplication::reverseLayout()) {
vHandleRight->show();
vHandleLeft->hide();
} else {
vHandleLeft->show();
vHandleRight->hide();
}
if (!area()->isLastDockWindow(this))
hHandleBottom->show();
else
hHandleBottom->hide();
hHandleTop->hide();
}
}
}
#ifndef Q_OS_WINCE
if (moveEnabled)
setLineWidth(1);
else
setLineWidth(0);
#endif
widgetResizeHandler->setActive(false);
}
}
void Q3DockWindow::updatePosition(const QPoint &globalPos)
{
if (curPlace == OutsideDock && state == InDock)
lastSize = size();
bool doAdjustSize = curPlace != state && state == OutsideDock;
bool doUpdate = true;
bool doOrientationChange = true;
if (state != curPlace && state == InDock) {
doUpdate = false;
curPlace = state;
updateGui();
QApplication::sendPostedEvents();
}
Qt::Orientation oo = orientation();
if (state == InDock) {
if (tmpDockArea) {
bool differentDocks = false;
if (dockArea && dockArea != tmpDockArea) {
differentDocks = true;
delete (Q3DockArea::DockWindowData*)dockWindowData;
dockWindowData = dockArea->dockWindowData(this);
dockArea->removeDockWindow(this, false, false);
}
dockArea = tmpDockArea;
if (differentDocks) {
if (doUpdate) {
doUpdate = false;
curPlace = state;
updateGui();
}
emit orientationChanged(tmpDockArea->orientation());
doOrientationChange = false;
} else {
updateGui();
}
dockArea->moveDockWindow(this, globalPos, currRect, startOrientation != oo);
}
} else {
if (dockArea) {
Q3MainWindow *mw = (Q3MainWindow*)dockArea->parentWidget();
if (qobject_cast<Q3MainWindow*>(mw) &&
(!mw->isDockEnabled(Qt::DockTornOff) ||
!mw->isDockEnabled(this, Qt::DockTornOff)))
return;
delete (Q3DockArea::DockWindowData*)dockWindowData;
dockWindowData = dockArea->dockWindowData(this);
dockArea->removeDockWindow(this, true,
startOrientation != Qt::Horizontal && qobject_cast<Q3ToolBar*>(this));
}
dockArea = 0;
QPoint topLeft = currRect.topLeft();
QRect screen = qApp->desktop()->availableGeometry(topLeft);
if (!screen.contains(topLeft)) {
topLeft.setY(qMax(topLeft.y(), screen.top()));
topLeft.setY(qMin(topLeft.y(), screen.bottom()-height()));
topLeft.setX(qMax(topLeft.x(), screen.left()));
topLeft.setX(qMin(topLeft.x(), screen.right()-width()));
}
move(topLeft);
}
if (curPlace == InDock && state == OutsideDock && !qobject_cast<Q3ToolBar*>(this)) {
if (lastSize != QSize(-1, -1))
resize(lastSize);
}
if (doUpdate) {
curPlace = state;
updateGui();
}
if (doOrientationChange)
emit orientationChanged(orientation());
tmpDockArea = 0;
if (doAdjustSize) {
QApplication::sendPostedEvents(this, QEvent::LayoutHint);
if (qobject_cast<Q3ToolBar*>(this))
adjustSize();
if (lastSize == QSize(-1, -1))
setAttribute(Qt::WA_Resized, false); // Ensures size is recalculated (non-opaque).
show();
if (parentWidget() && isWindow())
parentWidget()->setActiveWindow();
}
emit placeChanged(curPlace);
}
/*!
Sets the dock window's main widget to \a w.
\sa boxLayout()
*/
void Q3DockWindow::setWidget(QWidget *w)
{
wid = w;
boxLayout()->addWidget(w);
updateGui();
}
/*!
Returns the dock window's main widget.
\sa setWidget()
*/
QWidget *Q3DockWindow::widget() const
{
return wid;
}
void Q3DockWindow::startRectDraw(const QPoint &so, bool drawRect)
{
state = place();
if (rubberBand)
endRectDraw(!opaque);
rubberBand = new QRubberBand(QRubberBand::Rectangle);
currRect = QRect(realWidgetPos(this), size());
if (drawRect) {
rubberBand->setGeometry(currRect);
}
startOrientation = orientation();
startOffset = mapFromGlobal(so);
rubberBand->show();
}
void Q3DockWindow::endRectDraw(bool)
{
delete rubberBand;
rubberBand = 0;
}
/*!
\reimp
*/
void Q3DockWindow::drawFrame(QPainter *p)
{
if (place() == InDock) {
Q3Frame::drawFrame(p);
return;
}
QStyleOptionFrame opt;
opt.rect = rect();
opt.palette = palette();
opt.state = QStyle::State_None;
if (titleBar->isActive())
opt.state |= QStyle::State_Active;
opt.lineWidth = lineWidth();
opt.midLineWidth = midLineWidth();
style()->drawPrimitive(QStyle::PE_FrameWindow, &opt, p, this);
}
/*!
\reimp
*/
void Q3DockWindow::drawContents(QPainter *p)
{
// This is only used by the PocketPC style. We probably need to revist later.
QStyleOption opt(0, QStyleOption::SO_Default);
opt.init(this);
if (titleBar->isActive())
opt.state |= QStyle::State_Active;
style()->drawControl(QStyle::CE_Q3DockWindowEmptyArea, &opt, p, this);
}
/*!
\property Q3DockWindow::resizeEnabled
\brief whether the dock window is resizeable
A resizeable dock window can be resized using splitter-like
handles inside a dock area and like every other top level window
when floating.
A dock window is both horizontally and vertically stretchable if
you call setResizeEnabled(true).
This property is false by default.
\sa setVerticallyStretchable() setHorizontallyStretchable()
*/
void Q3DockWindow::setResizeEnabled(bool b)
{
resizeEnabled = b;
updateGui();
}
/*!
\property Q3DockWindow::movingEnabled
\brief whether the user can move the dock window within the dock
area, move the dock window to another dock area, or float the dock
window.
This property is true by default.
*/
void Q3DockWindow::setMovingEnabled(bool b)
{
moveEnabled = b;
updateGui();
}
bool Q3DockWindow::isResizeEnabled() const
{
return resizeEnabled;
}
bool Q3DockWindow::isMovingEnabled() const
{
return moveEnabled;
}
/*!
\property Q3DockWindow::closeMode
\brief the close mode of a dock window
Defines when (if ever) the dock window has a close button. The
choices are \c Never, \c Docked (i.e. only when docked), \c
Undocked (only when undocked, i.e. floated) or \c Always.
The default is \c Never.
*/
void Q3DockWindow::setCloseMode(int m)
{
cMode = m;
if (place() == InDock) {
horHandle->updateGui();
verHandle->updateGui();
} else {
titleBar->updateGui();
}
}
/*!
Returns true if the dock window has a close button; otherwise
returns false. The result depends on the dock window's \l Place
and its \l CloseMode.
\sa setCloseMode()
*/
bool Q3DockWindow::isCloseEnabled() const
{
return (((cMode & Docked) == Docked && place() == InDock) ||
((cMode & Undocked) == Undocked && place() == OutsideDock));
}
int Q3DockWindow::closeMode() const
{
return cMode;
}
/*!
\property Q3DockWindow::horizontallyStretchable
\brief whether the dock window is horizontally stretchable.
A dock window is horizontally stretchable if you call
setHorizontallyStretchable(true) or setResizeEnabled(true).
\warning Stretchability is broken. You must call
setResizeEnabled(true) to get proper behavior and even then
Q3DockWindow does not limit stretchablilty.
\sa setResizeEnabled()
*/
void Q3DockWindow::setHorizontallyStretchable(bool b)
{
stretchable[Qt::Horizontal] = b;
}
/*!
\property Q3DockWindow::verticallyStretchable
\brief whether the dock window is vertically stretchable.
A dock window is vertically stretchable if you call
setVerticallyStretchable(true) or setResizeEnabled(true).
\sa setResizeEnabled()
\warning Stretchability is broken. You must call
setResizeEnabled(true) to get proper behavior and even then
Q3DockWindow does not limit stretchablilty.
*/
void Q3DockWindow::setVerticallyStretchable(bool b)
{
stretchable[Qt::Vertical] = b;
}
bool Q3DockWindow::isHorizontallyStretchable() const
{
return isResizeEnabled() || stretchable[Qt::Horizontal];
}
bool Q3DockWindow::isVerticallyStretchable() const
{
return isResizeEnabled() || stretchable[Qt::Vertical];
}
/*!
\property Q3DockWindow::stretchable
\brief whether the dock window is stretchable in the current
orientation()
This property can be set using setHorizontallyStretchable() and
setVerticallyStretchable(), or with setResizeEnabled().
\warning Stretchability is broken. You must call
setResizeEnabled(true) to get proper behavior and even then
Q3DockWindow does not limit stretchablilty.
\sa setResizeEnabled()
*/
bool Q3DockWindow::isStretchable() const
{
if (orientation() == Qt::Horizontal)
return isHorizontallyStretchable();
return isVerticallyStretchable();
}
/*!
Returns the orientation of the dock window.
\sa orientationChanged()
*/
Qt::Orientation Q3DockWindow::orientation() const
{
if (dockArea)
return dockArea->orientation();
if (qobject_cast<const Q3ToolBar*>(this))
return Qt::Horizontal;
return (((Q3DockWindow*)this)->boxLayout()->direction() == QBoxLayout::LeftToRight ||
((Q3DockWindow*)this)->boxLayout()->direction() == QBoxLayout::RightToLeft ?
Qt::Horizontal : Qt::Vertical);
}
int Q3DockWindow::offset() const
{
return offs;
}
/*!
\property Q3DockWindow::offset
\brief the dock window's preferred offset from the dock area's
left edge (top edge for vertical dock areas)
The default is 0.
*/
void Q3DockWindow::setOffset(int o)
{
offs = o;
}
/*!
Returns the dock window's preferred size (fixed extent).
\sa setFixedExtentWidth() setFixedExtentHeight()
*/
QSize Q3DockWindow::fixedExtent() const
{
return fExtent;
}
/*!
Sets the dock window's preferred width for its fixed extent (size)
to \a w.
\sa setFixedExtentHeight()
*/
void Q3DockWindow::setFixedExtentWidth(int w)
{
fExtent.setWidth(w);
}
/*!
Sets the dock window's preferred height for its fixed extent
(size) to \a h.
\sa setFixedExtentWidth()
*/
void Q3DockWindow::setFixedExtentHeight(int h)
{
fExtent.setHeight(h);
}
/*!
\property Q3DockWindow::newLine
\brief whether the dock window prefers to start a new line in the
dock area.
The default is false, i.e. the dock window doesn't require a new
line in the dock area.
*/
void Q3DockWindow::setNewLine(bool b)
{
nl = b;
}
bool Q3DockWindow::newLine() const
{
return nl;
}
/*!
Returns the layout which is used for adding widgets to the dock
window. The layout's orientation is set automatically to match the
orientation of the dock window. You can add widgets to the layout
using the box layout's QBoxLayout::addWidget() function.
If the dock window only needs to contain a single widget use
setWidget() instead.
\sa setWidget() setOrientation()
*/
QBoxLayout *Q3DockWindow::boxLayout()
{
return childBox;
}
/*! \reimp
*/
QSize Q3DockWindow::sizeHint() const
{
QSize sh(Q3Frame::sizeHint());
if (place() == InDock)
sh = sh.expandedTo(fixedExtent());
sh = sh.expandedTo(QSize(16, 16));
if (area()) {
if (area()->orientation() == Qt::Horizontal && !vHandleRight->isVisible())
sh.setWidth(sh.width() + 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, 0, this) / 3);
else if (area()->orientation() == Qt::Vertical && !hHandleBottom->isVisible())
sh.setHeight(sh.height() + 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, 0, this) / 3);
}
return sh;
}
/*! \internal
*/
QSize Q3DockWindow::minimumSize() const
{
QSize ms(Q3Frame::minimumSize());
if (place() == InDock)
ms = ms.expandedTo(fixedExtent());
ms = ms.expandedTo(QSize(16, 16));
if (area()) {
if (area()->orientation() == Qt::Horizontal && !vHandleRight->isVisible())
ms.setWidth(ms.width() + 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, 0, this) / 3);
else if (area()->orientation() == Qt::Vertical && !hHandleBottom->isVisible())
ms.setHeight(ms.height() + 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, 0, this) / 3);
}
return ms;
}
/*! \reimp
*/
QSize Q3DockWindow::minimumSizeHint() const
{
QSize msh(Q3Frame::minimumSize());
if (place() == InDock)
msh = msh.expandedTo(fixedExtent());
msh = msh.expandedTo(QSize(16, 16));
if (area()) {
if (area()->orientation() == Qt::Horizontal && !vHandleRight->isVisible())
msh.setWidth(msh.width() + 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, 0, this) / 3);
else if (area()->orientation() == Qt::Vertical && !hHandleBottom->isVisible())
msh.setHeight(msh.height() + 2 * style()->pixelMetric(QStyle::PM_SplitterWidth, 0, this) / 3);
}
return msh;
}
/*!
\fn void Q3DockWindow::undock()
Undocks the Q3DockWindow from its current dock area if it is
docked; otherwise does nothing.
\sa dock() Q3DockArea::moveDockWindow(),
Q3DockArea::removeDockWindow(), Q3MainWindow::moveDockWindow(),
Q3MainWindow::removeDockWindow()
*/
/*!
\fn void Q3DockWindow::undock(QWidget *widget)
Undocks the specified \a widget from its current dock area if it is
docked; otherwise does nothing.
\sa dock() Q3DockArea::moveDockWindow(),
Q3DockArea::removeDockWindow(), Q3MainWindow::moveDockWindow(),
Q3MainWindow::removeDockWindow()
*/
void Q3DockWindow::undock(QWidget *w)
{
Q3MainWindow *mw = 0;
if (area())
mw = qobject_cast<Q3MainWindow*>(area()->parentWidget());
if (mw && !mw->isDockEnabled(this, Qt::DockTornOff))
return;
if ((place() == OutsideDock && !w))
return;
QPoint p(50, 50);
if (window())
p = window()->pos() + QPoint(20, 20);
if (dockArea) {
delete (Q3DockArea::DockWindowData*)dockWindowData;
dockWindowData = dockArea->dockWindowData(this);
dockArea->removeDockWindow(this, true, orientation() != Qt::Horizontal && qobject_cast<Q3ToolBar*>(this));
}
dockArea = 0;
if (lastPos != QPoint(-1, -1) && lastPos.x() > 0 && lastPos.y() > 0)
move(lastPos);
else
move(p);
if (lastSize != QSize(-1, -1))
resize(lastSize);
curPlace = OutsideDock;
updateGui();
emit orientationChanged(orientation());
QApplication::sendPostedEvents(this, QEvent::LayoutHint);
if (qobject_cast<Q3ToolBar*>(this))
adjustSize();
if (!w) {
if (!parentWidget() || parentWidget()->isVisible()) {
if (lastSize == QSize(-1, -1))
setAttribute(Qt::WA_Resized, false);// Ensures size is recalculated (opaque).
show();
}
} else {
setParent(w, 0);
move(-width() - 5, -height() - 5);
resize(1, 1);
show();
}
if (parentWidget() && isWindow())
parentWidget()->setActiveWindow();
emit placeChanged(place());
}
void Q3DockWindow::removeFromDock(bool fixNewLines)
{
if (dockArea)
dockArea->removeDockWindow(this, false, false, fixNewLines);
}
/*!
Docks the dock window into the last dock area in which it was
docked.
If the dock window has no last dock area (e.g. it was created as a
floating window and has never been docked), or if the last dock
area it was docked in does not exist (e.g. the dock area has been
deleted), nothing happens.
The dock window will dock with the dock area regardless of the return value
of Q3DockArea::isDockWindowAccepted().
\sa undock() Q3DockArea::moveDockWindow(),
Q3DockArea::removeDockWindow(), Q3MainWindow::moveDockWindow(),
Q3MainWindow::removeDockWindow(), Q3DockArea::isDockWindowAccepted()
*/
void Q3DockWindow::dock()
{
if (!(Q3DockArea::DockWindowData*)dockWindowData ||
!((Q3DockArea::DockWindowData*)dockWindowData)->area)
return;
curPlace = InDock;
lastPos = pos();
lastSize = size();
((Q3DockArea::DockWindowData*)dockWindowData)->
area->dockWindow(this, (Q3DockArea::DockWindowData*)dockWindowData);
emit orientationChanged(orientation());
emit placeChanged(place());
}
/*! \reimp
*/
void Q3DockWindow::hideEvent(QHideEvent *e)
{
Q3Frame::hideEvent(e);
}
/*! \reimp
*/
void Q3DockWindow::showEvent(QShowEvent *e)
{
if (curPlace == OutsideDock && (parent() && parent()->objectName() == QLatin1String("qt_hide_dock"))) {
QRect sr = qApp->desktop()->availableGeometry(this);
if (!sr.contains(pos())) {
int nx = qMin(qMax(x(), sr.x()), sr.right()-width());
int ny = qMin(qMax(y(), sr.y()), sr.bottom()-height());
move(nx, ny);
}
}
Q3Frame::showEvent(e);
}
/*!
\property Q3DockWindow::opaqueMoving
\brief whether the dock window will be shown normally whilst it is
being moved.
If this property is false, (the default), the dock window will be
represented by an outline rectangle whilst it is being moved.
\warning Currently opaque moving has some problems and we do not
recommend using it at this time. We expect to fix these problems
in a future release.
*/
void Q3DockWindow::setOpaqueMoving(bool b)
{
opaque = b;
horHandle->setOpaqueMoving(b);
verHandle->setOpaqueMoving(b);
titleBar->setOpaqueMoving(b);
}
bool Q3DockWindow::opaqueMoving() const
{
return opaque;
}
void Q3DockWindow::updateSplitterVisibility(bool visible)
{
if (area() && isResizeEnabled()) {
if (orientation() == Qt::Horizontal) {
if (visible)
vHandleRight->show();
else
vHandleRight->hide();
vHandleLeft->hide();
} else {
if (visible)
hHandleBottom->show();
else
hHandleBottom->hide();
hHandleTop->hide();
}
}
}
/*! \reimp */
bool Q3DockWindow::eventFilter(QObject * o, QEvent *e)
{
if (!o->isWidgetType())
return false;
if (e->type() == QEvent::KeyPress &&
(horHandle->mousePressed ||
verHandle->mousePressed ||
titleBar->mousePressed)) {
QKeyEvent *ke = (QKeyEvent*)e;
if (ke->key() == Qt::Key_Escape) {
horHandle->mousePressed =
verHandle->mousePressed =
titleBar->mousePressed = false;
endRectDraw(!opaque);
qApp->removeEventFilter(this);
return true;
}
} else if (((QWidget*)o)->window() != this && place() == OutsideDock && isWindow()) {
if ((e->type() == QEvent::WindowDeactivate ||
e->type() == QEvent::WindowActivate))
event(e);
}
return false;
}
/*! \reimp */
bool Q3DockWindow::event(QEvent *e)
{
switch (e->type()) {
case QEvent::WindowDeactivate:
if (place() == OutsideDock && isWindow() && parentWidget()
&& parentWidget()->isActiveWindow())
return true;
break;
case QEvent::HideToParent:
emit visibilityChanged(false);
break;
case QEvent::ShowToParent:
emit visibilityChanged(true);
break;
case QEvent::WindowTitleChange:
{
QString s = Q3Frame::windowTitle();
titleBar->setWindowTitle(s);
#ifndef QT_NO_TOOLTIP
horHandle->setToolTip(s);
verHandle->setToolTip(s);
#endif
break;
}
default:
break;
}
return Q3Frame::event(e);
}
/*!
Returns the dock window's title.
*/
QString Q3DockWindow::windowTitle() const
{
return titleBar->windowTitle();
}
/*! \reimp */
void Q3DockWindow::contextMenuEvent(QContextMenuEvent *e)
{
QObject *o = this;
while (o) {
if (qobject_cast<Q3MainWindow*>(o))
break;
o = o->parent();
}
if (!o || ! ((Q3MainWindow*)o)->showDockMenu(e->globalPos()))
e->ignore();
}
QT_END_NAMESPACE
#include "q3dockwindow.moc"
#endif //QT_NO_MAINWINDOW