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 #include <QtGui>

    45 #include <math.h>

    46 

    47 //TESTED_CLASS=QGraphicsLayout

    48 //TESTED_FILES=

    49 

    50 class tst_QGraphicsLayout : public QObject

    51 {

    52 Q_OBJECT

    53 

    54 public:

    55     tst_QGraphicsLayout();

    56     virtual ~tst_QGraphicsLayout();

    57 

    58 private slots:

    59     void sizeHints();

    60     void compressLayoutRequest();

    61     void automaticReparenting();

    62     void verifyActivate();

    63     void constructors();

    64     void alternativeLayoutItems();

    65     void ownership();

    66 };

    67 

    68 tst_QGraphicsLayout::tst_QGraphicsLayout()

    69 {

    70 }

    71 

    72 tst_QGraphicsLayout::~tst_QGraphicsLayout()

    73 {

    74 }

    75 

    76 void tst_QGraphicsLayout::sizeHints()

    77 {

    78 

    79     QGraphicsView view;

    80     QGraphicsScene scene;

    81     QGraphicsWidget *window = new QGraphicsWidget();

    82     scene.addItem(window);

    83     QGraphicsLinearLayout *lout = new QGraphicsLinearLayout(window);

    84     lout->setContentsMargins(0,0,0,0);

    85     QGraphicsWidget *gw = new QGraphicsWidget(window);

    86     gw->setMinimumSize(QSizeF(10,10));

    87     gw->setPreferredSize(QSizeF(100,100));

    88     gw->setMaximumSize(QSizeF(500,500));

    89     lout->addItem(gw);

    90     QCOMPARE(lout->effectiveSizeHint(Qt::MinimumSize), gw->effectiveSizeHint(Qt::MinimumSize));

    91     QCOMPARE(lout->effectiveSizeHint(Qt::PreferredSize), gw->effectiveSizeHint(Qt::PreferredSize));

    92     QCOMPARE(lout->effectiveSizeHint(Qt::MaximumSize), gw->effectiveSizeHint(Qt::MaximumSize));

    93 

    94 }

    95 

    96 class TestGraphicsWidget : public QGraphicsWidget {

    97 public:

    98     TestGraphicsWidget(QGraphicsWidget *parent = 0) : QGraphicsWidget(parent)

    99     { }

   100 

   101     bool event(QEvent *e) {

   102         ++(m_eventCount[int(e->type())]);

   103         return QGraphicsWidget::event(e);

   104     }

   105 

   106     int eventCount(QEvent::Type type) {

   107         return m_eventCount.value(int(type));

   108     }

   109     void clearEventCount() {

   110         m_eventCount.clear();

   111     }

   112 private:

   113     QMap<int, int> m_eventCount;

   114 };

   115 

   116 void tst_QGraphicsLayout::compressLayoutRequest()

   117 {

   118     QGraphicsView view;

   119     QGraphicsScene scene;

   120     TestGraphicsWidget *tw = new TestGraphicsWidget();

   121     scene.addItem(tw);

   122     view.show();

   123     QGraphicsLinearLayout *lout = new QGraphicsLinearLayout(tw);

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

   125         QGraphicsWidget *gw = new QGraphicsWidget(tw);

   126         gw->setPreferredSize(QSizeF(50, 50));

   127         lout->addItem(gw);

   128     }

   129     QApplication::processEvents();

   130     QCOMPARE(tw->eventCount(QEvent::LayoutRequest), 1);

   131 }

   132 

   133 void tst_QGraphicsLayout::automaticReparenting()

   134 {

   135     QGraphicsView view;

   136     QGraphicsScene scene;

   137     {

   138         QGraphicsWidget *w = new QGraphicsWidget();

   139         QGraphicsLinearLayout *l = new QGraphicsLinearLayout(w);

   140         QGraphicsWidget *w1 = new QGraphicsWidget;

   141         l->addItem(w1);

   142         scene.addItem(w);

   143         QCOMPARE(w1->parentWidget(), w);

   144         delete w;

   145     }

   146     {

   147         QGraphicsWidget *w = new QGraphicsWidget();

   148         QGraphicsLinearLayout *l = new QGraphicsLinearLayout(w);

   149         QGraphicsWidget *w1 = new QGraphicsWidget;

   150         l->addItem(w1);

   151         scene.addItem(w);

   152         QCOMPARE(w1->parentWidget(), w);

   153 

   154         QGraphicsWidget *ww = new QGraphicsWidget();

   155         QGraphicsLinearLayout *l1 = new QGraphicsLinearLayout(ww);

   156 #if !defined(Q_OS_MAC) && defined(QT_DEBUG)

   157         QTest::ignoreMessage(QtWarningMsg, "QGraphicsLayout::addChildLayoutItem: QGraphicsWidget \"\""

   158                              " in wrong parent; moved to correct parent");

   159 #endif

   160         l1->addItem(w1);

   161         QCOMPARE(w1->parentWidget(), ww);

   162         delete w;

   163     }

   164 

   165     QGraphicsWidget *window = new QGraphicsWidget();

   166     scene.addItem(window);

   167     view.show();

   168     QGraphicsLinearLayout *l1 = new QGraphicsLinearLayout();

   169     QGraphicsWidget *w1 = new QGraphicsWidget();

   170     l1->addItem(w1);

   171     QGraphicsWidget *w2 = new QGraphicsWidget();

   172     l1->addItem(w2);

   173     QCOMPARE(w1->parentItem(), static_cast<QGraphicsItem*>(0));

   174     QCOMPARE(w2->parentItem(), static_cast<QGraphicsItem*>(0));

   175     scene.addItem(w1);

   176     QCOMPARE(w1->parentItem(), static_cast<QGraphicsItem*>(0));

   177     window->setLayout(l1);

   178     QCOMPARE(w1->parentItem(), static_cast<QGraphicsItem*>(window));

   179     QCOMPARE(w2->parentItem(), static_cast<QGraphicsItem*>(window));

   180 

   181     // Sublayouts

   182     QGraphicsLinearLayout *l2 = new QGraphicsLinearLayout();

   183     QGraphicsWidget *w3 = new QGraphicsWidget();

   184     l2->addItem(w3);

   185     QGraphicsWidget *w4 = new QGraphicsWidget();

   186     l2->addItem(w4);

   187     QGraphicsLinearLayout *l3 = new QGraphicsLinearLayout();

   188     l2->addItem(l3);

   189     QGraphicsWidget *window2 = new QGraphicsWidget();

   190     scene.addItem(window2);

   191     window2->setLayout(l2);

   192 

   193     QCOMPARE(w3->parentItem(), static_cast<QGraphicsItem*>(window2));

   194     QCOMPARE(w4->parentItem(), static_cast<QGraphicsItem*>(window2));

   195 

   196     // graphics item with another parent

   197     QGraphicsLinearLayout *l5 = new QGraphicsLinearLayout();

   198     l5->addItem(w1);

   199     l5->addItem(w2);

   200     QCOMPARE(w1->parentItem(), static_cast<QGraphicsItem*>(window));

   201     QCOMPARE(w2->parentItem(), static_cast<QGraphicsItem*>(window));

   202     QGraphicsLinearLayout *l4 = new QGraphicsLinearLayout();

   203     l4->addItem(l5);

   204     QGraphicsWidget *window3 = new QGraphicsWidget();

   205     scene.addItem(window3);

   206     window3->setLayout(l4);

   207 

   208     QCOMPARE(w1->parentItem(), static_cast<QGraphicsItem*>(window3));

   209     QCOMPARE(w2->parentItem(), static_cast<QGraphicsItem*>(window3));

   210 }

   211 

   212 class TestLayout : public QGraphicsLinearLayout

   213 {

   214     public:

   215     TestLayout(QGraphicsLayoutItem *parent = 0)

   216         : QGraphicsLinearLayout(parent)

   217     {

   218         m_count = 0;

   219     }

   220 

   221     void setGeometry(const QRectF &rect) {

   222 

   223         ++m_count;

   224         QGraphicsLinearLayout::setGeometry(rect);

   225     }

   226 

   227 

   228     int m_count;

   229 };

   230 

   231 void tst_QGraphicsLayout::verifyActivate()

   232 {

   233     QGraphicsScene scene;

   234     QGraphicsView view(&scene);

   235 

   236     QGraphicsWidget *window = new QGraphicsWidget();

   237     scene.addItem(window);

   238     TestLayout *lout = new TestLayout(window);

   239     QGraphicsWidget *w = new QGraphicsWidget();

   240     lout->addItem(w);

   241     window->setLayout(lout);

   242 

   243     QCOMPARE(lout->m_count, 0);

   244     window->setVisible(false);

   245     QCOMPARE(lout->m_count, 0);

   246     window->setVisible(true);

   247     // on polish or the first time a widget is shown, the widget is resized.

   248     QCOMPARE(lout->m_count, 1);

   249 

   250 }

   251 

   252 class Layout : public QGraphicsLayout

   253 {

   254 public:

   255     Layout(QGraphicsLayoutItem *parentItem = 0) : QGraphicsLayout(parentItem) {}

   256 

   257     void setGeometry(const QRectF &rect)

   258     {

   259         QGraphicsLayout::setGeometry(rect);

   260     }

   261 

   262     int count() const {

   263         return 0;

   264     }

   265 

   266     QGraphicsLayoutItem *itemAt(int index) const {

   267         Q_UNUSED(index);

   268         return 0;

   269     }

   270 

   271     void removeAt(int index)

   272     {

   273         Q_UNUSED(index);

   274     }

   275 

   276 protected:

   277     QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const

   278     {

   279         Q_UNUSED(constraint);

   280         Q_UNUSED(which);

   281         return QSizeF(100,100);

   282     }

   283 

   284 };

   285 

   286 void tst_QGraphicsLayout::constructors()

   287 {

   288     // Strange test, but see the fix that was with this submit

   289     QVector<Layout*> layouts;

   290     for (int pass = 0; pass < 5; ++pass) {

   291         Layout *lay = new Layout();

   292         layouts << lay;

   293         qreal left, top, right, bottom;

   294         lay->getContentsMargins(&left, &top, &right, &bottom);

   295         // Test if the style defaults are sane (should always be ints)

   296         double intpart;

   297         QVERIFY(modf(left, &intpart) == 0.0);

   298         QVERIFY(modf(top, &intpart) == 0.0);

   299         QVERIFY(modf(right, &intpart) == 0.0);

   300         QVERIFY(modf(bottom, &intpart) == 0.0);

   301 

   302         lay->setContentsMargins(1, 2, 4, 8);

   303         lay->getContentsMargins(&left, &top, &right, &bottom);

   304 

   305         QCOMPARE(int(left), 1);

   306         QCOMPARE(int(top), 2);

   307         QCOMPARE(int(right), 4);

   308         QCOMPARE(int(bottom), 8);

   309     }

   310 

   311     qDeleteAll(layouts);

   312 }

   313 

   314 class AnimatedLayoutItem : public QGraphicsLayoutItem {

   315 public:

   316     AnimatedLayoutItem(QGraphicsRectItem *item)

   317     : QGraphicsLayoutItem()

   318     {

   319         setGraphicsItem(item);

   320     }

   321 

   322     void setGeometry(const QRectF &geom);

   323 

   324     QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;

   325 

   326     inline QGraphicsRectItem *rectItem() {

   327         return static_cast<QGraphicsRectItem *>(graphicsItem());

   328     }

   329 

   330     QRectF m_geom;

   331 private:

   332     AnimatedLayoutItem() {}

   333 };

   334 

   335 void AnimatedLayoutItem::setGeometry(const QRectF &geom)

   336 {

   337     QGraphicsLayoutItem::setGeometry(geom);

   338 }

   339 

   340 QSizeF AnimatedLayoutItem::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const

   341 {

   342     switch (which) {

   343     case Qt::MinimumSize:

   344         return QSizeF(32,32);

   345     case Qt::PreferredSize:

   346         return QSizeF(160,90);

   347     case Qt::MaximumSize:

   348         return QSizeF(1000,1000);

   349     default:

   350         return QSizeF(300, 300);

   351     }

   352 }

   353 

   354 class AnimatedLayout : public QObject, public QGraphicsLinearLayout {

   355     Q_OBJECT

   356 public:

   357     AnimatedLayout(QGraphicsWidget *widget) : QGraphicsLinearLayout(widget), m_timeline(500, this)

   358     {

   359         connect(&m_timeline, SIGNAL(valueChanged(qreal)), this, SLOT(valueChanged(qreal)));

   360     }

   361 

   362     void setGeometry(const QRectF &geom) {

   363         fromGeoms.clear();

   364         toGeoms.clear();

   365         for (int i = 0; i < count(); ++i) {

   366             fromGeoms << itemAt(i)->geometry();

   367         }

   368 

   369         QGraphicsLinearLayout::setGeometry(geom);

   370 

   371         for (int i = 0; i < count(); ++i) {

   372             toGeoms << itemAt(i)->geometry();

   373         }

   374         m_timeline.start();

   375     }

   376 

   377 private slots:

   378     void valueChanged(qreal value) {

   379         for (int i = 0; i < fromGeoms.count(); ++i) {

   380             QGraphicsLayoutItem *li = itemAt(i);

   381             QRectF from = fromGeoms.at(i);

   382             QRectF to = toGeoms.at(i);

   383 

   384             QRectF geom(from.topLeft() + (to.topLeft() - from.topLeft()) * value,

   385                         from.size() + (to.size() - from.size()) * value);

   386             static_cast<QGraphicsRectItem*>(li->graphicsItem())->setRect(geom);

   387         }

   388     }

   389 private:

   390     QTimeLine m_timeline;

   391     QVector<QRectF> fromGeoms;

   392     QVector<QRectF> toGeoms;

   393 };

   394 

   395 

   396 void tst_QGraphicsLayout::alternativeLayoutItems()

   397 {

   398     QGraphicsScene scene;

   399     QGraphicsView view(&scene);

   400 

   401     QGraphicsWidget *window = new QGraphicsWidget;

   402     scene.addItem(window);

   403     AnimatedLayout *lout = new AnimatedLayout(window);

   404     lout->setContentsMargins(0, 0, 0, 0);

   405     lout->setSpacing(0);

   406 

   407     QGraphicsRectItem *item1 = new QGraphicsRectItem;

   408     AnimatedLayoutItem *li1 = new AnimatedLayoutItem(item1);

   409     lout->addItem(li1);

   410 

   411     QGraphicsRectItem *item2 = new QGraphicsRectItem;

   412     AnimatedLayoutItem *li2 = new AnimatedLayoutItem(item2);

   413     lout->addItem(li2);

   414 

   415     QGraphicsRectItem *item3 = new QGraphicsRectItem;

   416     AnimatedLayoutItem *li3 = new AnimatedLayoutItem(item3);

   417     lout->addItem(li3);

   418 

   419     window->setLayout(lout);

   420 

   421     window->setGeometry(0, 0, 99, 99);

   422     view.setSceneRect(QRectF(-10, -10, 110, 110));

   423     view.resize(150, 150);

   424     view.show();

   425 

   426     QApplication::processEvents();

   427     QTest::qWait(750);

   428     QApplication::processEvents();

   429 

   430     QCOMPARE(static_cast<QGraphicsRectItem*>(li1->graphicsItem())->rect(), QRectF( 0, 0, 33, 99));

   431     QCOMPARE(static_cast<QGraphicsRectItem*>(li2->graphicsItem())->rect(), QRectF(33, 0, 33, 99));

   432     QCOMPARE(static_cast<QGraphicsRectItem*>(li3->graphicsItem())->rect(), QRectF(66, 0, 33, 99));

   433 

   434     lout->setOrientation(Qt::Vertical);

   435 

   436     QApplication::processEvents();

   437     QTest::qWait(750);

   438     QApplication::processEvents();

   439     QCOMPARE(static_cast<QGraphicsRectItem*>(li1->graphicsItem())->rect(), QRectF(0, 0,  99, 33));

   440     QCOMPARE(static_cast<QGraphicsRectItem*>(li2->graphicsItem())->rect(), QRectF(0, 33, 99, 33));

   441     QCOMPARE(static_cast<QGraphicsRectItem*>(li3->graphicsItem())->rect(), QRectF(0, 66, 99, 33));

   442 

   443 }

   444 

   445 class CustomLayoutItem : public QGraphicsLayoutItem {

   446 public:

   447     CustomLayoutItem(QSet<QGraphicsLayoutItem*> *destructedSet)

   448     : QGraphicsLayoutItem()

   449     {

   450         m_destructedSet = destructedSet;

   451         setOwnedByLayout(true);

   452     }

   453 

   454     QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;

   455 

   456     ~CustomLayoutItem() {

   457         m_destructedSet->insert(this);

   458     }

   459 private:

   460     QSet<QGraphicsLayoutItem*> *m_destructedSet;

   461 };

   462 

   463 QSizeF CustomLayoutItem::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const

   464 {

   465     switch (which) {

   466     case Qt::MinimumSize:

   467         return QSizeF(32,32);

   468     case Qt::PreferredSize:

   469         return QSizeF(160,90);

   470     case Qt::MaximumSize:

   471         return QSizeF(1000,1000);

   472     default:

   473         return QSizeF(300, 300);

   474     }

   475 }

   476 

   477 class CustomGraphicsWidget : public QGraphicsWidget {

   478 public:

   479     CustomGraphicsWidget(QSet<QGraphicsLayoutItem*> *destructedSet = 0)

   480     : QGraphicsWidget()

   481     {

   482         m_destructedSet = destructedSet;

   483     }

   484 

   485     QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;

   486 

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

   488     {

   489         const QRect r = option->rect.adjusted(0, 0, -1, -1);

   490         painter->drawLine(r.topLeft(), r.bottomRight());

   491         painter->drawLine(r.bottomLeft(), r.topRight());

   492         painter->drawRect(r);

   493     }

   494 

   495     ~CustomGraphicsWidget() {

   496         if (m_destructedSet)

   497             m_destructedSet->insert(this);

   498     }

   499 private:

   500     QSet<QGraphicsLayoutItem*> *m_destructedSet;

   501 };

   502 

   503 QSizeF CustomGraphicsWidget::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const

   504 {

   505     switch (which) {

   506     case Qt::MinimumSize:

   507         return QSizeF(32,32);

   508     case Qt::PreferredSize:

   509         return QSizeF(160,90);

   510     case Qt::MaximumSize:

   511         return QSizeF(1000,1000);

   512     default:

   513         return QSizeF(300, 300);

   514     }

   515 }

   516 

   517 static bool compareSets(const QSet<QGraphicsLayoutItem*> &actual, const QSet<QGraphicsLayoutItem*> &expected)

   518 {

   519     if (actual != expected) {

   520         qDebug() << "actual:" << actual << "expected:" << expected;

   521         return false;

   522     }

   523     return true;

   524 }

   525 

   526 class CustomLayout : public QGraphicsLayout

   527 {

   528 public :

   529 CustomLayout(QGraphicsLayoutItem *parent)

   530     : QGraphicsLayout(parent)

   531 {

   532 }

   533 

   534 

   535 ~CustomLayout()

   536 {

   537 }

   538 

   539 int count() const

   540 {

   541     return items.count();

   542 }

   543 

   544 QGraphicsLayoutItem* itemAt(int index) const

   545 {

   546     return items.at(index);

   547 }

   548 

   549 

   550 void removeAt(int index)

   551 {

   552     items.removeAt(index);

   553 }

   554 

   555 void addItem(QGraphicsLayoutItem *item)

   556 {

   557     insertItem(items.count(), item);

   558 }

   559 

   560 void insertItem(int index, QGraphicsLayoutItem *item)

   561 {

   562     index = qBound(0, index, items.count());

   563 

   564     item->setParentLayoutItem(this);

   565 

   566     QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);

   567     updateParentWidget(widget);

   568 

   569 

   570     if (index == items.count()) {

   571         items.append(item);

   572     } else {

   573         items.insert(index, item);

   574     }

   575 

   576     updateGeometry();

   577     activate();

   578 }

   579 

   580 void updateParentWidget(QGraphicsWidget *item)

   581 {

   582     QGraphicsLayoutItem *parentItem = parentLayoutItem();

   583     while (parentItem && parentItem->isLayout()) {

   584         parentItem = parentItem->parentLayoutItem();

   585     }

   586 

   587     if (parentItem) {

   588         item->setParentItem(static_cast<QGraphicsWidget*>(parentItem));

   589     }

   590 }

   591 

   592 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const

   593 {

   594     return QSizeF(50,50);

   595 }

   596 

   597 QList<QGraphicsLayoutItem*> items;

   598 

   599 };

   600 

   601 void tst_QGraphicsLayout::ownership()

   602 {

   603     QGraphicsScene scene;

   604     QGraphicsView view(&scene);

   605 

   606     {

   607         QGraphicsLinearLayout *lay = new QGraphicsLinearLayout;

   608         QSet<QGraphicsLayoutItem*> destructedSet;

   609         CustomLayoutItem *li1 = new CustomLayoutItem(&destructedSet);

   610         lay->addItem(li1);

   611         CustomLayoutItem *li2 = new CustomLayoutItem(&destructedSet);

   612         lay->addItem(li2);

   613         CustomLayoutItem *li3 = new CustomLayoutItem(&destructedSet);

   614         lay->addItem(li3);

   615         destructedSet.clear();

   616 

   617         delete lay;

   618         QSet<QGraphicsLayoutItem*> expected;

   619         expected << li1 << li2 << li3;

   620         QVERIFY(compareSets(destructedSet, expected));

   621     }

   622 

   623     {

   624         QGraphicsWidget *window = new QGraphicsWidget;

   625         QGraphicsLinearLayout *lay = new QGraphicsLinearLayout;

   626         QSet<QGraphicsLayoutItem*> destructedSet;

   627         CustomGraphicsWidget *li1 = new CustomGraphicsWidget(&destructedSet);

   628         lay->addItem(li1);

   629         CustomGraphicsWidget *li2 = new CustomGraphicsWidget(&destructedSet);

   630         lay->addItem(li2);

   631         CustomGraphicsWidget *li3 = new CustomGraphicsWidget(&destructedSet);

   632         lay->addItem(li3);

   633         window->setLayout(lay);

   634         scene.addItem(window);

   635 

   636         destructedSet.clear();

   637         window->setLayout(0);

   638         QVERIFY(destructedSet.count() == 0);

   639         delete window;

   640     }

   641 

   642     {

   643         QGraphicsWidget *window = new QGraphicsWidget(0, Qt::Window);

   644         QGraphicsLinearLayout *lay = new QGraphicsLinearLayout;

   645 

   646         CustomGraphicsWidget *li1 = new CustomGraphicsWidget;

   647         lay->addItem(li1);

   648 

   649         QGraphicsLinearLayout *li2 = new QGraphicsLinearLayout;

   650         CustomGraphicsWidget *li2_1 = new CustomGraphicsWidget;

   651         li2->addItem(li2_1);

   652         CustomGraphicsWidget *li2_2 = new CustomGraphicsWidget;

   653         li2->addItem(li2_2);

   654         CustomGraphicsWidget *li2_3 = new CustomGraphicsWidget;

   655         li2->addItem(li2_3);

   656         lay->addItem(li2);

   657 

   658         CustomGraphicsWidget *li3 = new CustomGraphicsWidget;

   659         lay->addItem(li3);

   660 

   661         window->setLayout(lay);

   662         scene.addItem(window);

   663         view.resize(500, 200);

   664         view.show();

   665 

   666         for (int i = li2->count(); i > 0; --i) {

   667             QCOMPARE(li2->count(), i);

   668             delete li2->itemAt(0);

   669         }

   670 

   671         for (int i = lay->count(); i > 0; --i) {

   672             QCOMPARE(lay->count(), i);

   673             delete lay->itemAt(0);

   674         }

   675 

   676         delete window;

   677     }

   678 

   679     {

   680         QGraphicsWidget *top = new QGraphicsWidget;

   681         QGraphicsWidget *w = new QGraphicsWidget;

   682         QGraphicsWidget *w2 = new QGraphicsWidget;

   683         CustomLayout *layout = new CustomLayout(top);

   684         layout->addItem(w);

   685         layout->addItem(w2);

   686         top->setLayout(layout);

   687         delete top;

   688         //don't crash after that.

   689     }

   690 }

   691 

   692 QTEST_MAIN(tst_QGraphicsLayout)

   693 #include "tst_qgraphicslayout.moc"