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 <private/qtextcontrol_p.h>

    46 #include <private/qgraphicsitem_p.h>

    47 #include <private/qgraphicsview_p.h>

    48 #include <QStyleOptionGraphicsItem>

    49 #include <QAbstractTextDocumentLayout>

    50 #include <QBitmap>

    51 #include <QCursor>

    52 #include <QLabel>

    53 #include <QDial>

    54 #include <QGraphicsItem>

    55 #include <QGraphicsScene>

    56 #include <QGraphicsSceneEvent>

    57 #include <QGraphicsView>

    58 #include <QGraphicsWidget>

    59 #include <QGraphicsProxyWidget>

    60 #include <QPainter>

    61 #include <QScrollBar>

    62 #include <QVBoxLayout>

    63 #include <QGraphicsEffect>

    64 

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

    66 

    67 //TESTED_CLASS=

    68 //TESTED_FILES=

    69 

    70 Q_DECLARE_METATYPE(QList<int>)

    71 Q_DECLARE_METATYPE(QList<QRectF>)

    72 Q_DECLARE_METATYPE(QPainterPath)

    73 Q_DECLARE_METATYPE(QPointF)

    74 Q_DECLARE_METATYPE(QRectF)

    75 

    76 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)

    77 #include <windows.h>

    78 #define Q_CHECK_PAINTEVENTS \

    79     if (::SwitchDesktop(::GetThreadDesktop(::GetCurrentThreadId())) == 0) \

    80         QSKIP("The Graphics View doesn't get the paint events", SkipSingle);

    81 #else

    82 #define Q_CHECK_PAINTEVENTS

    83 #endif

    84 

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

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

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

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

    89 #else

    90 #define COMPARE_REGIONS QTRY_COMPARE

    91 #endif

    92 

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

    94 {

    95     QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);

    96     event.setScenePos(point);

    97     event.setButton(button);

    98     event.setButtons(button);

    99     QApplication::sendEvent(scene, &event);

   100 }

   101 

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

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

   104 {

   105     QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseMove);

   106     event.setScenePos(point);

   107     event.setButton(button);

   108     event.setButtons(button);

   109     QApplication::sendEvent(scene, &event);

   110 }

   111 

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

   113 {

   114     QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMouseRelease);

   115     event.setScenePos(point);

   116     event.setButton(button);

   117     QApplication::sendEvent(scene, &event);

   118 }

   119 

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

   121 {

   122     sendMousePress(scene, point, button);

   123     sendMouseRelease(scene, point, button);

   124 }

   125 

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

   127 {

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

   129     QApplication::sendEvent(scene, &keyEvent);

   130 }

   131 

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

   133 {

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

   135     QApplication::sendEvent(scene, &keyEvent);

   136 }

   137 

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

   139 {

   140     sendKeyPress(scene, key);

   141     sendKeyRelease(scene, key);

   142 }

   143 

   144 class EventSpy : public QGraphicsWidget

   145 {

   146     Q_OBJECT

   147 public:

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

   149         : _count(0), spied(type)

   150     {

   151         watched->installEventFilter(this);

   152     }

   153 

   154     EventSpy(QGraphicsScene *scene, QGraphicsItem *watched, QEvent::Type type)

   155         : _count(0), spied(type)

   156     {

   157         scene->addItem(this);

   158         watched->installSceneEventFilter(this);

   159     }

   160 

   161     int count() const { return _count; }

   162 

   163 protected:

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

   165     {

   166         Q_UNUSED(watched);

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

   168             ++_count;

   169         return false;

   170     }

   171 

   172     bool sceneEventFilter(QGraphicsItem *watched, QEvent *event)

   173     {

   174         Q_UNUSED(watched);

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

   176             ++_count;

   177         return false;

   178     }

   179 

   180     int _count;

   181     QEvent::Type spied;

   182 };

   183 

   184 class EventSpy2 : public QGraphicsWidget

   185 {

   186     Q_OBJECT

   187 public:

   188     EventSpy2(QObject *watched)

   189     {

   190         watched->installEventFilter(this);

   191     }

   192 

   193     EventSpy2(QGraphicsScene *scene, QGraphicsItem *watched)

   194     {

   195         scene->addItem(this);

   196         watched->installSceneEventFilter(this);

   197     }

   198 

   199     QMap<QEvent::Type, int> counts;

   200 

   201 protected:

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

   203     {

   204         Q_UNUSED(watched);

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

   206         return false;

   207     }

   208 

   209     bool sceneEventFilter(QGraphicsItem *watched, QEvent *event)

   210     {

   211         Q_UNUSED(watched);

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

   213         return false;

   214     }

   215 };

   216 

   217 class EventTester : public QGraphicsItem

   218 {

   219 public:

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

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

   222 

   223     void setGeometry(const QRectF &rect)

   224     {

   225         prepareGeometryChange();

   226         br = rect;

   227         update();

   228     }

   229 

   230     QRectF boundingRect() const

   231     { return br; }

   232 

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

   234     {

   235         hints = painter->renderHints();

   236         painter->drawRect(boundingRect());

   237         ++repaints;

   238     }

   239 

   240     bool sceneEvent(QEvent *event)

   241     {

   242         events << event->type();

   243         return QGraphicsItem::sceneEvent(event);

   244     }

   245 

   246     QList<QEvent::Type> events;

   247     QPainter::RenderHints hints;

   248     int repaints;

   249     QRectF br;

   250 };

   251 

   252 class tst_QGraphicsItem : public QObject

   253 {

   254     Q_OBJECT

   255 

   256 public slots:

   257     void init();

   258 

   259 private slots:

   260     void construction();

   261     void constructionWithParent();

   262     void destruction();

   263     void deleteChildItem();

   264     void scene();

   265     void parentItem();

   266     void setParentItem();

   267     void children();

   268     void flags();

   269     void inputMethodHints();

   270     void toolTip();

   271     void visible();

   272     void explicitlyVisible();

   273     void enabled();

   274     void explicitlyEnabled();

   275     void selected();

   276     void selected2();

   277     void selected_group();

   278     void selected_textItem();

   279     void selected_multi();

   280     void acceptedMouseButtons();

   281     void acceptsHoverEvents();

   282     void childAcceptsHoverEvents();

   283     void hasFocus();

   284     void pos();

   285     void scenePos();

   286     void matrix();

   287     void sceneMatrix();

   288     void setMatrix();

   289     void zValue();

   290     void shape();

   291     void contains();

   292     void collidesWith_item();

   293     void collidesWith_path_data();

   294     void collidesWith_path();

   295     void collidesWithItemWithClip();

   296     void isObscuredBy();

   297     void isObscured();

   298     void mapFromToParent();

   299     void mapFromToScene();

   300     void mapFromToItem();

   301     void mapRectFromToParent_data();

   302     void mapRectFromToParent();

   303     void isAncestorOf();

   304     void commonAncestorItem();

   305     void data();

   306     void type();

   307     void graphicsitem_cast();

   308     void hoverEventsGenerateRepaints();

   309     void boundingRects_data();

   310     void boundingRects();

   311     void boundingRects2();

   312     void sceneBoundingRect();

   313     void childrenBoundingRect();

   314     void childrenBoundingRectTransformed();

   315     void childrenBoundingRect2();

   316     void childrenBoundingRect3();

   317     void group();

   318     void setGroup();

   319     void nestedGroups();

   320     void warpChildrenIntoGroup();

   321     void removeFromGroup();

   322     void handlesChildEvents();

   323     void handlesChildEvents2();

   324     void handlesChildEvents3();

   325     void filtersChildEvents();

   326     void filtersChildEvents2();

   327     void ensureVisible();

   328     void cursor();

   329     //void textControlGetterSetter();

   330     void defaultItemTest_QGraphicsLineItem();

   331     void defaultItemTest_QGraphicsPixmapItem();

   332     void defaultItemTest_QGraphicsTextItem();

   333     void defaultItemTest_QGraphicsEllipseItem();

   334     void itemChange();

   335     void sceneEventFilter();

   336     void prepareGeometryChange();

   337     void paint();

   338     void deleteItemInEventHandlers();

   339     void itemClipsToShape();

   340     void itemClipsChildrenToShape();

   341     void itemClipsChildrenToShape2();

   342     void itemClipsChildrenToShape3();

   343     void itemClipsChildrenToShape4();

   344     void itemClipsTextChildToShape();

   345     void itemClippingDiscovery();

   346     void ancestorFlags();

   347     void untransformable();

   348     void contextMenuEventPropagation();

   349     void itemIsMovable();

   350     void boundingRegion_data();

   351     void boundingRegion();

   352     void itemTransform_parentChild();

   353     void itemTransform_siblings();

   354     void itemTransform_unrelated();

   355     void opacity_data();

   356     void opacity();

   357     void opacity2();

   358     void opacityZeroUpdates();

   359     void itemStacksBehindParent();

   360     void nestedClipping();

   361     void nestedClippingTransforms();

   362     void sceneTransformCache();

   363     void tabChangesFocus();

   364     void tabChangesFocus_data();

   365     void cacheMode();

   366     void updateCachedItemAfterMove();

   367     void deviceTransform_data();

   368     void deviceTransform();

   369     void update();

   370     void setTransformProperties_data();

   371     void setTransformProperties();

   372     void itemUsesExtendedStyleOption();

   373     void itemSendsGeometryChanges();

   374     void moveItem();

   375     void sorting_data();

   376     void sorting();

   377     void itemHasNoContents();

   378     void hitTestUntransformableItem();

   379     void hitTestGraphicsEffectItem();

   380     void focusProxy();

   381     void subFocus();

   382     void focusProxyDeletion();

   383     void negativeZStacksBehindParent();

   384     void setGraphicsEffect();

   385     void panel();

   386     void addPanelToActiveScene();

   387     void activate();

   388     void setActivePanelOnInactiveScene();

   389     void activationOnShowHide();

   390     void moveWhileDeleting();

   391     void ensureDirtySceneTransform();

   392     void focusScope();

   393     void stackBefore();

   394     void sceneModality();

   395     void panelModality();

   396     void mixedModality();

   397     void modality_hover();

   398     void modality_mouseGrabber();

   399     void modality_clickFocus();

   400     void modality_keyEvents();

   401     void itemIsInFront();

   402 

   403     // task specific tests below me

   404     void task141694_textItemEnsureVisible();

   405     void task128696_textItemEnsureMovable();

   406     void ensureUpdateOnTextItem();

   407     void task177918_lineItemUndetected();

   408     void task240400_clickOnTextItem_data();

   409     void task240400_clickOnTextItem();

   410     void task243707_addChildBeforeParent();

   411     void task197802_childrenVisibility();

   412     void QTBUG_4233_updateCachedWithSceneRect();

   413 

   414 private:

   415     QList<QGraphicsItem *> paintedItems;

   416 };

   417 

   418 void tst_QGraphicsItem::init()

   419 {

   420 #ifdef Q_OS_WINCE //disable magic for WindowsCE

   421     qApp->setAutoMaximizeThreshold(-1);

   422 #endif

   423 }

   424 

   425 void tst_QGraphicsItem::construction()

   426 {

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

   428         QGraphicsItem *item;

   429         switch (i) {

   430         case 0:

   431             item = new QGraphicsEllipseItem;

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

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

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

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

   436             break;

   437         case 1:

   438             item = new QGraphicsLineItem;

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

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

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

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

   443             break;

   444         case 2:

   445             item = new QGraphicsPathItem;

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

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

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

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

   450             break;

   451         case 3:

   452             item = new QGraphicsPixmapItem;

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

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

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

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

   457             break;

   458         case 4:

   459             item = new QGraphicsPolygonItem;

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

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

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

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

   464             break;

   465         case 5:

   466             item = new QGraphicsRectItem;

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

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

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

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

   471             break;

   472         case 6:

   473             item = new QGraphicsTextItem;

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

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

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

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

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

   479             break;

   480         default:

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

   482             break;

   483         }

   484 

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

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

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

   488         QVERIFY(item->isVisible());

   489         QVERIFY(item->isEnabled());

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

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

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

   493             QVERIFY(item->acceptsHoverEvents());

   494         else

   495             QVERIFY(!item->acceptsHoverEvents());

   496         QVERIFY(!item->hasFocus());

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

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

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

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

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

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

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

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

   505         QVERIFY(item->collidesWithItem(item));

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

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

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

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

   510         delete item;

   511     }

   512 }

   513 

   514 class BoundingRectItem : public QGraphicsRectItem

   515 {

   516 public:

   517     BoundingRectItem(QGraphicsItem *parent = 0)

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

   519                             parent)

   520     {}

   521 

   522     QRectF boundingRect() const

   523     {

   524         QRectF tmp = QGraphicsRectItem::boundingRect();

   525         foreach (QGraphicsItem *child, children())

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

   527         return tmp;

   528     }

   529 };

   530 

   531 void tst_QGraphicsItem::constructionWithParent()

   532 {

   533     // This test causes a crash if item1 calls item2's pure virtuals before the

   534     // object has been constructed.

   535     QGraphicsItem *item0 = new BoundingRectItem;

   536     QGraphicsItem *item1 = new BoundingRectItem;

   537     QGraphicsScene scene;

   538     scene.addItem(item0);

   539     scene.addItem(item1);

   540     QGraphicsItem *item2 = new BoundingRectItem(item1);

   541     QCOMPARE(item1->children(), QList<QGraphicsItem *>() << item2);

   542     QCOMPARE(item1->boundingRect(), QRectF(0, 0, 200, 200));

   543 

   544     item2->setParentItem(item0);

   545     QCOMPARE(item0->children(), QList<QGraphicsItem *>() << item2);

   546     QCOMPARE(item0->boundingRect(), QRectF(0, 0, 200, 200));

   547 }

   548 

   549 static int itemDeleted = 0;

   550 class Item : public QGraphicsRectItem

   551 {

   552 public:

   553     ~Item()

   554     { ++itemDeleted; }

   555 };

   556 

   557 void tst_QGraphicsItem::destruction()

   558 {

   559     QCOMPARE(itemDeleted, 0);

   560     {

   561         QGraphicsItem *parent = new QGraphicsRectItem;

   562         Item *child = new Item;

   563         child->setParentItem(parent);

   564         QCOMPARE(child->parentItem(), parent);

   565         delete parent;

   566         QCOMPARE(itemDeleted, 1);

   567     }

   568     {

   569         QGraphicsItem *parent = new QGraphicsRectItem;

   570         Item *child = new Item;

   571         child->setParentItem(parent);

   572         QCOMPARE(parent->children().size(), 1);

   573         delete child;

   574         QCOMPARE(parent->children().size(), 0);

   575         delete parent;

   576         QCOMPARE(itemDeleted, 2);

   577     }

   578     {

   579         QGraphicsScene scene;

   580         QGraphicsItem *parent = new QGraphicsRectItem;

   581         Item *child = new Item;

   582         QCOMPARE(child->parentItem(), (QGraphicsItem *)0);

   583         child->setParentItem(parent);

   584         QCOMPARE(child->parentItem(), parent);

   585         scene.addItem(parent);

   586         QCOMPARE(child->parentItem(), parent);

   587         delete parent;

   588         QCOMPARE(itemDeleted, 3);

   589     }

   590     {

   591         QGraphicsScene scene;

   592         QGraphicsItem *parent = new QGraphicsRectItem;

   593         Item *child = new Item;

   594         child->setParentItem(parent);

   595         scene.addItem(parent);

   596         QCOMPARE(child->scene(), &scene);

   597         QCOMPARE(parent->children().size(), 1);

   598         delete child;

   599         QCOMPARE(parent->children().size(), 0);

   600         delete parent;

   601         QCOMPARE(itemDeleted, 4);

   602     }

   603     {

   604         QGraphicsScene scene;

   605         QGraphicsItem *parent = new QGraphicsRectItem;

   606         Item *child = new Item;

   607         child->setParentItem(parent);

   608         scene.addItem(parent);

   609         QCOMPARE(child->scene(), &scene);

   610         scene.removeItem(parent);

   611         QCOMPARE(child->scene(), (QGraphicsScene *)0);

   612         delete parent;

   613         QCOMPARE(itemDeleted, 5);

   614     }

   615     {

   616         QGraphicsScene scene;

   617         QGraphicsItem *parent = new QGraphicsRectItem;

   618         Item *child = new Item;

   619         child->setParentItem(parent);

   620         QCOMPARE(child->scene(), (QGraphicsScene *)0);

   621         QCOMPARE(parent->scene(), (QGraphicsScene *)0);

   622         scene.addItem(parent);

   623         QCOMPARE(child->scene(), &scene);

   624         scene.removeItem(child);

   625         QCOMPARE(child->scene(), (QGraphicsScene *)0);

   626         QCOMPARE(parent->scene(), &scene);

   627         QCOMPARE(child->parentItem(), (QGraphicsItem *)0);

   628         QVERIFY(parent->children().isEmpty());

   629         delete parent;

   630         QCOMPARE(itemDeleted, 5);

   631         delete child;

   632         QCOMPARE(itemDeleted, 6);

   633     }

   634     {

   635         QGraphicsScene scene;

   636         QGraphicsItem *parent = new QGraphicsRectItem;

   637         Item *child = new Item;

   638         child->setParentItem(parent);

   639         scene.addItem(parent);

   640         scene.removeItem(child);

   641         scene.removeItem(parent);

   642         delete child;

   643         delete parent;

   644         QCOMPARE(itemDeleted, 7);

   645     }

   646     {

   647         QGraphicsScene scene;

   648         QGraphicsItem *parent = new QGraphicsRectItem;

   649         Item *child = new Item;

   650         child->setParentItem(parent);

   651         scene.addItem(parent);

   652         QGraphicsScene scene2;

   653         scene2.addItem(parent);

   654         delete parent;

   655         QCOMPARE(itemDeleted, 8);

   656     }

   657     {

   658         QGraphicsScene scene;

   659         QGraphicsItem *parent = new QGraphicsRectItem;

   660         Item *child = new Item;

   661         child->setParentItem(parent);

   662         scene.addItem(parent);

   663         QCOMPARE(child->scene(), &scene);

   664         QGraphicsScene scene2;

   665         scene2.addItem(parent);

   666         QCOMPARE(child->scene(), &scene2);

   667         scene.addItem(parent);

   668         QCOMPARE(child->scene(), &scene);

   669         scene2.addItem(parent);

   670         QCOMPARE(child->scene(), &scene2);

   671         delete parent;

   672         QCOMPARE(itemDeleted, 9);

   673     }

   674     {

   675         QGraphicsScene scene;

   676         QGraphicsItem *parent = new QGraphicsRectItem;

   677         Item *child = new Item;

   678         child->setParentItem(parent);

   679         scene.addItem(parent);

   680         QCOMPARE(child->scene(), &scene);

   681         QGraphicsScene scene2;

   682         scene2.addItem(child);

   683         QCOMPARE(child->scene(), &scene2);

   684         delete parent;

   685         QCOMPARE(itemDeleted, 9);

   686         delete child;

   687         QCOMPARE(itemDeleted, 10);

   688     }

   689     {

   690         QGraphicsScene scene;

   691         QGraphicsItem *root = new QGraphicsRectItem;

   692         QGraphicsItem *parent = root;

   693         QGraphicsItem *middleItem = 0;

   694         for (int i = 0; i < 99; ++i) {

   695             Item *child = new Item;

   696             child->setParentItem(parent);

   697             parent = child;

   698             if (i == 50)

   699                 middleItem = parent;

   700         }

   701         scene.addItem(root);

   702 

   703         QCOMPARE(scene.items().size(), 100);

   704 

   705         QGraphicsScene scene2;

   706         scene2.addItem(middleItem);

   707 

   708         delete middleItem;

   709         QCOMPARE(itemDeleted, 59);

   710     }

   711     QCOMPARE(itemDeleted, 109);

   712     {

   713         QGraphicsScene *scene = new QGraphicsScene;

   714         QGraphicsRectItem *parent = new QGraphicsRectItem;

   715         Item *child = new Item;

   716         child->setParentItem(parent);

   717         parent->setVisible(false);

   718         scene->addItem(parent);

   719         QCOMPARE(child->parentItem(), static_cast<QGraphicsItem*>(parent));

   720         delete scene;

   721         QCOMPARE(itemDeleted, 110);

   722     }

   723 }

   724 

   725 void tst_QGraphicsItem::deleteChildItem()

   726 {

   727     QGraphicsScene scene;

   728     QGraphicsItem *rect = scene.addRect(QRectF());

   729     QGraphicsItem *child1 = new QGraphicsRectItem(rect);

   730     QGraphicsItem *child2 = new QGraphicsRectItem(rect);

   731     QGraphicsItem *child3 = new QGraphicsRectItem(rect);

   732     delete child1;

   733     child2->setParentItem(0);

   734     delete child2;

   735 }

   736 

   737 void tst_QGraphicsItem::scene()

   738 {

   739     QGraphicsRectItem *item = new QGraphicsRectItem;

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

   741 

   742     QGraphicsScene scene;

   743     scene.addItem(item);

   744     QCOMPARE(item->scene(), (QGraphicsScene *)&scene);

   745 

   746     QGraphicsScene scene2;

   747     scene2.addItem(item);

   748     QCOMPARE(item->scene(), (QGraphicsScene *)&scene2);

   749 

   750     scene2.removeItem(item);

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

   752 

   753     delete item;

   754 }

   755 

   756 void tst_QGraphicsItem::parentItem()

   757 {

   758     QGraphicsRectItem item;

   759     QCOMPARE(item.parentItem(), (QGraphicsItem *)0);

   760 

   761     QGraphicsRectItem *item2 = new QGraphicsRectItem(QRectF(), &item);

   762     QCOMPARE(item2->parentItem(), (QGraphicsItem *)&item);

   763     item2->setParentItem(&item);

   764     QCOMPARE(item2->parentItem(), (QGraphicsItem *)&item);

   765     item2->setParentItem(0);

   766     QCOMPARE(item2->parentItem(), (QGraphicsItem *)0);

   767 

   768     delete item2;

   769 }

   770 

   771 void tst_QGraphicsItem::setParentItem()

   772 {

   773     QGraphicsScene scene;

   774     QGraphicsItem *item = scene.addRect(QRectF(0, 0, 10, 10));

   775     QCOMPARE(item->scene(), &scene);

   776 

   777     QGraphicsRectItem *child = new QGraphicsRectItem;

   778     QCOMPARE(child->scene(), (QGraphicsScene *)0);

   779 

   780     // This implicitly adds the item to the parent's scene

   781     child->setParentItem(item);

   782     QCOMPARE(child->scene(), &scene);

   783 

   784     // This just makes it a toplevel

   785     child->setParentItem(0);

   786     QCOMPARE(child->scene(), &scene);

   787 

   788     // Add the child back to the parent, then remove the parent from the scene

   789     child->setParentItem(item);

   790     scene.removeItem(item);

   791     QCOMPARE(child->scene(), (QGraphicsScene *)0);

   792 }

   793 

   794 void tst_QGraphicsItem::children()

   795 {

   796     QGraphicsRectItem item;

   797     QVERIFY(item.children().isEmpty());

   798 

   799     QGraphicsRectItem *item2 = new QGraphicsRectItem(QRectF(), &item);

   800     QCOMPARE(item.children().size(), 1);

   801     QCOMPARE(item.children().first(), (QGraphicsItem *)item2);

   802     QVERIFY(item2->children().isEmpty());

   803 

   804     delete item2;

   805     QVERIFY(item.children().isEmpty());

   806 }

   807 

   808 void tst_QGraphicsItem::flags()

   809 {

   810     QGraphicsRectItem *item = new QGraphicsRectItem(QRectF(-10, -10, 20, 20));

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

   812 

   813     QGraphicsScene scene;

   814     QEvent activate(QEvent::WindowActivate);

   815     QApplication::sendEvent(&scene, &activate);

   816 

   817     scene.addItem(item);

   818 

   819     {

   820         // Focus

   821         item->setFlag(QGraphicsItem::ItemIsFocusable, false);

   822         QVERIFY(!item->hasFocus());

   823         item->setFocus();

   824         QVERIFY(!item->hasFocus());

   825 

   826         item->setFlag(QGraphicsItem::ItemIsFocusable, true);

   827         QVERIFY(!item->hasFocus());

   828         item->setFocus();

   829         QVERIFY(item->hasFocus());

   830         QVERIFY(scene.hasFocus());

   831 

   832         item->setFlag(QGraphicsItem::ItemIsFocusable, false);

   833         QVERIFY(!item->hasFocus());

   834         QVERIFY(scene.hasFocus());

   835     }

   836     {

   837         // Selectable

   838         item->setFlag(QGraphicsItem::ItemIsSelectable, false);

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

   840         item->setSelected(true);

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

   842 

   843         item->setFlag(QGraphicsItem::ItemIsSelectable, true);

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

   845         item->setSelected(true);

   846         QVERIFY(item->isSelected());

   847         item->setFlag(QGraphicsItem::ItemIsSelectable, false);

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

   849     }

   850     {

   851         // Movable

   852         item->setFlag(QGraphicsItem::ItemIsMovable, false);

   853         QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);

   854         event.setScenePos(QPointF(0, 0));

   855         event.setButton(Qt::LeftButton);

   856         event.setButtons(Qt::LeftButton);

   857         QApplication::sendEvent(&scene, &event);

   858         QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0); // mouse grabber is reset

   859 

   860         QGraphicsSceneMouseEvent event2(QEvent::GraphicsSceneMouseMove);

   861         event2.setScenePos(QPointF(10, 10));

   862         event2.setButton(Qt::LeftButton);

   863         event2.setButtons(Qt::LeftButton);

   864         QApplication::sendEvent(&scene, &event2);

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

   866 

   867         QGraphicsSceneMouseEvent event3(QEvent::GraphicsSceneMouseRelease);

   868         event3.setScenePos(QPointF(10, 10));

   869         event3.setButtons(0);

   870         QApplication::sendEvent(&scene, &event3);

   871         QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);

   872 

   873         item->setFlag(QGraphicsItem::ItemIsMovable, true);

   874         QGraphicsSceneMouseEvent event4(QEvent::GraphicsSceneMousePress);

   875         event4.setScenePos(QPointF(0, 0));

   876         event4.setButton(Qt::LeftButton);

   877         event4.setButtons(Qt::LeftButton);

   878         QApplication::sendEvent(&scene, &event4);

   879         QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)item);

   880         QGraphicsSceneMouseEvent event5(QEvent::GraphicsSceneMouseMove);

   881         event5.setScenePos(QPointF(10, 10));

   882         event5.setButton(Qt::LeftButton);

   883         event5.setButtons(Qt::LeftButton);

   884         QApplication::sendEvent(&scene, &event5);

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

   886     }

   887     {

   888         QGraphicsItem* clippingParent = new QGraphicsRectItem;

   889         clippingParent->setFlag(QGraphicsItem::ItemClipsChildrenToShape, true);

   890 

   891         QGraphicsItem* nonClippingParent = new QGraphicsRectItem;

   892         nonClippingParent->setFlag(QGraphicsItem::ItemClipsChildrenToShape, false);

   893 

   894         QGraphicsItem* child = new QGraphicsRectItem(nonClippingParent);

   895         QVERIFY(!child->isClipped());

   896 

   897         child->setParentItem(clippingParent);

   898         QVERIFY(child->isClipped());

   899 

   900         child->setParentItem(nonClippingParent);

   901         QVERIFY(!child->isClipped());

   902     }

   903 }

   904 

   905 class ImhTester : public QGraphicsItem

   906 {

   907     QRectF boundingRect() const { return QRectF(); }

   908     void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) {}

   909 };

   910 

   911 void tst_QGraphicsItem::inputMethodHints()

   912 {

   913     ImhTester item;

   914     QCOMPARE(item.inputMethodHints(), Qt::ImhNone);

   915 }

   916 

   917 void tst_QGraphicsItem::toolTip()

   918 {

   919     QString toolTip = "Qt rocks!";

   920 

   921     QGraphicsRectItem *item = new QGraphicsRectItem(QRectF(0, 0, 100, 100));

   922     item->setPen(QPen(Qt::red, 1));

   923     item->setBrush(QBrush(Qt::blue));

   924     QVERIFY(item->toolTip().isEmpty());

   925     item->setToolTip(toolTip);

   926     QCOMPARE(item->toolTip(), toolTip);

   927 

   928     QGraphicsScene scene;

   929     scene.addItem(item);

   930 

   931     QGraphicsView view(&scene);

   932     view.setFixedSize(200, 200);

   933     view.show();

   934     QTest::qWait(250);

   935     {

   936         QHelpEvent helpEvent(QEvent::ToolTip, view.viewport()->rect().topLeft(),

   937                              view.viewport()->mapToGlobal(view.viewport()->rect().topLeft()));

   938         QApplication::sendEvent(view.viewport(), &helpEvent);

   939         QTest::qWait(250);

   940 

   941         bool foundView = false;

   942         bool foundTipLabel = false;

   943         foreach (QWidget *widget, QApplication::topLevelWidgets()) {

   944             if (widget == &view)

   945                 foundView = true;

   946             if (widget->inherits("QTipLabel"))

   947                 foundTipLabel = true;

   948         }

   949         QVERIFY(foundView);

   950         QVERIFY(!foundTipLabel);

   951     }

   952 

   953     {

   954         QHelpEvent helpEvent(QEvent::ToolTip, view.viewport()->rect().center(),

   955                              view.viewport()->mapToGlobal(view.viewport()->rect().center()));

   956         QApplication::sendEvent(view.viewport(), &helpEvent);

   957         QTest::qWait(250);

   958 

   959         bool foundView = false;

   960         bool foundTipLabel = false;

   961         foreach (QWidget *widget, QApplication::topLevelWidgets()) {

   962             if (widget == &view)

   963                 foundView = true;

   964             if (widget->inherits("QTipLabel"))

   965                 foundTipLabel = true;

   966         }

   967         QVERIFY(foundView);

   968         QVERIFY(foundTipLabel);

   969     }

   970 

   971     {

   972         QHelpEvent helpEvent(QEvent::ToolTip, view.viewport()->rect().topLeft(),

   973                              view.viewport()->mapToGlobal(view.viewport()->rect().topLeft()));

   974         QApplication::sendEvent(view.viewport(), &helpEvent);

   975         QTest::qWait(1000);

   976 

   977         bool foundView = false;

   978         bool foundTipLabel = false;

   979         foreach (QWidget *widget, QApplication::topLevelWidgets()) {

   980             if (widget == &view)

   981                 foundView = true;

   982             if (widget->inherits("QTipLabel") && widget->isVisible())

   983                 foundTipLabel = true;

   984         }

   985         QVERIFY(foundView);

   986         QVERIFY(!foundTipLabel);

   987     }

   988 }

   989 

   990 void tst_QGraphicsItem::visible()

   991 {

   992     QGraphicsItem *item = new QGraphicsRectItem(QRectF(-10, -10, 20, 20));

   993     item->setFlag(QGraphicsItem::ItemIsMovable);

   994     QVERIFY(item->isVisible());

   995     item->setVisible(false);

   996     QVERIFY(!item->isVisible());

   997     item->setVisible(true);

   998     QVERIFY(item->isVisible());

   999 

  1000     QGraphicsScene scene;

  1001     QEvent activate(QEvent::WindowActivate);

  1002     QApplication::sendEvent(&scene, &activate);

  1003 

  1004     scene.addItem(item);

  1005     QVERIFY(item->isVisible());

  1006     QCOMPARE(scene.itemAt(0, 0), item);

  1007     item->setVisible(false);

  1008     QCOMPARE(scene.itemAt(0, 0), (QGraphicsItem *)0);

  1009     item->setVisible(true);

  1010     QCOMPARE(scene.itemAt(0, 0), item);

  1011 

  1012     QGraphicsSceneMouseEvent event(QEvent::GraphicsSceneMousePress);

  1013     event.setButton(Qt::LeftButton);

  1014     event.setScenePos(QPointF(0, 0));

  1015     QApplication::sendEvent(&scene, &event);

  1016     QCOMPARE(scene.mouseGrabberItem(), item);

  1017     item->setVisible(false);

  1018     QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);

  1019     item->setVisible(true);

  1020     QCOMPARE(scene.mouseGrabberItem(), (QGraphicsItem *)0);

  1021 

  1022     item->setFlag(QGraphicsItem::ItemIsFocusable);

  1023     item->setFocus();

  1024     QVERIFY(item->hasFocus());

  1025     item->setVisible(false);

  1026     QVERIFY(!item->hasFocus());

  1027     item->setVisible(true);

  1028     QVERIFY(!item->hasFocus());

  1029 }

  1030 

  1031 void tst_QGraphicsItem::explicitlyVisible()

  1032 {

  1033     QGraphicsScene scene;

  1034     QGraphicsItem *parent = scene.addRect(QRectF(0, 0, 100, 100));

  1035     QGraphicsItem *child = scene.addRect(QRectF(25, 25, 50, 50));

  1036     child->setParentItem(parent);

  1037 

  1038     QVERIFY(parent->isVisible());

  1039     QVERIFY(child->isVisible());

  1040 

  1041     parent->hide();

  1042 

  1043     QVERIFY(!parent->isVisible());

  1044     QVERIFY(!child->isVisible());

  1045 

  1046     parent->show();

  1047     child->hide();

  1048 

  1049     QVERIFY(parent->isVisible());

  1050     QVERIFY(!child->isVisible());

  1051 

  1052     parent->hide();

  1053 

  1054     QVERIFY(!parent->isVisible());

  1055     QVERIFY(!child->isVisible());

  1056 

  1057     parent->show();

  1058 

  1059     QVERIFY(parent->isVisible());

  1060     QVERIFY(!child->isVisible()); // <- explicitly hidden

  1061 

  1062     child->show();

  1063 

  1064     QVERIFY(child->isVisible());

  1065 

  1066     parent->hide();

  1067 

  1068     QVERIFY(!parent->isVisible());

  1069     QVERIFY(!child->isVisible()); // <- explicit show doesn't work

  1070 

  1071     parent->show();

  1072 

  1073     QVERIFY(parent->isVisible());

  1074     QVERIFY(child->isVisible()); // <- no longer explicitly hidden

  1075 

  1076     // ------------------- Reparenting ------------------------------

  1077 

  1078     QGraphicsItem *parent2 = scene.addRect(-50, -50, 200, 200);

  1079     QVERIFY(parent2->isVisible());

  1080 

  1081     // Reparent implicitly hidden item to a visible parent.

  1082     parent->hide();

  1083     QVERIFY(!parent->isVisible());

  1084     QVERIFY(!child->isVisible());

  1085     child->setParentItem(parent2);

  1086     QVERIFY(parent2->isVisible());

  1087     QVERIFY(child->isVisible());

  1088 

  1089     // Reparent implicitly hidden item to a hidden parent.

  1090     child->setParentItem(parent);

  1091     parent2->hide();

  1092     child->setParentItem(parent2);

  1093     QVERIFY(!parent2->isVisible());

  1094     QVERIFY(!child->isVisible());

  1095 

  1096     // Reparent explicitly hidden item to a visible parent.

  1097     child->hide();

  1098     parent->show();

  1099     child->setParentItem(parent);

  1100     QVERIFY(parent->isVisible());

  1101     QVERIFY(!child->isVisible());

  1102 

  1103     // Reparent explicitly hidden item to a hidden parent.

  1104     child->setParentItem(parent2);

  1105     QVERIFY(!parent2->isVisible());

  1106     QVERIFY(!child->isVisible());

  1107 

  1108     // Reparent explicitly hidden item to a visible parent.

  1109     parent->show();

  1110     child->setParentItem(parent);

  1111     QVERIFY(parent->isVisible());

  1112     QVERIFY(!child->isVisible());

  1113 

  1114     // Reparent visible item to a hidden parent.

  1115     child->show();

  1116     parent2->hide();

  1117     child->setParentItem(parent2);

  1118     QVERIFY(!parent2->isVisible());

  1119     QVERIFY(!child->isVisible());

  1120     parent2->show();

  1121     QVERIFY(parent2->isVisible());

  1122     QVERIFY(child->isVisible());

  1123 

  1124     // Reparent implicitly hidden child to root.

  1125     parent2->hide();

  1126     QVERIFY(!child->isVisible());

  1127     child->setParentItem(0);

  1128     QVERIFY(child->isVisible());

  1129 

  1130     // Reparent an explicitly hidden child to root.

  1131     child->hide();

  1132     child->setParentItem(parent2);

  1133     parent2->show();

  1134     QVERIFY(!child->isVisible());