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

**

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

#include <qgraphicsscene.h>

#include <qgraphicssceneevent.h>

#include <qgraphicsview.h>

#include <qgraphicswidget.h>

#include <qgraphicsproxywidget.h>

#include <math.h>

#include <QtGui/QLabel>

#if !defined(QT_NO_STYLE_MOTIF)

#include <QtGui/QMotifStyle>

#endif

#if !defined(QT_NO_STYLE_WINDOWS)

#include <QtGui/QWindowsStyle>

#endif

#if !defined(QT_NO_STYLE_PLASTIQUE)

#include <QtGui/QPlastiqueStyle>

#endif

#include <QtGui/QPainterPath>

#include <QtGui/QRubberBand>

#include <QtGui/QScrollBar>

#include <QtGui/QStyleOption>

#include <QtGui/QBoxLayout>

#include <QtGui/QStyle>

#include <QtGui/QPushButton>

#include <QtGui/QInputContext>

#include <private/qgraphicsview_p.h>

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

//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(QPolygonF)

Q_DECLARE_METATYPE(QRectF)

Q_DECLARE_METATYPE(Qt::ScrollBarPolicy)

#ifdef Q_WS_MAC

//On mac we 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 QCOMPARE

#endif

static void sendMousePress(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::LeftButton)

{

    QMouseEvent event(QEvent::MouseButtonPress, point, widget->mapToGlobal(point), button, 0, 0);

    QApplication::sendEvent(widget, &event);

}

static void sendMouseMove(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::NoButton, Qt::MouseButtons buttons = 0)

{

    QTest::mouseMove(widget, point);

    QMouseEvent event(QEvent::MouseMove, point, button, buttons, 0);

    QApplication::sendEvent(widget, &event);

}

static void sendMouseRelease(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::LeftButton)

{

    QMouseEvent event(QEvent::MouseButtonRelease, point, widget->mapToGlobal(point), button, 0, 0);

    QApplication::sendEvent(widget, &event);

}

class EventSpy : public QObject

{

    Q_OBJECT

public:

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

        : _count(0), spied(type)

    {

        watched->installEventFilter(this);

    }

    int count() const { return _count; }

    void reset() { _count = 0; }

protected:

    bool eventFilter(QObject *watched, QEvent *event)

    {

        Q_UNUSED(watched);

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

            ++_count;

        return false;

    }

    int _count;

    QEvent::Type spied;

};

class tst_QGraphicsView : public QObject

{

    Q_OBJECT

private slots:

    void initTestCase();

    void construction();

    void renderHints();

    void alignment();

    void interactive();

    void scene();

    void setScene();

    void deleteScene();

    void sceneRect();

    void sceneRect_growing();

    void setSceneRect();

    void viewport();

    void dragMode_scrollHand();

    void dragMode_rubberBand();

    void rubberBandSelectionMode();

    void backgroundBrush();

    void foregroundBrush();

    void matrix();

    void matrix_convenience();

    void matrix_combine();

    void centerOnPoint();

    void centerOnItem();

    void ensureVisibleRect();

    void fitInView();

    void itemsAtPoint();

    void itemsInRect();

    void itemsInRect_cosmeticAdjust_data();

    void itemsInRect_cosmeticAdjust();

    void itemsInPoly();

    void itemsInPath();

    void itemAt();

    void itemAt2();

    void mapToScene();

    void mapToScenePoint();

    void mapToSceneRect_data();

    void mapToSceneRect();

    void mapToScenePoly();

    void mapToScenePath();

    void mapFromScenePoint();

    void mapFromSceneRect();

    void mapFromScenePoly();

    void mapFromScenePath();

    void sendEvent();

    void wheelEvent();

    void cursor();

    void cursor2();

    void transformationAnchor();

    void resizeAnchor();

    void viewportUpdateMode();

    void viewportUpdateMode2();

    void acceptDrops();

    void optimizationFlags();

    void optimizationFlags_dontSavePainterState();

    void optimizationFlags_dontSavePainterState2_data();

