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

**

** 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 test suite 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 <QtTest/QtTest>

#include <qstandarditemmodel.h>

#include <qitemdelegate.h>

#include <qcolumnview.h>

#include "../../../src/gui/itemviews/qcolumnviewgrip_p.h"

#ifndef Q_OS_SYMBIAN

#include "../../../src/gui/dialogs/qfilesystemmodel_p.h"

#endif

#include <qdirmodel.h>

#include <qstringlistmodel.h>

#include <qdebug.h>

#include <qitemdelegate.h>

#include <qscrollbar.h>

#include <private/qcolumnview_p.h>

#include "../../shared/util.h"

//TESTED_CLASS=

//TESTED_FILES=

#define ANIMATION_DELAY 300

class tst_QColumnView : public QObject {

  Q_OBJECT

public:

    tst_QColumnView();

    virtual ~tst_QColumnView();

public Q_SLOTS:

    void init();

    void cleanup();

private slots:

    void rootIndex();

    void grips();

    void isIndexHidden();

    void indexAt();

    void scrollContentsBy_data();

    void scrollContentsBy();

    void scrollTo_data();

    void scrollTo();

    void moveCursor_data();

    void moveCursor();

    void selectAll();

    void clicked();

    void selectedColumns();

    void setSelection();

    void setSelectionModel();

    void visualRegionForSelection();

    void dynamicModelChanges();

    // grip

    void moveGrip_basic();

    void moveGrip_data();

    void moveGrip();

    void doubleClick();

    void gripMoved();

    void preview();

    void swapPreview();

    void sizes();

    void rowDelegate();

    void resize();

    void changeSameColumn();

    void parentCurrentIndex_data();

    void parentCurrentIndex();

    void pullRug_data();

    void pullRug();

protected slots:

    void setPreviewWidget();

};

class TreeModel : public QStandardItemModel

{

public:

    TreeModel()

    {

        for (int j = 0; j < 10; ++j) {

            QStandardItem *parentItem = invisibleRootItem();

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

                QStandardItem *item = new QStandardItem(QString("item %0").arg(i));

                parentItem->appendRow(item);

                QStandardItem *item2 = new QStandardItem(QString("item %0").arg(i));

                parentItem->appendRow(item2);

                item2->appendRow(new QStandardItem(QString("item %0").arg(i)));

                parentItem->appendRow(new QStandardItem(QString("file %0").arg(i)));

                parentItem = item;

            }

        }

    }

    inline QModelIndex firstLevel() { return index(0, 0, QModelIndex()); }

    inline QModelIndex secondLevel() { return index(0, 0, firstLevel()); }

    inline QModelIndex thirdLevel() { return index(0, 0, secondLevel()); }

};

class ColumnView : public QColumnView {

public:

    ColumnView(QWidget *parent = 0) : QColumnView(parent){}

    QList<QPointer<QAbstractItemView> > createdColumns;

    void ScrollContentsBy(int x, int y) {scrollContentsBy(x,y); }

    int HorizontalOffset() const { return horizontalOffset(); }

    void emitClicked() { emit clicked(QModelIndex()); }

    enum PublicCursorAction {

        MoveUp = QAbstractItemView::MoveUp,

        MoveDown = QAbstractItemView::MoveDown,

        MoveLeft = QAbstractItemView::MoveLeft,

        MoveRight = QAbstractItemView::MoveRight,

        MoveHome = QAbstractItemView::MoveHome,

        MoveEnd = QAbstractItemView::MoveEnd,

        MovePageUp = QAbstractItemView::MovePageUp,

        MovePageDown = QAbstractItemView::MovePageDown,

        MoveNext = QAbstractItemView::MoveNext,

        MovePrevious = QAbstractItemView::MovePrevious

    };

    inline QModelIndex MoveCursor(PublicCursorAction ca, Qt::KeyboardModifiers kbm)

        { return QColumnView::moveCursor((CursorAction)ca, kbm); }

    bool IsIndexHidden(const QModelIndex&index) const

        { return isIndexHidden(index); }

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

    {

        QColumnView::setSelection(rect, command);

    }

