/****************************************************************************

**

** 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 QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qdockwidget.h"

#ifndef QT_NO_DOCKWIDGET

#include <qaction.h>

#include <qapplication.h>

#include <qdesktopwidget.h>

#include <qdrawutil.h>

#include <qevent.h>

#include <qfontmetrics.h>

#include <qmainwindow.h>

#include <qrubberband.h>

#include <qstylepainter.h>

#include <qtoolbutton.h>

#include <qdebug.h>

#include <private/qwidgetresizehandler_p.h>

#include "qdockwidget_p.h"

#include "qmainwindowlayout_p.h"

#ifdef Q_WS_MAC

#include <private/qapplication_p.h>

#include <private/qt_mac_p.h>

#include <qmacstyle_mac.h>

#endif

QT_BEGIN_NAMESPACE

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

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

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

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

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

/*

    A Dock Window:

    [+] is the float button

    [X] is the close button

    +-------------------------------+

    | Dock Window Title       [+][X]|

    +-------------------------------+

    |                               |

    | place to put the single       |

    | QDockWidget child (this space |

    | does not yet have a name)     |

    |                               |

    |                               |

    |                               |

    |                               |

    |                               |

    |                               |

    |                               |

    |                               |

    |                               |

    +-------------------------------+

*/

/******************************************************************************

** QDockWidgetTitleButton

*/

class QDockWidgetTitleButton : public QAbstractButton

{

    Q_OBJECT

public:

    QDockWidgetTitleButton(QDockWidget *dockWidget);

    QSize sizeHint() const;

    inline QSize minimumSizeHint() const

    { return sizeHint(); }

    void enterEvent(QEvent *event);

    void leaveEvent(QEvent *event);

    void paintEvent(QPaintEvent *event);

};

QDockWidgetTitleButton::QDockWidgetTitleButton(QDockWidget *dockWidget)

    : QAbstractButton(dockWidget)

{

    setFocusPolicy(Qt::NoFocus);

}

QSize QDockWidgetTitleButton::sizeHint() const

{

    ensurePolished();

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

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

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

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

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

    }

    return QSize(size, size);

}

void QDockWidgetTitleButton::enterEvent(QEvent *event)

{

    if (isEnabled()) update();

    QAbstractButton::enterEvent(event);

}

void QDockWidgetTitleButton::leaveEvent(QEvent *event)

{

    if (isEnabled()) update();

    QAbstractButton::leaveEvent(event);

}

void QDockWidgetTitleButton::paintEvent(QPaintEvent *)

{

    QPainter p(this);

    QRect r = rect();

    QStyleOptionToolButton opt;

    opt.init(this);

    opt.state |= QStyle::State_AutoRaise;

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

    {

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

            opt.state |= QStyle::State_Raised;

        if (isChecked())

            opt.state |= QStyle::State_On;

        if (isDown())

            opt.state |= QStyle::State_Sunken;

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

    }

    opt.icon = icon();

    opt.subControls = 0;

    opt.activeSubControls = 0;

    opt.features = QStyleOptionToolButton::None;

    opt.arrowType = Qt::NoArrow;

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

    opt.iconSize = QSize(size, size);

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

}

/******************************************************************************

** QDockWidgetLayout

*/

QDockWidgetLayout::QDockWidgetLayout(QWidget *parent)

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

{

}

QDockWidgetLayout::~QDockWidgetLayout()

{

    qDeleteAll(item_list);

}

bool QDockWidgetLayout::nativeWindowDeco() const

{

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

}

bool QDockWidgetLayout::nativeWindowDeco(bool floating) const

{

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

    Q_UNUSED(floating);

    return false;

#else

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

#endif

}

void QDockWidgetLayout::addItem(QLayoutItem*)

{

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

    return;

}

QLayoutItem *QDockWidgetLayout::itemAt(int index) const

{

    int cnt = 0;

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

        QLayoutItem *item = item_list.at(i);

        if (item == 0)

            continue;

        if (index == cnt++)

            return item;

    }

    return 0;

}

QLayoutItem *QDockWidgetLayout::takeAt(int index)

{

    int j = 0;

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

        QLayoutItem *item = item_list.at(i);

        if (item == 0)

            continue;

        if (index == j) {

            item_list[i] = 0;

            invalidate();

            return item;

        }

        ++j;

    }

    return 0;

}

int QDockWidgetLayout::count() const

{

    int result = 0;

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

        if (item_list.at(i))

            ++result;

    }

    return result;

}

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

