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

**

** 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>

#if defined(Q_OS_WINCE)

#include <ceconfig.h>

#endif

#include <QtGui>

#include <private/qgraphicsscene_p.h>

#include <private/qgraphicssceneindex_p.h>

#include <math.h>

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

#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)

#include <windows.h>

#define Q_CHECK_PAINTEVENTS \

    if (::SwitchDesktop(::GetThreadDesktop(::GetCurrentThreadId())) == 0) \

        QSKIP("The Graphics View doesn't get the paint events", SkipSingle);

#else

#define Q_CHECK_PAINTEVENTS

#endif

#ifdef Q_OS_SYMBIAN

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

// Current path (C:\private\<UID>) contains only ascii chars

#define SRCDIR QDir::currentPath().append("\\").toAscii()

#endif

//TESTED_CLASS=

//TESTED_FILES=

Q_DECLARE_METATYPE(QList<int>)

Q_DECLARE_METATYPE(QList<QRectF>)

Q_DECLARE_METATYPE(QMatrix)

Q_DECLARE_METATYPE(QPainterPath)

Q_DECLARE_METATYPE(QPointF)

Q_DECLARE_METATYPE(QRectF)

Q_DECLARE_METATYPE(Qt::AspectRatioMode)

Q_DECLARE_METATYPE(Qt::ItemSelectionMode)

static const int randomX[] = {276, 40, 250, 864, -56, 426, 855, 825, 184, 955, -798, -804, 773,

                              282, 489, 686, 780, -220, 50, 749, -856, -205, 81, 492, -819, 518,

                              895, 57, -559, 788, -965, 68, -442, -247, -339, -648, 292, 891,

                              -865, 462, 864, 673, 640, 523, 194, 500, -727, 307, -243, 320,

                              -545, 415, 448, 341, -619, 652, 892, -16, -14, -659, -101, -934,

                              532, 356, 824, 132, 160, 130, 104, 886, -179, -174, 543, -644, 60,

                              -470, -354, -728, 689, 682, -587, -694, -221, -741, 37, 372, -289,

                              741, -300, 858, -320, 729, -602, -956, -544, -403, 203, 398, 284,

                              -972, -572, -946, 81, 51, -403, -580, 867, 546, 565, -580, -484,

                              659, 982, -518, -976, 423, -800, 659, -297, 712, 938, -19, -16,

                              824, -252, 197, 321, -837, 824, 136, 226, -980, -909, -826, -479,

                              -835, -503, -828, -901, -810, -641, -548, -179, 194, 749, -296, 539,

                              -37, -599, -235, 121, 35, -230, -915, 789, 764, -622, -382, -90, -701,

                              676, -407, 998, 267, 913, 817, -748, -370, -162, -797, 19, -556, 933,

                              -670, -101, -765, -941, -17, 360, 31, 960, 509, 933, -35, 974, -924,

                              -734, 589, 963, 724, 794, 843, 16, -272, -811, 721, 99, -122, 216,

                              -404, 158, 787, -443, -437, -337, 383, -342, 538, -641, 791, 637,

                              -848, 397, 820, 109, 11, 45, 809, 591, 933, 961, 625, -140, -592,

                              -694, -969, 317, 293, 777, -18, -282, 835, -455, -708, -407, -204,

                              748, 347, -501, -545, 292, -362, 176, 546, -573, -38, -854, -395,

                              560, -624, -940, -971, 66, -910, 782, 985};