    void optimizationFlags_dontSavePainterState2();

    void levelOfDetail_data();

    void levelOfDetail();

    void scrollBarRanges_data();

    void scrollBarRanges();

    void acceptMousePressEvent();

    void replayMouseMove();

    void itemsUnderMouse();

    void embeddedViews();

    void scrollAfterResize_data();

    void scrollAfterResize();

    void moveItemWhileScrolling_data();

    void moveItemWhileScrolling();

    void centerOnDirtyItem();

    void mouseTracking();

    void mouseTracking2();

    void mouseTracking3();

    void render();

    void exposeRegion();

    void update_data();

    void update();

    void update2_data();

    void update2();

    void update_ancestorClipsChildrenToShape();

    void update_ancestorClipsChildrenToShape2();

    void inputMethodSensitivity();

    void inputContextReset();

    void indirectPainting();

    void compositionModeInDrawBackground();

    // task specific tests below me

    void task172231_untransformableItems();

    void task180429_mouseReleaseDragMode();

    void task187791_setSceneCausesUpdate();

    void task186827_deleteReplayedItem();

    void task207546_focusCrash();

    void task210599_unsetDragWhileDragging();

    void task236394_sendShortcutOverrideEvent();

    void task239729_noViewUpdate_data();

    void task239729_noViewUpdate();

    void task239047_fitInViewSmallViewport();

    void task245469_itemsAtPointWithClip();

    void task253415_reconnectUpdateSceneOnSceneChanged();

    void task255529_transformationAnchorMouseAndViewportMargins();

    void task259503_scrollingArtifacts();

    void QTBUG_4151_clipAndIgnore_data();

    void QTBUG_4151_clipAndIgnore();

    void QTBUG_5859_exposedRect();

    void QTBUG_7438_cursor();

};

void tst_QGraphicsView::initTestCase()

{

#ifdef Q_OS_WINCE_WM

    qApp->setAutoMaximizeThreshold(-1);

#endif

}

void tst_QGraphicsView::construction()

{

    QGraphicsView view;

    QCOMPARE(view.renderHints(), QPainter::TextAntialiasing);

    QCOMPARE(view.dragMode(), QGraphicsView::NoDrag);

    QVERIFY(view.isInteractive());

    QVERIFY(!view.scene());

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

    QVERIFY(view.viewport());

    QCOMPARE(view.viewport()->metaObject()->className(), "QWidget");

    QCOMPARE(view.matrix(), QMatrix());

    QVERIFY(view.items().isEmpty());

    QVERIFY(view.items(QPoint()).isEmpty());

    QVERIFY(view.items(QRect()).isEmpty());

    QVERIFY(view.items(QPolygon()).isEmpty());

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

    QVERIFY(!view.itemAt(QPoint()));

    QCOMPARE(view.mapToScene(QPoint()), QPointF());

    QCOMPARE(view.mapToScene(QRect()), QPolygonF());

    QCOMPARE(view.mapToScene(QPolygon()), QPolygonF());

    QCOMPARE(view.mapFromScene(QPointF()), QPoint());

    QPolygon poly;

    poly << QPoint() << QPoint() << QPoint() << QPoint();

    QCOMPARE(view.mapFromScene(QRectF()), poly);

    QCOMPARE(view.mapFromScene(QPolygonF()), QPolygon());

    QCOMPARE(view.transformationAnchor(), QGraphicsView::AnchorViewCenter);

    QCOMPARE(view.resizeAnchor(), QGraphicsView::NoAnchor);

    view.show();

    QTest::qWaitForWindowShown(&view);

}

class TestItem : public QGraphicsItem

{

public:

    QRectF boundingRect() const

    { return QRectF(-10, -10, 20, 20); }

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

    { hints = painter->renderHints(); painter->drawRect(boundingRect()); }

    bool sceneEvent(QEvent *event)

    {

        events << event->type();

        return QGraphicsItem::sceneEvent(event);

    }

    QList<QEvent::Type> events;

    QPainter::RenderHints hints;

};

void tst_QGraphicsView::renderHints()

