tests/auto/widgets/graphicsview/qgraphicssceneindex/tst_qgraphicssceneindex.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2011 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 ** GNU Lesser General Public License Usage
  11 ** This file may be used under the terms of the GNU Lesser General Public
  12 ** License version 2.1 as published by the Free Software Foundation and
  13 ** appearing in the file LICENSE.LGPL included in the packaging of this
  14 ** file. Please review the following information to ensure the GNU Lesser
  15 ** General Public License version 2.1 requirements will be met:
  16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  17 **
  18 ** In addition, as a special exception, Nokia gives you certain additional
  19 ** rights. These rights are described in the Nokia Qt LGPL Exception
  20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  21 **
  22 ** GNU General Public License Usage
  23 ** Alternatively, this file may be used under the terms of the GNU General
  24 ** Public License version 3.0 as published by the Free Software Foundation
  25 ** and appearing in the file LICENSE.GPL included in the packaging of this
  26 ** file. Please review the following information to ensure the GNU General
  27 ** Public License version 3.0 requirements will be met:
  28 ** http://www.gnu.org/copyleft/gpl.html.
  29 **
  30 ** Other Usage
  31 ** Alternatively, this file may be used in accordance with the terms and
  32 ** conditions contained in a signed written agreement between you and Nokia.
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42
  43 #include <QtTest/QtTest>
  44 #include <QtWidgets/qgraphicsscene.h>
  45 #include <private/qgraphicsscenebsptreeindex_p.h>
  46 #include <private/qgraphicssceneindex_p.h>
  47 #include <private/qgraphicsscenelinearindex_p.h>
  48
  49 //TESTED_CLASS=
  50 //TESTED_FILES=
  51
  52 class tst_QGraphicsSceneIndex : public QObject
  53 {
  54     Q_OBJECT
  55 public slots:
  56     void initTestCase();
  57
  58 private slots:
  59     void scatteredItems_data();
  60     void scatteredItems();
  61     void overlappedItems_data();
  62     void overlappedItems();
  63     void movingItems_data();
  64     void movingItems();
  65     void connectedToSceneRectChanged();
  66     void items();
  67     void removeItems();
  68     void clear();
  69
  70 private:
  71     void common_data();
  72     QGraphicsSceneIndex *createIndex(const QString &name);
  73 };
  74
  75 void tst_QGraphicsSceneIndex::initTestCase()
  76 {
  77 }
  78
  79 void tst_QGraphicsSceneIndex::common_data()
  80 {
  81     QTest::addColumn<QString>("indexMethod");
  82
  83     QTest::newRow("BSP") << QString("bsp");
  84     QTest::newRow("Linear") << QString("linear");
  85 }
  86
  87 QGraphicsSceneIndex *tst_QGraphicsSceneIndex::createIndex(const QString &indexMethod)
  88 {
  89     QGraphicsSceneIndex *index = 0;
  90     QGraphicsScene *scene = new QGraphicsScene();
  91     if (indexMethod == "bsp")
  92         index = new QGraphicsSceneBspTreeIndex(scene);
  93
  94     if (indexMethod == "linear")
  95         index = new QGraphicsSceneLinearIndex(scene);
  96
  97     return index;
  98 }
  99
 100 void tst_QGraphicsSceneIndex::scatteredItems_data()
 101 {
 102     common_data();
 103 }
 104
 105 void tst_QGraphicsSceneIndex::scatteredItems()
 106 {
 107     QFETCH(QString, indexMethod);
 108
 109     QGraphicsScene scene;
 110     scene.setItemIndexMethod(indexMethod == "linear" ? QGraphicsScene::NoIndex : QGraphicsScene::BspTreeIndex);
 111
 112     for (int i = 0; i < 10; ++i)
 113         scene.addRect(i*50, i*50, 40, 35);
 114
 115     QCOMPARE(scene.items(QPointF(5, 5)).count(), 1);
 116     QCOMPARE(scene.items(QPointF(55, 55)).count(), 1);
 117     QCOMPARE(scene.items(QPointF(-100, -100)).count(), 0);
 118
 119     QCOMPARE(scene.items(QRectF(0, 0, 10, 10)).count(), 1);
 120     QCOMPARE(scene.items(QRectF(0, 0, 1000, 1000)).count(), 10);
 121     QCOMPARE(scene.items(QRectF(-100, -1000, 0, 0)).count(), 0);
 122 }
 123
 124 void tst_QGraphicsSceneIndex::overlappedItems_data()
 125 {
 126     common_data();
 127 }
 128
 129 void tst_QGraphicsSceneIndex::overlappedItems()
 130 {
 131     QFETCH(QString, indexMethod);
 132
 133     QGraphicsScene scene;
 134     scene.setItemIndexMethod(indexMethod == "linear" ? QGraphicsScene::NoIndex : QGraphicsScene::BspTreeIndex);
 135
 136     for (int i = 0; i < 10; ++i)
 137         for (int j = 0; j < 10; ++j)
 138             scene.addRect(i*50, j*50, 200, 200);
 139
 140     QCOMPARE(scene.items(QPointF(5, 5)).count(), 1);
 141     QCOMPARE(scene.items(QPointF(55, 55)).count(), 4);
 142     QCOMPARE(scene.items(QPointF(105, 105)).count(), 9);
 143     QCOMPARE(scene.items(QPointF(-100, -100)).count(), 0);
 144
 145     QCOMPARE(scene.items(QRectF(0, 0, 1000, 1000)).count(), 100);
 146     QCOMPARE(scene.items(QRectF(-100, -1000, 0, 0)).count(), 0);
 147     QCOMPARE(scene.items(QRectF(0, 0, 200, 200)).count(), 16);
 148     QCOMPARE(scene.items(QRectF(0, 0, 100, 100)).count(), 4);
 149     QCOMPARE(scene.items(QRectF(0, 0, 1, 100)).count(), 2);
 150     QCOMPARE(scene.items(QRectF(0, 0, 1, 1000)).count(), 10);
 151 }
 152
 153 void tst_QGraphicsSceneIndex::movingItems_data()
 154 {
 155     common_data();
 156 }
 157
 158 void tst_QGraphicsSceneIndex::movingItems()
 159 {
 160     QFETCH(QString, indexMethod);
 161
 162     QGraphicsScene scene;
 163     scene.setItemIndexMethod(indexMethod == "linear" ? QGraphicsScene::NoIndex : QGraphicsScene::BspTreeIndex);
 164
 165     for (int i = 0; i < 10; ++i)
 166         scene.addRect(i*50, i*50, 40, 35);
 167
 168     QGraphicsRectItem *box = scene.addRect(0, 0, 10, 10);
 169     QCOMPARE(scene.items(QPointF(5, 5)).count(), 2);
 170     QCOMPARE(scene.items(QPointF(-1, -1)).count(), 0);
 171     QCOMPARE(scene.items(QRectF(0, 0, 5, 5)).count(), 2);
 172
 173     box->setPos(10, 10);
 174     QCOMPARE(scene.items(QPointF(9, 9)).count(), 1);
 175     QCOMPARE(scene.items(QPointF(15, 15)).count(), 2);
 176     QCOMPARE(scene.items(QRectF(0, 0, 1, 1)).count(), 1);
 177
 178     box->setPos(-5, -5);
 179     QCOMPARE(scene.items(QPointF(-1, -1)).count(), 1);
 180     QCOMPARE(scene.items(QRectF(0, 0, 1, 1)).count(), 2);
 181
 182     QCOMPARE(scene.items(QRectF(0, 0, 1000, 1000)).count(), 11);
 183 }
 184
 185 void tst_QGraphicsSceneIndex::connectedToSceneRectChanged()
 186 {
 187
 188     class MyScene : public QGraphicsScene
 189     {
 190     public:
 191         using QGraphicsScene::receivers;
 192     };
 193
 194     MyScene scene; // Uses QGraphicsSceneBspTreeIndex by default.
 195     QCOMPARE(scene.receivers(SIGNAL(sceneRectChanged(const QRectF&))), 1);
 196
 197     scene.setItemIndexMethod(QGraphicsScene::NoIndex); // QGraphicsSceneLinearIndex
 198     QCOMPARE(scene.receivers(SIGNAL(sceneRectChanged(const QRectF&))), 1);
 199 }
 200
 201 void tst_QGraphicsSceneIndex::items()
 202 {
 203     QGraphicsScene scene;
 204     QGraphicsItem *item1 = scene.addRect(0, 0, 10, 10);
 205     QGraphicsItem *item2 = scene.addRect(10, 10, 10, 10);
 206     QCOMPARE(scene.items().size(), 2);
 207
 208     // Move from unindexed items into bsp tree.
 209     QTest::qWait(50);
 210     QCOMPARE(scene.items().size(), 2);
 211
 212     // Add untransformable item.
 213     QGraphicsItem *item3 = new QGraphicsRectItem(QRectF(20, 20, 10, 10));
 214     item3->setFlag(QGraphicsItem::ItemIgnoresTransformations);
 215     scene.addItem(item3);
 216     QCOMPARE(scene.items().size(), 3);
 217
 218     // Move from unindexed items into untransformable items.
 219     QTest::qWait(50);
 220     QCOMPARE(scene.items().size(), 3);
 221
 222     // Move from untransformable items into unindexed items.
 223     item3->setFlag(QGraphicsItem::ItemIgnoresTransformations, false);
 224     QCOMPARE(scene.items().size(), 3);
 225     QTest::qWait(50);
 226     QCOMPARE(scene.items().size(), 3);
 227
 228     // Make all items untransformable.
 229     item1->setFlag(QGraphicsItem::ItemIgnoresTransformations);
 230     item2->setParentItem(item1);
 231     item3->setParentItem(item2);
 232     QCOMPARE(scene.items().size(), 3);
 233
 234     // Move from unindexed items into untransformable items.
 235     QTest::qWait(50);
 236     QCOMPARE(scene.items().size(), 3);
 237 }
 238
 239 class RectWidget : public QGraphicsWidget
 240 {
 241     Q_OBJECT
 242 public:
 243     RectWidget(QGraphicsItem *parent = 0) : QGraphicsWidget(parent)
 244     {
 245     }
 246
 247     void paint(QPainter *painter, const QStyleOptionGraphicsItem * /* option */, QWidget * /* widget */)
 248     {
 249         painter->setBrush(brush);
 250         painter->drawRect(boundingRect());
 251     }
 252 public:
 253     QBrush brush;
 254 };
 255
 256 void tst_QGraphicsSceneIndex::removeItems()
 257 {
 258      QGraphicsScene scene;
 259
 260     RectWidget *parent = new RectWidget;
 261     parent->brush = QBrush(QColor(Qt::magenta));
 262     parent->setGeometry(250, 250, 400, 400);
 263
 264     RectWidget *widget = new RectWidget(parent);
 265     widget->brush = QBrush(QColor(Qt::blue));
 266     widget->setGeometry(10, 10, 200, 200);
 267
 268     RectWidget *widgetChild1 = new RectWidget(widget);
 269     widgetChild1->brush = QBrush(QColor(Qt::green));
 270     widgetChild1->setGeometry(20, 20, 100, 100);
 271
 272     RectWidget *widgetChild2 = new RectWidget(widgetChild1);
 273     widgetChild2->brush = QBrush(QColor(Qt::yellow));
 274     widgetChild2->setGeometry(25, 25, 50, 50);
 275
 276     scene.addItem(parent);
 277
 278     QGraphicsView view(&scene);
 279     view.resize(600, 600);
 280     view.show();
 281     QApplication::setActiveWindow(&view);
 282     QTest::qWaitForWindowShown(&view);
 283
 284     QApplication::processEvents();
 285
 286     scene.removeItem(widgetChild1);
 287
 288     delete widgetChild1;
 289
 290     //We move the parent
 291     scene.items(295, 295, 50, 50);
 292
 293     //This should not crash
 294 }
 295
 296 void tst_QGraphicsSceneIndex::clear()
 297 {
 298     class MyItem : public QGraphicsItem
 299     {
 300     public:
 301         MyItem(QGraphicsItem *parent = 0) : QGraphicsItem(parent), numPaints(0) {}
 302         int numPaints;
 303     protected:
 304         QRectF boundingRect() const { return QRectF(0, 0, 10, 10); }
 305         void paint(QPainter * /* painter */, const QStyleOptionGraphicsItem *, QWidget *)
 306         { ++numPaints; }
 307     };
 308
 309     QGraphicsScene scene;
 310     scene.setSceneRect(0, 0, 100, 100);
 311     scene.addItem(new MyItem);
 312
 313     QGraphicsView view(&scene);
 314     view.show();
 315 #ifdef Q_WS_X11
 316     qt_x11_wait_for_window_manager(&view);
 317 #endif
 318     QTest::qWait(250);
 319     scene.clear();
 320
 321     // Make sure the index is re-generated after QGraphicsScene::clear();
 322     // otherwise no items will be painted.
 323     MyItem *item = new MyItem;
 324     scene.addItem(item);
 325     qApp->processEvents();
 326     QTRY_COMPARE(item->numPaints, 1);
 327 }
 328
 329 QTEST_MAIN(tst_QGraphicsSceneIndex)
 330 #include "tst_qgraphicssceneindex.moc"