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

**

** 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 "QtGui/qapplication.h"

#include "QtGui/qwidget.h"

#include "QtGui/qtabbar.h"

#include "QtGui/qstyle.h"

#include "QtGui/qdesktopwidget.h"

#include "QtCore/qvariant.h"

#include "qdockarealayout_p.h"

#include "qdockwidget.h"

#include "qmainwindow.h"

#include "qwidgetanimator_p.h"

#include "qmainwindowlayout_p.h"

#include "qdockwidget_p.h"

#include <private/qlayoutengine_p.h>

#include <qpainter.h>

#include <qstyleoption.h>

#ifndef QT_NO_DOCKWIDGET

QT_BEGIN_NAMESPACE

enum { StateFlagVisible = 1, StateFlagFloating = 2 };

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

** QPlaceHolderItem

*/

QPlaceHolderItem::QPlaceHolderItem(QWidget *w)

{

    objectName = w->objectName();

    hidden = w->isHidden();

    window = w->isWindow();

    if (window)

        topLevelRect = w->geometry();

}

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

** QDockAreaLayoutItem

*/

QDockAreaLayoutItem::QDockAreaLayoutItem(QLayoutItem *_widgetItem)

    : widgetItem(_widgetItem), subinfo(0), placeHolderItem(0), pos(0), size(-1), flags(NoFlags)

{

}

QDockAreaLayoutItem::QDockAreaLayoutItem(QDockAreaLayoutInfo *_subinfo)

    : widgetItem(0), subinfo(_subinfo), placeHolderItem(0), pos(0), size(-1), flags(NoFlags)

{

}

QDockAreaLayoutItem::QDockAreaLayoutItem(QPlaceHolderItem *_placeHolderItem)

    : widgetItem(0), subinfo(0), placeHolderItem(_placeHolderItem), pos(0), size(-1), flags(NoFlags)

{

}

QDockAreaLayoutItem::QDockAreaLayoutItem(const QDockAreaLayoutItem &other)

    : widgetItem(other.widgetItem), subinfo(0), placeHolderItem(0), pos(other.pos),

        size(other.size), flags(other.flags)

{

    if (other.subinfo != 0)

        subinfo = new QDockAreaLayoutInfo(*other.subinfo);

    else if (other.placeHolderItem != 0)

        placeHolderItem = new QPlaceHolderItem(*other.placeHolderItem);

}

QDockAreaLayoutItem::~QDockAreaLayoutItem()

{

    delete subinfo;

    delete placeHolderItem;

}

bool QDockAreaLayoutItem::skip() const

{

    if (placeHolderItem != 0)

        return true;

    if (flags & GapItem)

        return false;

    if (widgetItem != 0)

        return widgetItem->isEmpty();

    if (subinfo != 0) {

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

            if (!subinfo->item_list.at(i).skip())

                return false;

        }

    }

    return true;

}

QSize QDockAreaLayoutItem::minimumSize() const

{

    if (widgetItem != 0) {

        int left, top, right, bottom;

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

        return widgetItem->minimumSize() + QSize(left+right, top+bottom);

    }

    if (subinfo != 0)

        return subinfo->minimumSize();

    return QSize(0, 0);

}

QSize QDockAreaLayoutItem::maximumSize() const

{

    if (widgetItem != 0) {

        int left, top, right, bottom;

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

        return widgetItem->maximumSize()+ QSize(left+right, top+bottom);

    }

    if (subinfo != 0)

        return subinfo->maximumSize();

    return QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);

}

bool QDockAreaLayoutItem::hasFixedSize(Qt::Orientation o) const

{

    return perp(o, minimumSize()) == perp(o, maximumSize());

}

bool QDockAreaLayoutItem::expansive(Qt::Orientation o) const

{

    if ((flags & GapItem) || placeHolderItem != 0)

        return false;

    if (widgetItem != 0)

        return ((widgetItem->expandingDirections() & o) == o);

    if (subinfo != 0)

        return subinfo->expansive(o);

    return false;

}

QSize QDockAreaLayoutItem::sizeHint() const

{

    if (placeHolderItem != 0)

        return QSize(0, 0);

    if (widgetItem != 0) {

        int left, top, right, bottom;

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

        return widgetItem->sizeHint() + QSize(left+right, top+bottom);

    }

    if (subinfo != 0)

        return subinfo->sizeHint();

    return QSize(-1, -1);

}

QDockAreaLayoutItem

    &QDockAreaLayoutItem::operator = (const QDockAreaLayoutItem &other)

