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

**

** Copyright (C) 2009 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 <private/qtextcontrol_p.h>

#include <private/qgraphicsitem_p.h>

#include <private/qgraphicsview_p.h>

#include <QStyleOptionGraphicsItem>

#include <QAbstractTextDocumentLayout>

#include <QBitmap>

#include <QCursor>

#include <QLabel>

#include <QDial>

#include <QGraphicsItem>

#include <QGraphicsScene>

#include <QGraphicsSceneEvent>

#include <QGraphicsView>

#include <QGraphicsWidget>

#include <QGraphicsProxyWidget>

#include <QPainter>

#include <QScrollBar>

#include <QVBoxLayout>

#include <QGraphicsEffect>

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

//TESTED_CLASS=

//TESTED_FILES=

Q_DECLARE_METATYPE(QList<int>)

Q_DECLARE_METATYPE(QList<QRectF>)

Q_DECLARE_METATYPE(QPainterPath)

Q_DECLARE_METATYPE(QPointF)

Q_DECLARE_METATYPE(QRectF)

#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

#if defined(Q_WS_MAC) && defined(QT_MAC_USE_COCOA)

// On mac (cocoa) we always get full update.

// So check that the expected region is contained inside the actual

#define COMPARE_REGIONS(ACTUAL, EXPECTED) QVERIFY((EXPECTED).subtracted(ACTUAL).isEmpty())

#else

#define COMPARE_REGIONS QTRY_COMPARE

#endif

static void sendMousePress(QGraphicsScene *scene, const QPointF &point, Qt::MouseButton button = Qt::LeftButton)

{

    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);

    event.setScenePos(point);

    event.setButton(button);

    event.setButtons(button);

    QApplication::sendEvent(scene, &event);

}

static void sendMouseMove(QGraphicsScene *scene, const QPointF &point,

                          Qt::MouseButton button = Qt::NoButton, Qt::MouseButtons buttons = 0)

{

    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseMove);

    event.setScenePos(point);

    event.setButton(button);

    event.setButtons(button);

    QApplication::sendEvent(scene, &event);

}

static void sendMouseRelease(QGraphicsScene *scene, const QPointF &point, Qt::MouseButton button = Qt::LeftButton)

{

    QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseRelease);

    event.setScenePos(point);

    event.setButton(button);

    QApplication::sendEvent(scene, &event);

}

static void sendMouseClick(QGraphicsScene *scene, const QPointF &point, Qt::MouseButton button = Qt::LeftButton)

{

    sendMousePress(scene, point, button);

    sendMouseRelease(scene, point, button);

}

static void sendKeyPress(QGraphicsScene *scene, Qt::Key key)

{

    QKeyEvent keyEvent(QEvent::KeyPress, key, Qt::NoModifier);

    QApplication::sendEvent(scene, &keyEvent);

}

static void sendKeyRelease(QGraphicsScene *scene, Qt::Key key)

{

    QKeyEvent keyEvent(QEvent::KeyRelease, key, Qt::NoModifier);

    QApplication::sendEvent(scene, &keyEvent);

}

static void sendKeyClick(QGraphicsScene *scene, Qt::Key key)

{

    sendKeyPress(scene, key);

    sendKeyRelease(scene, key);

}

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 EventSpy2 : public QGraphicsWidget

{

    Q_OBJECT

public:

    EventSpy2(QObject *watched)

    {

        watched->installEventFilter(this);

    }

    EventSpy2(QGraphicsScene *scene, QGraphicsItem *watched)

    {

        scene->addItem(this);

        watched->installSceneEventFilter(this);

    }

    QMap<QEvent::Type, int> counts;

protected:

    bool eventFilter(QObject *watched, QEvent *event)

    {

        Q_UNUSED(watched);

        ++counts[event->type()];

        return false;

    }

    bool sceneEventFilter(QGraphicsItem *watched, QEvent *event)

    {

        Q_UNUSED(watched);

        ++counts[event->type()];

        return false;

    }

};

class EventTester : public QGraphicsItem

{

public:

    EventTester(QGraphicsItem *parent = 0) : QGraphicsItem(parent), repaints(0)

    { br = QRectF(-10, -10, 20, 20); }

    void setGeometry(const QRectF &rect)

    {

        prepareGeometryChange();

        br = rect;

        update();

    }

    QRectF boundingRect() const

    { return br; }

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

    {

        hints = painter->renderHints();

        painter->drawRect(boundingRect());

        ++repaints;

    }

    bool sceneEvent(QEvent *event)

    {

        events << event->type();

        return QGraphicsItem::sceneEvent(event);

    }

    QList<QEvent::Type> events;

    QPainter::RenderHints hints;

    int repaints;

    QRectF br;

};

class tst_QGraphicsItem : public QObject

{

    Q_OBJECT

public slots:

