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

**

** Copyright (C) 2009 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 <QWidgetItem>

#include <QToolBar>

#include <QStyleOption>

#include <QApplication>

#include <qdebug.h>

#include "qtoolbararealayout_p.h"

#include "qmainwindowlayout_p.h"

#include "qwidgetanimator_p.h"

#include "qtoolbarlayout_p.h"

#include "qtoolbar_p.h"

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

** QToolBarAreaLayoutItem

*/

#ifndef QT_NO_TOOLBAR

QT_BEGIN_NAMESPACE

QSize QToolBarAreaLayoutItem::minimumSize() const

{

    if (skip())

        return QSize(0, 0);

    return qSmartMinSize(static_cast<QWidgetItem*>(widgetItem));

}

QSize QToolBarAreaLayoutItem::sizeHint() const

{

    if (skip())

        return QSize(0, 0);

    return realSizeHint();

}

//returns the real size hint not taking into account the visibility of the widget

QSize QToolBarAreaLayoutItem::realSizeHint() const

{

    QWidget *wid = widgetItem->widget();

    QSize s = wid->sizeHint().expandedTo(wid->minimumSizeHint());

    if (wid->sizePolicy().horizontalPolicy() == QSizePolicy::Ignored)

        s.setWidth(0);

    if (wid->sizePolicy().verticalPolicy() == QSizePolicy::Ignored)

        s.setHeight(0);

    s = s.boundedTo(wid->maximumSize())

        .expandedTo(wid->minimumSize());

    return s;

}

bool QToolBarAreaLayoutItem::skip() const

{

    if (gap)

        return false;

    return widgetItem == 0 || widgetItem->isEmpty();

}

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

** QToolBarAreaLayoutLine

*/

QToolBarAreaLayoutLine::QToolBarAreaLayoutLine(Qt::Orientation orientation)

    : o(orientation)

{

}

QSize QToolBarAreaLayoutLine::sizeHint() const

{

    int a = 0, b = 0;

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

        const QToolBarAreaLayoutItem &item = toolBarItems.at(i);

        if (item.skip())

            continue;

        QSize sh = item.sizeHint();

        a += item.preferredSize > 0 ? item.preferredSize : pick(o, sh);

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

    }

    QSize result;

    rpick(o, result) = a;

    rperp(o, result) = b;

    return result;

}

QSize QToolBarAreaLayoutLine::minimumSize() const

{

    int a = 0, b = 0;

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

        const QToolBarAreaLayoutItem &item = toolBarItems[i];

        if (item.skip())

            continue;

        QSize ms = item.minimumSize();

        a += pick(o, ms);

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

    }

    QSize result;

    rpick(o, result) = a;

    rperp(o, result) = b;

    return result;

}

void QToolBarAreaLayoutLine::fitLayout()

{

    int last = -1;

    int min = pick(o, minimumSize());

    int space = pick(o, rect.size());

    int extra = qMax(0, space - min);

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

        QToolBarAreaLayoutItem &item = toolBarItems[i];

        if (item.skip())

            continue;

        if (QToolBarLayout *tblayout = qobject_cast<QToolBarLayout*>(item.widgetItem->widget()->layout()))

            tblayout->checkUsePopupMenu();

        const int itemMin = pick(o, item.minimumSize());

        //preferredSize is the default if it is set, otherwise, we take the sizehint

        item.size = item.preferredSize > 0 ? item.preferredSize : pick(o, item.sizeHint());

        //the extraspace is the space above the item minimum sizehint

        const int extraSpace = qMin(item.size - itemMin, extra);

        item.size = itemMin + extraSpace; //that is the real size

        extra -= extraSpace;

        last = i;

    }

    // calculate the positions from the sizes

    int pos = 0;

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

        QToolBarAreaLayoutItem &item = toolBarItems[i];

        if (item.skip())

            continue;

        item.pos = pos;

        if (i == last) // stretch the last item to the end of the line

            item.size = qMax(0, pick(o, rect.size()) - item.pos);

        pos += item.size;

    }

}

bool QToolBarAreaLayoutLine::skip() const

{

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

        if (!toolBarItems.at(i).skip())

            return false;

    }

    return true;

}

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

** QToolBarAreaLayoutInfo

*/

QToolBarAreaLayoutInfo::QToolBarAreaLayoutInfo(QInternal::DockPosition pos)

    : dockPos(pos), dirty(false)

{

    switch (pos) {

        case QInternal::LeftDock:

        case QInternal::RightDock:

            o = Qt::Vertical;

            break;

        case QInternal::TopDock:

        case QInternal::BottomDock:

            o = Qt::Horizontal;

            break;

        default:

            o = Qt::Horizontal;

            break;

    }

}

