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

**

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

#include <QtTest/QtTest>

#include <QtGui/QtGui>

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

//TESTED_CLASS=

//TESTED_FILES=

Q_DECLARE_METATYPE(QModelIndex)

#ifndef QT_NO_DRAGANDDROP

Q_DECLARE_METATYPE(QAbstractItemView::DragDropMode)

#endif

Q_DECLARE_METATYPE(QAbstractItemView::EditTriggers)

Q_DECLARE_METATYPE(QAbstractItemView::EditTrigger)

static void initStandardTreeModel(QStandardItemModel *model)

{

    QStandardItem *item;

    item = new QStandardItem(QLatin1String("Row 1 Item"));

    model->insertRow(0, item);

    item = new QStandardItem(QLatin1String("Row 2 Item"));

    item->setCheckable(true);

    model->insertRow(1, item);

    QStandardItem *childItem = new QStandardItem(QLatin1String("Row 2 Child Item"));

    item->setChild(0, childItem);

    item = new QStandardItem(QLatin1String("Row 3 Item"));

    item->setIcon(QIcon());

    model->insertRow(2, item);

}

struct PublicView : public QTreeView

{

    inline void executeDelayedItemsLayout()

    { QTreeView::executeDelayedItemsLayout(); }

    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 QTreeView::moveCursor((CursorAction)ca, kbm); }

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

    {

        QTreeView::setSelection(rect, command);

    }

    inline int state()

    {

        return QTreeView::state();

    }

    inline int rowHeight(QModelIndex idx) { return QTreeView::rowHeight(idx); }

    inline int indexRowSizeHint(const QModelIndex &index) const { return QTreeView::indexRowSizeHint(index); }

    inline QModelIndexList selectedIndexes() const { return QTreeView::selectedIndexes(); }

    inline QStyleOptionViewItem viewOptions() const { return QTreeView::viewOptions(); }

    inline int sizeHintForColumn(int column) const { return QTreeView::sizeHintForColumn(column); }

};

class tst_QTreeView : public QObject

{

    Q_OBJECT

public:

    tst_QTreeView();

    virtual ~tst_QTreeView();

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

    void selectionOrderTest();

private slots:

    void getSetCheck();

    // one test per QTreeView property

    void construction();

    void alternatingRowColors();

    void currentIndex_data();

    void currentIndex();

#ifndef QT_NO_DRAGANDDROP

    void dragDropMode_data();

    void dragDropMode();

    void dragDropModeFromDragEnabledAndAcceptDrops_data();

    void dragDropModeFromDragEnabledAndAcceptDrops();

    void dragDropOverwriteMode();

#endif

    void editTriggers_data();

    void editTriggers();

    void hasAutoScroll();

    void horizontalScrollMode();

    void iconSize();

    void indexAt();

    void indexWidget();

    void itemDelegate();

    void itemDelegateForColumnOrRow();

    void keyboardSearch();

    void setModel();

    void openPersistentEditor();

    void rootIndex();

    // specialized tests below

    void setHeader();

    void columnHidden();

    void rowHidden();

    void noDelegate();

    void noModel();

    void emptyModel();

    void removeRows();

    void removeCols();

    void expandAndCollapse_data();

    void expandAndCollapse();

    void expandAndCollapseAll();

    void expandWithNoChildren();

    void keyboardNavigation();

    void headerSections();

    void moveCursor_data();

    void moveCursor();

    void setSelection_data();

    void setSelection();

    void extendedSelection_data();

    void extendedSelection();

    void indexAbove();

    void indexBelow();

    void clicked();

    void mouseDoubleClick();

    void rowsAboutToBeRemoved();

    void headerSections_unhideSection();

    void columnAt();

    void scrollTo();

    void rowsAboutToBeRemoved_move();

    void resizeColumnToContents();

    void insertAfterSelect();

    void removeAfterSelect();

    void hiddenItems();

    void spanningItems();

    void rowSizeHint();

    void setSortingEnabled();

    void headerHidden();