    void init();

private slots:

    void construction();

    void constructionWithParent();

    void destruction();

    void deleteChildItem();

    void scene();

    void parentItem();

    void setParentItem();

    void children();

    void flags();

    void inputMethodHints();

    void toolTip();

    void visible();

    void explicitlyVisible();

    void enabled();

    void explicitlyEnabled();

    void selected();

    void selected2();

    void selected_group();

    void selected_textItem();

    void selected_multi();

    void acceptedMouseButtons();

    void acceptsHoverEvents();

    void childAcceptsHoverEvents();

    void hasFocus();

    void pos();

    void scenePos();

    void matrix();

    void sceneMatrix();

    void setMatrix();

    void zValue();

    void shape();

    void contains();

    void collidesWith_item();

    void collidesWith_path_data();

    void collidesWith_path();

    void collidesWithItemWithClip();

    void isObscuredBy();

    void isObscured();

    void mapFromToParent();

    void mapFromToScene();

    void mapFromToItem();

    void mapRectFromToParent_data();

    void mapRectFromToParent();

    void isAncestorOf();

    void commonAncestorItem();

    void data();

    void type();

    void graphicsitem_cast();

    void hoverEventsGenerateRepaints();

    void boundingRects_data();

    void boundingRects();

    void boundingRects2();

    void sceneBoundingRect();

    void childrenBoundingRect();

    void childrenBoundingRectTransformed();

    void childrenBoundingRect2();

    void childrenBoundingRect3();

    void group();

    void setGroup();

    void nestedGroups();

    void warpChildrenIntoGroup();

    void removeFromGroup();

    void handlesChildEvents();

    void handlesChildEvents2();

    void handlesChildEvents3();

    void filtersChildEvents();

    void filtersChildEvents2();

    void ensureVisible();

    void cursor();

    //void textControlGetterSetter();

    void defaultItemTest_QGraphicsLineItem();

    void defaultItemTest_QGraphicsPixmapItem();

    void defaultItemTest_QGraphicsTextItem();

    void defaultItemTest_QGraphicsEllipseItem();

    void itemChange();

    void sceneEventFilter();

    void prepareGeometryChange();

    void paint();

    void deleteItemInEventHandlers();

    void itemClipsToShape();

    void itemClipsChildrenToShape();

    void itemClipsChildrenToShape2();

    void itemClipsChildrenToShape3();

    void itemClipsChildrenToShape4();

    void itemClipsTextChildToShape();

    void itemClippingDiscovery();

    void ancestorFlags();

    void untransformable();

    void contextMenuEventPropagation();

    void itemIsMovable();

    void boundingRegion_data();

    void boundingRegion();

    void itemTransform_parentChild();

    void itemTransform_siblings();

    void itemTransform_unrelated();

    void opacity_data();

    void opacity();

    void opacity2();

    void opacityZeroUpdates();

    void itemStacksBehindParent();

    void nestedClipping();

    void nestedClippingTransforms();

    void sceneTransformCache();

    void tabChangesFocus();

    void tabChangesFocus_data();

    void cacheMode();

    void updateCachedItemAfterMove();

    void deviceTransform_data();

    void deviceTransform();

    void update();

    void setTransformProperties_data();

    void setTransformProperties();

    void itemUsesExtendedStyleOption();

    void itemSendsGeometryChanges();

    void moveItem();

    void sorting_data();

    void sorting();

    void itemHasNoContents();

    void hitTestUntransformableItem();

    void hitTestGraphicsEffectItem();

    void focusProxy();

    void subFocus();

    void focusProxyDeletion();

    void negativeZStacksBehindParent();

    void setGraphicsEffect();

    void panel();

    void addPanelToActiveScene();

    void activate();

    void setActivePanelOnInactiveScene();

    void activationOnShowHide();

    void moveWhileDeleting();

    void ensureDirtySceneTransform();

    void focusScope();

    void stackBefore();

    void sceneModality();

    void panelModality();

    void mixedModality();

    void modality_hover();

    void modality_mouseGrabber();

    void modality_clickFocus();

    void modality_keyEvents();

    void itemIsInFront();

    // task specific tests below me

    void task141694_textItemEnsureVisible();

    void task128696_textItemEnsureMovable();

    void ensureUpdateOnTextItem();

    void task177918_lineItemUndetected();

    void task240400_clickOnTextItem_data();

    void task240400_clickOnTextItem();

    void task243707_addChildBeforeParent();

    void task197802_childrenVisibility();

    void QTBUG_4233_updateCachedWithSceneRect();

private:

    QList<QGraphicsItem *> paintedItems;

};

void tst_QGraphicsItem::init()

{

#ifdef Q_OS_WINCE //disable magic for WindowsCE

    qApp->setAutoMaximizeThreshold(-1);

#endif

}

void tst_QGraphicsItem::construction()

