1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 

    45 #include <qgraphicsitem.h>

    46 #include <qgraphicsscene.h>

    47 #include <qgraphicssceneevent.h>

    48 #include <qgraphicsview.h>

    49 #include <qgraphicswidget.h>

    50 #include <qgraphicsproxywidget.h>

    51 

    52 #include <math.h>

    53 

    54 #include <QtGui/QLabel>

    55 #if !defined(QT_NO_STYLE_MOTIF)

    56 #include <QtGui/QMotifStyle>

    57 #endif

    58 #if !defined(QT_NO_STYLE_WINDOWS)

    59 #include <QtGui/QWindowsStyle>

    60 #endif

    61 #if !defined(QT_NO_STYLE_PLASTIQUE)

    62 #include <QtGui/QPlastiqueStyle>

    63 #endif

    64 #include <QtGui/QPainterPath>

    65 #include <QtGui/QRubberBand>

    66 #include <QtGui/QScrollBar>

    67 #include <QtGui/QStyleOption>

    68 #include <QtGui/QBoxLayout>

    69 #include <QtGui/QStyle>

    70 #include <QtGui/QPushButton>

    71 #include <QtGui/QInputContext>

    72 #include <private/qgraphicsview_p.h>

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

    74 

    75 //TESTED_CLASS=

    76 //TESTED_FILES=

    77 

    78 Q_DECLARE_METATYPE(QList<int>)

    79 Q_DECLARE_METATYPE(QList<QRectF>)

    80 Q_DECLARE_METATYPE(QMatrix)

    81 Q_DECLARE_METATYPE(QPainterPath)

    82 Q_DECLARE_METATYPE(QPointF)

    83 Q_DECLARE_METATYPE(QPolygonF)

    84 Q_DECLARE_METATYPE(QRectF)

    85 Q_DECLARE_METATYPE(Qt::ScrollBarPolicy)

    86 

    87 #ifdef Q_WS_MAC

    88 //On mac we get full update. So check that the expected region is contained inside the actual

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

    90 #else

    91 #define COMPARE_REGIONS QCOMPARE

    92 #endif

    93 

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

    95 {

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

    97     QApplication::sendEvent(widget, &event);

    98 }

    99 

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

   101 {

   102     QTest::mouseMove(widget, point);

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

   104     QApplication::sendEvent(widget, &event);

   105 }

   106 

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

   108 {

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

   110     QApplication::sendEvent(widget, &event);

   111 }

   112 

   113 class EventSpy : public QObject

   114 {

   115     Q_OBJECT

   116 public:

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

   118         : _count(0), spied(type)

   119     {

   120         watched->installEventFilter(this);

   121     }

   122 

   123     int count() const { return _count; }

   124     void reset() { _count = 0; }

   125 

   126 protected:

   127     bool eventFilter(QObject *watched, QEvent *event)

   128     {

   129         Q_UNUSED(watched);

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

   131             ++_count;

   132         return false;

   133     }

   134 

   135     int _count;

   136     QEvent::Type spied;

   137 };

   138 

   139 class tst_QGraphicsView : public QObject

   140 {

   141     Q_OBJECT

   142 

   143 private slots:

   144     void initTestCase();

   145     void construction();

   146     void renderHints();

   147     void alignment();

   148     void interactive();

   149     void scene();

   150     void setScene();

   151     void deleteScene();

   152     void sceneRect();

   153     void sceneRect_growing();

   154     void setSceneRect();

   155     void viewport();

   156     void dragMode_scrollHand();

   157     void dragMode_rubberBand();

   158     void rubberBandSelectionMode();

   159     void backgroundBrush();

   160     void foregroundBrush();

   161     void matrix();

   162     void matrix_convenience();

   163     void matrix_combine();

   164     void centerOnPoint();

   165     void centerOnItem();

   166     void ensureVisibleRect();

   167     void fitInView();

   168     void itemsAtPoint();

   169     void itemsInRect();

   170     void itemsInRect_cosmeticAdjust_data();

   171     void itemsInRect_cosmeticAdjust();

   172     void itemsInPoly();

   173     void itemsInPath();

   174     void itemAt();

   175     void itemAt2();

   176     void mapToScene();

   177     void mapToScenePoint();

   178     void mapToSceneRect_data();

   179     void mapToSceneRect();

   180     void mapToScenePoly();

   181     void mapToScenePath();

   182     void mapFromScenePoint();

   183     void mapFromSceneRect();

   184     void mapFromScenePoly();

   185     void mapFromScenePath();

   186     void sendEvent();

   187     void wheelEvent();

   188     void cursor();

   189     void cursor2();

   190     void transformationAnchor();

   191     void resizeAnchor();

   192     void viewportUpdateMode();

   193     void viewportUpdateMode2();

   194     void acceptDrops();

   195     void optimizationFlags();

   196     void optimizationFlags_dontSavePainterState();

   197     void levelOfDetail_data();

   198     void levelOfDetail();

   199     void scrollBarRanges_data();

   200     void scrollBarRanges();

   201     void acceptMousePressEvent();

   202     void replayMouseMove();

   203     void itemsUnderMouse();

   204     void embeddedViews();

   205     void scrollAfterResize_data();

   206     void scrollAfterResize();

   207     void moveItemWhileScrolling_data();

   208     void moveItemWhileScrolling();

   209     void centerOnDirtyItem();

   210     void mouseTracking();

   211     void mouseTracking2();

   212     void render();

   213     void exposeRegion();

   214     void update_data();

   215     void update();

   216     void inputMethodSensitivity();

   217     void inputContextReset();

   218 

   219     // task specific tests below me

   220     void task172231_untransformableItems();

   221     void task180429_mouseReleaseDragMode();

   222     void task187791_setSceneCausesUpdate();

   223     void task186827_deleteReplayedItem();

   224     void task207546_focusCrash();

   225     void task210599_unsetDragWhileDragging();

   226     void task236394_sendShortcutOverrideEvent();

   227     void task239729_noViewUpdate_data();

   228     void task239729_noViewUpdate();

   229     void task239047_fitInViewSmallViewport();

   230     void task245469_itemsAtPointWithClip();

   231     void task253415_reconnectUpdateSceneOnSceneChanged();

   232     void task255529_transformationAnchorMouseAndViewportMargins();

   233     void task259503_scrollingArtifacts();

   234     void QTBUG_4151_clipAndIgnore_data();

   235     void QTBUG_4151_clipAndIgnore();

   236 };

   237 

   238 void tst_QGraphicsView::initTestCase()

   239 {

   240 #ifdef Q_OS_WINCE_WM

   241     qApp->setAutoMaximizeThreshold(-1);

   242 #endif

   243 }

   244 

   245 void tst_QGraphicsView::construction()

   246 {

   247     QGraphicsView view;

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

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

   250     QVERIFY(view.isInteractive());

   251     QVERIFY(!view.scene());

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

   253     QVERIFY(view.viewport());

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

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

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

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

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

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

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

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

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

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

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

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

   266     QPolygon poly;

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

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

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

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

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

   272     view.show();

   273     QTest::qWaitForWindowShown(&view);

   274 }

   275 

   276 class TestItem : public QGraphicsItem

   277 {

   278 public:

   279     QRectF boundingRect() const

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

   281 

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

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

   284 

   285     bool sceneEvent(QEvent *event)

   286     {

   287         events << event->type();

   288         return QGraphicsItem::sceneEvent(event);

   289     }

   290 

   291     QList<QEvent::Type> events;

   292     QPainter::RenderHints hints;

   293 };

   294 

   295 void tst_QGraphicsView::renderHints()

   296 {

   297     QGraphicsView view;

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

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

   300     QCOMPARE(view.renderHints(), 0);

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

   302     QCOMPARE(view.renderHints(), 0);

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

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

   305     view.setRenderHint(QPainter::Antialiasing);

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

   307     view.setRenderHints(0);

   308     QCOMPARE(view.renderHints(), 0);

   309 

   310     TestItem *item = new TestItem;

   311     QGraphicsScene scene;

   312     scene.addItem(item);

   313 

   314     view.setScene(&scene);

   315 

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

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

   318 

   319     QCOMPARE(item->hints, 0);

   320     view.show();

   321     QTest::qWaitForWindowShown(&view);

   322     view.repaint();

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

   324 

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

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

   327 

   328     view.repaint();

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

   330 }

   331 

   332 void tst_QGraphicsView::alignment()

   333 {

   334     QGraphicsScene scene;

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

   336 

   337     QGraphicsView view(&scene);

   338     view.show();

   339     QTest::qWaitForWindowShown(&view);

   340 

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

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

   343             Qt::Alignment alignment = 0;

   344             switch (i) {

   345             case 0:

   346                 alignment |= Qt::AlignLeft;

   347                 break;

   348             case 1:

   349                 alignment |= Qt::AlignHCenter;

   350                 break;

   351             case 2:

   352             default:

   353                 alignment |= Qt::AlignRight;

   354                 break;

   355             }

   356             switch (j) {

   357             case 0:

   358                 alignment |= Qt::AlignTop;

   359                 break;

   360             case 1:

   361                 alignment |= Qt::AlignVCenter;

   362                 break;

   363             case 2:

   364             default:

   365                 alignment |= Qt::AlignBottom;

   366                 break;

   367             }

   368             view.setAlignment(alignment);

   369             QCOMPARE(view.alignment(), alignment);

   370 

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

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

   373                 QApplication::processEvents();

   374             }

   375         }

   376     }

   377 }

   378 

   379 void tst_QGraphicsView::interactive()

   380 {

   381     TestItem *item = new TestItem;

   382     item->setFlags(QGraphicsItem::ItemIsMovable);

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

   384 

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

   386     scene.addItem(item);

   387 

   388     QGraphicsView view(&scene);

   389     view.setFixedSize(300, 300);

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

   391     view.show();

   392     QTest::qWaitForWindowShown(&view);

   393 

   394     QApplication::processEvents();

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

   396 

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

   398 

   399     QVERIFY(view.itemAt(itemPoint));

   400 

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

   402         sendMousePress(view.viewport(), itemPoint);

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

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

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

   406         sendMouseRelease(view.viewport(), itemPoint);

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

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

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

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

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

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

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

   414     }

   415 

   416     view.setInteractive(false);

   417 

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

   419         sendMousePress(view.viewport(), itemPoint);

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

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

   422         sendMouseRelease(view.viewport(), itemPoint);

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

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

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

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

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

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

   429     }

   430 }

   431 

   432 void tst_QGraphicsView::scene()

   433 {

   434     QGraphicsView view;

   435     QVERIFY(!view.scene());

   436     view.setScene(0);

   437     QVERIFY(!view.scene());

   438 

   439     {

   440         QGraphicsScene scene;

   441         view.setScene(&scene);

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

   443     }

   444 

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

   446 }

   447 

   448 void tst_QGraphicsView::setScene()

   449 {

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

   451 

   452     QGraphicsView view(&scene);

   453     view.show();

   454     QTest::qWaitForWindowShown(&view);

   455 

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

   457 

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

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

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

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

   462 

   463     view.setScene(0);

   464 

   465     QTest::qWait(25);

   466 

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

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

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

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

   471 

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

   473 }

   474 

   475 void tst_QGraphicsView::deleteScene()

   476 {

   477     QGraphicsScene *scene = new QGraphicsScene;

   478     QGraphicsView view1(scene);

   479     view1.show();

   480     QGraphicsView view2(scene);

   481     view2.show();

   482     QGraphicsView view3(scene);

   483     view3.show();

   484     delete scene;

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

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

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

   488 }

   489 

   490 void tst_QGraphicsView::sceneRect()

   491 {

   492     QGraphicsView view;

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

   494 

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

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

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

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

   499 

   500     view.setSceneRect(QRectF());

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

   502     QGraphicsScene scene;

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

   504 

   505     view.setScene(&scene);

   506 

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

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

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

   510     item->moveBy(100, 100);

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

   512 

   513     view.setScene(0);

   514     view.setSceneRect(QRectF());

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

   516 }

   517 

   518 void tst_QGraphicsView::sceneRect_growing()

   519 {

   520     QGraphicsScene scene;

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

   522         scene.addText(QString("(0, %1)").arg((i - 50) * 20))->setPos(0, (i - 50) * 20);

   523 

   524     QGraphicsView view(&scene);

   525     view.setFixedSize(200, 200);

   526     view.show();

   527 

   528     int size = 200;

   529     scene.setSceneRect(-size, -size, size * 2, size * 2);

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

   531 

   532     QTest::qWait(25);

   533 

   534     QPointF topLeft = view.mapToScene(0, 0);

   535 

   536     for (int i = 0; i < 5; ++i) {

   537         size *= 2;

   538         scene.setSceneRect(-size, -size, size * 2, size * 2);

   539 

   540         QApplication::processEvents();

   541 

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

   543         QCOMPARE(view.mapToScene(0, 0), topLeft);

   544         view.setSceneRect(-size, -size, size * 2, size * 2);

   545         QCOMPARE(view.mapToScene(0, 0), topLeft);

   546         view.setSceneRect(QRectF());

   547     }

   548 }

   549 

   550 void tst_QGraphicsView::setSceneRect()

   551 {

   552     QRectF rect1(-100, -100, 200, 200);

   553     QRectF rect2(-300, -300, 150, 150);

   554 

   555     QGraphicsScene scene;

   556     QGraphicsView view(&scene);

   557 

   558     scene.setSceneRect(rect1);

   559     QCOMPARE(scene.sceneRect(), rect1);

   560     QCOMPARE(view.sceneRect(), rect1);

   561 

   562     scene.setSceneRect(rect2);

   563     QCOMPARE(scene.sceneRect(), rect2);

   564     QCOMPARE(view.sceneRect(), rect2);

   565 

   566     view.setSceneRect(rect1);

   567     QCOMPARE(scene.sceneRect(), rect2);

   568     QCOMPARE(view.sceneRect(), rect1);

   569 

   570     view.setSceneRect(rect2);

   571     QCOMPARE(scene.sceneRect(), rect2);

   572     QCOMPARE(view.sceneRect(), rect2);

   573 

   574     scene.setSceneRect(rect1);

   575     QCOMPARE(scene.sceneRect(), rect1);

   576     QCOMPARE(view.sceneRect(), rect2);

   577 

   578     // extreme transformations will max out the scrollbars' ranges.

   579     view.setSceneRect(-2000000, -2000000, 4000000, 4000000);

   580     view.scale(9000, 9000);

   581     QCOMPARE(view.horizontalScrollBar()->minimum(), INT_MIN);

   582     QCOMPARE(view.horizontalScrollBar()->maximum(), INT_MAX);

   583     QCOMPARE(view.verticalScrollBar()->minimum(), INT_MIN);

   584     QCOMPARE(view.verticalScrollBar()->maximum(), INT_MAX);

   585 }

   586 

   587 void tst_QGraphicsView::viewport()

   588 {

   589     QGraphicsScene scene;

   590     scene.addText("GraphicsView");

   591 

   592     QGraphicsView view(&scene);

   593     QVERIFY(view.viewport() != 0);

   594 

   595     view.show();

   596     QTest::qWait(25);

   597 

   598     QPointer<QWidget> widget = new QWidget;

   599     view.setViewport(widget);

   600     QCOMPARE(view.viewport(), (QWidget *)widget);

   601 

   602     view.show();

   603     QTest::qWait(25);

   604 

   605     view.setViewport(0);

   606     QVERIFY(widget.isNull());

   607     QVERIFY(view.viewport() != 0);

   608     QVERIFY(view.viewport() != widget);

   609 

   610     view.show();

   611     QTest::qWait(25);

   612 }

   613 

   614 void tst_QGraphicsView::dragMode_scrollHand()

   615 {

   616     for (int j = 0; j < 2; ++j) {

   617         QGraphicsView view;

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

   619 

   620         view.setSceneRect(-1000, -1000, 2000, 2000);

   621         view.setFixedSize(100, 100);

   622         view.show();

   623 

   624         QTest::qWaitForWindowShown(&view);

   625         QApplication::processEvents();

   626 

   627         view.setInteractive(j ? false : true);

   628 

   629         QGraphicsScene scene;

   630         scene.addRect(QRectF(-100, -100, 5, 5));

   631         scene.addRect(QRectF(95, -100, 5, 5));

   632         scene.addRect(QRectF(95, 95, 5, 5));

   633         QGraphicsItem *item = scene.addRect(QRectF(-100, 95, 5, 5));

   634         item->setFlag(QGraphicsItem::ItemIsSelectable);

   635         item->setSelected(true);

   636         QVERIFY(item->isSelected());

   637         QVERIFY(!view.scene());

   638 

   639         view.setDragMode(QGraphicsView::ScrollHandDrag);

   640 

   641         for (int i = 0; i < 2; ++i) {

   642             // ScrollHandDrag

   643 #ifndef QT_NO_CURSOR

   644             Qt::CursorShape cursorShape = view.viewport()->cursor().shape();

   645 #endif

   646             int horizontalScrollBarValue = view.horizontalScrollBar()->value();

   647             int verticalScrollBarValue = view.verticalScrollBar()->value();

   648             {

   649                 // Press

   650                 QMouseEvent event(QEvent::MouseButtonPress,

   651                                   view.viewport()->rect().center(),

   652                                   Qt::LeftButton, Qt::LeftButton, 0);

   653                 event.setAccepted(true);

   654                 QApplication::sendEvent(view.viewport(), &event);

   655                 QVERIFY(event.isAccepted());

   656             }

   657             QApplication::processEvents();

   658 

   659             QTRY_VERIFY(item->isSelected());

   660 

   661             for (int k = 0; k < 4; ++k) {

   662 #ifndef QT_NO_CURSOR

   663                 QCOMPARE(view.viewport()->cursor().shape(), Qt::ClosedHandCursor);

   664 #endif

   665                 {

   666                     // Move

   667                     QMouseEvent event(QEvent::MouseMove,

   668                                       view.viewport()->rect().center() + QPoint(10, 0),

   669                                       Qt::LeftButton, Qt::LeftButton, 0);

   670                     event.setAccepted(true);

   671                     QApplication::sendEvent(view.viewport(), &event);

   672                     QVERIFY(event.isAccepted());

   673                 }

   674                 QVERIFY(item->isSelected());

   675                 QCOMPARE(view.horizontalScrollBar()->value(), horizontalScrollBarValue - 10);

   676                 QCOMPARE(view.verticalScrollBar()->value(), verticalScrollBarValue);

   677                 {

   678                     // Move

   679                     QMouseEvent event(QEvent::MouseMove,

   680                                       view.viewport()->rect().center() + QPoint(10, 10),

   681                                       Qt::LeftButton, Qt::LeftButton, 0);

   682                     event.setAccepted(true);

   683                     QApplication::sendEvent(view.viewport(), &event);

   684                     QVERIFY(event.isAccepted());

   685                 }

   686                 QVERIFY(item->isSelected());

   687                 QCOMPARE(view.horizontalScrollBar()->value(), horizontalScrollBarValue - 10);

   688                 QCOMPARE(view.verticalScrollBar()->value(), verticalScrollBarValue - 10);

   689             }

   690 

   691             {

   692                 // Release

   693                 QMouseEvent event(QEvent::MouseButtonRelease,

   694                                   view.viewport()->rect().center() + QPoint(10, 10),

   695                                   Qt::LeftButton, Qt::LeftButton, 0);

   696                 event.setAccepted(true);

   697                 QApplication::sendEvent(view.viewport(), &event);

   698                 QVERIFY(event.isAccepted());

   699             }

   700             QApplication::processEvents();

   701 

   702             QTRY_VERIFY(item->isSelected());

   703             QCOMPARE(view.horizontalScrollBar()->value(), horizontalScrollBarValue - 10);

   704             QCOMPARE(view.verticalScrollBar()->value(), verticalScrollBarValue - 10);

   705 #ifndef QT_NO_CURSOR

   706             QCOMPARE(view.viewport()->cursor().shape(), cursorShape);

   707 #endif

   708 

   709             // Check that items are not unselected because of a scroll hand drag.

   710             QVERIFY(item->isSelected());

   711 

   712             // Check that a click will still unselect the item.

   713             {

   714                 // Press

   715                 QMouseEvent event(QEvent::MouseButtonPress,

   716                                   view.viewport()->rect().center() + QPoint(10, 10),

   717                                   Qt::LeftButton, Qt::LeftButton, 0);

   718                 QApplication::sendEvent(view.viewport(), &event);

   719             }

   720             {

   721                 // Release

   722                 QMouseEvent event(QEvent::MouseButtonRelease,

   723                                   view.viewport()->rect().center() + QPoint(10, 10),

   724                                   Qt::LeftButton, Qt::LeftButton, 0);

   725                 QApplication::sendEvent(view.viewport(), &event);

   726             }

   727 

   728             if (view.isInteractive()) {

   729                 if (view.scene()) {

   730                     QVERIFY(!item->isSelected());

   731                     item->setSelected(true);

   732                 } else {

   733                     QVERIFY(item->isSelected());

   734                 }

   735             } else {

   736                 QVERIFY(item->isSelected());

   737             }

   738 

   739             view.setScene(&scene);

   740         }

   741     }

   742 }

   743 

   744 void tst_QGraphicsView::dragMode_rubberBand()

   745 {

   746     QGraphicsView view;

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

   748 

   749     view.setSceneRect(-1000, -1000, 2000, 2000);

   750     view.show();

   751 

   752     QGraphicsScene scene;

   753     scene.addRect(QRectF(-100, -100, 25, 25))->setFlag(QGraphicsItem::ItemIsSelectable);

   754     scene.addRect(QRectF(75, -100, 25, 25))->setFlag(QGraphicsItem::ItemIsSelectable);

   755     scene.addRect(QRectF(75, 75, 25, 25))->setFlag(QGraphicsItem::ItemIsSelectable);

   756     scene.addRect(QRectF(-100, 75, 25, 25))->setFlag(QGraphicsItem::ItemIsSelectable);

   757 

   758     view.setDragMode(QGraphicsView::RubberBandDrag);

   759 

   760     QTest::qWaitForWindowShown(&view);

   761     QApplication::processEvents();

   762 

   763     for (int i = 0; i < 2; ++i) {

   764         // RubberBandDrag

   765 #ifndef QT_NO_CURSOR

   766         Qt::CursorShape cursorShape = view.viewport()->cursor().shape();

   767 #endif

   768         int horizontalScrollBarValue = view.horizontalScrollBar()->value();

   769         int verticalScrollBarValue = view.verticalScrollBar()->value();

   770         {

   771             // Press

   772             QMouseEvent event(QEvent::MouseButtonPress,

   773                               view.viewport()->rect().center(),

   774                               Qt::LeftButton, Qt::LeftButton, 0);

   775             event.setAccepted(true);

   776             QApplication::sendEvent(view.viewport(), &event);

   777             QVERIFY(event.isAccepted());

   778         }

   779 #ifndef QT_NO_CURSOR

   780         QCOMPARE(view.viewport()->cursor().shape(), cursorShape);

   781 #endif

   782 

   783         QApplication::processEvents();

   784 

   785         {

   786             // Move

   787             QMouseEvent event(QEvent::MouseMove,

   788                               view.viewport()->rect().center() + QPoint(100, 0),

   789                               Qt::LeftButton, Qt::LeftButton, 0);

   790             event.setAccepted(true);

   791             QApplication::sendEvent(view.viewport(), &event);

   792             QVERIFY(event.isAccepted());

   793         }

   794         QCOMPARE(view.horizontalScrollBar()->value(), horizontalScrollBarValue);

   795         QCOMPARE(view.verticalScrollBar()->value(), verticalScrollBarValue);

   796 

   797         // We don't use QRubberBand as of 4.3; the band is drawn internally.

   798         QVERIFY(!qFindChild<QRubberBand *>(&view));

   799 

   800         QTest::qWait(25);

   801 

   802         {

   803             // Move

   804             QMouseEvent event(QEvent::MouseMove,

   805                               view.viewport()->rect().center() + QPoint(100, 100),

   806                               Qt::LeftButton, Qt::LeftButton, 0);

   807             event.setAccepted(true);

   808             QApplication::sendEvent(view.viewport(), &event);

   809             QVERIFY(event.isAccepted());

   810         }

   811         QCOMPARE(view.horizontalScrollBar()->value(), horizontalScrollBarValue);

   812         QCOMPARE(view.verticalScrollBar()->value(), verticalScrollBarValue);

   813 

   814         QTest::qWait(25);

   815 

   816         {

   817             // Release

   818             QMouseEvent event(QEvent::MouseButtonRelease,

   819                               view.viewport()->rect().center() + QPoint(100, 100),

   820                               Qt::LeftButton, Qt::LeftButton, 0);

   821             event.setAccepted(true);

   822             QApplication::sendEvent(view.viewport(), &event);

   823             QVERIFY(event.isAccepted());

   824         }

   825         QCOMPARE(view.horizontalScrollBar()->value(), horizontalScrollBarValue);

   826         QCOMPARE(view.verticalScrollBar()->value(), verticalScrollBarValue);

   827 #ifndef QT_NO_CURSOR

   828         QCOMPARE(view.viewport()->cursor().shape(), cursorShape);

   829 #endif

   830 

   831         QTest::qWait(25);

   832 

   833         if (view.scene())

   834             QCOMPARE(scene.selectedItems().size(), 1);

   835 

   836         view.setScene(&scene);

   837         view.centerOn(0, 0);

   838     }

   839 }

   840 

   841 void tst_QGraphicsView::rubberBandSelectionMode()

   842 {

   843     QGraphicsScene scene;

   844     QGraphicsRectItem *rect = scene.addRect(QRectF(10, 10, 80, 80));

   845     rect->setFlag(QGraphicsItem::ItemIsSelectable);

   846 

   847     QGraphicsView view(&scene);

   848     QCOMPARE(view.rubberBandSelectionMode(), Qt::IntersectsItemShape);

   849     view.setDragMode(QGraphicsView::RubberBandDrag);

   850     view.resize(120, 120);

   851     view.show();

   852 

   853     // Disable mouse tracking to prevent the window system from sending mouse

   854     // move events to the viewport while we are synthesizing events. If

   855     // QGraphicsView gets a mouse move event with no buttons down, it'll

   856     // terminate the rubber band.

   857     view.viewport()->setMouseTracking(false);

   858 

   859     QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>());

   860     sendMousePress(view.viewport(), QPoint(), Qt::LeftButton);

   861     sendMouseMove(view.viewport(), view.viewport()->rect().center(),

   862                   Qt::LeftButton, Qt::LeftButton);

   863     QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>() << rect);

   864     sendMouseRelease(view.viewport(), QPoint(), Qt::LeftButton);

   865 

   866     view.setRubberBandSelectionMode(Qt::ContainsItemShape);

   867     QCOMPARE(view.rubberBandSelectionMode(), Qt::ContainsItemShape);

   868     sendMousePress(view.viewport(), QPoint(), Qt::LeftButton);

   869     QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>());

   870     sendMouseMove(view.viewport(), view.viewport()->rect().center(),

   871                   Qt::LeftButton, Qt::LeftButton);

   872     QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>());

   873     sendMouseMove(view.viewport(), view.viewport()->rect().bottomRight(),

   874                   Qt::LeftButton, Qt::LeftButton);

   875     QCOMPARE(scene.selectedItems(), QList<QGraphicsItem *>() << rect);

   876 }

   877 

   878 void tst_QGraphicsView::backgroundBrush()

   879 {

   880     QGraphicsScene scene;

   881     QGraphicsView view(&scene);

   882     scene.setBackgroundBrush(Qt::blue);

   883     QCOMPARE(scene.backgroundBrush(), QBrush(Qt::blue));

   884 

   885     view.show();

   886     QTest::qWait(25);

   887 

   888     scene.setBackgroundBrush(QBrush());

   889     QCOMPARE(scene.backgroundBrush(), QBrush());

   890     QTest::qWait(25);

   891 

   892     QRadialGradient gradient(0, 0, 10);

   893     gradient.setSpread(QGradient::RepeatSpread);

   894     scene.setBackgroundBrush(gradient);

   895 

   896     QCOMPARE(scene.backgroundBrush(), QBrush(gradient));

   897     QTest::qWait(25);

   898 }

   899 

   900 void tst_QGraphicsView::foregroundBrush()

   901 {

   902     QGraphicsScene scene;

   903     QGraphicsView view(&scene);

   904     scene.setForegroundBrush(Qt::blue);

   905     QCOMPARE(scene.foregroundBrush(), QBrush(Qt::blue));

   906 

   907     view.show();

   908     QTest::qWait(25);

   909 

   910     scene.setForegroundBrush(QBrush());

   911     QCOMPARE(scene.foregroundBrush(), QBrush());

   912     QTest::qWait(25);

   913 

   914     QRadialGradient gradient(0, 0, 10);

   915     gradient.setSpread(QGradient::RepeatSpread);

   916     scene.setForegroundBrush(gradient);

   917 

   918     QCOMPARE(scene.foregroundBrush(), QBrush(gradient));

   919     QTest::qWait(25);

   920 

   921     for (int i = 0; i < 50; ++i) {

   922         QRadialGradient gradient(view.rect().center() + QPoint(int(sin(i / 2.0) * 10), int(cos(i / 2.0) * 10)), 10);

   923         gradient.setColorAt(0, Qt::transparent);

   924         gradient.setColorAt(0.5, Qt::black);

   925         gradient.setColorAt(1, Qt::transparent);

   926         gradient.setSpread(QGradient::RepeatSpread);

   927         scene.setForegroundBrush(gradient);

   928 

   929         QRadialGradient gradient2(view.rect().center() + QPoint(int(sin(i / 1.7) * 10), int(cos(i / 1.7) * 10)), 10);

   930         gradient2.setColorAt(0, Qt::transparent);

   931         gradient2.setColorAt(0.5, Qt::black);

   932         gradient2.setColorAt(1, Qt::transparent);

   933         gradient2.setSpread(QGradient::RepeatSpread);

   934         scene.setBackgroundBrush(gradient2);

   935 

   936         QRadialGradient gradient3(view.rect().center() + QPoint(int(sin(i / 1.85) * 10), int(cos(i / 1.85) * 10)), 10);

   937         gradient3.setColorAt(0, Qt::transparent);

   938         gradient3.setColorAt(0.5, Qt::black);

   939         gradient3.setColorAt(1, Qt::transparent);

   940         gradient3.setSpread(QGradient::RepeatSpread);

   941         scene.setBackgroundBrush(gradient3);

   942 

   943         QApplication::processEvents();

   944     }

   945 

   946     view.setSceneRect(-1000, -1000, 2000, 2000);

   947     for (int i = -500; i < 500; i += 10) {

   948         view.centerOn(i, 0);

   949         QApplication::processEvents();

   950         QApplication::processEvents();

   951     }

   952     for (int i = -500; i < 500; i += 10) {

   953         view.centerOn(0, i);

   954         QApplication::processEvents();

   955         QApplication::processEvents();

   956     }

   957 }

   958 

   959 void tst_QGraphicsView::matrix()

   960 {

   961     {

   962         QGraphicsScene scene;

   963         QGraphicsView view(&scene);

   964         view.show();

   965 

   966         // Show rendering of background with no scene

   967         for (int i = 0; i < 50; ++i) {

   968             view.rotate(5);

   969             QRadialGradient gradient(view.rect().center() + QPoint(int(sin(i / 2.0) * 10), int(cos(i / 2.0) * 10)), 10);

   970             gradient.setColorAt(0, Qt::transparent);

   971             gradient.setColorAt(0.5, Qt::black);

   972             gradient.setColorAt(1, Qt::transparent);

   973             gradient.setSpread(QGradient::RepeatSpread);

   974             scene.setForegroundBrush(gradient);

   975             QRadialGradient gradient2(view.rect().center() + QPoint(int(sin(i / 1.7) * 10), int(cos(i / 1.7) * 10)), 10);

   976             gradient2.setColorAt(0, Qt::transparent);

   977             gradient2.setColorAt(0.5, Qt::black);

   978             gradient2.setColorAt(1, Qt::transparent);

   979             gradient2.setSpread(QGradient::RepeatSpread);

   980             scene.setBackgroundBrush(gradient2);

   981             QApplication::processEvents();

   982             QApplication::processEvents();

   983         }

   984     }

   985 

   986     // Test transformation extremes, see if they cause crashes

   987     {

   988         QGraphicsScene scene;

   989         scene.addText("GraphicsView rotated clockwise");

   990 

   991         QGraphicsView view(&scene);

   992         view.show();

   993         for (int i = 0; i < 160; ++i) {

   994             view.rotate(18);

   995             QApplication::processEvents();

   996             QApplication::processEvents();

   997         }

   998         /*

   999           // These cause a crash

  1000         for (int i = 0; i < 40; ++i) {

  1001             view.shear(1.2, 1.2);

  1002             QTest::qWait(20);

  1003         }

  1004         for (int i = 0; i < 40; ++i) {

  1005             view.shear(-1.2, -1.2);

  1006             QTest::qWait(20);

  1007         }

  1008         */

  1009         for (int i = 0; i < 20; ++i) {

  1010             view.scale(1.2, 1.2);

  1011             QApplication::processEvents();

  1012             QApplication::processEvents();

  1013         }

  1014         for (int i = 0; i < 20; ++i) {

  1015             view.scale(0.6, 0.6);

  1016             QApplication::processEvents();

  1017             QApplication::processEvents();

  1018         }

  1019     }

  1020 }

  1021 

  1022 void tst_QGraphicsView::matrix_convenience()

  1023 {

  1024     QGraphicsView view;

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

  1026 

  1027     // Check the convenience functions

  1028     view.rotate(90);

  1029     QCOMPARE(view.matrix(), QMatrix().rotate(90));

  1030     view.scale(2, 2);

  1031     QCOMPARE(view.matrix(), QMatrix().scale(2, 2) * QMatrix().rotate(90));

  1032     view.shear(1.2, 1.2);

  1033     QCOMPARE(view.matrix(), QMatrix().shear(1.2, 1.2) * QMatrix().scale(2, 2) * QMatrix().rotate(90));

  1034     view.translate(1, 1);

  1035     QCOMPARE(view.matrix(), QMatrix().translate(1, 1) * QMatrix().shear(1.2, 1.2) * QMatrix().scale(2, 2) * QMatrix().rotate(90));

  1036 }

  1037 

  1038 void tst_QGraphicsView::matrix_combine()

  1039 {

  1040     // Check matrix combining

  1041     QGraphicsView view;

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

  1043     view.setMatrix(QMatrix().rotate(90), true);

  1044     view.setMatrix(QMatrix().rotate(90), true);

  1045     view.setMatrix(QMatrix().rotate(90), true);

  1046     view.setMatrix(QMatrix().rotate(90), true);

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

  1048 

  1049     view.resetMatrix();

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

  1051     view.setMatrix(QMatrix().rotate(90), false);

  1052     view.setMatrix(QMatrix().rotate(90), false);

  1053     view.setMatrix(QMatrix().rotate(90), false);

  1054     view.setMatrix(QMatrix().rotate(90), false);

  1055     QCOMPARE(view.matrix(), QMatrix().rotate(90));

  1056 }

  1057 

  1058 void tst_QGraphicsView::centerOnPoint()

  1059 {

  1060     QGraphicsScene scene;

  1061     scene.addEllipse(QRectF(-100, -100, 50, 50));

  1062     scene.addEllipse(QRectF(50, -100, 50, 50));

  1063     scene.addEllipse(QRectF(-100, 50, 50, 50));

  1064     scene.addEllipse(QRectF(50, 50, 50, 50));

  1065 

  1066     QGraphicsView view(&scene);

  1067     view.setSceneRect(-400, -400, 800, 800);

  1068     view.setFixedSize(100, 100);

  1069     view.show();

  1070 

  1071     int tolerance = 5;

  1072 

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

  1074         for (int y = -100; y < 100; y += 23) {

  1075             for (int x = -100; x < 100; x += 23) {

  1076                 view.centerOn(x, y);

  1077                 QPoint viewCenter = view.mapToScene(view.viewport()->rect().center()).toPoint();

  1078 

  1079                 // Fuzzy compare

  1080                 if (viewCenter.x() < x - tolerance || viewCenter.x() > x + tolerance

  1081                     || viewCenter.y() < y - tolerance || viewCenter.y() > y + tolerance) {

  1082                     QString error = QString("Compared values are not the same\n\tActual: (%1, %2)\n\tExpected: (%3, %4)")

  1083                                     .arg(viewCenter.x()).arg(viewCenter.y()).arg(x).arg(y);

  1084                     QFAIL(qPrintable(error));

  1085                 }

  1086 

  1087                 QApplication::processEvents();

  1088             }

  1089         }

  1090 

  1091         view.rotate(13);

  1092         view.scale(1.5, 1.5);

  1093         view.shear(1.25, 1.25);

  1094     }

  1095 }

  1096 

  1097 void tst_QGraphicsView::centerOnItem()

  1098 {

  1099     QGraphicsScene scene;

  1100     QGraphicsItem *items[4];

  1101     items[0] = scene.addEllipse(QRectF(-25, -25, 50, 50));

  1102     items[1] = scene.addEllipse(QRectF(-25, -25, 50, 50));

  1103     items[2] = scene.addEllipse(QRectF(-25, -25, 50, 50));

  1104     items[3] = scene.addEllipse(QRectF(-25, -25, 50, 50));

  1105     items[0]->setPos(-100, -100);

  1106     items[1]->setPos(100, -100);

  1107     items[2]->setPos(-100, 100);

  1108     items[3]->setPos(100, 100);

  1109 

  1110     QGraphicsView view(&scene);

  1111     view.setSceneRect(-1000, -1000, 2000, 2000);

  1112     view.show();

  1113     QTest::qWaitForWindowShown(&view);

  1114     int tolerance = 7;

  1115 

  1116     for (int x = 0; x < 3; ++x) {

  1117         for (int i = 0; i < 4; ++i) {

  1118             QApplication::processEvents();

  1119             view.centerOn(items[i]);

  1120 

  1121             QPoint viewCenter = view.mapToScene(view.viewport()->rect().center()).toPoint();

  1122             qreal x = items[i]->pos().x();

  1123             qreal y = items[i]->pos().y();

  1124 

  1125             // Fuzzy compare

  1126             if (viewCenter.x() < x - tolerance || viewCenter.x() > x + tolerance

  1127                 || viewCenter.y() < y - tolerance || viewCenter.y() > y + tolerance) {

  1128                 QString error = QString("Compared values are not the same\n\tActual: (%1, %2)\n\tExpected: (%3, %4)")

  1129                                 .arg(viewCenter.x()).arg(viewCenter.y()).arg(x).arg(y);

  1130                 QFAIL(qPrintable(error));

  1131             }

  1132 

  1133             QApplication::processEvents();

  1134         }