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

**

** 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 <QtDeclarative/qdeclarativeview.h>

#include <QtDeclarative/qdeclarativeengine.h>

#include <QtDeclarative/qdeclarativecomponent.h>

#include <QtDeclarative/qdeclarativecontext.h>

#include <QtDeclarative/qdeclarativeexpression.h>

#include <QtDeclarative/private/qdeclarativepathview_p.h>

#include <QtDeclarative/private/qdeclarativepath_p.h>

#include <QtDeclarative/private/qdeclarativetext_p.h>

#include <QtDeclarative/private/qdeclarativerectangle_p.h>

#include <QtDeclarative/private/qdeclarativelistmodel_p.h>

#include <QtDeclarative/private/qdeclarativevaluetype_p.h>

#include <QAbstractListModel>

#include <QStringListModel>

#include <QFile>

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

class tst_QDeclarativePathView : public QObject

{

    Q_OBJECT

public:

    tst_QDeclarativePathView();

private slots:

    void initValues();

    void items();

    void dataModel();

    void pathview2();

    void pathview3();

    void path();

    void pathMoved();

    void setCurrentIndex();

    void resetModel();

    void propertyChanges();

    void pathChanges();

    void componentChanges();

    void modelChanges();

    void pathUpdateOnStartChanged();

    void package();

private:

    QDeclarativeView *createView();

    template<typename T>

    T *findItem(QGraphicsObject *parent, const QString &objectName, int index=-1);

    template<typename T>

    QList<T*> findItems(QGraphicsObject *parent, const QString &objectName);

};

class TestObject : public QObject

{

    Q_OBJECT

    Q_PROPERTY(bool error READ error WRITE setError)

    Q_PROPERTY(bool useModel READ useModel NOTIFY useModelChanged)

    Q_PROPERTY(int pathItemCount READ pathItemCount NOTIFY pathItemCountChanged)

public:

    TestObject() : QObject(), mError(true), mUseModel(true), mPathItemCount(-1) {}

    bool error() const { return mError; }

    void setError(bool err) { mError = err; }

    bool useModel() const { return mUseModel; }

    void setUseModel(bool use) { mUseModel = use; emit useModelChanged(); }

    int pathItemCount() const { return mPathItemCount; }

    void setPathItemCount(int count) { mPathItemCount = count; emit pathItemCountChanged(); }

signals:

    void useModelChanged();

    void pathItemCountChanged();

private:

    bool mError;

    bool mUseModel;

    int mPathItemCount;

};

class TestModel : public QAbstractListModel

{

public:

    enum Roles { Name = Qt::UserRole+1, Number = Qt::UserRole+2 };

    TestModel(QObject *parent=0) : QAbstractListModel(parent) {

        QHash<int, QByteArray> roles;

        roles[Name] = "name";

        roles[Number] = "number";

        setRoleNames(roles);

    }

    int rowCount(const QModelIndex &parent=QModelIndex()) const { Q_UNUSED(parent); return list.count(); }

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

        QVariant rv;

        if (role == Name)

            rv = list.at(index.row()).first;

        else if (role == Number)

            rv = list.at(index.row()).second;

        return rv;

    }

    int count() const { return rowCount(); }

    QString name(int index) const { return list.at(index).first; }

    QString number(int index) const { return list.at(index).second; }

    void addItem(const QString &name, const QString &number) {

        emit beginInsertRows(QModelIndex(), list.count(), list.count());

        list.append(QPair<QString,QString>(name, number));

        emit endInsertRows();

    }

    void insertItem(int index, const QString &name, const QString &number) {

        emit beginInsertRows(QModelIndex(), index, index);

        list.insert(index, QPair<QString,QString>(name, number));

        emit endInsertRows();

    }

    void removeItem(int index) {

        emit beginRemoveRows(QModelIndex(), index, index);

        list.removeAt(index);

        emit endRemoveRows();

    }

    void moveItem(int from, int to) {

        emit beginMoveRows(QModelIndex(), from, from, QModelIndex(), to);

        list.move(from, to);

        emit endMoveRows();

    }

    void modifyItem(int idx, const QString &name, const QString &number) {

        list[idx] = QPair<QString,QString>(name, number);

        emit dataChanged(index(idx,0), index(idx,0));

    }

private:

    QList<QPair<QString,QString> > list;

};

tst_QDeclarativePathView::tst_QDeclarativePathView()

{

}

void tst_QDeclarativePathView::initValues()