    void selection();

    void removeAndInsertExpandedCol0();

    void selectionWithHiddenItems();

    void selectAll();

    void disabledButCheckable();

    void sortByColumn_data();

    void sortByColumn();

    void evilModel_data();

    void evilModel();

    void indexRowSizeHint();

    void addRowsWhileSectionsAreHidden();

    void filterProxyModelCrash();

    void styleOptionViewItem();

    void keyboardNavigationWithDisabled();

    // task-specific tests:

    void task174627_moveLeftToRoot();

    void task171902_expandWith1stColHidden();

    void task203696_hidingColumnsAndRowsn();

    void task211293_removeRootIndex();

    void task216717_updateChildren();

    void task220298_selectColumns();

    void task224091_appendColumns();

    void task225539_deleteModel();

    void task230123_setItemsExpandable();

    void task202039_closePersistentEditor();

    void task238873_avoidAutoReopening();

    void task244304_clickOnDecoration();

    void task246536_scrollbarsNotWorking();

    void task250683_wrongSectionSize();

    void task239271_addRowsWithFirstColumnHidden();

    void task254234_proxySort();

    void task248022_changeSelection();

    void task245654_changeModelAndExpandAll();

    void doubleClickedWithSpans();

    void taskQTBUG_6450_selectAllWith1stColumnHidden();

    void taskQTBUG_9216_setSizeAndUniformRowHeightsWrongRepaint();

};

class QtTestModel: public QAbstractItemModel

{

public:

    QtTestModel(QObject *parent = 0): QAbstractItemModel(parent),

       fetched(false), rows(0), cols(0), levels(INT_MAX), wrongIndex(false) { init(); }

    QtTestModel(int _rows, int _cols, QObject *parent = 0): QAbstractItemModel(parent),

       fetched(false), rows(_rows), cols(_cols), levels(INT_MAX), wrongIndex(false) { init(); }

    void init() {

        decorationsEnabled = false;

    }

    inline qint32 level(const QModelIndex &index) const {

        return index.isValid() ? qint32(index.internalId()) : qint32(-1);

    }

    bool canFetchMore(const QModelIndex &) const {

        return !fetched;

    }

    void fetchMore(const QModelIndex &) {

        fetched = true;

    }

    bool hasChildren(const QModelIndex &parent = QModelIndex()) const {

        bool hasFetched = fetched;

        fetched = true;

        bool r = QAbstractItemModel::hasChildren(parent);

        fetched = hasFetched;

        return r;

    }

    int rowCount(const QModelIndex& parent = QModelIndex()) const {

        Q_ASSERT(fetched);

        if ((parent.column() > 0) || (level(parent) > levels))

            return 0;

        return rows;

    }

    int columnCount(const QModelIndex& parent = QModelIndex()) const {

        if ((parent.column() > 0) || (level(parent) > levels))

            return 0;

        return cols;

    }

    bool isEditable(const QModelIndex &index) const {

        if (index.isValid())

            return true;

        return false;

    }

    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const

    {

        if (row < 0 || column < 0 || (level(parent) > levels) || column >= cols || row >= rows) {

            return QModelIndex();

        }

        QModelIndex i = createIndex(row, column, level(parent) + 1);

        parentHash[i] = parent;

        return i;

    }

    QModelIndex parent(const QModelIndex &index) const

    {

        if (!parentHash.contains(index))

            return QModelIndex();

        return parentHash[index];

    }

    QVariant data(const QModelIndex &idx, int role) const

    {

        if (!idx.isValid())

            return QVariant();

        if (role == Qt::DisplayRole) {

            if (idx.row() < 0 || idx.column() < 0 || idx.column() >= cols || idx.row() >= rows) {

                wrongIndex = true;

                qWarning("Invalid modelIndex [%d,%d,%p]", idx.row(), idx.column(),

                         idx.internalPointer());

            }

            if (idx.row() & 1)

                return QString("[%1,%2,%3] - this item is extra wide").arg(idx.row()).arg(idx.column()).arg(level(idx));

            return QString("[%1,%2,%3]").arg(idx.row()).arg(idx.column()).arg(level(idx));

        }

        if (decorationsEnabled && role == Qt::DecorationRole) {

            QPixmap pm(16,16);

            pm.fill(QColor::fromHsv((idx.column() % 16)*8 + 64, 254, (idx.row() % 16)*8 + 32));

            return pm;

        }

        return QVariant();

    }

