/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: Container for pan (drag) gesture -related data and logic.

*

*/

#include <QtTest/QtTest>

#include <QMetaType>

#include <QModelIndex>

#include "hbautotest.h"

#include <HbApplication>

#include <HbMainWindow>

#include <HbScrollbar>

#include <HbView>

#include <hgwidgets/hgwidgets.h>

#include <hgwidgets/hggrid.h>

#include <hgwidgets/hgmediawall.h>

Q_DECLARE_METATYPE(QItemSelection)

Q_DECLARE_METATYPE(QModelIndex)

static const int default_delay(1500);

class TestGanesWidgets : public QObject

{

    Q_OBJECT

public:

    TestGanesWidgets();

    virtual ~TestGanesWidgets();

private slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void test_setModel();

    void test_panGridLandscape();

    void test_panCoverFlowLandscape();

    void test_scrollbarGridLandscape();

    void test_scrollbarGridPortrait();

    void test_scrollbarCoverFlowLandscape();

    void test_scrollbarCoverFlowPortrait();

    void test_addRemoveItemsGrid();

    void test_addRemoveItemsCoverflow();

    void test_updateData();

    void test_tap();

    void test_currentItemCoverflow();

    void test_currentItemGrid();

    void test_selectionMode();

    void test_selectionModel();

    void test_scrollTo();

    void test_addItemsCoverFlow();

    void test_removeItemsCoverFlow();

    void test_moveItemsCoverFlow();

    void test_labelFontSpecsCoverFlow();

    void test_resetModelCoverFlow();

    void test_resetModelGrid();

private:

    void pan( Qt::Orientation, TBool begin );

private:

    HbMainWindow* mWindow;

    HgWidget* mWidget;

    HgMediawall* mMediawall;

};

class TestModel : public QAbstractListModel

{

    Q_OBJECT

public:

    explicit TestModel(QList<QModelIndex> *requestedIndexes = 0);

    virtual ~TestModel();

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

    QVariant data(const QModelIndex &index, int role=Qt::DisplayRole) const;

    void generateItems(int count);

    void appendItem();

    void insertItems(int index, int count=1);

    void removeItems(int index, int count=1);

    void moveItems(int from, int to, int count=1);

    void changeItem(int index);

    void reset(int newItemCount=0);

    QImage mImage;

    QStringList mItems;

    bool mValidData;

    QList<QModelIndex> *mRequestedIndexes;

};

TestModel::TestModel(QList<QModelIndex> *requestedIndexes) :

    mValidData(true),

{

}

TestModel::~TestModel()

{

}

void TestModel::generateItems(int count)

{

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

        mItems.append(QString("Item ").append(i));

    }

}

void TestModel::appendItem()

{

    insertItems(mItems.count(),1);

}

void TestModel::insertItems(int index, int count)

{

    beginInsertRows(QModelIndex(), index, index+count-1); // Inclusive

    int end = index+count;

    for ( ;index<end; index++) {

        mItems.insert(index, QString("Item ").append(mItems.count()));

    }

    endInsertRows();

}

void TestModel::removeItems(int index, int count)

{

    if (index >= 0 && index < mItems.count()) {

        beginRemoveRows(QModelIndex(), index, index+count-1); // Inclusive

        int end = index+count;

        for (; index<end; index++) {

            mItems.removeAt(index);

        }

        endRemoveRows();

    }

}

void TestModel::moveItems(int from, int to, int count)

{

    if (beginMoveRows(QModelIndex(), from, from+count-1, QModelIndex(), to)) { // Inclusive

        // No need to actually move rows here

        endMoveRows();

    }

    else {

        qDebug() << "Cannot move" << from << "-" << from+count-1 << "to" << to;

    }

}

void TestModel::reset(int newItemCount)

{

    beginResetModel();

    mItems.clear();

    if (newItemCount > 0) {

        generateItems(newItemCount);

    }

    endResetModel();

}

void TestModel::changeItem(int index)

{

    if ( index >= 0 && index < mItems.count() ) {

        QModelIndex modelIndex = QAbstractItemModel::createIndex(index, 0);

        emit dataChanged(modelIndex, modelIndex);

    }

}

int TestModel::rowCount(const QModelIndex &parent) const

{

    Q_UNUSED(parent);

    return mItems.count();

}

QVariant TestModel::data(const QModelIndex &index, int role) const

{

    QVariant returnValue;

    if( !mValidData)

        return returnValue;

    int row = index.row();

    switch ( role )

        {

        case Qt::DisplayRole:

            {

            QStringList list;

            returnValue = list;

            break;

            }

        case Qt::DecorationRole:

            {

            if (mRequestedIndexes && !mRequestedIndexes->contains(index)) {

                mRequestedIndexes->append(index);

                qSort(*mRequestedIndexes);

            }

            break;

            }

        default:

            break;

        }

    return returnValue;

}

TestGanesWidgets::TestGanesWidgets()

{

}

TestGanesWidgets::~TestGanesWidgets()

{

}

void TestGanesWidgets::initTestCase()

{

}

void TestGanesWidgets::cleanupTestCase()

{

}

void TestGanesWidgets::init()

{

}

void TestGanesWidgets::cleanup()

{

}

void TestGanesWidgets::pan( Qt::Orientation orientation, TBool begin )

{

    if (orientation==Qt::Horizontal){

    }

    else {

    }

    if( begin )

        end = start - move;

    else

        end = start + move;

    HbAutoTest::mousePress( (HbAutoTestMainWindow*)mWindow, mWidget, start, -1 );

    HbAutoTest::mouseMove( (HbAutoTestMainWindow*)mWindow, mWidget, end, -1 );

    HbAutoTest::mouseRelease( (HbAutoTestMainWindow*)mWindow, mWidget, end, 100 );

}

void TestGanesWidgets::test_setModel()

{

    mWidget = new HgGrid(Qt::Horizontal);

    mWindow->addView(mWidget);

    QVERIFY(mWidget->model() == 0);

    TestModel model1;

    model1.generateItems(10);

    mWidget->setModel(&model1);

    QVERIFY(&model1 == mWidget->model());

    TestModel model2;

    model2.generateItems(20);

    mWidget->setModel(&model2);

    QVERIFY(&model2 == mWidget->model());

    mWidget->setModel(0);

    QVERIFY(mWidget->model() == 0);

}

void TestGanesWidgets::test_panGridLandscape()

{

    mWidget = new HgGrid(Qt::Horizontal);

    TestModel model;

    model.generateItems(30);

    mWindow->addView( mWidget );

    QVERIFY( mWidget->model() == 0 );

    mWidget->setModel( &model );

    QVERIFY( &model == mWidget->model() );

    mWindow->show();

    pan( Qt::Horizontal, true );

    model.reset();

    model.generateItems(5);

    pan( Qt::Horizontal, false );

    model.reset();

    pan( Qt::Horizontal, true );

}

void TestGanesWidgets::test_panCoverFlowLandscape()

{

    mWidget = new HgMediawall();

    TestModel model;

    model.generateItems(30);

    mWindow->addView( mWidget );

    QVERIFY( mWidget->model() == 0 );

    mWidget->setModel( &model );

    QVERIFY( &model == mWidget->model() );

    mWindow->show();

    QTest::qWait( 2000 );

    pan( Qt::Horizontal, true );

    model.reset();

    model.generateItems(5);

    QTest::qWait( 2000 );

    pan( Qt::Horizontal, false );

    model.reset();

    QTest::qWait( 2000 );

    pan( Qt::Horizontal, true );

}

void TestGanesWidgets::test_scrollbarGridLandscape()

{