{

    QDeclarativeEngine engine;

    QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/pathview1.qml"));

    QDeclarativePathView *obj = qobject_cast<QDeclarativePathView*>(c.create());

    QVERIFY(obj != 0);

    QVERIFY(obj->path() == 0);

    QVERIFY(obj->delegate() == 0);

    QCOMPARE(obj->model(), QVariant());

    QCOMPARE(obj->currentIndex(), 0);

    QCOMPARE(obj->offset(), 0.);

    QCOMPARE(obj->preferredHighlightBegin(), 0.);

    QCOMPARE(obj->dragMargin(), 0.);

    QCOMPARE(obj->count(), 0);

    QCOMPARE(obj->pathItemCount(), -1);

}

void tst_QDeclarativePathView::items()

{

    QDeclarativeView *canvas = createView();

    TestModel model;

    model.addItem("Fred", "12345");

    model.addItem("John", "2345");

    model.addItem("Bob", "54321");

    model.addItem("Bill", "4321");

    QDeclarativeContext *ctxt = canvas->rootContext();

    ctxt->setContextProperty("testModel", &model);

    canvas->setSource(QUrl::fromLocalFile(SRCDIR "/data/pathview0.qml"));

    qApp->processEvents();

    QDeclarativePathView *pathview = findItem<QDeclarativePathView>(canvas->rootObject(), "view");

    QVERIFY(pathview != 0);

    QCOMPARE(pathview->childItems().count(), model.count()+1); // assumes all are visible, including highlight

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

        QDeclarativeText *name = findItem<QDeclarativeText>(pathview, "textName", i);

        QVERIFY(name != 0);

        QCOMPARE(name->text(), model.name(i));

        QDeclarativeText *number = findItem<QDeclarativeText>(pathview, "textNumber", i);

        QVERIFY(number != 0);

        QCOMPARE(number->text(), model.number(i));

    }

    QDeclarativePath *path = qobject_cast<QDeclarativePath*>(pathview->path());

    QVERIFY(path);

    QVERIFY(pathview->highlightItem());

    QPointF start = path->pointAt(0.0);

    QPointF offset;

    offset.setX(pathview->highlightItem()->width()/2);

    offset.setY(pathview->highlightItem()->height()/2);

    QCOMPARE(pathview->highlightItem()->pos() + offset, start);

    delete canvas;

}

void tst_QDeclarativePathView::pathview2()

{

    QDeclarativeEngine engine;

    QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/pathview2.qml"));

    QDeclarativePathView *obj = qobject_cast<QDeclarativePathView*>(c.create());

    QVERIFY(obj != 0);

    QVERIFY(obj->path() != 0);

    QVERIFY(obj->delegate() != 0);

    QVERIFY(obj->model() != QVariant());

    QCOMPARE(obj->currentIndex(), 0);

    QCOMPARE(obj->offset(), 0.);

    QCOMPARE(obj->preferredHighlightBegin(), 0.);

    QCOMPARE(obj->dragMargin(), 0.);

    QCOMPARE(obj->count(), 8);

    QCOMPARE(obj->pathItemCount(), 10);

}

void tst_QDeclarativePathView::pathview3()

{

    QDeclarativeEngine engine;

    QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/pathview3.qml"));

    QDeclarativePathView *obj = qobject_cast<QDeclarativePathView*>(c.create());

    QVERIFY(obj != 0);

    QVERIFY(obj->path() != 0);

    QVERIFY(obj->delegate() != 0);

    QVERIFY(obj->model() != QVariant());

    QCOMPARE(obj->currentIndex(), 0);

    QCOMPARE(obj->offset(), 1.0);

    QCOMPARE(obj->preferredHighlightBegin(), 0.5);

    QCOMPARE(obj->dragMargin(), 24.);

    QCOMPARE(obj->count(), 8);

    QCOMPARE(obj->pathItemCount(), 4);

}

void tst_QDeclarativePathView::path()