{

    QGraphicsView view;

    QCOMPARE(view.renderHints(), QPainter::TextAntialiasing);

    view.setRenderHint(QPainter::TextAntialiasing, false);

    QCOMPARE(view.renderHints(), 0);

    view.setRenderHint(QPainter::Antialiasing, false);

    QCOMPARE(view.renderHints(), 0);

    view.setRenderHint(QPainter::TextAntialiasing, true);

    QCOMPARE(view.renderHints(), QPainter::TextAntialiasing);

    view.setRenderHint(QPainter::Antialiasing);

    QCOMPARE(view.renderHints(), QPainter::TextAntialiasing | QPainter::Antialiasing);

    view.setRenderHints(0);

    QCOMPARE(view.renderHints(), 0);

    TestItem *item = new TestItem;

    QGraphicsScene scene;

    scene.addItem(item);

    view.setScene(&scene);

    view.setRenderHints(QPainter::TextAntialiasing | QPainter::Antialiasing | QPainter::NonCosmeticDefaultPen);

    QCOMPARE(view.renderHints(), QPainter::TextAntialiasing | QPainter::Antialiasing | QPainter::NonCosmeticDefaultPen);

    QCOMPARE(item->hints, 0);

    view.show();

    QTest::qWaitForWindowShown(&view);

    view.repaint();

    QTRY_COMPARE(item->hints, view.renderHints());

    view.setRenderHints(QPainter::Antialiasing | QPainter::NonCosmeticDefaultPen);

    QCOMPARE(view.renderHints(), QPainter::Antialiasing | QPainter::NonCosmeticDefaultPen);

    view.repaint();

    QTRY_COMPARE(item->hints, view.renderHints());

}

void tst_QGraphicsView::alignment()

{

    QGraphicsScene scene;

    scene.addRect(QRectF(-10, -10, 20, 20));

    QGraphicsView view(&scene);

    view.show();

    QTest::qWaitForWindowShown(&view);

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

        for (int j = 0; j < 3; ++j) {

            Qt::Alignment alignment = 0;

            switch (i) {

            case 0:

                alignment |= Qt::AlignLeft;

                break;

            case 1:

                alignment |= Qt::AlignHCenter;

                break;

            case 2:

            default:

                alignment |= Qt::AlignRight;

                break;

            }

            switch (j) {

            case 0:

                alignment |= Qt::AlignTop;

                break;

            case 1:

                alignment |= Qt::AlignVCenter;

                break;

            case 2:

            default:

                alignment |= Qt::AlignBottom;

                break;

            }

            view.setAlignment(alignment);

            QCOMPARE(view.alignment(), alignment);

            for (int k = 0; k < 3; ++k) {

                view.resize(100 + k * 25, 100 + k * 25);

                QApplication::processEvents();

            }

        }

    }

}

void tst_QGraphicsView::interactive()

