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

**

** 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 <qglobal.h>

#ifndef QT_NO_COLUMNVIEW

#include "qcolumnview.h"

#include "qcolumnview_p.h"

#include "qcolumnviewgrip_p.h"

#include <qlistview.h>

#include <qabstractitemdelegate.h>

#include <qscrollbar.h>

#include <qpainter.h>

#include <qdebug.h>

QT_BEGIN_NAMESPACE

#define ANIMATION_DURATION_MSEC 150

/*!

    \since 4.3

    \class QColumnView

    \brief The QColumnView class provides a model/view implementation of a column view.

    \ingroup model-view

    \ingroup advanced

    QColumnView displays a model in a number of QListViews, one for each

    hierarchy in the tree.  This is sometimes referred to as a cascading list.

    The QColumnView class is one of the \l{Model/View Classes}

    and is part of Qt's \l{Model/View Programming}{model/view framework}.

    QColumnView implements the interfaces defined by the

    QAbstractItemView class to allow it to display data provided by

    models derived from the QAbstractItemModel class.

    \image qcolumnview.png

    \sa \link model-view-programming.html Model/View Programming\endlink

*/

/*!

    Constructs a column view with a \a parent to represent a model's

    data. Use setModel() to set the model.

    \sa QAbstractItemModel

*/

QColumnView::QColumnView(QWidget * parent)

:  QAbstractItemView(*new QColumnViewPrivate, parent)

{

    Q_D(QColumnView);

    d->initialize();

}

/*!

    \internal

*/

QColumnView::QColumnView(QColumnViewPrivate & dd, QWidget * parent)

:  QAbstractItemView(dd, parent)

{

    Q_D(QColumnView);

    d->initialize();

}

void QColumnViewPrivate::initialize()

{

    Q_Q(QColumnView);

    q->setTextElideMode(Qt::ElideMiddle);

#ifndef QT_NO_ANIMATION

    QObject::connect(&currentAnimation, SIGNAL(finished()), q, SLOT(_q_changeCurrentColumn()));

    currentAnimation.setDuration(ANIMATION_DURATION_MSEC);

    currentAnimation.setTargetObject(hbar);

    currentAnimation.setPropertyName("value");

    currentAnimation.setEasingCurve(QEasingCurve::InOutQuad);

#endif //QT_NO_ANIMATION

    delete itemDelegate;

    q->setItemDelegate(new QColumnViewDelegate(q));

}

/*!

    Destroys the column view.

*/

QColumnView::~QColumnView()

{

}

/*!

    \property QColumnView::resizeGripsVisible

    \brief the way to specify if the list views gets resize grips or not

    By default, \c visible is set to true

    \sa setRootIndex()

*/

void QColumnView::setResizeGripsVisible(bool visible)

{

    Q_D(QColumnView);

    if (d->showResizeGrips == visible)

        return;

    d->showResizeGrips = visible;

    for (int i = 0; i < d->columns.count(); ++i) {

        QAbstractItemView *view = d->columns[i];

        if (visible) {

            QColumnViewGrip *grip = new QColumnViewGrip(view);

            view->setCornerWidget(grip);

            connect(grip, SIGNAL(gripMoved(int)), this, SLOT(_q_gripMoved(int)));

        } else {

            QWidget *widget = view->cornerWidget();

            view->setCornerWidget(0);

            widget->deleteLater();

        }

    }

}

bool QColumnView::resizeGripsVisible() const

{

    Q_D(const QColumnView);

    return d->showResizeGrips;

}

/*!

    \reimp

*/

void QColumnView::setModel(QAbstractItemModel *model)

{

    Q_D(QColumnView);

    if (model == d->model)

        return;

    d->closeColumns();

    QAbstractItemView::setModel(model);

}

/*!

    \reimp

*/

void QColumnView::setRootIndex(const QModelIndex &index)

{

    Q_D(QColumnView);

    if (!model())

        return;

    d->closeColumns();

    Q_ASSERT(d->columns.count() == 0);

    QAbstractItemView *view = d->createColumn(index, true);

    if (view->selectionModel())

        view->selectionModel()->deleteLater();

    if (view->model())

        view->setSelectionModel(selectionModel());

    QAbstractItemView::setRootIndex(index);

    d->updateScrollbars();

}

/*!

    \reimp

*/

bool QColumnView::isIndexHidden(const QModelIndex &index) const

{

    Q_UNUSED(index);

    return false;

}

/*!

    \reimp

*/

QModelIndex QColumnView::indexAt(const QPoint &point) const