    QRegion visualRegionForSelection(QItemSelection selection){

        return QColumnView::visualRegionForSelection(selection);

    }

protected:

    QAbstractItemView *createColumn(const QModelIndex &index) {

        QAbstractItemView *view = QColumnView::createColumn(index);

        QPointer<QAbstractItemView> savedView = view;

        createdColumns.append(savedView);

        return view;

    }

};

tst_QColumnView::tst_QColumnView()

{

}

tst_QColumnView::~tst_QColumnView()

{

}

void tst_QColumnView::init()

{

    qApp->setLayoutDirection(Qt::LeftToRight);

#ifdef Q_OS_WINCE //disable magic for WindowsCE

    qApp->setAutoMaximizeThreshold(-1);

#endif

}

void tst_QColumnView::cleanup()

{

}

void tst_QColumnView::rootIndex()

{

    ColumnView view;

    // no model

    view.setRootIndex(QModelIndex());

    TreeModel model;

    view.setModel(&model);

    // A top level index

    QModelIndex drive = model.firstLevel();

    QVERIFY(view.visualRect(drive).isValid());

    view.setRootIndex(QModelIndex());

    QCOMPARE(view.HorizontalOffset(), 0);

    QCOMPARE(view.rootIndex(), QModelIndex());

    QVERIFY(view.visualRect(drive).isValid());

    // A item under the rootIndex exists

    QModelIndex home = model.thirdLevel();

    QModelIndex homeFile = model.index(0, 0, home);

    int i = 0;

    while (i < model.rowCount(home) - 1 && !model.hasChildren(homeFile))

        homeFile = model.index(++i, 0, home);

    view.setRootIndex(home);

    QCOMPARE(view.HorizontalOffset(), 0);

    QCOMPARE(view.rootIndex(), home);

    QVERIFY(!view.visualRect(drive).isValid());

    QVERIFY(!view.visualRect(home).isValid());

    if (homeFile.isValid())

        QVERIFY(view.visualRect(homeFile).isValid());

    // set root when there already is one and everything should still be ok

    view.setRootIndex(home);

    view.setCurrentIndex(homeFile);

    view.scrollTo(model.index(0,0, homeFile));

    QCOMPARE(view.HorizontalOffset(), 0);

    QCOMPARE(view.rootIndex(), home);

    QVERIFY(!view.visualRect(drive).isValid());

    QVERIFY(!view.visualRect(home).isValid());

     if (homeFile.isValid())

        QVERIFY(view.visualRect(homeFile).isValid());

    //

    homeFile = model.thirdLevel();

    home = homeFile.parent();

    view.setRootIndex(home);

    view.setCurrentIndex(homeFile);

    view.show();

    i = 0;

    QModelIndex two = model.index(0, 0, homeFile);

    while (i < model.rowCount(homeFile) - 1 && !model.hasChildren(two))

        two = model.index(++i, 0, homeFile);

    qApp->processEvents();

    QTest::qWait(ANIMATION_DELAY);

    view.setCurrentIndex(two);

    view.scrollTo(two);

    QTest::qWait(ANIMATION_DELAY);

    qApp->processEvents();

    QVERIFY(two.isValid());

    QVERIFY(view.HorizontalOffset() != 0);

    view.setRootIndex(homeFile);

    QCOMPARE(view.HorizontalOffset(), 0);

}

void tst_QColumnView::grips()

{

    QColumnView view;

    QDirModel model;

    view.setModel(&model);

    QCOMPARE(view.resizeGripsVisible(), true);

    view.setResizeGripsVisible(true);

    QCOMPARE(view.resizeGripsVisible(), true);

    {

        const QObjectList list = view.viewport()->children();

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

            if (QAbstractItemView *view = qobject_cast<QAbstractItemView*>(list.at(i)))

                QVERIFY(view->cornerWidget() != 0);

        }

    }

    view.setResizeGripsVisible(false);

    QCOMPARE(view.resizeGripsVisible(), false);

    {

        const QObjectList list = view.viewport()->children();

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

            if (QAbstractItemView *view = qobject_cast<QAbstractItemView*>(list.at(i))) {

                if (view->isVisible())

                    QVERIFY(view->cornerWidget() == 0);

            }

        }

    }

    view.setResizeGripsVisible(true);

    QCOMPARE(view.resizeGripsVisible(), true);

}