{

    QSize result = content;

    if (verticalTitleBar) {

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

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

    } else {

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

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

    }

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

    const bool nativeDeco = nativeWindowDeco(floating);

    int fw = floating && !nativeDeco

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

            : 0;

    const int th = titleHeight();

    if (!nativeDeco) {

        if (verticalTitleBar)

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

        else

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

    }

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

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

    if (content.width() < 0)

        result.setWidth(-1);

    if (content.height() < 0)

        result.setHeight(-1);

    int left, top, right, bottom;

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

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

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

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

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

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

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

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

       minimum size + window decorations. */

    uint explicitMin = 0;

    uint explicitMax = 0;

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

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

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

    }

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

        min.setWidth(-1);

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

        min.setHeight(-1);

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

        max.setWidth(QWIDGETSIZE_MAX);

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

        max.setHeight(QWIDGETSIZE_MAX);

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

}

QSize QDockWidgetLayout::sizeHint() const

{

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

    QSize content(-1, -1);

    if (item_list[Content] != 0)

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

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

}

QSize QDockWidgetLayout::maximumSize() const

{

    if (item_list[Content] != 0) {

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

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

    } else {

        return parentWidget()->maximumSize();

    }

}

QSize QDockWidgetLayout::minimumSize() const

{

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

    QSize content(0, 0);

    if (item_list[Content] != 0)

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

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

}

QWidget *QDockWidgetLayout::widgetForRole(Role r) const

{

    QLayoutItem *item = item_list.at(r);

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

}

QLayoutItem *QDockWidgetLayout::itemForRole(Role r) const

{

    return item_list.at(r);

}

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

{

    QWidget *old = widgetForRole(r);

    if (old != 0) {

        old->hide();

        removeWidget(old);

    }

    if (w != 0) {

        addChildWidget(w);

        item_list[r] = new QWidgetItemV2(w);

        w->show();

    } else {

        item_list[r] = 0;

    }

    invalidate();

}

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

{

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

}

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

{

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

}

int QDockWidgetLayout::minimumTitleWidth() const

{

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

    if (QWidget *title = widgetForRole(TitleBar))

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

    QSize closeSize(0, 0);

    QSize floatSize(0, 0);

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

        if (QLayoutItem *item = item_list[CloseButton])

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

    }

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

        if (QLayoutItem *item = item_list[FloatButton])

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

    }

    int titleHeight = this->titleHeight();

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

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

    return pick(verticalTitleBar, closeSize)

            + pick(verticalTitleBar, floatSize)

            + titleHeight + 2*fw + 3*mw;

}

int QDockWidgetLayout::titleHeight() const

{

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

    if (QWidget *title = widgetForRole(TitleBar))

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

    QSize closeSize(0, 0);

    QSize floatSize(0, 0);

    if (QLayoutItem *item = item_list[CloseButton])

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

    if (QLayoutItem *item = item_list[FloatButton])

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

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

                            perp(verticalTitleBar, floatSize));

    QFontMetrics titleFontMetrics = q->fontMetrics();

#ifdef Q_WS_MAC

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

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

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

        titleFontMetrics = QFontMetrics(font);

    }

#endif

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

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

}

void QDockWidgetLayout::setGeometry(const QRect &geometry)

{

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

    bool nativeDeco = nativeWindowDeco();

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

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

            : 0;

    if (nativeDeco) {

        if (QLayoutItem *item = item_list[Content])

            item->setGeometry(geometry);

    } else {

        int titleHeight = this->titleHeight();

        if (verticalTitleBar) {

            _titleArea = QRect(QPoint(fw, fw),

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

        } else {

            _titleArea = QRect(QPoint(fw, fw),

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

        }

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

            item->setGeometry(_titleArea);

        } else {

            QStyleOptionDockWidgetV2 opt;

            q->initStyleOption(&opt);

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

                if (!item->isEmpty()) {

                    QRect r = q->style()

                        ->subElementRect(QStyle::SE_DockWidgetCloseButton,

                                            &opt, q);

                    if (!r.isNull())

                        item->setGeometry(r);

                }

            }

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

                if (!item->isEmpty()) {

                    QRect r = q->style()

                        ->subElementRect(QStyle::SE_DockWidgetFloatButton,

                                            &opt, q);

                    if (!r.isNull())

                        item->setGeometry(r);

                }

            }

        }

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

            QRect r = geometry;

            if (verticalTitleBar) {

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

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

            } else {

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

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

            }

            item->setGeometry(r);

        }

    }

}

void QDockWidgetLayout::setVerticalTitleBar(bool b)

{