static const int randomY[] = {603, 70, -318, 843, 450, -637, 199, -527, 407, 964, -54, 620, -207,

                              -736, -700, -476, -706, -142, 837, 621, 522, -98, 232, 292, -267, 900,

                              615, -356, -415, 783, 290, 462, -857, -314, 677, 36, 772, 424, -72,

                              -121, 547, -533, 537, -656, 289, 508, 914, 601, 434, 588, -779, -714,

                              -368, 628, -276, 432, -1, -929, 638, -36, 253, -922, -943, 979, -34,

                              -268, -193, 601, 686, -330, 165, 98, 75, -691, -605, 617, 773, 617,

                              619, 238, -42, -405, 17, 384, -472, -846, 520, 110, 591, -217, 936,

                              -373, 731, 734, 810, 961, 881, 939, 379, -905, -137, 437, 298, 688,

                              -71, -204, 573, -120, -821, 489, -722, -926, 529, -113, -243, 543,

                              868, -301, -781, -549, -842, -489, -80, -910, -928, 51, -91, 324,

                              204, -92, 867, 723, 248, 709, -357, 591, -365, -379, 266, -649, -95,

                              205, 551, 355, -631, 79, -186, 795, -7, -225, 46, -410, 665, -874,

                              -618, 845, -548, 443, 471, -644, 606, -607, 59, -619, 288, -244, 529,

                              690, 349, -738, -611, -879, -642, 801, -178, 823, -748, -552, -247,

                              -223, -408, 651, -62, 949, -795, 171, -107, -210, -207, -842, -86,

                              436, 528, 366, -178, 245, -695, 665, 613, -948, 667, -620, -979, -949,

                              905, 181, -412, -467, -437, -774, 750, -10, 54, 205, -674, -290, -924,

                              -361, -463, 912, -702, 622, -542, 220, 115, 832, 451, -38, -952, -230,

                              -588, 864, 234, 225, -303, 493, 246, 153, 338, -378, 377, -819, 140, 136,

                              467, -849, -326, -533, 166, 252, -994, -699, 904, -566, 621, -752};

class HoverItem : public QGraphicsRectItem

{

public:

    HoverItem()

        : QGraphicsRectItem(QRectF(-10, -10, 20, 20)), isHovered(false)

    { setAcceptsHoverEvents(true); }

    bool isHovered;

protected:

    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *)

    {

        isHovered = (option->state & QStyle::State_MouseOver);

        painter->setOpacity(0.75);

        painter->setPen(Qt::NoPen);

        painter->setBrush(Qt::darkGray);

        painter->drawRoundRect(boundingRect().adjusted(3, 3, -3, -3), Qt::darkGray);

        painter->setPen(Qt::black);

        if (isHovered) {

            painter->setBrush(QColor(Qt::blue).light(120));

        } else {

            painter->setBrush(Qt::gray);

        }

        painter->drawRoundRect(boundingRect().adjusted(0, 0, -5, -5));

    }

};

class EventSpy : public QGraphicsWidget

{

    Q_OBJECT

public:

    EventSpy(QObject *watched, QEvent::Type type)

        : _count(0), spied(type)

    {

        watched->installEventFilter(this);

    }

    EventSpy(QGraphicsScene *scene, QGraphicsItem *watched, QEvent::Type type)

        : _count(0), spied(type)

    {

        scene->addItem(this);

        watched->installSceneEventFilter(this);

    }

    int count() const { return _count; }

protected:

    bool eventFilter(QObject *watched, QEvent *event)

    {

        Q_UNUSED(watched);

        if (event->type() == spied)

            ++_count;

        return false;

    }

    bool sceneEventFilter(QGraphicsItem *watched, QEvent *event)

    {

        Q_UNUSED(watched);

        if (event->type() == spied)

            ++_count;

        return false;

    }

    int _count;

    QEvent::Type spied;

};

class tst_QGraphicsScene : public QObject

{

    Q_OBJECT

public slots:

    void initTestCase();

private slots:

    void construction();

    void sceneRect();

    void itemIndexMethod();

    void bspTreeDepth();

    void itemsBoundingRect_data();

    void itemsBoundingRect();

    void items();

    void items_QPointF_data();

    void items_QPointF();

    void items_QRectF();

    void items_QRectF_2_data();

    void items_QRectF_2();

    void items_QPolygonF();

    void items_QPolygonF_2();

    void items_QPainterPath();

    void items_QPainterPath_2();

    void selection();

    void selectionChanged();