    void removeLastRow()

    {

        beginRemoveRows(QModelIndex(), rows - 1, rows - 1);

        --rows;

        endRemoveRows();

    }

    void removeAllRows()

    {

        beginRemoveRows(QModelIndex(), 0, rows - 1);

        rows = 0;

        endRemoveRows();

    }

    void removeLastColumn()

    {

        beginRemoveColumns(QModelIndex(), cols - 1, cols - 1);

        --cols;

        endRemoveColumns();

    }

    void removeAllColumns()

    {

        beginRemoveColumns(QModelIndex(), 0, cols - 1);

        cols = 0;

        endRemoveColumns();

    }

    void insertNewRow()

    {

        beginInsertRows(QModelIndex(), rows - 1, rows - 1);

        ++rows;

        endInsertRows();

    }

    void setDecorationsEnabled(bool enable)

    {

        decorationsEnabled = enable;

    }

    mutable bool fetched;

    bool decorationsEnabled;

    int rows, cols;

    int levels;

    mutable bool wrongIndex;

    mutable QMap<QModelIndex,QModelIndex> parentHash;

};

tst_QTreeView::tst_QTreeView()

{

}

tst_QTreeView::~tst_QTreeView()

{

}

void tst_QTreeView::initTestCase()

{

#ifdef Q_OS_WINCE //disable magic for WindowsCE

    qApp->setAutoMaximizeThreshold(-1);

#endif

    qRegisterMetaType<QModelIndex>("QModelIndex");

}

void tst_QTreeView::cleanupTestCase()

{

}

void tst_QTreeView::init()

{

}

void tst_QTreeView::cleanup()

{

}

// Testing get/set functions

void tst_QTreeView::getSetCheck()

{

    QTreeView obj1;

    // int QTreeView::indentation()

    // void QTreeView::setIndentation(int)

    QCOMPARE(obj1.indentation(), 20);

    obj1.setIndentation(0);

    QCOMPARE(obj1.indentation(), 0);

    obj1.setIndentation(INT_MIN);

    QCOMPARE(obj1.indentation(), INT_MIN);

    obj1.setIndentation(INT_MAX);

    QCOMPARE(obj1.indentation(), INT_MAX);

    // bool QTreeView::rootIsDecorated()

    // void QTreeView::setRootIsDecorated(bool)

    QCOMPARE(obj1.rootIsDecorated(), true);

    obj1.setRootIsDecorated(false);

    QCOMPARE(obj1.rootIsDecorated(), false);

    obj1.setRootIsDecorated(true);

    QCOMPARE(obj1.rootIsDecorated(), true);

    // bool QTreeView::uniformRowHeights()

    // void QTreeView::setUniformRowHeights(bool)

    QCOMPARE(obj1.uniformRowHeights(), false);

    obj1.setUniformRowHeights(false);

    QCOMPARE(obj1.uniformRowHeights(), false);

    obj1.setUniformRowHeights(true);

    QCOMPARE(obj1.uniformRowHeights(), true);

    // bool QTreeView::itemsExpandable()

    // void QTreeView::setItemsExpandable(bool)

    QCOMPARE(obj1.itemsExpandable(), true);

    obj1.setItemsExpandable(false);

    QCOMPARE(obj1.itemsExpandable(), false);

    obj1.setItemsExpandable(true);

    QCOMPARE(obj1.itemsExpandable(), true);

    // bool QTreeView::allColumnsShowFocus

    // void QTreeView::setAllColumnsShowFocus

    QCOMPARE(obj1.allColumnsShowFocus(), false);

    obj1.setAllColumnsShowFocus(false);

    QCOMPARE(obj1.allColumnsShowFocus(), false);

    obj1.setAllColumnsShowFocus(true);

    QCOMPARE(obj1.allColumnsShowFocus(), true);

    // bool QTreeView::isAnimated

    // void QTreeView::setAnimated

    QCOMPARE(obj1.isAnimated(), false);

    obj1.setAnimated(false);

    QCOMPARE(obj1.isAnimated(), false);

    obj1.setAnimated(true);

    QCOMPARE(obj1.isAnimated(), true);

    // bool QTreeView::setSortingEnabled

    // void QTreeView::isSortingEnabled

    QCOMPARE(obj1.isSortingEnabled(), false);

    obj1.setSortingEnabled(false);

    QCOMPARE(obj1.isSortingEnabled(), false);

    obj1.setSortingEnabled(true);

    QCOMPARE(obj1.isSortingEnabled(), true);

}