{

    widgetItem = other.widgetItem;

    if (other.subinfo == 0)

        subinfo = 0;

    else

        subinfo = new QDockAreaLayoutInfo(*other.subinfo);

    delete placeHolderItem;

    if (other.placeHolderItem == 0)

        placeHolderItem = 0;

    else

        placeHolderItem = new QPlaceHolderItem(*other.placeHolderItem);

    pos = other.pos;

    size = other.size;

    flags = other.flags;

    return *this;

}

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

** QDockAreaLayoutInfo

*/

#ifndef QT_NO_TABBAR

static quintptr tabId(const QDockAreaLayoutItem &item)

{

    if (item.widgetItem == 0)

        return 0;

    return reinterpret_cast<quintptr>(item.widgetItem->widget());

}

#endif

QDockAreaLayoutInfo::QDockAreaLayoutInfo()

    : sep(0), dockPos(QInternal::LeftDock), o(Qt::Horizontal), mainWindow(0)

#ifndef QT_NO_TABBAR

    , tabbed(false), tabBar(0), tabBarShape(QTabBar::RoundedSouth), tabBarVisible(false)

#endif

{

}

QDockAreaLayoutInfo::QDockAreaLayoutInfo(int _sep, QInternal::DockPosition _dockPos,

                                            Qt::Orientation _o, int tbshape,

                                            QMainWindow *window)

    : sep(_sep), dockPos(_dockPos), o(_o), mainWindow(window)

#ifndef QT_NO_TABBAR

    , tabbed(false), tabBar(0), tabBarShape(static_cast<QTabBar::Shape>(tbshape)), tabBarVisible(false)

#endif

{

#ifdef QT_NO_TABBAR

    Q_UNUSED(tbshape);

#endif

}

QSize QDockAreaLayoutInfo::size() const

{

    return isEmpty() ? QSize(0, 0) : rect.size();

}

void QDockAreaLayoutInfo::clear()

{

    item_list.clear();

    rect = QRect();

#ifndef QT_NO_TABBAR

    tabbed = false;

    tabBar = 0;

#endif

}

bool QDockAreaLayoutInfo::isEmpty() const

{

    return next(-1) == -1;

}

QSize QDockAreaLayoutInfo::minimumSize() const

{

    if (isEmpty())

        return QSize(0, 0);

    int a = 0, b = 0;

    bool first = true;

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

        const QDockAreaLayoutItem &item = item_list.at(i);

        if (item.skip())

            continue;

        QSize min_size = item.minimumSize();

#ifndef QT_NO_TABBAR

        if (tabbed) {

            a = qMax(a, pick(o, min_size));

        } else

#endif

        {

            if (!first)

                a += sep;

            a += pick(o, min_size);

        }

        b = qMax(b, perp(o, min_size));

        first = false;

    }

    QSize result;

    rpick(o, result) = a;

    rperp(o, result) = b;

#ifndef QT_NO_TABBAR

    if (tabbed) {

        QSize tbm = tabBarMinimumSize();

        switch (tabBarShape) {

            case QTabBar::RoundedNorth:

            case QTabBar::RoundedSouth:

            case QTabBar::TriangularNorth:

            case QTabBar::TriangularSouth:

                result.rheight() += tbm.height();

                result.rwidth() = qMax(tbm.width(), result.width());

                break;

            case QTabBar::RoundedEast:

            case QTabBar::RoundedWest:

            case QTabBar::TriangularEast:

            case QTabBar::TriangularWest:

                result.rheight() = qMax(tbm.height(), result.height());

                result.rwidth() += tbm.width();

                break;

            default:

                break;

        }

    }

#endif // QT_NO_TABBAR

    return result;

}

QSize QDockAreaLayoutInfo::maximumSize() const

{

    if (isEmpty())

        return QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);

    int a = 0, b = QWIDGETSIZE_MAX;

#ifndef QT_NO_TABBAR

    if (tabbed)

        a = QWIDGETSIZE_MAX;

#endif

    int min_perp = 0;

    bool first = true;

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

        const QDockAreaLayoutItem &item = item_list.at(i);

        if (item.skip())

            continue;

        QSize max_size = item.maximumSize();

        min_perp = qMax(min_perp, perp(o, item.minimumSize()));

#ifndef QT_NO_TABBAR

        if (tabbed) {

            a = qMin(a, pick(o, max_size));

        } else

#endif

        {

            if (!first)

                a += sep;

            a += pick(o, max_size);

        }

        b = qMin(b, perp(o, max_size));

        a = qMin(a, int(QWIDGETSIZE_MAX));

        b = qMin(b, int(QWIDGETSIZE_MAX));

        first = false;

    }

    b = qMax(b, min_perp);

    QSize result;

    rpick(o, result) = a;

    rperp(o, result) = b;