{

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

        QGraphicsItem *item;

        switch (i) {

        case 0:

            item = new QGraphicsEllipseItem;

            QCOMPARE(int(item->type()), int(QGraphicsEllipseItem::Type));

            QCOMPARE(qgraphicsitem_cast<QGraphicsEllipseItem *>(item), (QGraphicsEllipseItem *)item);

            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)0);

            QCOMPARE(item->flags(), 0);

            break;

        case 1:

            item = new QGraphicsLineItem;

            QCOMPARE(int(item->type()), int(QGraphicsLineItem::Type));

            QCOMPARE(qgraphicsitem_cast<QGraphicsLineItem *>(item), (QGraphicsLineItem *)item);

            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)0);

            QCOMPARE(item->flags(), 0);

            break;

        case 2:

            item = new QGraphicsPathItem;

            QCOMPARE(int(item->type()), int(QGraphicsPathItem::Type));

            QCOMPARE(qgraphicsitem_cast<QGraphicsPathItem *>(item), (QGraphicsPathItem *)item);

            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)0);

            QCOMPARE(item->flags(), 0);

            break;

        case 3:

            item = new QGraphicsPixmapItem;

            QCOMPARE(int(item->type()), int(QGraphicsPixmapItem::Type));

            QCOMPARE(qgraphicsitem_cast<QGraphicsPixmapItem *>(item), (QGraphicsPixmapItem *)item);

            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)0);

            QCOMPARE(item->flags(), 0);

            break;

        case 4:

            item = new QGraphicsPolygonItem;

            QCOMPARE(int(item->type()), int(QGraphicsPolygonItem::Type));

            QCOMPARE(qgraphicsitem_cast<QGraphicsPolygonItem *>(item), (QGraphicsPolygonItem *)item);

            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)0);

            QCOMPARE(item->flags(), 0);

            break;

        case 5:

            item = new QGraphicsRectItem;

            QCOMPARE(int(item->type()), int(QGraphicsRectItem::Type));

            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)item);

            QCOMPARE(qgraphicsitem_cast<QGraphicsLineItem *>(item), (QGraphicsLineItem *)0);

            QCOMPARE(item->flags(), 0);

            break;

        case 6:

            item = new QGraphicsTextItem;

            QCOMPARE(int(item->type()), int(QGraphicsTextItem::Type));

            QCOMPARE(qgraphicsitem_cast<QGraphicsTextItem *>(item), (QGraphicsTextItem *)item);

            QCOMPARE(qgraphicsitem_cast<QGraphicsRectItem *>(item), (QGraphicsRectItem *)0);

            // This is the only item that uses an extended style option.

            QCOMPARE(item->flags(), QGraphicsItem::GraphicsItemFlags(QGraphicsItem::ItemUsesExtendedStyleOption));

            break;

        default:

            qFatal("You broke the logic, please fix!");

            break;

        }

        QCOMPARE(item->scene(), (QGraphicsScene *)0);

        QCOMPARE(item->parentItem(), (QGraphicsItem *)0);

        QVERIFY(item->children().isEmpty());

        QVERIFY(item->isVisible());

        QVERIFY(item->isEnabled());

        QVERIFY(!item->isSelected());

        QCOMPARE(item->acceptedMouseButtons(), Qt::MouseButtons(0x1f));

        if (item->type() == QGraphicsTextItem::Type)

            QVERIFY(item->acceptsHoverEvents());

        else

            QVERIFY(!item->acceptsHoverEvents());

        QVERIFY(!item->hasFocus());

        QCOMPARE(item->pos(), QPointF());

        QCOMPARE(item->matrix(), QMatrix());

        QCOMPARE(item->sceneMatrix(), QMatrix());

        QCOMPARE(item->zValue(), qreal(0));

        QCOMPARE(item->sceneBoundingRect(), QRectF());

        QCOMPARE(item->shape(), QPainterPath());

        QVERIFY(!item->contains(QPointF(0, 0)));

        QVERIFY(!item->collidesWithItem(0));

        QVERIFY(item->collidesWithItem(item));

        QVERIFY(!item->collidesWithPath(QPainterPath()));

        QVERIFY(!item->isAncestorOf(0));

        QVERIFY(!item->isAncestorOf(item));

        QCOMPARE(item->data(0), QVariant());

        delete item;

    }

}

class BoundingRectItem : public QGraphicsRectItem

{

public:

    BoundingRectItem(QGraphicsItem *parent = 0)

        : QGraphicsRectItem(0, 0, parent ? 200 : 100, parent ? 200 : 100,

                            parent)

    {}

    QRectF boundingRect() const

    {

        QRectF tmp = QGraphicsRectItem::boundingRect();

        foreach (QGraphicsItem *child, children())

            tmp |= child->boundingRect(); // <- might be pure virtual

        return tmp;

    }