void tst_QTreeView::construction()

{

    QTreeView view;

    // QAbstractItemView properties

    QVERIFY(!view.alternatingRowColors());

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

#ifndef QT_NO_DRAGANDDROP

    QCOMPARE(view.dragDropMode(), QAbstractItemView::NoDragDrop);

    QVERIFY(!view.dragDropOverwriteMode());

    QVERIFY(!view.dragEnabled());

#endif

    QCOMPARE(view.editTriggers(), QAbstractItemView::EditKeyPressed | QAbstractItemView::DoubleClicked);

    QVERIFY(view.hasAutoScroll());

    QCOMPARE(view.horizontalScrollMode(), QAbstractItemView::ScrollPerPixel);

    QCOMPARE(view.iconSize(), QSize());

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

    QVERIFY(!view.indexWidget(QModelIndex()));

    QVERIFY(qobject_cast<QStyledItemDelegate *>(view.itemDelegate()));

    QVERIFY(!view.itemDelegateForColumn(-1));

    QVERIFY(!view.itemDelegateForColumn(0));

    QVERIFY(!view.itemDelegateForColumn(1));

    QVERIFY(!view.itemDelegateForRow(-1));

    QVERIFY(!view.itemDelegateForRow(0));

    QVERIFY(!view.itemDelegateForRow(1));

    QVERIFY(!view.model());

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

    QCOMPARE(view.selectionBehavior(), QAbstractItemView::SelectRows);

    QCOMPARE(view.selectionMode(), QAbstractItemView::SingleSelection);

    QVERIFY(!view.selectionModel());

#ifndef QT_NO_DRAGANDDROP

    QVERIFY(view.showDropIndicator());

#endif

    QCOMPARE(view.QAbstractItemView::sizeHintForColumn(-1), -1); // <- protected in QTreeView

    QCOMPARE(view.QAbstractItemView::sizeHintForColumn(0), -1); // <- protected in QTreeView

    QCOMPARE(view.QAbstractItemView::sizeHintForColumn(1), -1); // <- protected in QTreeView

    QCOMPARE(view.sizeHintForIndex(QModelIndex()), QSize());

    QCOMPARE(view.sizeHintForRow(-1), -1);

    QCOMPARE(view.sizeHintForRow(0), -1);

    QCOMPARE(view.sizeHintForRow(1), -1);

    QVERIFY(!view.tabKeyNavigation());

    QCOMPARE(view.textElideMode(), Qt::ElideRight);

    QCOMPARE(view.verticalScrollMode(), QAbstractItemView::ScrollPerItem);

    QCOMPARE(view.visualRect(QModelIndex()), QRect());

    // QTreeView properties

    QVERIFY(!view.allColumnsShowFocus());

    QCOMPARE(view.autoExpandDelay(), -1);

    QCOMPARE(view.columnAt(-1), -1);

    QCOMPARE(view.columnAt(0), -1);

    QCOMPARE(view.columnAt(1), -1);

    QCOMPARE(view.columnViewportPosition(-1), -1);