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

**

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

#include <QtTest/QSignalSpy>

#include <QtDeclarative/qdeclarativeengine.h>

#include <QtDeclarative/qdeclarativecomponent.h>

#include <QtDeclarative/qdeclarativecontext.h>

#include <QtDeclarative/qdeclarativeview.h>

#include <private/qdeclarativerectangle_p.h>

#include <private/qdeclarativeitem_p.h>

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

#ifdef Q_OS_SYMBIAN

// In Symbian OS test data is located in applications private dir

#define SRCDIR "."

#endif

class tst_QDeclarativeItem : public QObject

{

    Q_OBJECT

public:

    tst_QDeclarativeItem();

private slots:

    void initTestCase();

    void keys();

    void keysProcessingOrder();

    void keyNavigation();

    void smooth();

    void clip();

    void mapCoordinates();

    void mapCoordinates_data();

    void propertyChanges();

    void transforms();

    void transforms_data();

    void childrenRect();

    void childrenRectBug();

    void childrenRectBug2();

    void childrenProperty();

    void resourcesProperty();

    void mouseFocus();

private:

    template<typename T>

    T *findItem(QGraphicsObject *parent, const QString &objectName);

    QDeclarativeEngine engine;

};

class KeysTestObject : public QObject

{

    Q_OBJECT

    Q_PROPERTY(bool processLast READ processLast NOTIFY processLastChanged)

public:

    KeysTestObject() : mKey(0), mModifiers(0), mForwardedKey(0), mLast(false) {}

    void reset() {

        mKey = 0;

        mText = QString();

        mModifiers = 0;

        mForwardedKey = 0;

    }

    bool processLast() const { return mLast; }

    void setProcessLast(bool b) {

        if (b != mLast) {

            mLast = b;

            emit processLastChanged();

        }

    }

public slots:

    void keyPress(int key, QString text, int modifiers) {

        mKey = key;

        mText = text;

        mModifiers = modifiers;

    }

    void keyRelease(int key, QString text, int modifiers) {

        mKey = key;

        mText = text;

        mModifiers = modifiers;

    }

    void forwardedKey(int key) {

        mForwardedKey = key;

    }

signals:

    void processLastChanged();

public:

    int mKey;

    QString mText;

    int mModifiers;

    int mForwardedKey;

    bool mLast;

private:

};

class KeyTestItem : public QDeclarativeItem

{

    Q_OBJECT

public:

    KeyTestItem(QDeclarativeItem *parent=0) : QDeclarativeItem(parent), mKey(0) {}

protected:

    void keyPressEvent(QKeyEvent *e) {

        keyPressPreHandler(e);

        if (e->isAccepted())

            return;

        mKey = e->key();

        if (e->key() == Qt::Key_A)

            e->accept();

        else

            e->ignore();

        if (!e->isAccepted())

            QDeclarativeItem::keyPressEvent(e);

    }

    void keyReleaseEvent(QKeyEvent *e) {

        keyReleasePreHandler(e);

        if (e->isAccepted())

            return;

        if (e->key() == Qt::Key_B)

            e->accept();

        else

            e->ignore();

        if (!e->isAccepted())

            QDeclarativeItem::keyReleaseEvent(e);

    }

public:

    int mKey;

};

QML_DECLARE_TYPE(KeyTestItem);

tst_QDeclarativeItem::tst_QDeclarativeItem()

{

}

void tst_QDeclarativeItem::initTestCase()

{

    qmlRegisterType<KeyTestItem>("Test",1,0,"KeyTestItem");

}

void tst_QDeclarativeItem::keys()