    void selectionChanged2();

    void addItem();

    void addEllipse();

    void addLine();

    void addPath();

    void addPixmap();

    void addRect();

    void addText();

    void removeItem();

    void clear();

    void focusItem();

    void focusItemLostFocus();

    void setFocusItem();

    void setFocusItem_inactive();

    void mouseGrabberItem();

    void hoverEvents_siblings();

    void hoverEvents_parentChild();

    void createItemGroup();

    void mouseEventPropagation();

    void mouseEventPropagation_ignore();

    void mouseEventPropagation_focus();

    void mouseEventPropagation_doubleclick();

    void mouseEventPropagation_mouseMove();

#ifndef QT_NO_DRAGANDDROP

    void dragAndDrop_simple();

    void dragAndDrop_disabledOrInvisible();

    void dragAndDrop_propagate();

#endif

    void render_data();

    void render();

    void contextMenuEvent();

    void contextMenuEvent_ItemIgnoresTransformations();

    void update();

    void update2();

    void views();

    void event();

    void eventsToDisabledItems();

    void exposedRect();

    void tabFocus_emptyScene();

    void tabFocus_sceneWithFocusableItems();

    void tabFocus_sceneWithFocusWidgets();

    void tabFocus_sceneWithNestedFocusWidgets();

    void style();

    void sorting_data();

    void sorting();

    void changedSignal_data();

    void changedSignal();

    void stickyFocus_data();

    void stickyFocus();

    void sendEvent();

    void inputMethod_data();

    void inputMethod();

    void dispatchHoverOnPress();

    void initialFocus_data();

    void initialFocus();

    void polishItems();

    void isActive();

    void siblingIndexAlwaysValid();

    // task specific tests below me

    void task139710_bspTreeCrash();

    void task139782_containsItemBoundingRect();

    void task176178_itemIndexMethodBreaksSceneRect();

    void task160653_selectionChanged();

    void task250680_childClip();

    void taskQTBUG_5904_crashWithDeviceCoordinateCache();

    void taskQT657_paintIntoCacheWithTransparentParts();

};

void tst_QGraphicsScene::initTestCase()

{

#ifdef Q_OS_WINCE //disable magic for WindowsCE

    qApp->setAutoMaximizeThreshold(-1);

#endif

}

void tst_QGraphicsScene::construction()

{

    QGraphicsScene scene;

    QCOMPARE(scene.itemsBoundingRect(), QRectF());

    QVERIFY(scene.items().isEmpty());

    QVERIFY(scene.items(QPointF()).isEmpty());

    QVERIFY(scene.items(QRectF()).isEmpty());

    QVERIFY(scene.items(QPolygonF()).isEmpty());

    QVERIFY(scene.items(QPainterPath()).isEmpty());

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsScene::collidingItems: cannot find collisions for null item");

    QVERIFY(scene.collidingItems(0).isEmpty());

    QVERIFY(!scene.itemAt(QPointF()));

    QVERIFY(scene.selectedItems().isEmpty());

    QVERIFY(!scene.focusItem());

}

void tst_QGraphicsScene::sceneRect()

