/****************************************************************************+
−
**+
−
** 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+
−