{

    QDeclarativeView *canvas = new QDeclarativeView(0);

    canvas->setFixedSize(240,320);

    KeysTestObject *testObject = new KeysTestObject;

    canvas->rootContext()->setContextProperty("keysTestObject", testObject);

    canvas->rootContext()->setContextProperty("enableKeyHanding", QVariant(true));

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

    canvas->show();

    qApp->processEvents();

    QEvent wa(QEvent::WindowActivate);

    QApplication::sendEvent(canvas, &wa);

    QFocusEvent fe(QEvent::FocusIn);

    QApplication::sendEvent(canvas, &fe);

    QKeyEvent key(QEvent::KeyPress, Qt::Key_A, Qt::NoModifier, "A", false, 1);

    QApplication::sendEvent(canvas, &key);

    QCOMPARE(testObject->mKey, int(Qt::Key_A));

    QCOMPARE(testObject->mForwardedKey, int(Qt::Key_A));

    QCOMPARE(testObject->mText, QLatin1String("A"));

    QVERIFY(testObject->mModifiers == Qt::NoModifier);

    QVERIFY(!key.isAccepted());

    testObject->reset();

    key = QKeyEvent(QEvent::KeyRelease, Qt::Key_A, Qt::ShiftModifier, "A", false, 1);

    QApplication::sendEvent(canvas, &key);

    QCOMPARE(testObject->mKey, int(Qt::Key_A));

    QCOMPARE(testObject->mForwardedKey, int(Qt::Key_A));

    QCOMPARE(testObject->mText, QLatin1String("A"));

    QVERIFY(testObject->mModifiers == Qt::ShiftModifier);

    QVERIFY(key.isAccepted());

    testObject->reset();

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::NoModifier, "", false, 1);

    QApplication::sendEvent(canvas, &key);

    QCOMPARE(testObject->mKey, int(Qt::Key_Return));

    QCOMPARE(testObject->mForwardedKey, int(Qt::Key_Return));

    QCOMPARE(testObject->mText, QLatin1String("Return"));

    QVERIFY(testObject->mModifiers == Qt::NoModifier);

    QVERIFY(key.isAccepted());

    testObject->reset();

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_0, Qt::NoModifier, "0", false, 1);

    QApplication::sendEvent(canvas, &key);

    QCOMPARE(testObject->mKey, int(Qt::Key_0));

    QCOMPARE(testObject->mForwardedKey, int(Qt::Key_0));

    QCOMPARE(testObject->mText, QLatin1String("0"));

    QVERIFY(testObject->mModifiers == Qt::NoModifier);

    QVERIFY(key.isAccepted());

    testObject->reset();

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_9, Qt::NoModifier, "9", false, 1);

    QApplication::sendEvent(canvas, &key);

    QCOMPARE(testObject->mKey, int(Qt::Key_9));

    QCOMPARE(testObject->mForwardedKey, int(Qt::Key_9));

    QCOMPARE(testObject->mText, QLatin1String("9"));

    QVERIFY(testObject->mModifiers == Qt::NoModifier);

    QVERIFY(!key.isAccepted());

    testObject->reset();

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier, "", false, 1);

    QApplication::sendEvent(canvas, &key);

    QCOMPARE(testObject->mKey, int(Qt::Key_Tab));

    QCOMPARE(testObject->mForwardedKey, int(Qt::Key_Tab));

    QCOMPARE(testObject->mText, QLatin1String("Tab"));

    QVERIFY(testObject->mModifiers == Qt::NoModifier);

    QVERIFY(key.isAccepted());

    testObject->reset();

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_Backtab, Qt::NoModifier, "", false, 1);

    QApplication::sendEvent(canvas, &key);

    QCOMPARE(testObject->mKey, int(Qt::Key_Backtab));

    QCOMPARE(testObject->mForwardedKey, int(Qt::Key_Backtab));

    QCOMPARE(testObject->mText, QLatin1String("Backtab"));

    QVERIFY(testObject->mModifiers == Qt::NoModifier);

    QVERIFY(key.isAccepted());

    testObject->reset();

    canvas->rootContext()->setContextProperty("enableKeyHanding", QVariant(false));

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::NoModifier, "", false, 1);

    QApplication::sendEvent(canvas, &key);

    QCOMPARE(testObject->mKey, 0);

    QVERIFY(!key.isAccepted());

    canvas->rootContext()->setContextProperty("enableKeyHanding", QVariant(true));

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::NoModifier, "", false, 1);

    QApplication::sendEvent(canvas, &key);

    QCOMPARE(testObject->mKey, int(Qt::Key_Return));

    QVERIFY(key.isAccepted());

    delete canvas;

    delete testObject;

}

void tst_QDeclarativeItem::keysProcessingOrder()