{

    QGraphicsScene scene;

    QSignalSpy sceneRectChanged(&scene, SIGNAL(sceneRectChanged(QRectF)));

    QCOMPARE(scene.sceneRect(), QRectF());

    QCOMPARE(sceneRectChanged.count(), 0);

    QGraphicsItem *item = scene.addRect(QRectF(0, 0, 10, 10));

    item->setPos(-5, -5);

    QCOMPARE(sceneRectChanged.count(), 0);

    QCOMPARE(scene.itemAt(0, 0), item);

    QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)0);

    QCOMPARE(sceneRectChanged.count(), 0);

    QCOMPARE(scene.sceneRect(), QRectF(-5, -5, 10, 10));

    QCOMPARE(sceneRectChanged.count(), 1);

    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());

    item->setPos(0, 0);

    QCOMPARE(scene.sceneRect(), QRectF(-5, -5, 15, 15));

    QCOMPARE(sceneRectChanged.count(), 2);

    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());

    scene.setSceneRect(-100, -100, 10, 10);

    QCOMPARE(sceneRectChanged.count(), 3);

    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());

    QCOMPARE(scene.itemAt(0, 0), item);

    QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)0);

    QCOMPARE(scene.sceneRect(), QRectF(-100, -100, 10, 10));

    item->setPos(10, 10);

    QCOMPARE(scene.sceneRect(), QRectF(-100, -100, 10, 10));

    QCOMPARE(sceneRectChanged.count(), 3);

    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());

    scene.setSceneRect(QRectF());

    QCOMPARE(scene.itemAt(10, 10), item);

    QCOMPARE(scene.itemAt(20, 20), (QGraphicsItem *)0);

    QCOMPARE(sceneRectChanged.count(), 4);

    QCOMPARE(scene.sceneRect(), QRectF(-5, -5, 25, 25));

    QCOMPARE(sceneRectChanged.count(), 5);

    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());

}

void tst_QGraphicsScene::itemIndexMethod()

{

    QGraphicsScene scene;

    QCOMPARE(scene.itemIndexMethod(), QGraphicsScene::BspTreeIndex);

#ifdef QT_ARCH_ARM

    const int minY = -500;

    const int maxY = 500;

    const int minX = -500;

    const int maxX = 500;

#else

    const int minY = -1000;

    const int maxY = 2000;

    const int minX = -1000;

    const int maxX = 2000;

#endif

    QList<QGraphicsItem *> items;

    for (int y = minY; y < maxY; y += 100) {

        for (int x = minX; x < maxX; x += 100) {

            QGraphicsItem *item = scene.addRect(QRectF(0, 0, 10, 10));

            item->setPos(x, y);

            QCOMPARE(scene.itemAt(x, y), item);

            items << item;

        }

    }

    int n = 0;

    for (int y = minY; y < maxY; y += 100) {

        for (int x = minX; x < maxX; x += 100)

            QCOMPARE(scene.itemAt(x, y), items.at(n++));

    }

    scene.setItemIndexMethod(QGraphicsScene::NoIndex);

    QCOMPARE(scene.itemIndexMethod(), QGraphicsScene::NoIndex);

    n = 0;

    for (int y = minY; y < maxY; y += 100) {

        for (int x = minX; x < maxX; x += 100)

            QCOMPARE(scene.itemAt(x, y), items.at(n++));

    }

    scene.setItemIndexMethod(QGraphicsScene::BspTreeIndex);

    QCOMPARE(scene.itemIndexMethod(), QGraphicsScene::BspTreeIndex);

    n = 0;

    for (int y = minY; y < maxY; y += 100) {

        for (int x = minX; x < maxX; x += 100)

            QCOMPARE(scene.itemAt(x, y), items.at(n++));

    }

}

void tst_QGraphicsScene::bspTreeDepth()

{

    QGraphicsScene scene;

    QCOMPARE(scene.itemIndexMethod(), QGraphicsScene::BspTreeIndex);

    QCOMPARE(scene.bspTreeDepth(), 0);

    scene.setBspTreeDepth(1);

    QCOMPARE(scene.bspTreeDepth(), 1);

    QTest::ignoreMessage(QtWarningMsg, "QGraphicsScene::setBspTreeDepth: invalid depth -1 ignored; must be >= 0");

    scene.setBspTreeDepth(-1);

    QCOMPARE(scene.bspTreeDepth(), 1);

}

void tst_QGraphicsScene::items()