QSize QToolBarAreaLayoutInfo::sizeHint() const

{

    int a = 0, b = 0;

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

        const QToolBarAreaLayoutLine &l = lines.at(i);

        if (l.skip())

            continue;

        QSize hint = l.sizeHint();

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

        b += perp(o, hint);

    }

    QSize result;

    rpick(o, result) = a;

    rperp(o, result) = b;

    return result;

}

QSize QToolBarAreaLayoutInfo::minimumSize() const

{

    int a = 0, b = 0;

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

        const QToolBarAreaLayoutLine &l = lines.at(i);

        if (l.skip())

            continue;

        QSize m = l.minimumSize();

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

        b += perp(o, m);

    }

    QSize result;

    rpick(o, result) = a;

    rperp(o, result) = b;

    return result;

}

void QToolBarAreaLayoutInfo::fitLayout()

{

    dirty = false;

    int b = 0;

    bool reverse = dockPos == QInternal::RightDock || dockPos == QInternal::BottomDock;

    int i = reverse ? lines.count() - 1 : 0;

    for (;;) {

        if ((reverse && i < 0) || (!reverse && i == lines.count()))

            break;

        QToolBarAreaLayoutLine &l = lines[i];

        if (!l.skip()) {

            if (o == Qt::Horizontal) {

                l.rect.setLeft(rect.left());

                l.rect.setRight(rect.right());

                l.rect.setTop(b + rect.top());

                b += l.sizeHint().height();

                l.rect.setBottom(b - 1 + rect.top());

            } else {

                l.rect.setTop(rect.top());

                l.rect.setBottom(rect.bottom());

                l.rect.setLeft(b + rect.left());

                b += l.sizeHint().width();

                l.rect.setRight(b - 1 + rect.left());

            }

            l.fitLayout();

        }

        i += reverse ? -1 : 1;

    }

}

QLayoutItem *QToolBarAreaLayoutInfo::insertToolBar(QToolBar *before, QToolBar *toolBar)

{

    toolBar->setOrientation(o);

    QLayoutItem *item = new QWidgetItemV2(toolBar);

    insertItem(before, item);

    return item;

}

void QToolBarAreaLayoutInfo::insertItem(QToolBar *before, QLayoutItem *item)

{

    if (before == 0) {

        if (lines.isEmpty())

            lines.append(QToolBarAreaLayoutLine(o));

        lines.last().toolBarItems.append(item);

        return;

    }

    for (int j = 0; j < lines.count(); ++j) {

        QToolBarAreaLayoutLine &line = lines[j];

        for (int k = 0; k < line.toolBarItems.count(); ++k) {

            if (line.toolBarItems.at(k).widgetItem->widget() == before) {

                line.toolBarItems.insert(k, item);

                return;

            }

        }

    }

}

void QToolBarAreaLayoutInfo::removeToolBar(QToolBar *toolBar)

{

    for (int j = 0; j < lines.count(); ++j) {

        QToolBarAreaLayoutLine &line = lines[j];

        for (int k = 0; k < line.toolBarItems.count(); ++k) {

            QToolBarAreaLayoutItem &item = line.toolBarItems[k];

            if (item.widgetItem->widget() == toolBar) {

                delete item.widgetItem;

                item.widgetItem = 0;

                line.toolBarItems.removeAt(k);

                if (line.toolBarItems.isEmpty() && j < lines.count() - 1)

                    lines.removeAt(j);

                return;

            }

        }

    }

}

void QToolBarAreaLayoutInfo::insertToolBarBreak(QToolBar *before)

{

    if (before == 0) {

        if (!lines.isEmpty() && lines.last().toolBarItems.isEmpty())

            return;

        lines.append(QToolBarAreaLayoutLine(o));

        return;

    }

    for (int j = 0; j < lines.count(); ++j) {

        QToolBarAreaLayoutLine &line = lines[j];

        for (int k = 0; k < line.toolBarItems.count(); ++k) {

            if (line.toolBarItems.at(k).widgetItem->widget() == before) {

                if (k == 0)

                    return;

                QToolBarAreaLayoutLine newLine(o);

                newLine.toolBarItems = line.toolBarItems.mid(k);

                line.toolBarItems = line.toolBarItems.mid(0, k);

                lines.insert(j + 1, newLine);

                return;

            }

        }

    }

}

void QToolBarAreaLayoutInfo::removeToolBarBreak(QToolBar *before)