{

    QDeclarativeView *canvas = new QDeclarativeView(0);

    canvas->setFixedSize(240,320);

    KeysTestObject *testObject = new KeysTestObject;

    canvas->rootContext()->setContextProperty("keysTestObject", testObject);

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

    canvas->show();

    qApp->processEvents();

    KeyTestItem *testItem = qobject_cast<KeyTestItem*>(canvas->rootObject());

    QVERIFY(testItem);

    QEvent wa(QEvent::WindowActivate);

    QApplication::sendEvent(canvas, &wa);

    QFocusEvent fe(QEvent::FocusIn);

    QApplication::sendEvent(canvas, &fe);

    QKeyEvent key(QEvent::KeyPress, Qt::Key_A, Qt::NoModifier, "A", false, 1);

    QApplication::sendEvent(canvas, &key);

    QCOMPARE(testObject->mKey, int(Qt::Key_A));

    QCOMPARE(testObject->mText, QLatin1String("A"));

    QVERIFY(testObject->mModifiers == Qt::NoModifier);

    QVERIFY(key.isAccepted());

    testObject->reset();

    testObject->setProcessLast(true);

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_A, Qt::NoModifier, "A", false, 1);

    QApplication::sendEvent(canvas, &key);

    QCOMPARE(testObject->mKey, 0);

    QVERIFY(key.isAccepted());

    testObject->reset();

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_B, Qt::NoModifier, "B", false, 1);

    QApplication::sendEvent(canvas, &key);

    QCOMPARE(testObject->mKey, int(Qt::Key_B));

    QCOMPARE(testObject->mText, QLatin1String("B"));

    QVERIFY(testObject->mModifiers == Qt::NoModifier);

    QVERIFY(!key.isAccepted());

    testObject->reset();

    key = QKeyEvent(QEvent::KeyRelease, Qt::Key_B, Qt::NoModifier, "B", false, 1);

    QApplication::sendEvent(canvas, &key);

    QCOMPARE(testObject->mKey, 0);

    QVERIFY(key.isAccepted());

    delete canvas;

    delete testObject;

}

void tst_QDeclarativeItem::keyNavigation()

{

    QDeclarativeView *canvas = new QDeclarativeView(0);

    canvas->setFixedSize(240,320);

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

    canvas->show();

    qApp->processEvents();

    QEvent wa(QEvent::WindowActivate);

    QApplication::sendEvent(canvas, &wa);

    QFocusEvent fe(QEvent::FocusIn);

    QApplication::sendEvent(canvas, &fe);

    QDeclarativeItem *item = findItem<QDeclarativeItem>(canvas->rootObject(), "item1");

    QVERIFY(item);

    QVERIFY(item->hasActiveFocus());

    // right

    QKeyEvent key(QEvent::KeyPress, Qt::Key_Right, Qt::NoModifier, "", false, 1);

    QApplication::sendEvent(canvas, &key);

    QVERIFY(key.isAccepted());

    item = findItem<QDeclarativeItem>(canvas->rootObject(), "item2");

    QVERIFY(item);

    QVERIFY(item->hasActiveFocus());

    // down

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_Down, Qt::NoModifier, "", false, 1);

    QApplication::sendEvent(canvas, &key);

    QVERIFY(key.isAccepted());

    item = findItem<QDeclarativeItem>(canvas->rootObject(), "item4");

    QVERIFY(item);

    QVERIFY(item->hasActiveFocus());

    // left

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_Left, Qt::NoModifier, "", false, 1);

    QApplication::sendEvent(canvas, &key);

    QVERIFY(key.isAccepted());

    item = findItem<QDeclarativeItem>(canvas->rootObject(), "item3");

    QVERIFY(item);

    QVERIFY(item->hasActiveFocus());

    // up

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_Up, Qt::NoModifier, "", false, 1);

    QApplication::sendEvent(canvas, &key);

    QVERIFY(key.isAccepted());

    item = findItem<QDeclarativeItem>(canvas->rootObject(), "item1");

    QVERIFY(item);

    QVERIFY(item->hasActiveFocus());

    // tab

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier, "", false, 1);

    QApplication::sendEvent(canvas, &key);

    QVERIFY(key.isAccepted());

    item = findItem<QDeclarativeItem>(canvas->rootObject(), "item2");

    QVERIFY(item);

    QVERIFY(item->hasActiveFocus());

    // backtab

    key = QKeyEvent(QEvent::KeyPress, Qt::Key_Backtab, Qt::NoModifier, "", false, 1);

    QApplication::sendEvent(canvas, &key);

    QVERIFY(key.isAccepted());

    item = findItem<QDeclarativeItem>(canvas->rootObject(), "item1");

    QVERIFY(item);

    QVERIFY(item->hasActiveFocus());

    delete canvas;

}