{

    QDeclarativeEngine engine;

    QDeclarativeComponent c(&engine, QUrl::fromLocalFile(SRCDIR "/data/pathtest.qml"));

    QDeclarativePath *obj = qobject_cast<QDeclarativePath*>(c.create());

    QVERIFY(obj != 0);

    QCOMPARE(obj->startX(), 120.);

    QCOMPARE(obj->startY(), 100.);

    QVERIFY(obj->path() != QPainterPath());

    QDeclarativeListReference list(obj, "pathElements");

    QCOMPARE(list.count(), 5);

    QDeclarativePathAttribute* attr = qobject_cast<QDeclarativePathAttribute*>(list.at(0));

    QVERIFY(attr != 0);

    QCOMPARE(attr->name(), QString("scale"));

    QCOMPARE(attr->value(), 1.0);

    QDeclarativePathQuad* quad = qobject_cast<QDeclarativePathQuad*>(list.at(1));

    QVERIFY(quad != 0);

    QCOMPARE(quad->x(), 120.);

    QCOMPARE(quad->y(), 25.);

    QCOMPARE(quad->controlX(), 260.);

    QCOMPARE(quad->controlY(), 75.);

    QDeclarativePathPercent* perc = qobject_cast<QDeclarativePathPercent*>(list.at(2));

    QVERIFY(perc != 0);

    QCOMPARE(perc->value(), 0.3);

    QDeclarativePathLine* line = qobject_cast<QDeclarativePathLine*>(list.at(3));

    QVERIFY(line != 0);

    QCOMPARE(line->x(), 120.);

    QCOMPARE(line->y(), 100.);

    QDeclarativePathCubic* cubic = qobject_cast<QDeclarativePathCubic*>(list.at(4));

    QVERIFY(cubic != 0);

    QCOMPARE(cubic->x(), 180.);

    QCOMPARE(cubic->y(), 0.);

    QCOMPARE(cubic->control1X(), -10.);

    QCOMPARE(cubic->control1Y(), 90.);

    QCOMPARE(cubic->control2X(), 210.);

    QCOMPARE(cubic->control2Y(), 90.);

}

void tst_QDeclarativePathView::dataModel()

{

    QDeclarativeView *canvas = createView();

    QDeclarativeContext *ctxt = canvas->rootContext();

    TestObject *testObject = new TestObject;

    ctxt->setContextProperty("testObject", testObject);

    TestModel model;

    model.addItem("red", "1");

    model.addItem("green", "2");

    model.addItem("blue", "3");

    model.addItem("purple", "4");

    model.addItem("gray", "5");

    model.addItem("brown", "6");

    model.addItem("yellow", "7");

    model.addItem("thistle", "8");

    model.addItem("cyan", "9");

    ctxt->setContextProperty("testData", &model);

    canvas->setSource(QUrl::fromLocalFile(SRCDIR "/data/datamodel.qml"));

    qApp->processEvents();

    QDeclarativePathView *pathview = qobject_cast<QDeclarativePathView*>(canvas->rootObject());

    QVERIFY(pathview != 0);

    QMetaObject::invokeMethod(canvas->rootObject(), "checkProperties");

    QVERIFY(testObject->error() == false);

    QDeclarativeItem *item = findItem<QDeclarativeItem>(pathview, "wrapper", 0);

    QVERIFY(item);

    QCOMPARE(item->x(), 110.0);

    QCOMPARE(item->y(), 10.0);

    model.insertItem(4, "orange", "10");

    int itemCount = findItems<QDeclarativeItem>(pathview, "wrapper").count();

    QCOMPARE(itemCount, 10);

    QDeclarativeText *text = findItem<QDeclarativeText>(pathview, "myText", 4);

    QVERIFY(text);

    QCOMPARE(text->text(), model.name(4));

    model.removeItem(2);

    text = findItem<QDeclarativeText>(pathview, "myText", 2);

    QVERIFY(text);

    QCOMPARE(text->text(), model.name(2));

    testObject->setPathItemCount(5);

    QMetaObject::invokeMethod(canvas->rootObject(), "checkProperties");

    QVERIFY(testObject->error() == false);

    itemCount = findItems<QDeclarativeItem>(pathview, "wrapper").count();

    QCOMPARE(itemCount, 5);

    QDeclarativeRectangle *testItem = findItem<QDeclarativeRectangle>(pathview, "wrapper", 4);

    QVERIFY(testItem != 0);

    testItem = findItem<QDeclarativeRectangle>(pathview, "wrapper", 5);

    QVERIFY(testItem == 0);

    model.insertItem(2, "pink", "2");

    itemCount = findItems<QDeclarativeItem>(pathview, "wrapper").count();

    QCOMPARE(itemCount, 5);

    text = findItem<QDeclarativeText>(pathview, "myText", 2);

    QVERIFY(text);

    QCOMPARE(text->text(), model.name(2));

    model.removeItem(3);

    itemCount = findItems<QDeclarativeItem>(pathview, "wrapper").count();

    QCOMPARE(itemCount, 5);

    text = findItem<QDeclarativeText>(pathview, "myText", 3);

    QVERIFY(text);

    QCOMPARE(text->text(), model.name(3));

    delete canvas;

}

void tst_QDeclarativePathView::pathMoved()