void tst_QColumnView::isIndexHidden()

{

    ColumnView view;

    QModelIndex idx;

    QCOMPARE(view.IsIndexHidden(idx), false);

    QDirModel model;

    view.setModel(&model);

    QCOMPARE(view.IsIndexHidden(idx), false);

}

void tst_QColumnView::indexAt()

{

    QColumnView view;

    QCOMPARE(view.indexAt(QPoint(0,0)), QModelIndex());

    QDirModel model;

    view.setModel(&model);

    QModelIndex home = model.index(QDir::homePath());

    QModelIndex homeFile = model.index(0, 0, home);

    if (!homeFile.isValid())

        return;

    view.setRootIndex(home);

    QRect rect = view.visualRect(QModelIndex());

    QVERIFY(!rect.isValid());

    rect = view.visualRect(homeFile);

    QVERIFY(rect.isValid());

    QModelIndex child;

    for (int i = 0; i < model.rowCount(home); ++i) {

        child = model.index(i, 0, home);

        rect = view.visualRect(child);

        QVERIFY(rect.isValid());

        if (i > 0)

            QVERIFY(rect.top() > 0);

        QCOMPARE(view.indexAt(rect.center()), child);

        view.selectionModel()->select(child, QItemSelectionModel::SelectCurrent);

        view.setCurrentIndex(child);

        qApp->processEvents();

        QTest::qWait(200);

        // test that the second row doesn't start at 0

        if (model.rowCount(child) > 0) {

            child = model.index(0, 0, child);

            QVERIFY(child.isValid());

            rect = view.visualRect(child);

            QVERIFY(rect.isValid());

            QVERIFY(rect.left() > 0);

            QCOMPARE(view.indexAt(rect.center()), child);

            break;

        }

    }

}

void tst_QColumnView::scrollContentsBy_data()

{

    QTest::addColumn<bool>("reverse");

    QTest::newRow("normal") << false;

    QTest::newRow("reverse") << true;

}

void tst_QColumnView::scrollContentsBy()

{

    QFETCH(bool, reverse);

    if (reverse)

        qApp->setLayoutDirection(Qt::RightToLeft);

    ColumnView view;

    view.ScrollContentsBy(-1, -1);

    view.ScrollContentsBy(0, 0);

    TreeModel model;

    view.setModel(&model);

    view.ScrollContentsBy(0, 0);

    QModelIndex home = model.thirdLevel();

    view.setCurrentIndex(home);

    QTest::qWait(ANIMATION_DELAY);

    view.ScrollContentsBy(0, 0);

}

void tst_QColumnView::scrollTo_data()

{

    QTest::addColumn<bool>("reverse");

    QTest::addColumn<bool>("giveFocus");

    /// ### add test later for giveFocus == true

    QTest::newRow("normal") << false << false;

    QTest::newRow("reverse") << true << false;

}

void tst_QColumnView::scrollTo()