void tst_QDeclarativeItem::smooth()

{

    QDeclarativeComponent component(&engine);

    component.setData("import Qt 4.7; Item { smooth: false; }", QUrl::fromLocalFile(""));

    QDeclarativeItem *item = qobject_cast<QDeclarativeItem*>(component.create());

    QSignalSpy spy(item, SIGNAL(smoothChanged(bool)));

    QVERIFY(item);

    QVERIFY(!item->smooth());

    item->setSmooth(true);

    QVERIFY(item->smooth());

    QCOMPARE(spy.count(),1);

    QList<QVariant> arguments = spy.first();

    QVERIFY(arguments.count() == 1);

    QVERIFY(arguments.at(0).toBool() == true);

    item->setSmooth(true);

    QCOMPARE(spy.count(),1);

    item->setSmooth(false);

    QVERIFY(!item->smooth());

    QCOMPARE(spy.count(),2);

    item->setSmooth(false);

    QCOMPARE(spy.count(),2);

    delete item;

}

void tst_QDeclarativeItem::clip()

{

    QDeclarativeComponent component(&engine);

    component.setData("import Qt 4.7\nItem { clip: false\n }", QUrl::fromLocalFile(""));

    QDeclarativeItem *item = qobject_cast<QDeclarativeItem*>(component.create());

    QSignalSpy spy(item, SIGNAL(clipChanged(bool)));

    QVERIFY(item);

    QVERIFY(!item->clip());

    item->setClip(true);

    QVERIFY(item->clip());

    QList<QVariant> arguments = spy.first();

    QVERIFY(arguments.count() == 1);

    QVERIFY(arguments.at(0).toBool() == true);

    QCOMPARE(spy.count(),1);

    item->setClip(true);

    QCOMPARE(spy.count(),1);

    item->setClip(false);

    QVERIFY(!item->clip());

    QCOMPARE(spy.count(),2);

    item->setClip(false);

    QCOMPARE(spy.count(),2);

    delete item;

}

void tst_QDeclarativeItem::mapCoordinates()

{

    QFETCH(int, x);

    QFETCH(int, y);

    QDeclarativeView *canvas = new QDeclarativeView(0);

    canvas->setFixedSize(300, 300);

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

    canvas->show();

    qApp->processEvents();

    QDeclarativeItem *root = qobject_cast<QDeclarativeItem*>(canvas->rootObject());

    QVERIFY(root != 0);

    QDeclarativeItem *a = findItem<QDeclarativeItem>(canvas->rootObject(), "itemA");

    QVERIFY(a != 0);

    QDeclarativeItem *b = findItem<QDeclarativeItem>(canvas->rootObject(), "itemB");

    QVERIFY(b != 0);

    QVariant result;

    QVERIFY(QMetaObject::invokeMethod(root, "mapAToB",

            Q_RETURN_ARG(QVariant, result), Q_ARG(QVariant, x), Q_ARG(QVariant, y)));

    QCOMPARE(result.value<QPointF>(), qobject_cast<QGraphicsItem*>(a)->mapToItem(b, x, y));

    QVERIFY(QMetaObject::invokeMethod(root, "mapAFromB",

            Q_RETURN_ARG(QVariant, result), Q_ARG(QVariant, x), Q_ARG(QVariant, y)));

    QCOMPARE(result.value<QPointF>(), qobject_cast<QGraphicsItem*>(a)->mapFromItem(b, x, y));

    QVERIFY(QMetaObject::invokeMethod(root, "mapAToNull",

            Q_RETURN_ARG(QVariant, result), Q_ARG(QVariant, x), Q_ARG(QVariant, y)));

    QCOMPARE(result.value<QPointF>(), qobject_cast<QGraphicsItem*>(a)->mapToScene(x, y));

    QVERIFY(QMetaObject::invokeMethod(root, "mapAFromNull",

            Q_RETURN_ARG(QVariant, result), Q_ARG(QVariant, x), Q_ARG(QVariant, y)));

    QCOMPARE(result.value<QPointF>(), qobject_cast<QGraphicsItem*>(a)->mapFromScene(x, y));