{

#ifdef QT_ARCH_ARM

    const int minY = -500;

    const int maxY = 500;

    const int minX = -500;

    const int maxX = 500;

#else

    const int minY = -1000;

    const int maxY = 2000;

    const int minX = -1000;

    const int maxX = 2000;

#endif

    {

        QGraphicsScene scene;

        QList<QGraphicsItem *> items;

        for (int y = minY; y < maxY; y += 100) {

            for (int x = minX; x < maxX; x += 100)

                items << scene.addRect(QRectF(0, 0, 10, 10));

        }

        QCOMPARE(scene.items().size(), items.size());

        scene.itemAt(0, 0); // trigger indexing

        scene.removeItem(items.at(5));

        delete items.at(5);

        QVERIFY(!scene.items().contains(0));

        delete items.at(7);

        QVERIFY(!scene.items().contains(0));

    }

    {

        QGraphicsScene scene;

        QGraphicsLineItem *l1 = scene.addLine(-5, 0, 5, 0);

        QGraphicsLineItem *l2 = scene.addLine(0, -5, 0, 5);

        QVERIFY(!l1->sceneBoundingRect().intersects(l2->sceneBoundingRect()));

        QVERIFY(!l2->sceneBoundingRect().intersects(l1->sceneBoundingRect()));

        QList<QGraphicsItem *> items;

        items<<l1<<l2;

        QCOMPARE(scene.items().size(), items.size());

        QVERIFY(scene.items(-1, -1, 2, 2).contains(l1));

        QVERIFY(scene.items(-1, -1, 2, 2).contains(l2));

    }

}

void tst_QGraphicsScene::itemsBoundingRect_data()

{

    QTest::addColumn<QList<QRectF> >("rects");

    QTest::addColumn<QMatrix>("matrix");

    QTest::addColumn<QRectF>("boundingRect");

    QMatrix transformationMatrix;

    transformationMatrix.translate(50, -50);

    transformationMatrix.scale(2, 2);

    transformationMatrix.rotate(90);

    QTest::newRow("none")

        << QList<QRectF>()

        << QMatrix()

        << QRectF();

    QTest::newRow("{{0, 0, 10, 10}}")

        << (QList<QRectF>() << QRectF(0, 0, 10, 10))

        << QMatrix()

        << QRectF(0, 0, 10, 10);

    QTest::newRow("{{-10, -10, 10, 10}}")

        << (QList<QRectF>() << QRectF(-10, -10, 10, 10))

        << QMatrix()

        << QRectF(-10, -10, 10, 10);

    QTest::newRow("{{-1000, -1000, 1, 1}, {-10, -10, 10, 10}}")

        << (QList<QRectF>() << QRectF(-1000, -1000, 1, 1) << QRectF(-10, -10, 10, 10))

        << QMatrix()

        << QRectF(-1000, -1000, 1000, 1000);

    QTest::newRow("transformed {{0, 0, 10, 10}}")

        << (QList<QRectF>() << QRectF(0, 0, 10, 10))

        << transformationMatrix

        << QRectF(30, -50, 20, 20);

    QTest::newRow("transformed {{-10, -10, 10, 10}}")

        << (QList<QRectF>() << QRectF(-10, -10, 10, 10))

        << transformationMatrix

        << QRectF(50, -70, 20, 20);

    QTest::newRow("transformed {{-1000, -1000, 1, 1}, {-10, -10, 10, 10}}")

        << (QList<QRectF>() << QRectF(-1000, -1000, 1, 1) << QRectF(-10, -10, 10, 10))

        << transformationMatrix

        << QRectF(50, -2050, 2000, 2000);

    QList<QRectF> all;

    for (int i = 0; i < 256; ++i)

        all << QRectF(randomX[i], randomY[i], 10, 10);

    QTest::newRow("all")

        << all

        << QMatrix()

        << QRectF(-980, -994, 1988, 1983);

    QTest::newRow("transformed all")

        << all

        << transformationMatrix

        << QRectF(-1928, -2010, 3966, 3976);

}

void tst_QGraphicsScene::itemsBoundingRect()

{

    QFETCH(QList<QRectF>, rects);

    QFETCH(QMatrix, matrix);

    QFETCH(QRectF, boundingRect);

    QGraphicsScene scene;

    foreach (QRectF rect, rects) {

        QPainterPath path;

        path.addRect(rect);