{

    QFETCH(bool, reverse);

    QFETCH(bool, giveFocus);

    if (reverse)

        qApp->setLayoutDirection(Qt::RightToLeft);

    ColumnView view;

    view.resize(200, 200);

    view.show();

    view.scrollTo(QModelIndex(), QAbstractItemView::EnsureVisible);

    QCOMPARE(view.HorizontalOffset(), 0);

    TreeModel model;

    view.setModel(&model);

    view.scrollTo(QModelIndex(), QAbstractItemView::EnsureVisible);

    QModelIndex home;

    home = model.index(0, 0, home);

    home = model.index(0, 0, home);

    home = model.index(0, 0, home);

    view.scrollTo(home, QAbstractItemView::EnsureVisible);

    QModelIndex homeFile = model.index(0, 0, home);

    view.setRootIndex(home);

    QModelIndex index = model.index(0, 0, home);

    view.scrollTo(index, QAbstractItemView::EnsureVisible);

    QCOMPARE(view.HorizontalOffset(), 0);

    // Embedded requires that at least one widget have focus

    QWidget w;

    w.show();

    if (giveFocus)

        view.setFocus(Qt::OtherFocusReason);

    else

        view.clearFocus();

    QTRY_COMPARE(view.hasFocus(), giveFocus);

    // scroll to the right

    int level = 0;

    int last = view.HorizontalOffset();

    while(model.hasChildren(index) && level < 5) {

        view.setCurrentIndex(index);

        QTest::qWait(ANIMATION_DELAY);

        view.scrollTo(index, QAbstractItemView::EnsureVisible);

        QTest::qWait(ANIMATION_DELAY);

        qApp->processEvents();

        index = model.index(0, 0, index);

        level++;

        if (level >= 2) {

            if (!reverse) {

                QTRY_VERIFY(view.HorizontalOffset() < 0);

                QTRY_VERIFY(last > view.HorizontalOffset());

            } else {

                QTRY_VERIFY(view.HorizontalOffset() > 0);

                QTRY_VERIFY(last < view.HorizontalOffset());

            }

        }

        last = view.HorizontalOffset();

    }

    // scroll to the left

    int start = level;

    while(index.parent().isValid() && index != view.rootIndex()) {

        view.setCurrentIndex(index);

        QTest::qWait(ANIMATION_DELAY);

        view.scrollTo(index, QAbstractItemView::EnsureVisible);

        index = index.parent();

        if (start != level) {

            if (!reverse)

                QTRY_VERIFY(last < view.HorizontalOffset());

            else

                QTRY_VERIFY(last > view.HorizontalOffset());

        }

        level--;

        last = view.HorizontalOffset();

    }

    // It shouldn't automatically steal focus if it doesn't have it

    QTRY_COMPARE(view.hasFocus(), giveFocus);

    // Try scrolling to something that is above the root index

    home = model.index(0, 0, QModelIndex());

    QModelIndex temp = model.index(1, 0, home);

    home = model.index(0, 0, home);

    home = model.index(0, 0, home);

    view.setRootIndex(home);

    view.scrollTo(model.index(0, 0, home));

    QTest::qWait(ANIMATION_DELAY);

    view.scrollTo(temp);

}

void tst_QColumnView::moveCursor_data()

{

    QTest::addColumn<bool>("reverse");

    QTest::newRow("normal") << false;

    QTest::newRow("reverse") << true;

}

void tst_QColumnView::moveCursor()

{

    QFETCH(bool, reverse);

    if (reverse)

        qApp->setLayoutDirection(Qt::RightToLeft);

    ColumnView view;

    // don't crash

    view.MoveCursor(ColumnView::MoveUp, Qt::NoModifier);

    // don't do anything

    QCOMPARE(view.MoveCursor(ColumnView::MoveEnd, Qt::NoModifier), QModelIndex());

    QDirModel model;

    view.setModel(&model);

    QModelIndex home = model.index(QDir::homePath());

    QModelIndex ci = view.currentIndex();

    QCOMPARE(view.MoveCursor(ColumnView::MoveUp, Qt::NoModifier), QModelIndex());

    QCOMPARE(view.MoveCursor(ColumnView::MoveDown, Qt::NoModifier), QModelIndex());

    // left at root

    view.setCurrentIndex(model.index(0,0));

    ColumnView::PublicCursorAction action = reverse ? ColumnView::MoveRight : ColumnView::MoveLeft;

    QCOMPARE(view.MoveCursor(action, Qt::NoModifier), model.index(0,0));

    // left shouldn't move up

    int i = 0;

    ci = model.index(0, 0);

    while (i < model.rowCount() - 1 && !model.hasChildren(ci))

        ci = model.index(++i, 0);

    QVERIFY(model.hasChildren(ci));

    view.setCurrentIndex(ci);

    action = reverse ? ColumnView::MoveRight : ColumnView::MoveLeft;

    QCOMPARE(view.MoveCursor(action, Qt::NoModifier), ci);

    // now move to the left (i.e. move over one column)

    view.setCurrentIndex(home);