{

    TestItem *item = new TestItem;

    item->setFlags(QGraphicsItem::ItemIsMovable);

    QCOMPARE(item->events.size(), 0);

    QGraphicsScene scene(-200, -200, 400, 400);

    scene.addItem(item);

    QGraphicsView view(&scene);

    view.setFixedSize(300, 300);

    QCOMPARE(item->events.size(), 0);

    view.show();

    QTest::qWaitForWindowShown(&view);

    QApplication::processEvents();

    QTRY_COMPARE(item->events.size(), 1); // activate

    QPoint itemPoint = view.mapFromScene(item->scenePos());

    QVERIFY(view.itemAt(itemPoint));

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

        sendMousePress(view.viewport(), itemPoint);

        QCOMPARE(item->events.size(), i * 5 + 3);

        QCOMPARE(item->events.at(item->events.size() - 2), QEvent::GrabMouse);

        QCOMPARE(item->events.at(item->events.size() - 1), QEvent::GraphicsSceneMousePress);

        sendMouseRelease(view.viewport(), itemPoint);

        QCOMPARE(item->events.size(), i * 5 + 5);

        QCOMPARE(item->events.at(item->events.size() - 2), QEvent::GraphicsSceneMouseRelease);

        QCOMPARE(item->events.at(item->events.size() - 1), QEvent::UngrabMouse);

        QContextMenuEvent contextEvent(QContextMenuEvent::Mouse, itemPoint, view.mapToGlobal(itemPoint));

        QApplication::sendEvent(view.viewport(), &contextEvent);

        QCOMPARE(item->events.size(), i * 5 + 6);

        QCOMPARE(item->events.last(), QEvent::GraphicsSceneContextMenu);

    }

    view.setInteractive(false);

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

        sendMousePress(view.viewport(), itemPoint);

        QCOMPARE(item->events.size(), 501);

        QCOMPARE(item->events.last(), QEvent::GraphicsSceneContextMenu);

        sendMouseRelease(view.viewport(), itemPoint);

        QCOMPARE(item->events.size(), 501);

        QCOMPARE(item->events.last(), QEvent::GraphicsSceneContextMenu);

        QContextMenuEvent contextEvent(QContextMenuEvent::Mouse, itemPoint, view.mapToGlobal(itemPoint));

        QApplication::sendEvent(view.viewport(), &contextEvent);

        QCOMPARE(item->events.size(), 501);

        QCOMPARE(item->events.last(), QEvent::GraphicsSceneContextMenu);

    }

}

void tst_QGraphicsView::scene()

{

    QGraphicsView view;

    QVERIFY(!view.scene());

    view.setScene(0);

    QVERIFY(!view.scene());

    {

        QGraphicsScene scene;

        view.setScene(&scene);

        QCOMPARE(view.scene(), &scene);

    }

    QCOMPARE(view.scene(), (QGraphicsScene *)0);

}

void tst_QGraphicsView::setScene()

{

    QGraphicsScene scene(-1000, -1000, 2000, 2000);

    QGraphicsView view(&scene);

    view.show();

    QTest::qWaitForWindowShown(&view);

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

    QVERIFY(view.horizontalScrollBar()->isVisible());

    QVERIFY(view.verticalScrollBar()->isVisible());

    QVERIFY(!view.horizontalScrollBar()->isHidden());

    QVERIFY(!view.verticalScrollBar()->isHidden());

    view.setScene(0);

    QTest::qWait(25);

    QVERIFY(!view.horizontalScrollBar()->isVisible());

    QVERIFY(!view.verticalScrollBar()->isVisible());

    QVERIFY(!view.horizontalScrollBar()->isHidden());

    QVERIFY(!view.verticalScrollBar()->isHidden());

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

}

void tst_QGraphicsView::deleteScene()

{

    QGraphicsScene *scene = new QGraphicsScene;

    QGraphicsView view1(scene);

    view1.show();

    QGraphicsView view2(scene);

    view2.show();

    QGraphicsView view3(scene);

    view3.show();

    delete scene;

    QCOMPARE(view1.scene(), (QGraphicsScene *)0);

    QCOMPARE(view2.scene(), (QGraphicsScene *)0);

    QCOMPARE(view3.scene(), (QGraphicsScene *)0);

}

void tst_QGraphicsView::sceneRect()

{

    QGraphicsView view;

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

    view.setSceneRect(QRectF(-100, -100, 200, 200));

    QCOMPARE(view.sceneRect(), QRectF(-100, -100, 200, 200));

    view.setSceneRect(-100, -100, 200, 200);

    QCOMPARE(view.sceneRect(), QRectF(-100, -100, 200, 200));

    view.setSceneRect(QRectF());

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

    QGraphicsScene scene;

    QGraphicsRectItem *item = scene.addRect(QRectF(-100, -100, 100, 100));

    view.setScene(&scene);

    QCOMPARE(view.sceneRect(), QRectF(-100, -100, 100, 100));

    item->moveBy(-100, -100);

    QCOMPARE(view.sceneRect(), QRectF(-200, -200, 200, 200));

    item->moveBy(100, 100);

    QCOMPARE(view.sceneRect(), QRectF(-200, -200, 200, 200));