{

    Q_D(const QColumnView);

    for (int i = 0; i < d->columns.size(); ++i) {

        QPoint topLeft = d->columns.at(i)->frameGeometry().topLeft();

        QPoint adjustedPoint(point.x() - topLeft.x(), point.y() - topLeft.y());

        QModelIndex index = d->columns.at(i)->indexAt(adjustedPoint);

        if (index.isValid())

            return index;

    }

    return QModelIndex();

}

/*!

    \reimp

*/

QRect QColumnView::visualRect(const QModelIndex &index) const

{

    if (!index.isValid())

        return QRect();

    Q_D(const QColumnView);

    for (int i = 0; i < d->columns.size(); ++i) {

        QRect rect = d->columns.at(i)->visualRect(index);

        if (!rect.isNull()) {

            rect.translate(d->columns.at(i)->frameGeometry().topLeft());

            return rect;

        }

    }

    return QRect();

}

/*!

    \reimp

 */

void QColumnView::scrollContentsBy(int dx, int dy)

{

    Q_D(QColumnView);

    if (d->columns.isEmpty() || dx == 0)

        return;

    dx = isRightToLeft() ? -dx : dx;

    for (int i = 0; i < d->columns.count(); ++i)

        d->columns.at(i)->move(d->columns.at(i)->x() + dx, 0);

    d->offset += dx;

    QAbstractItemView::scrollContentsBy(dx, dy);

}

/*!

    \reimp

*/

void QColumnView::scrollTo(const QModelIndex &index, ScrollHint hint)

{

    Q_D(QColumnView);

    Q_UNUSED(hint);

    if (!index.isValid() || d->columns.isEmpty())

        return;

#ifndef QT_NO_ANIMATION

    if (d->currentAnimation.state() == QPropertyAnimation::Running)

        return;

    d->currentAnimation.stop();

#endif //QT_NO_ANIMATION

    // Fill up what is needed to get to index

    d->closeColumns(index, true);

    QModelIndex indexParent = index.parent();

    // Find the left edge of the column that contains index

    int currentColumn = 0;

    int leftEdge = 0;

    while (currentColumn < d->columns.size()) {

        if (indexParent == d->columns.at(currentColumn)->rootIndex())

            break;

        leftEdge += d->columns.at(currentColumn)->width();

        ++currentColumn;

    }

    // Don't let us scroll above the root index

    if (currentColumn == d->columns.size())

        return;

    int indexColumn = currentColumn;

    // Find the width of what we want to show (i.e. the right edge)

    int visibleWidth = d->columns.at(currentColumn)->width();

    // We want to always try to show two columns

    if (currentColumn + 1 < d->columns.size()) {

        ++currentColumn;

        visibleWidth += d->columns.at(currentColumn)->width();

    }

    int rightEdge = leftEdge + visibleWidth;

    if (isRightToLeft()) {

        leftEdge = viewport()->width() - leftEdge;

        rightEdge = leftEdge - visibleWidth;

        qSwap(rightEdge, leftEdge);

    }

    // If it is already visible don't animate

    if (leftEdge > -horizontalOffset()

        && rightEdge <= ( -horizontalOffset() + viewport()->size().width())) {

            d->columns.at(indexColumn)->scrollTo(index);

            d->_q_changeCurrentColumn();

            return;

    }

    int newScrollbarValue = 0;

    if (isRightToLeft()) {

        if (leftEdge < 0) {

            // scroll to the right

            newScrollbarValue = viewport()->size().width() - leftEdge;

        } else {

            // scroll to the left

            newScrollbarValue = rightEdge + horizontalOffset();

        }

    } else {

        if (leftEdge > -horizontalOffset()) {

            // scroll to the right

            newScrollbarValue = rightEdge - viewport()->size().width();

        } else {

            // scroll to the left

            newScrollbarValue = leftEdge;

        }

    }

#ifndef QT_NO_ANIMATION

    d->currentAnimation.setEndValue(newScrollbarValue);

    d->currentAnimation.start();

#else

    horizontalScrollBar()->setValue(newScrollbarValue);

#endif //QT_NO_ANIMATION

}

/*!

    \reimp

    Move left should go to the parent index

    Move right should go to the child index or down if there is no child

*/

QModelIndex QColumnView::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers)

{

    // the child views which have focus get to deal with this first and if

    // they don't accept it then it comes up this view and we only grip left/right

    Q_UNUSED(modifiers);

    if (!model())

        return QModelIndex();

    QModelIndex current = currentIndex();

    if (isRightToLeft()) {

        if (cursorAction == MoveLeft)

            cursorAction = MoveRight;

        else if (cursorAction == MoveRight)

            cursorAction = MoveLeft;

    }

    switch (cursorAction) {

    case MoveLeft:

        if (current.parent().isValid() && current.parent() != rootIndex())

            return (current.parent());

        else

            return current;

        break;

    case MoveRight:

        if (model()->hasChildren(current))

            return model()->index(0, 0, current);

        else

            return current.sibling(current.row() + 1, current.column());

        break;

    default:

        break;

    }

    return QModelIndex();

}