#ifndef QT_NO_TABBAR

    if (tabbed) {

        QSize tbh = tabBarSizeHint();

        switch (tabBarShape) {

            case QTabBar::RoundedNorth:

            case QTabBar::RoundedSouth:

                result.rheight() += tbh.height();

                break;

            case QTabBar::RoundedEast:

            case QTabBar::RoundedWest:

                result.rwidth() += tbh.width();

                break;

            default:

                break;

        }

    }

#endif // QT_NO_TABBAR

    return result;

}

QSize QDockAreaLayoutInfo::sizeHint() const

{

    if (isEmpty())

        return QSize(0, 0);

    int a = 0, b = 0;

    int min_perp = 0;

    int max_perp = QWIDGETSIZE_MAX;

    const QDockAreaLayoutItem *previous = 0;

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

        const QDockAreaLayoutItem &item = item_list.at(i);

        if (item.skip())

            continue;

        bool gap = item.flags & QDockAreaLayoutItem::GapItem;

        QSize size_hint = item.sizeHint();

        min_perp = qMax(min_perp, perp(o, item.minimumSize()));

        max_perp = qMin(max_perp, perp(o, item.maximumSize()));

#ifndef QT_NO_TABBAR

        if (tabbed) {

            a = qMax(a, gap ? item.size : pick(o, size_hint));

        } else

#endif

        {

            if (previous && !gap && !(previous->flags &  QDockAreaLayoutItem::GapItem)

                && !previous->hasFixedSize(o)) {

                a += sep;

            }

            a += gap ? item.size : pick(o, size_hint);

        }

        b = qMax(b, perp(o, size_hint));

        previous = &item;

    }

    max_perp = qMax(max_perp, min_perp);

    b = qMax(b, min_perp);

    b = qMin(b, max_perp);

    QSize result;

    rpick(o, result) = a;

    rperp(o, result) = b;

#ifndef QT_NO_TABBAR

    if (tabbed) {

        QSize tbh = tabBarSizeHint();

        switch (tabBarShape) {

            case QTabBar::RoundedNorth:

            case QTabBar::RoundedSouth:

            case QTabBar::TriangularNorth:

            case QTabBar::TriangularSouth:

                result.rheight() += tbh.height();

                result.rwidth() = qMax(tbh.width(), result.width());

                break;

            case QTabBar::RoundedEast:

            case QTabBar::RoundedWest:

            case QTabBar::TriangularEast:

            case QTabBar::TriangularWest:

                result.rheight() = qMax(tbh.height(), result.height());

                result.rwidth() += tbh.width();

                break;

            default:

                break;

        }

    }

#endif // QT_NO_TABBAR

    return result;

}

bool QDockAreaLayoutInfo::expansive(Qt::Orientation o) const

{

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

        if (item_list.at(i).expansive(o))

            return true;

    }

    return false;

}

/* QDockAreaLayoutInfo::maximumSize() doesn't return the real max size. For example,

   if the layout is empty, it returns QWIDGETSIZE_MAX. This is so that empty dock areas

   don't constrain the size of the QMainWindow, but sometimes we really need to know the

   maximum size. Also, these functions take into account widgets that want to keep their

   size (f.ex. when they are hidden and then shown, they should not change size).

*/

static int realMinSize(const QDockAreaLayoutInfo &info)

{

    int result = 0;

    bool first = true;

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

        const QDockAreaLayoutItem &item = info.item_list.at(i);

        if (item.skip())

            continue;

        int min = 0;

        if ((item.flags & QDockAreaLayoutItem::KeepSize) && item.size != -1)

            min = item.size;

        else

            min = pick(info.o, item.minimumSize());

        if (!first)

            result += info.sep;

        result += min;

        first = false;

    }

    return result;

}

static int realMaxSize(const QDockAreaLayoutInfo &info)

{

    int result = 0;

    bool first = true;

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

        const QDockAreaLayoutItem &item = info.item_list.at(i);

        if (item.skip())

            continue;

        int max = 0;

        if ((item.flags & QDockAreaLayoutItem::KeepSize) && item.size != -1)

            max = item.size;

        else

            max = pick(info.o, item.maximumSize());

        if (!first)

            result += info.sep;

        result += max;

        if (result >= QWIDGETSIZE_MAX)

            return QWIDGETSIZE_MAX;

        first = false;

    }

    return result;