{

    QDeclarativeView *canvas = createView();

    TestModel model;

    model.addItem("Ben", "12345");

    model.addItem("Bohn", "2345");

    model.addItem("Bob", "54321");

    model.addItem("Bill", "4321");

    QDeclarativeContext *ctxt = canvas->rootContext();

    ctxt->setContextProperty("testModel", &model);

    canvas->setSource(QUrl::fromLocalFile(SRCDIR "/data/pathview0.qml"));

    qApp->processEvents();

    QDeclarativePathView *pathview = findItem<QDeclarativePathView>(canvas->rootObject(), "view");

    QVERIFY(pathview != 0);

    QDeclarativeRectangle *firstItem = findItem<QDeclarativeRectangle>(pathview, "wrapper", 0);

    QVERIFY(firstItem);

    QDeclarativePath *path = qobject_cast<QDeclarativePath*>(pathview->path());

    QVERIFY(path);

    QPointF start = path->pointAt(0.0);

    QPointF offset;//Center of item is at point, but pos is from corner

    offset.setX(firstItem->width()/2);

    offset.setY(firstItem->height()/2);

    QCOMPARE(firstItem->pos() + offset, start);

    pathview->setOffset(1.0);

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

        QDeclarativeRectangle *curItem = findItem<QDeclarativeRectangle>(pathview, "wrapper", i);

        QPointF itemPos(path->pointAt(0.25 + i*0.25));

        QCOMPARE(curItem->pos() + offset, QPointF(qRound(itemPos.x()), qRound(itemPos.y())));

    }

    pathview->setOffset(0.0);

    QCOMPARE(firstItem->pos() + offset, start);

    delete canvas;

}

void tst_QDeclarativePathView::setCurrentIndex()

{

    QDeclarativeView *canvas = createView();

    TestModel model;

    model.addItem("Ben", "12345");

    model.addItem("Bohn", "2345");

    model.addItem("Bob", "54321");

    model.addItem("Bill", "4321");

    QDeclarativeContext *ctxt = canvas->rootContext();

    ctxt->setContextProperty("testModel", &model);

    canvas->setSource(QUrl::fromLocalFile(SRCDIR "/data/pathview0.qml"));

    qApp->processEvents();

    QDeclarativePathView *pathview = findItem<QDeclarativePathView>(canvas->rootObject(), "view");

    QVERIFY(pathview != 0);

    QDeclarativeRectangle *firstItem = findItem<QDeclarativeRectangle>(pathview, "wrapper", 0);

    QVERIFY(firstItem);

    QDeclarativePath *path = qobject_cast<QDeclarativePath*>(pathview->path());

    QVERIFY(path);

    QPointF start = path->pointAt(0.0);

    QPointF offset;//Center of item is at point, but pos is from corner

    offset.setX(firstItem->width()/2);

    offset.setY(firstItem->height()/2);

    QCOMPARE(firstItem->pos() + offset, start);

    QCOMPARE(canvas->rootObject()->property("currentA").toInt(), 0);

    QCOMPARE(canvas->rootObject()->property("currentB").toInt(), 0);

    pathview->setCurrentIndex(2);

    firstItem = findItem<QDeclarativeRectangle>(pathview, "wrapper", 2);

    QTRY_COMPARE(firstItem->pos() + offset, start);

    QCOMPARE(canvas->rootObject()->property("currentA").toInt(), 2);

    QCOMPARE(canvas->rootObject()->property("currentB").toInt(), 2);

    pathview->decrementCurrentIndex();

    QTRY_COMPARE(pathview->currentIndex(), 1);

    firstItem = findItem<QDeclarativeRectangle>(pathview, "wrapper", 1);

    QVERIFY(firstItem);

    QTRY_COMPARE(firstItem->pos() + offset, start);

    pathview->decrementCurrentIndex();

    QTRY_COMPARE(pathview->currentIndex(), 0);

    firstItem = findItem<QDeclarativeRectangle>(pathview, "wrapper", 0);

    QVERIFY(firstItem);

    QTRY_COMPARE(firstItem->pos() + offset, start);

    pathview->decrementCurrentIndex();

    QTRY_COMPARE(pathview->currentIndex(), 3);

    firstItem = findItem<QDeclarativeRectangle>(pathview, "wrapper", 3);

    QVERIFY(firstItem);

    QTRY_COMPARE(firstItem->pos() + offset, start);

    pathview->incrementCurrentIndex();

    QTRY_COMPARE(pathview->currentIndex(), 0);

    firstItem = findItem<QDeclarativeRectangle>(pathview, "wrapper", 0);

    QVERIFY(firstItem);

    QTRY_COMPARE(firstItem->pos() + offset, start);

    delete canvas;

}

void tst_QDeclarativePathView::resetModel()

{

    QDeclarativeView *canvas = createView();

    QStringList strings;

    strings << "one" << "two" << "three";

    QStringListModel model(strings);

    QDeclarativeContext *ctxt = canvas->rootContext();

    ctxt->setContextProperty("testModel", &model);

    canvas->setSource(QUrl::fromLocalFile(SRCDIR "/data/displaypath.qml"));

    qApp->processEvents();