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 <qgraphicswidget.h>

    45 #include <qgraphicsscene.h>

    46 #include <qgraphicssceneevent.h>

    47 #include <qgraphicsview.h>

    48 #include <qstyleoption.h>

    49 #include <qgraphicslinearlayout.h>

    50 #include <qcleanlooksstyle.h>

    51 #include <qlineedit.h>

    52 #include <qboxlayout.h>

    53 #include <qaction.h>

    54 #include <qwidgetaction.h>

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

    56 

    57 

    58 class EventSpy : public QObject

    59 {

    60     Q_OBJECT

    61 public:

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

    63         : _count(0), spied(type)

    64     {

    65         watched->installEventFilter(this);

    66     }

    67 

    68     int count() const { return _count; }

    69 

    70 protected:

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

    72     {

    73         Q_UNUSED(watched);

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

    75             ++_count;

    76         return false;

    77     }

    78 

    79     int _count;

    80     QEvent::Type spied;

    81 };

    82 

    83 #ifndef QT_NO_STYLE_CLEANLOOKS

    84 class tst_QGraphicsWidget : public QObject {

    85 Q_OBJECT

    86 

    87 public slots:

    88     void initTestCase();

    89     void cleanupTestCase();

    90     void init();

    91     void cleanup();

    92 

    93 private slots:

    94     void qgraphicswidget();

    95 

    96     void activation();

    97     void boundingRect_data();

    98     void boundingRect();

    99     void dumpFocusChain_data();

   100     void dumpFocusChain();

   101     void focusWidget_data();

   102     void focusWidget();

   103     void focusWidget2();

   104     void focusPolicy_data();

   105     void focusPolicy();

   106     void font_data();

   107     void font();

   108     void fontPropagation();

   109     void fontPropagationWidgetItemWidget();

   110     void fontPropagationSceneChange();

   111     void geometry_data();

   112     void geometry();

   113     void getContentsMargins_data();

   114     void getContentsMargins();

   115     void initStyleOption_data();

   116     void initStyleOption();

   117     void layout_data();

   118     void layout();

   119     void layoutDirection_data();

   120     void layoutDirection();

   121     void paint_data();

   122     void paint();

   123     void palettePropagation();

   124     void parentWidget_data();

   125     void parentWidget();

   126     void resize_data();

   127     void resize();

   128     void setAttribute_data();

   129     void setAttribute();

   130     void setStyle_data();

   131     void setStyle();

   132     void setTabOrder_data();

   133     void setTabOrder();

   134     void setTabOrderAndReparent();

   135     void topLevelWidget_data();

   136     void topLevelWidget();

   137     void unsetLayoutDirection_data();

   138     void unsetLayoutDirection();

   139     void focusNextPrevChild_data();

   140     void focusNextPrevChild();

   141     void verifyFocusChain();

   142     void updateFocusChainWhenChildDie();

   143     void sizeHint_data();

   144     void sizeHint();

   145     void consistentPosSizeGeometry_data();

   146     void consistentPosSizeGeometry();

   147     void setSizes_data();

   148     void setSizes();

   149     void closePopupOnOutsideClick();

   150     void defaultSize();

   151     void explicitMouseGrabber();

   152     void implicitMouseGrabber();

   153     void doubleClickAfterExplicitMouseGrab();

   154     void popupMouseGrabber();

   155     void windowFlags_data();

   156     void windowFlags();

   157     void shortcutsDeletion();

   158     void painterStateProtectionOnWindowFrame();

   159     void ensureClipping();

   160     void widgetSendsGeometryChanges();

   161     void respectHFW();

   162     void addChildInpolishEvent();

   163 

   164     // Task fixes

   165     void task236127_bspTreeIndexFails();

   166     void task243004_setStyleCrash();

   167     void task250119_shortcutContext();

   168 };

   169 

   170 

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

   172 {

   173     QTest::mouseMove(widget, point);

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

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

   176 }

   177 

   178 // Subclass that exposes the protected functions.

   179 class SubQGraphicsWidget : public QGraphicsWidget {

   180 public:

   181     SubQGraphicsWidget(QGraphicsItem *parent = 0, Qt::WindowFlags windowFlags = 0)

   182         : QGraphicsWidget(parent, windowFlags), eventCount(0)

   183         { }

   184 

   185     void initStyleOption(QStyleOption *option)

   186         { QGraphicsWidget::initStyleOption(option); }

   187 

   188     void call_changeEvent(QEvent* event)

   189         { return QGraphicsWidget::changeEvent(event); }

   190 

   191     bool call_event(QEvent *e)

   192         { return event(e); }

   193 

   194     void call_focusInEvent(QFocusEvent* event)

   195         { return QGraphicsWidget::focusInEvent(event); }

   196 

   197     bool call_focusNextPrevChild(bool next)

   198         { return QGraphicsWidget::focusNextPrevChild(next); }

   199 

   200     void call_focusOutEvent(QFocusEvent* event)

   201         { return QGraphicsWidget::focusOutEvent(event); }

   202 

   203     void call_hideEvent(QHideEvent* event)

   204         { return QGraphicsWidget::hideEvent(event); }

   205 

   206     QVariant call_itemChange(QGraphicsItem::GraphicsItemChange change, QVariant const& value)

   207         { return QGraphicsWidget::itemChange(change, value); }

   208 

   209     void call_moveEvent(QGraphicsSceneMoveEvent* event)

   210         { return QGraphicsWidget::moveEvent(event); }

   211 

   212     void call_polishEvent()

   213         { return QGraphicsWidget::polishEvent(); }

   214 

   215     QVariant call_propertyChange(QString const& propertyName, QVariant const& value)

   216         { return QGraphicsWidget::propertyChange(propertyName, value); }

   217 

   218     void call_resizeEvent(QGraphicsSceneResizeEvent* event)

   219         { return QGraphicsWidget::resizeEvent(event); }

   220 

   221     bool call_sceneEvent(QEvent* event)

   222         { return QGraphicsWidget::sceneEvent(event); }

   223 

   224     void call_showEvent(QShowEvent* event)

   225         { return QGraphicsWidget::showEvent(event); }

   226 

   227     QSizeF call_sizeHint(Qt::SizeHint which, QSizeF const& constraint = QSizeF()) const

   228         { return QGraphicsWidget::sizeHint(which, constraint); }

   229 

   230     void call_updateGeometry()

   231         { return QGraphicsWidget::updateGeometry(); }

   232 

   233     int eventCount;

   234     Qt::LayoutDirection m_painterLayoutDirection;

   235 

   236     void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)

   237     {

   238         m_painterLayoutDirection = painter->layoutDirection();

   239         QGraphicsWidget::paint(painter, option, widget);

   240         if (hasFocus()) {

   241             painter->setPen(Qt::DotLine);

   242             painter->drawRect(rect());

   243         }

   244         //painter->drawText(QPointF(0,15), data(0).toString());

   245     }

   246 

   247 protected:

   248     bool event(QEvent *event)

   249     {

   250         eventCount++;

   251         return QGraphicsWidget::event(event);

   252     }

   253 };

   254 

   255 // This will be called before the first test function is executed.

   256 // It is only called once.

   257 void tst_QGraphicsWidget::initTestCase()

   258 {

   259 }

   260 

   261 // This will be called after the last test function is executed.

   262 // It is only called once.

   263 void tst_QGraphicsWidget::cleanupTestCase()

   264 {

   265 }

   266 

   267 // This will be called before each test function is executed.

   268 void tst_QGraphicsWidget::init()

   269 {

   270 }

   271 

   272 // This will be called after every test function.

   273 void tst_QGraphicsWidget::cleanup()

   274 {

   275 }

   276 

   277 class SizeHinter : public QGraphicsWidget

   278 {

   279 public:

   280     SizeHinter(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0,

   281                 const QSizeF &min = QSizeF(5,5),

   282                 const QSizeF &pref = QSizeF(50, 50),

   283                 const QSizeF &max = QSizeF(500, 500))

   284         : QGraphicsWidget(parent, wFlags)

   285     {

   286         m_sizes[Qt::MinimumSize] = min;

   287         m_sizes[Qt::PreferredSize] = pref;

   288         m_sizes[Qt::MaximumSize] = max;

   289 

   290     }

   291     void setSizeHint(Qt::SizeHint which, const QSizeF &newSizeHint)

   292     {

   293         m_sizes[which] = newSizeHint;

   294     }

   295 

   296 protected:

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

   298     {

   299         Q_UNUSED(constraint);

   300         return m_sizes[which];

   301     }

   302 private:

   303     QSizeF m_sizes[4];

   304 };

   305 

   306 void tst_QGraphicsWidget::qgraphicswidget()

   307 {

   308     SubQGraphicsWidget widget;

   309     QVERIFY(widget.isVisible());

   310 

   311     QVERIFY(!widget.isWindow());

   312     QCOMPARE(widget.boundingRect(), QRectF(0, 0, 0, 0));

   313     QCOMPARE(widget.focusWidget(), (QGraphicsWidget*)0);

   314     QCOMPARE(widget.focusPolicy(), Qt::NoFocus);

   315     QCOMPARE(widget.font(), QFont());

   316     QCOMPARE(widget.geometry(), QRectF(widget.pos(), widget.size()));

   317     QCOMPARE(widget.layout(), (QGraphicsLayout*)0);

   318     QCOMPARE(widget.layoutDirection(), Qt::LeftToRight);

   319     QCOMPARE(widget.palette(), QPalette());

   320     QCOMPARE(widget.parentWidget(), (QGraphicsWidget*)0);

   321     QCOMPARE(widget.rect(), QRectF(QPointF(), widget.size()));

   322     QCOMPARE(widget.size(), QSizeF(0, 0));

   323     QVERIFY(widget.style() != (QStyle*)0);

   324     QCOMPARE(widget.testAttribute(Qt::WA_AcceptDrops), false);

   325     QCOMPARE(widget.topLevelWidget(), (QGraphicsWidget*)&widget);

   326     QCOMPARE(widget.type(), (int)QGraphicsWidget::Type);

   327     QCOMPARE(widget.call_propertyChange(QString(), QVariant()), QVariant());

   328     widget.call_sizeHint(Qt::PreferredSize, QSizeF());

   329 

   330     QGraphicsScene scene;

   331     QGraphicsWidget *parent = new QGraphicsWidget;

   332     SizeHinter *child = new SizeHinter(parent);

   333 

   334     QCOMPARE(child->minimumSize(), QSizeF(5, 5));

   335 }

   336 

   337 void tst_QGraphicsWidget::activation()

   338 {

   339     QGraphicsWidget *widget = new QGraphicsWidget;

   340     QGraphicsWidget *window1 = new QGraphicsWidget(0, Qt::Window);

   341     QGraphicsWidget *window2 = new QGraphicsWidget(0, Qt::Window);

   342     QVERIFY(!widget->isActiveWindow());

   343     QVERIFY(!window1->isActiveWindow());

   344     QVERIFY(!window2->isActiveWindow());

   345 

   346     QGraphicsScene scene;

   347     scene.addItem(widget);

   348     scene.addItem(window1);

   349     scene.addItem(window2);

   350 

   351     QVERIFY(!widget->isActiveWindow());

   352     QVERIFY(!window1->isActiveWindow());

   353     QVERIFY(!window2->isActiveWindow());

   354 

   355     QEvent activateEvent(QEvent::WindowActivate);

   356     QApplication::sendEvent(&scene, &activateEvent);

   357 

   358     QVERIFY(!widget->isActiveWindow());

   359     QVERIFY(window1->isActiveWindow());

   360     QVERIFY(!window2->isActiveWindow());

   361 

   362     scene.setActiveWindow(window1);

   363     QVERIFY(!widget->isActiveWindow());

   364     QVERIFY(window1->isActiveWindow());

   365     QVERIFY(!window2->isActiveWindow());

   366 

   367     QEvent deactivateEvent(QEvent::WindowDeactivate);

   368     QApplication::sendEvent(&scene, &deactivateEvent);

   369 

   370     QVERIFY(!widget->isActiveWindow());

   371     QVERIFY(!window1->isActiveWindow());

   372     QVERIFY(!window2->isActiveWindow());

   373 }

   374 

   375 void tst_QGraphicsWidget::boundingRect_data()

   376 {

   377     QTest::addColumn<QSizeF>("size");

   378     QTest::newRow("null") << QSizeF(0, 0);

   379     QTest::newRow("avg") << QSizeF(10, 10);

   380 }

   381 

   382 // QRectF boundingRect() const public

   383 void tst_QGraphicsWidget::boundingRect()

   384 {

   385     QFETCH(QSizeF, size);

   386     SubQGraphicsWidget widget;

   387     widget.resize(size);

   388     QCOMPARE(widget.rect(), QRectF(QPointF(), size));

   389     QCOMPARE(widget.boundingRect(), QRectF(QPointF(0, 0), size));

   390 }

   391 

   392 void tst_QGraphicsWidget::dumpFocusChain_data()

   393 {

   394     QTest::addColumn<bool>("scene");

   395     QTest::addColumn<int>("children");

   396     QTest::addColumn<bool>("setFocus");

   397     QTest::newRow("empty world") << false << 0 << false;

   398     QTest::newRow("one world") << true << 2 << false;

   399     QTest::newRow("one world w/focus") << true << 2 << true;

   400 }

   401 

   402 // void dumpFocusChain(QGraphicsScene* scene) public (static)

   403 void tst_QGraphicsWidget::dumpFocusChain()

   404 {

   405     // ### this test is very strange...

   406     QFETCH(bool, scene);

   407     SubQGraphicsWidget *parent = new SubQGraphicsWidget;

   408     QGraphicsScene *theScene = 0;

   409     if (scene) {

   410         theScene = new QGraphicsScene(this);

   411         theScene->addItem(parent);

   412     }

   413     QFETCH(int, children);

   414     QFETCH(bool, setFocus);

   415     for (int i = 0; i < children; ++i) {

   416         SubQGraphicsWidget *widget = new SubQGraphicsWidget(parent);

   417         if (setFocus) {

   418             widget->setFlag(QGraphicsItem::ItemIsFocusable, true);

   419             if (scene)

   420                 theScene->setFocusItem(widget);

   421         }

   422     }

   423 

   424     if (!scene)

   425         delete parent;

   426 }

   427 

   428 void tst_QGraphicsWidget::focusWidget_data()

   429 {

   430     QTest::addColumn<int>("childCount");

   431     QTest::addColumn<int>("childWithFocus");

   432     QTest::newRow("none") << 0 << 0;

   433     QTest::newRow("first") << 3 << 0;

   434     QTest::newRow("last") << 3 << 2;

   435 }

   436 

   437 // QGraphicsWidget* focusWidget() const public

   438 void tst_QGraphicsWidget::focusWidget()

   439 {

   440     SubQGraphicsWidget *parent = new SubQGraphicsWidget;

   441     QCOMPARE(parent->focusWidget(), (QGraphicsWidget *)0);

   442     QGraphicsScene scene;

   443     QEvent windowActivate(QEvent::WindowActivate);

   444     qApp->sendEvent(&scene, &windowActivate);

   445     scene.addItem(parent);

   446 

   447     QFETCH(int, childCount);

   448     QList<SubQGraphicsWidget *> children;

   449     for (int i = 0; i < childCount; ++i) {

   450         SubQGraphicsWidget *widget = new SubQGraphicsWidget(parent);

   451         widget->setFlag(QGraphicsItem::ItemIsFocusable, true);

   452         children.append(widget);

   453     }

   454     if (childCount > 0) {

   455         QFETCH(int, childWithFocus);

   456         SubQGraphicsWidget *widget = children[childWithFocus];

   457         widget->setFocus();

   458         QVERIFY(widget->hasFocus());

   459         QCOMPARE(parent->focusWidget(), static_cast<QGraphicsWidget*>(widget));

   460     }

   461 }

   462 

   463 void tst_QGraphicsWidget::focusWidget2()

   464 {

   465     QGraphicsScene scene;

   466     QEvent windowActivate(QEvent::WindowActivate);

   467     qApp->sendEvent(&scene, &windowActivate);

   468 

   469     QGraphicsWidget *widget = new QGraphicsWidget;

   470     EventSpy focusInSpy(widget, QEvent::FocusIn);

   471     EventSpy focusOutSpy(widget, QEvent::FocusOut);

   472 

   473     scene.addItem(widget);

   474 

   475     QVERIFY(!widget->hasFocus());

   476     widget->setFocusPolicy(Qt::StrongFocus);

   477     QVERIFY(!widget->hasFocus());

   478 

   479     QGraphicsWidget *subWidget = new QGraphicsWidget(widget);

   480     QVERIFY(!subWidget->hasFocus());

   481 

   482     scene.setFocus();

   483 

   484     QVERIFY(!widget->hasFocus());

   485     QVERIFY(!subWidget->hasFocus());

   486 

   487     widget->setFocus();

   488 

   489     QVERIFY(widget->hasFocus());

   490     QCOMPARE(focusInSpy.count(), 1);

   491     QVERIFY(!subWidget->hasFocus());

   492 

   493     QGraphicsWidget *otherSubWidget = new QGraphicsWidget;

   494     EventSpy otherFocusInSpy(otherSubWidget, QEvent::FocusIn);

   495     EventSpy otherFocusOutSpy(otherSubWidget, QEvent::FocusOut);

   496 

   497     otherSubWidget->setFocusPolicy(Qt::StrongFocus);

   498     otherSubWidget->setParentItem(widget);

   499 

   500     QVERIFY(widget->hasFocus());

   501     QCOMPARE(scene.focusItem(), (QGraphicsItem *)widget);

   502     QVERIFY(!subWidget->hasFocus());

   503     QVERIFY(!otherSubWidget->hasFocus());

   504 

   505     widget->hide();

   506     QVERIFY(!widget->hasFocus()); // lose but still has subfocus

   507     QCOMPARE(focusInSpy.count(), 1);

   508     QCOMPARE(focusOutSpy.count(), 1);

   509 

   510     widget->show();

   511     QVERIFY(!widget->hasFocus()); // no regain

   512     QCOMPARE(focusInSpy.count(), 1);

   513     QCOMPARE(focusOutSpy.count(), 1);

   514 

   515     widget->hide();

   516 

   517     // try to setup subFocus on item that can't take focus

   518     subWidget->setFocus();

   519     QVERIFY(!subWidget->hasFocus());

   520     QVERIFY(!scene.focusItem()); // but isn't the scene's focus item

   521 

   522     // try to setup subFocus on item that can take focus

   523     otherSubWidget->setFocus();

   524     QVERIFY(!otherSubWidget->hasFocus());

   525     QCOMPARE(widget->focusWidget(), otherSubWidget);

   526     QVERIFY(!scene.focusItem()); // but isn't the scene's focus item

   527 

   528     widget->show();

   529 

   530     QCOMPARE(scene.focusItem(), (QGraphicsItem *)otherSubWidget); // but isn't the scene's focus item

   531     QCOMPARE(otherFocusInSpy.count(), 1);

   532     QCOMPARE(otherFocusOutSpy.count(), 0);

   533 

   534     delete otherSubWidget;

   535 

   536     QCOMPARE(otherFocusOutSpy.count(), 1);

   537     QVERIFY(!scene.focusItem());

   538     QVERIFY(!widget->focusWidget());

   539 }

   540 

   541 Q_DECLARE_METATYPE(Qt::FocusPolicy)

   542 void tst_QGraphicsWidget::focusPolicy_data()

   543 {

   544     QTest::addColumn<Qt::FocusPolicy>("focusPolicy1");

   545     QTest::addColumn<Qt::FocusPolicy>("focusPolicy2");

   546 

   547     for (int i = 0; i < 25; ++i) {

   548         QTestData &data = QTest::newRow(QString("%1").arg(i).toLatin1());

   549         switch(i % 5) {

   550         case 0: data << Qt::TabFocus; break;

   551         case 1: data << Qt::ClickFocus; break;

   552         case 2: data << Qt::StrongFocus; break;

   553         case 3: data << Qt::WheelFocus; break;

   554         case 4: data << Qt::NoFocus; break;

   555         }

   556         switch(i / 5) {

   557         case 0: data << Qt::TabFocus; break;

   558         case 1: data << Qt::ClickFocus; break;

   559         case 2: data << Qt::StrongFocus; break;

   560         case 3: data << Qt::WheelFocus; break;

   561         case 4: data << Qt::NoFocus; break;

   562         }

   563     }

   564 }

   565 

   566 // Qt::FocusPolicy focusPolicy() const public

   567 void tst_QGraphicsWidget::focusPolicy()

   568 {

   569     QGraphicsScene scene;

   570     QEvent windowActivate(QEvent::WindowActivate);

   571     qApp->sendEvent(&scene, &windowActivate);

   572 

   573     SubQGraphicsWidget *widget = new SubQGraphicsWidget;

   574     scene.addItem(widget);

   575     QCOMPARE(Qt::NoFocus, widget->focusPolicy());

   576 

   577     QFETCH(Qt::FocusPolicy, focusPolicy1);

   578     widget->setFocusPolicy(focusPolicy1);

   579     QCOMPARE(widget->focusPolicy(), focusPolicy1);

   580     bool isFocusable = widget->flags() & QGraphicsItem::ItemIsFocusable;

   581     bool wasFocusable = isFocusable;

   582     QVERIFY(isFocusable == (focusPolicy1 != Qt::NoFocus));

   583     widget->setFocus();

   584     QCOMPARE(widget->hasFocus(), isFocusable);

   585 

   586     QFETCH(Qt::FocusPolicy, focusPolicy2);

   587     widget->setFocusPolicy(focusPolicy2);

   588     QCOMPARE(widget->focusPolicy(), focusPolicy2);

   589     isFocusable = widget->flags() & QGraphicsItem::ItemIsFocusable;

   590     QVERIFY(isFocusable == (focusPolicy2 != Qt::NoFocus));

   591     QCOMPARE(widget->hasFocus(), wasFocusable && isFocusable);

   592 }

   593 

   594 void tst_QGraphicsWidget::font_data()

   595 {

   596     QTest::addColumn<QString>("fontName");

   597     QTest::newRow("Helvetica") << "Helvetica";

   598 }

   599 

   600 // QFont font() const public

   601 void tst_QGraphicsWidget::font()

   602 {

   603     QFETCH(QString, fontName);

   604     SubQGraphicsWidget widget;

   605     QCOMPARE(widget.font(), QFont());

   606 

   607     QFont font(fontName);

   608     widget.setFont(font);

   609     QCOMPARE(widget.font().family(), font.family());

   610 }

   611 

   612 void tst_QGraphicsWidget::fontPropagation()

   613 {

   614     QGraphicsWidget *root = new QGraphicsWidget;

   615     QGraphicsWidget *child0 = new QGraphicsWidget(root);

   616     QGraphicsWidget *child1 = new QGraphicsWidget(child0);

   617     QGraphicsWidget *child2 = new QGraphicsWidget(child1);

   618     QGraphicsScene scene;

   619     scene.addItem(root);

   620 

   621     // Check that only the application fonts apply.

   622     QFont appFont = QApplication::font();

   623     QCOMPARE(scene.font(), appFont);

   624     QCOMPARE(root->font(), appFont);

   625     QCOMPARE(child0->font(), appFont);

   626     QCOMPARE(child1->font(), appFont);

   627 

   628     // Set child0's Text, and set ToolTipBase on child1.

   629     QFont boldFont;

   630     boldFont.setBold(true);

   631     child0->setFont(boldFont);

   632     QFont italicFont;

   633     italicFont.setItalic(true);

   634     child1->setFont(italicFont);

   635 

   636     // Check that the above settings propagate correctly.

   637     QCOMPARE(root->font(), appFont);

   638     QCOMPARE(scene.font(), appFont);

   639     QVERIFY(child0->font().bold());

   640     QVERIFY(!child0->font().italic());

   641     QVERIFY(child1->font().bold());

   642     QVERIFY(child1->font().italic());

   643     QVERIFY(child2->font().bold());

   644     QVERIFY(child2->font().italic());

   645 

   646     QGraphicsWidget *child3 = new QGraphicsWidget(child2);

   647     QVERIFY(child3->font().bold());

   648     QVERIFY(child3->font().italic());

   649 

   650     QGraphicsWidget *child4 = new QGraphicsWidget;

   651     child4->setParentItem(child3);

   652     QVERIFY(child4->font().bold());

   653     QVERIFY(child4->font().italic());

   654 

   655     // Replace the app font for child2. Button should propagate but Text

   656     // should still be ignored. The previous ToolTipBase setting is gone.

   657     QFont sizeFont;

   658     sizeFont.setPointSize(43);

   659     child1->setFont(sizeFont);

   660 

   661     // Check that the above settings propagate correctly.

   662     QCOMPARE(root->font(), appFont);

   663     QCOMPARE(scene.font(), appFont);

   664     QVERIFY(child0->font().bold());

   665     QVERIFY(!child0->font().italic());

   666     QVERIFY(child1->font().bold());

   667     QVERIFY(!child1->font().italic());

   668     QCOMPARE(child1->font().pointSize(), 43);

   669     QVERIFY(child2->font().bold());

   670     QVERIFY(!child2->font().italic());

   671     QCOMPARE(child2->font().pointSize(), 43);

   672 }

   673 

   674 void tst_QGraphicsWidget::fontPropagationWidgetItemWidget()

   675 {

   676     QGraphicsWidget *widget = new QGraphicsWidget;

   677     QGraphicsRectItem *rect = new QGraphicsRectItem(widget);

   678     QGraphicsWidget *widget2 = new QGraphicsWidget(rect);

   679 

   680     QGraphicsScene scene;

   681     scene.addItem(widget);

   682 

   683     QFont font;

   684     font.setPointSize(43);

   685     widget->setFont(font);

   686 

   687     QCOMPARE(widget2->font().pointSize(), 43);

   688     QCOMPARE(widget2->font().resolve(), QFont().resolve());

   689 

   690     widget->setFont(QFont());

   691 

   692     QCOMPARE(widget2->font().pointSize(), qApp->font().pointSize());

   693 }

   694 

   695 void tst_QGraphicsWidget::fontPropagationSceneChange()

   696 {

   697     QGraphicsWidget *widget = new QGraphicsWidget;

   698     QGraphicsRectItem *rect = new QGraphicsRectItem(widget);

   699     QGraphicsWidget *widget2 = new QGraphicsWidget(rect);

   700 

   701     QGraphicsScene scene;

   702     QGraphicsScene scene2;

   703 

   704     QFont font;

   705     font.setPointSize(47);

   706     scene.setFont(font);

   707 

   708     QFont font2;

   709     font2.setPointSize(74);

   710     scene2.setFont(font2);

   711 

   712     scene.addItem(widget);

   713     QCOMPARE(widget2->font().pointSize(), 47);

   714     scene2.addItem(widget);

   715     QCOMPARE(widget2->font().pointSize(), 74);

   716 }

   717 

   718 void tst_QGraphicsWidget::geometry_data()

   719 {

   720     QTest::addColumn<QPointF>("pos");

   721     QTest::addColumn<QSizeF>("size");

   722     QTest::newRow("null, null") << QPointF() << QSizeF(0, 0);

   723     QTest::newRow("null, normal") << QPointF() << QSizeF(10, 10);

   724     QTest::newRow("neg, normal") << QPointF(-5, -5) << QSizeF(10, 10);

   725 }

   726 

   727 // QRectF geometry() const public

   728 void tst_QGraphicsWidget::geometry()

   729 {

   730     SubQGraphicsWidget widget;

   731     QCOMPARE(widget.geometry(), QRectF(widget.pos(), widget.size()));

   732 

   733     QFETCH(QPointF, pos);

   734     QFETCH(QSizeF, size);

   735     widget.setPos(pos);

   736     widget.resize(size);

   737     QCOMPARE(widget.geometry(), QRectF(pos, size));

   738 }

   739 

   740 void tst_QGraphicsWidget::getContentsMargins_data()

   741 {

   742     QTest::addColumn<qreal>("left");

   743     QTest::addColumn<qreal>("top");

   744     QTest::addColumn<qreal>("right");

   745     QTest::addColumn<qreal>("bottom");

   746     QTest::newRow("null") << (qreal)0 << (qreal)0 << (qreal)0 << (qreal)0;

   747     QTest::newRow("something") << (qreal)10 << (qreal)5 << (qreal)3 << (qreal)7;

   748     QTest::newRow("real") << (qreal)1.7 << (qreal)5.9 << (qreal)3.2 << (qreal)9.7;

   749 }

   750 

   751 // void getContentsMargins(qreal* left, qreal* top, qreal* right, qreal* bottom) const public

   752 void tst_QGraphicsWidget::getContentsMargins()

   753 {

   754     qreal gleft;

   755     qreal gtop;

   756     qreal gright;

   757     qreal gbottom;

   758 

   759     SubQGraphicsWidget widget;

   760     widget.getContentsMargins(&gleft, &gtop, &gright, &gbottom);

   761     QCOMPARE(gleft, (qreal)0);

   762     QCOMPARE(gtop, (qreal)0);

   763     QCOMPARE(gright, (qreal)0);

   764     QCOMPARE(gbottom, (qreal)0);

   765 

   766     QFETCH(qreal, left);

   767     QFETCH(qreal, top);

   768     QFETCH(qreal, right);

   769     QFETCH(qreal, bottom);

   770     int oldEventCounts = widget.eventCount;

   771     widget.setContentsMargins(left, top, right, bottom);

   772     QVERIFY(left == 0 || oldEventCounts != widget.eventCount);

   773     widget.getContentsMargins(&gleft, &gtop, &gright, &gbottom);

   774     QCOMPARE(gleft, left);

   775     QCOMPARE(gtop, top);

   776     QCOMPARE(gright, right);

   777     QCOMPARE(gbottom, bottom);

   778 }

   779 

   780 Q_DECLARE_METATYPE(Qt::LayoutDirection)

   781 void tst_QGraphicsWidget::initStyleOption_data()

   782 {

   783     QTest::addColumn<bool>("enabled");

   784     QTest::addColumn<bool>("focus");

   785     QTest::addColumn<bool>("underMouse");

   786     QTest::addColumn<Qt::LayoutDirection>("layoutDirection");

   787     QTest::addColumn<QSizeF>("size");

   788     QTest::addColumn<QPalette>("palette");

   789     QTest::addColumn<QString>("fontName");

   790     QTest::newRow("none") << false << false << false << Qt::LeftToRight << QSizeF(0, 0) << QPalette() << QString();

   791     QTest::newRow("all") << true << true << true << Qt::RightToLeft << QSizeF(300, 300) << QPalette(Qt::magenta) << "Helvetica";

   792     QTest::newRow("rand") << true << false << false << Qt::RightToLeft << QSizeF(1, 0) << QPalette(Qt::darkCyan) << "Times";

   793 }

   794 

   795 // void initStyleOption(QStyleOption* option) const public

   796 void tst_QGraphicsWidget::initStyleOption()

   797 {

   798     QGraphicsScene scene;

   799     QGraphicsView view(&scene);

   800     view.show();

   801 #ifdef Q_WS_X11

   802     qt_x11_wait_for_window_manager(&view);

   803 #endif

   804     QApplication::setActiveWindow(&view);

   805     QTest::qWait(25);

   806     QTRY_COMPARE(QApplication::activeWindow(), &view);

   807 

   808     view.setAlignment(Qt::AlignTop | Qt::AlignLeft);

   809     SubQGraphicsWidget *widget = new SubQGraphicsWidget;

   810     widget->setAcceptsHoverEvents(true);

   811     QStyleOption option;

   812     scene.addItem(widget);

   813 

   814     QFETCH(QSizeF, size);

   815     widget->resize(size);

   816 

   817     QFETCH(bool, enabled);

   818     widget->setEnabled(enabled);

   819     QFETCH(bool, focus);

   820     if (focus) {

   821         widget->setFlag(QGraphicsItem::ItemIsFocusable, true);

   822         widget->setFocus();

   823         QVERIFY(widget->hasFocus());

   824     }

   825     QFETCH(bool, underMouse);

   826     if (underMouse) {

   827         view.resize(300, 300);

   828         view.show();

   829         QTest::qWaitForWindowShown(&view);

   830         QTest::qWait(20);

   831         sendMouseMove(view.viewport(), view.mapFromScene(widget->mapToScene(widget->boundingRect().center())));

   832     }

   833 

   834     QFETCH(QPalette, palette);

   835     widget->setPalette(palette);

   836 

   837     QFETCH(QString, fontName);

   838     widget->setFont(QFont(fontName));

   839 

   840     // The test

   841     widget->initStyleOption(&option);

   842 

   843     bool isEnabled = option.state & QStyle::State_Enabled;

   844     QCOMPARE(isEnabled, enabled);

   845     bool hasFocus = option.state & QStyle::State_HasFocus;

   846     QCOMPARE(hasFocus, focus);

   847     bool isUnderMouse = option.state & QStyle::State_MouseOver;

   848 #ifndef Q_OS_WINCE

   849     QCOMPARE(isUnderMouse, underMouse);

   850 #endif

   851     // if (layoutDirection != Qt::LeftToRight)

   852     //QEXPECT_FAIL("", "QApplicaiton::layoutDirection doesn't propagate to QGraphicsWidget", Continue);

   853     //QCOMPARE(option.direction, layoutDirection);

   854     QCOMPARE(option.rect, QRectF(QPointF(), size).toRect());

   855     QCOMPARE(option.palette, palette.resolve(QApplication::palette()));

   856     QCOMPARE(option.fontMetrics, QFontMetrics(widget->font()));

   857 }

   858 

   859 void tst_QGraphicsWidget::layout_data()

   860 {

   861     QTest::addColumn<int>("childCount");

   862     QTest::newRow("empty") << 0;

   863     QTest::newRow("10") << 10;

   864 }

   865 

   866 // QGraphicsLayout* layout() const public

   867 void tst_QGraphicsWidget::layout()

   868 {

   869     SubQGraphicsWidget widget;

   870     widget.setContentsMargins(10, 5, 50, 100);

   871     QCOMPARE(widget.layout(), (QGraphicsLayout *)0);

   872     QFETCH(int, childCount);

   873 

   874     QGraphicsLinearLayout *layout = new QGraphicsLinearLayout;

   875     QList<SubQGraphicsWidget*> children;

   876     for (int i = 0; i < childCount; ++i) {

   877         SubQGraphicsWidget *item = new SubQGraphicsWidget;

   878         layout->addItem(item);

   879         children.append(item);

   880     }

   881     widget.setLayout(layout);

   882 

   883     QTest::qWait(25);

   884 

   885     QCOMPARE(widget.layout(), static_cast<QGraphicsLayout*>(layout));

   886     for (int i = 0; i < children.count(); ++i) {

   887         SubQGraphicsWidget *item = children[i];

   888         QCOMPARE(item->parentWidget(), (QGraphicsWidget *)&widget);

   889         QVERIFY(item->geometry() != QRectF(0, 0, -1, -1));

   890     }

   891 

   892     // don't crash

   893     widget.setLayout(0);

   894 }

   895 

   896 void tst_QGraphicsWidget::layoutDirection_data()

   897 {

   898     QTest::addColumn<Qt::LayoutDirection>("layoutDirection");

   899     QTest::newRow("rtl") << Qt::RightToLeft;

   900     QTest::newRow("ltr") << Qt::LeftToRight;

   901 }

   902 

   903 // Qt::LayoutDirection layoutDirection() const public

   904 void tst_QGraphicsWidget::layoutDirection()

   905 {

   906     QFETCH(Qt::LayoutDirection, layoutDirection);

   907     QGraphicsScene scene;

   908     QGraphicsView *view = new QGraphicsView(&scene);

   909     SubQGraphicsWidget widget;

   910     scene.addItem(&widget);

   911     QCOMPARE(widget.layoutDirection(), Qt::LeftToRight);

   912     QCOMPARE(widget.testAttribute(Qt::WA_SetLayoutDirection), false);

   913 

   914     QList<SubQGraphicsWidget*> children;

   915     for (int i = 0; i < 10; ++i) {

   916         SubQGraphicsWidget *item = new SubQGraphicsWidget(&widget);

   917         children.append(item);

   918         QCOMPARE(item->testAttribute(Qt::WA_SetLayoutDirection), false);

   919     }

   920     widget.setLayoutDirection(layoutDirection);

   921     QCOMPARE(widget.testAttribute(Qt::WA_SetLayoutDirection), true);

   922     view->show();

   923     QTest::qWaitForWindowShown(view);

   924     for (int i = 0; i < children.count(); ++i) {

   925         QCOMPARE(children[i]->layoutDirection(), layoutDirection);

   926         QCOMPARE(children[i]->testAttribute(Qt::WA_SetLayoutDirection), false);

   927         view->repaint();

   928         QApplication::processEvents();

   929         QTRY_COMPARE(children[i]->m_painterLayoutDirection, layoutDirection);

   930     }

   931     delete view;

   932 }

   933 

   934 void tst_QGraphicsWidget::paint_data()

   935 {

   936     // currently QGraphicsWidget doesn't paint or do anything ...

   937 }

   938 

   939 // void paint(QPainter* painter, QStyleOptionGraphicsItem const* option, QWidget* widget) public

   940 void tst_QGraphicsWidget::paint()

   941 {

   942     SubQGraphicsWidget widget;

   943     QPainter painter;

   944     QStyleOptionGraphicsItem option;

   945     widget.paint(&painter, &option, 0); // check that widget = 0 works.

   946 }

   947 

   948 void tst_QGraphicsWidget::palettePropagation()

   949 {

   950     QGraphicsWidget *root = new QGraphicsWidget;

   951     QGraphicsWidget *child0 = new QGraphicsWidget(root);

   952     QGraphicsWidget *child1 = new QGraphicsWidget(child0);

   953     QGraphicsWidget *child2 = new QGraphicsWidget(child1);

   954     QGraphicsScene scene;

   955     scene.addItem(root);

   956 

   957     // These colors are unlikely to be imposed on the default palette of

   958     // QWidget ;-).

   959     QColor sysPalText(21, 22, 23);

   960     QColor sysPalToolTipBase(12, 13, 14);

   961     QColor overridePalText(42, 43, 44);

   962     QColor overridePalToolTipBase(45, 46, 47);

   963     QColor sysPalButton(99, 98, 97);

   964 

   965     // Check that only the application fonts apply.

   966     QPalette appPal = QApplication::palette();

   967     QCOMPARE(scene.palette(), appPal);

   968     QCOMPARE(root->palette(), appPal);

   969     QCOMPARE(child0->palette(), appPal);

   970     QCOMPARE(child1->palette(), appPal);

   971 

   972     // Set child0's Text, and set ToolTipBase on child1.

   973     QPalette textPalette;

   974     textPalette.setColor(QPalette::Text, overridePalText);

   975     child0->setPalette(textPalette);

   976     QPalette toolTipPalette;

   977     toolTipPalette.setColor(QPalette::ToolTipBase, overridePalToolTipBase);

   978     child1->setPalette(toolTipPalette);

   979 

   980     // Check that the above settings propagate correctly.

   981     QCOMPARE(root->palette(), appPal);

   982     QCOMPARE(scene.palette(), appPal);

   983     QCOMPARE(child0->palette().color(QPalette::Text), overridePalText);

   984     QCOMPARE(child0->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));

   985     QCOMPARE(child1->palette().color(QPalette::Text), overridePalText);

   986     QCOMPARE(child1->palette().color(QPalette::ToolTipBase), overridePalToolTipBase);

   987     QCOMPARE(child2->palette().color(QPalette::Text), overridePalText);

   988     QCOMPARE(child2->palette().color(QPalette::ToolTipBase), overridePalToolTipBase);

   989 

   990     QGraphicsWidget *child3 = new QGraphicsWidget(child2);

   991     QCOMPARE(child3->palette().color(QPalette::Text), overridePalText);

   992     QCOMPARE(child3->palette().color(QPalette::ToolTipBase), overridePalToolTipBase);

   993 

   994     QGraphicsWidget *child4 = new QGraphicsWidget;

   995     child4->setParentItem(child3);

   996     QCOMPARE(child4->palette().color(QPalette::Text), overridePalText);

   997     QCOMPARE(child4->palette().color(QPalette::ToolTipBase), overridePalToolTipBase);

   998 

   999     // Replace the app palette for child2. Button should propagate but Text

  1000     // should still be ignored. The previous ToolTipBase setting is gone.

  1001     QPalette buttonPalette;

  1002     buttonPalette.setColor(QPalette::Button, sysPalButton);

  1003     child1->setPalette(buttonPalette);

  1004 

  1005     QCOMPARE(root->palette(), appPal);

  1006     QCOMPARE(scene.palette(), appPal);

  1007     QCOMPARE(child0->palette().color(QPalette::Text), overridePalText);

  1008     QCOMPARE(child0->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));

  1009     QCOMPARE(child1->palette().color(QPalette::Text), overridePalText);

  1010     QCOMPARE(child1->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));

  1011     QCOMPARE(child1->palette().color(QPalette::Button), sysPalButton);

  1012     QCOMPARE(child2->palette().color(QPalette::Text), overridePalText);

  1013     QCOMPARE(child2->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));

  1014     QCOMPARE(child2->palette().color(QPalette::Button), sysPalButton);

  1015 }

  1016 

  1017 void tst_QGraphicsWidget::parentWidget_data()

  1018 {

  1019     QTest::addColumn<int>("childrenCount");

  1020     QTest::newRow("0") << 0;

  1021     QTest::newRow("1") << 1;

  1022     QTest::newRow("10") << 10;

  1023 }

  1024 

  1025 // QGraphicsWidget* parentWidget() const public

  1026 void tst_QGraphicsWidget::parentWidget()

  1027 {

  1028     QFETCH(int, childrenCount);

  1029     SubQGraphicsWidget standAlongWidget;

  1030     QGraphicsLineItem standAlongItem;

  1031 

  1032     SubQGraphicsWidget widgetChild(&standAlongWidget);

  1033     SubQGraphicsWidget itemChild(&standAlongItem);

  1034 

  1035     QCOMPARE(standAlongWidget.parentWidget(), (QGraphicsWidget*)0);

  1036     QCOMPARE(widgetChild.parentWidget(), static_cast<QGraphicsWidget*>(&standAlongWidget));

  1037     QCOMPARE(itemChild.parentWidget(), (QGraphicsWidget*)0);

  1038 

  1039     for (int i = 0; i < childrenCount; ++i) {

  1040         SubQGraphicsWidget *item = new SubQGraphicsWidget(&standAlongWidget);

  1041         QCOMPARE(item->parentWidget(), static_cast<QGraphicsWidget*>(&standAlongWidget));

  1042     }

  1043 }

  1044 

  1045 void tst_QGraphicsWidget::resize_data()

  1046 {

  1047     QTest::addColumn<QSizeF>("size");

  1048     QTest::newRow("null") << QSizeF();

  1049     QTest::newRow("10x10") << QSizeF(10, 10);

  1050     QTest::newRow("10x-1") << QSizeF(10, -1);

  1051 }

  1052 

  1053 // void resize(qreal w, qreal h) public

  1054 void tst_QGraphicsWidget::resize()

  1055 {

  1056     QFETCH(QSizeF, size);

  1057     SubQGraphicsWidget widget;

  1058 

  1059     int oldEventCounts = widget.eventCount;

  1060     QSizeF oldSize = widget.size();

  1061     widget.resize(size);

  1062 

  1063     QSizeF boundedSize = size.expandedTo(widget.minimumSize()).boundedTo(widget.maximumSize());

  1064     QCOMPARE(widget.eventCount, oldEventCounts + ((oldSize == boundedSize) ? 0 : 1));

  1065     QCOMPARE(widget.size(), boundedSize);

  1066 }

  1067 

  1068 Q_DECLARE_METATYPE(Qt::WidgetAttribute)

  1069 void tst_QGraphicsWidget::setAttribute_data()

  1070 {

  1071     QTest::addColumn<Qt::WidgetAttribute>("attribute");

  1072     QTest::addColumn<bool>("supported");

  1073     QTest::newRow("WA_SetLayoutDirection") << Qt::WA_SetLayoutDirection << true;

  1074     QTest::newRow("WA_RightToLeft") << Qt::WA_RightToLeft << true;

  1075     QTest::newRow("WA_SetStyle") << Qt::WA_SetStyle << true;

  1076     QTest::newRow("WA_Resized") << Qt::WA_Resized << true;

  1077     QTest::newRow("unsupported") << Qt::WA_PaintOutsidePaintEvent << false;

  1078 }

  1079 

  1080 // void setAttribute(Qt::WidgetAttribute attribute, bool on = true) public

  1081 void tst_QGraphicsWidget::setAttribute()

  1082 {

  1083     QFETCH(Qt::WidgetAttribute, attribute);

  1084     QFETCH(bool, supported);

  1085     SubQGraphicsWidget widget;

  1086     if (attribute == Qt::WA_PaintOutsidePaintEvent)

  1087         QTest::ignoreMessage(QtWarningMsg, "QGraphicsWidget::setAttribute: unsupported attribute 13");

  1088     widget.setAttribute(attribute);

  1089     QCOMPARE(widget.testAttribute(attribute), supported);

  1090 }

  1091 

  1092 void tst_QGraphicsWidget::setStyle_data()

  1093 {

  1094     QTest::addColumn<QString>("style");

  1095     QTest::newRow("null") << "";

  1096     QTest::newRow("cleanlooks") << "QCleanlooksStyle";

  1097 }

  1098 

  1099 // void setStyle(QStyle* style) public

  1100 void tst_QGraphicsWidget::setStyle()

  1101 {

  1102     SubQGraphicsWidget widget;

  1103     QCleanlooksStyle cleanlooksStyle;

  1104 

  1105     int oldEventCounts = widget.eventCount;

  1106 

  1107     QFETCH(QString, style);

  1108     if (style == "QCleanlooksStyle") {

  1109         widget.setStyle(&cleanlooksStyle);

  1110         QCOMPARE(widget.style(), static_cast<QStyle*>(&cleanlooksStyle));

  1111     } else {

  1112         widget.setStyle(0);

  1113         QVERIFY(widget.style() != (QStyle *)0);

  1114     }

  1115     QCOMPARE(widget.eventCount, oldEventCounts + 1);

  1116     QCOMPARE(widget.testAttribute(Qt::WA_SetStyle), !style.isEmpty());

  1117 

  1118     // cleanup

  1119     widget.setStyle(0);

  1120 }

  1121 

  1122 void tst_QGraphicsWidget::setTabOrder_data()

  1123 {

  1124     QTest::addColumn<int>("childrenCount");

  1125     QTest::newRow("0") << 0;

  1126     QTest::newRow("1") << 1;

  1127     QTest::newRow("10") << 10;

  1128 }

  1129 

  1130 // void setTabOrder(QGraphicsWidget* first, QGraphicsWidget* second) public

  1131 void tst_QGraphicsWidget::setTabOrder()

  1132 {

  1133     QFETCH(int, childrenCount);

  1134     QGraphicsScene scene;