/*!

    \reimp

*/

void QColumnView::resizeEvent(QResizeEvent *event)

{

    Q_D(QColumnView);

    d->doLayout();

    d->updateScrollbars();

    if (!isRightToLeft()) {

        int diff = event->oldSize().width() - event->size().width();

        if (diff < 0 && horizontalScrollBar()->isVisible()

            && horizontalScrollBar()->value() == horizontalScrollBar()->maximum()) {

            horizontalScrollBar()->setMaximum(horizontalScrollBar()->maximum() + diff);

        }

    }

    QAbstractItemView::resizeEvent(event);

}

/*!

    \internal

*/

void QColumnViewPrivate::updateScrollbars()

{

    Q_Q(QColumnView);

#ifndef QT_NO_ANIMATION

    if (currentAnimation.state() == QPropertyAnimation::Running)

        return;

#endif //QT_NO_ANIMATION

    // find the total horizontal length of the laid out columns

    int horizontalLength = 0;

    if (!columns.isEmpty()) {

        horizontalLength = (columns.last()->x() + columns.last()->width()) - columns.first()->x();

        if (horizontalLength <= 0) // reverse mode

            horizontalLength = (columns.first()->x() + columns.first()->width()) - columns.last()->x();

    }

    QSize viewportSize = viewport->size();

    if (horizontalLength < viewportSize.width() && hbar->value() == 0) {

        hbar->setRange(0, 0);

    } else {

        int visibleLength = qMin(horizontalLength + q->horizontalOffset(), viewportSize.width());

        int hiddenLength = horizontalLength - visibleLength;

        if (hiddenLength != hbar->maximum())

            hbar->setRange(0, hiddenLength);

    }

    if (!columns.isEmpty()) {

        int pageStepSize = columns.at(0)->width();

        if (pageStepSize != hbar->pageStep())

            hbar->setPageStep(pageStepSize);

    }

    bool visible = (hbar->maximum() > 0);

    if (visible != hbar->isVisible())

        hbar->setVisible(visible);

}

/*!

    \reimp

*/

int QColumnView::horizontalOffset() const

{

    Q_D(const QColumnView);

    return d->offset;

}

/*!

    \reimp

*/

int QColumnView::verticalOffset() const

{

    return 0;

}

/*!

    \reimp

*/

QRegion QColumnView::visualRegionForSelection(const QItemSelection &selection) const

{

    int ranges = selection.count();

    if (ranges == 0)

        return QRect();

    // Note that we use the top and bottom functions of the selection range

    // since the data is stored in rows.

    int firstRow = selection.at(0).top();

    int lastRow = selection.at(0).top();

    for (int i = 0; i < ranges; ++i) {

        firstRow = qMin(firstRow, selection.at(i).top());

        lastRow = qMax(lastRow, selection.at(i).bottom());

    }

    QModelIndex firstIdx = model()->index(qMin(firstRow, lastRow), 0, rootIndex());

    QModelIndex lastIdx = model()->index(qMax(firstRow, lastRow), 0, rootIndex());

    if (firstIdx == lastIdx)

        return visualRect(firstIdx);

    QRegion firstRegion = visualRect(firstIdx);

    QRegion lastRegion = visualRect(lastIdx);

    return firstRegion.unite(lastRegion);

}

/*!

    \reimp

*/

void QColumnView::setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags command)

{

    Q_UNUSED(rect);

    Q_UNUSED(command);

}

/*!

    \reimp

*/

void QColumnView::setSelectionModel(QItemSelectionModel *newSelectionModel)

{

    Q_D(const QColumnView);

    for (int i = 0; i < d->columns.size(); ++i) {

        if (d->columns.at(i)->selectionModel() == selectionModel()) {

            d->columns.at(i)->setSelectionModel(newSelectionModel);

            break;

        }

    }

    QAbstractItemView::setSelectionModel(newSelectionModel);

}

/*!

    \reimp

*/

QSize QColumnView::sizeHint() const

{

    Q_D(const QColumnView);

    QSize sizeHint;

    for (int i = 0; i < d->columns.size(); ++i) {

        sizeHint += d->columns.at(i)->sizeHint();

    }

    return sizeHint.expandedTo(QAbstractItemView::sizeHint());

}

/*!

    \internal

    Move all widgets from the corner grip and to the right

  */

void QColumnViewPrivate::_q_gripMoved(int offset)