{

    for (int j = 0; j < lines.count(); ++j) {

        const QToolBarAreaLayoutLine &line = lines.at(j);

        for (int k = 0; k < line.toolBarItems.count(); ++k) {

            if (line.toolBarItems.at(k).widgetItem->widget() == before) {

                if (k != 0)

                    return;

                if (j == 0)

                    return;

                lines[j - 1].toolBarItems += lines[j].toolBarItems;

                lines.removeAt(j);

                return;

            }

        }

    }

}

void QToolBarAreaLayoutInfo::moveToolBar(QToolBar *toolbar, int pos)

{

    if (dirty)

        fitLayout();

    dirty = true;

    if (o == Qt::Vertical)

        pos -= rect.top();

    //here we actually update the preferredSize for the line containing the toolbar so that we move it

    for (int j = 0; j < lines.count(); ++j) {

        QToolBarAreaLayoutLine &line = lines[j];

        int previousIndex = -1;

        int minPos = 0;

        for (int k = 0; k < line.toolBarItems.count(); ++k) {

            QToolBarAreaLayoutItem &current = line.toolBarItems[k];

            if (current.widgetItem->widget() == toolbar) {

                int newPos = current.pos;

                if (previousIndex >= 0) {

                    QToolBarAreaLayoutItem &previous = line.toolBarItems[previousIndex];

                    if (pos < current.pos) {

                        newPos = qMax(pos, minPos);

                    } else {

                        //we check the max value for the position (until everything at the right is "compressed")

                        int maxPos = pick(o, rect.size());

                        for(int l = k; l < line.toolBarItems.count(); ++l) {

                            const QToolBarAreaLayoutItem &item = line.toolBarItems.at(l);

                            if (!item.skip()) {

                                maxPos -= pick(o, item.minimumSize());

                            }

                        }

                        newPos = qMin(pos, maxPos);

                    }

                    //extra is the number of pixels to add to the previous toolbar

                    int extra = newPos - current.pos;

                    //we check if the previous is near its size hint

                    //in which case we try to stick to it

                    const int diff = pick(o, previous.sizeHint()) - (previous.size + extra);

                    if (qAbs(diff) < QApplication::startDragDistance()) {

                        //we stick to the default place and size

                        extra += diff;

                    }

                    //update for the current item

                    current.extendSize(line.o, -extra);

                    if (extra >= 0) {

                        previous.extendSize(line.o, extra);

                    } else {

                        //we need to push the toolbars on the left starting with previous

                        extra = -extra; // we just need to know the number of pixels

                        ///at this point we need to get extra pixels from the toolbars at the left

                        for(int l = previousIndex; l >=0; --l) {

                            QToolBarAreaLayoutItem &item = line.toolBarItems[l];

                            if (!item.skip()) {

                                const int minPreferredSize = pick(o, item.minimumSize());

                                const int margin =  item.size - minPreferredSize;

                                if (margin < extra) {

                                    item.resize(line.o, minPreferredSize);

                                    extra -= margin;

                                } else {

                                    item.extendSize(line.o, -extra);

                                    extra = 0;

                                }

                            }

                        }

                        Q_ASSERT(extra == 0);

                    }

                } else {

                    //the item is the first one, it should be at position 0

                }

                return;

            } else if (!current.skip()) {

                previousIndex = k;

                minPos += pick(o, current.minimumSize());

            }

        }

    }

}

QList<int> QToolBarAreaLayoutInfo::gapIndex(const QPoint &pos) const

{

    int p = pick(o, pos);

    if (rect.contains(pos)) {

        for (int j = 0; j < lines.count(); ++j) {

            const QToolBarAreaLayoutLine &line = lines.at(j);

            if (line.skip())

                continue;

            if (!line.rect.contains(pos))

                continue;

            int k = 0;

            for (; k < line.toolBarItems.count(); ++k) {

                const QToolBarAreaLayoutItem &item = line.toolBarItems.at(k);

                if (item.skip())

                    continue;

                int size = qMin(item.size, pick(o, item.sizeHint()));

                if (p > item.pos + size)

                    continue;

                if (p > item.pos + size/2)

                    ++k;

                break;

            }

            QList<int> result;

            result << j << k;

            return result;

        }

    } else if (appendLineDropRect().contains(pos)) {

        QList<int> result;

        result << lines.count() << 0;

        return result;

    }

    return QList<int>();

}

bool QToolBarAreaLayoutInfo::insertGap(const QList<int> &path, QLayoutItem *item)

{

    Q_ASSERT(path.count() == 2);

    int j = path.first();

    if (j == lines.count())

        lines.append(QToolBarAreaLayoutLine(o));