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 "../../shared/util.h"

    46 #include <private/qlayoutengine_p.h>    // qSmartMin functions...

    47 #if defined(Q_WS_MAC) && !defined(QT_NO_STYLE_MAC)

    48 #include <QMacStyle>

    49 #endif

    50 #ifdef Q_WS_X11

    51 #include <private/qt_x11_p.h>

    52 #endif

    53 

    54 static void sendMouseMove(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::NoButton)

    55 {

    56     QMouseEvent event(QEvent::MouseMove, point, widget->mapToGlobal(point), button, button, 0);

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

    58 }

    59 

    60 

    61 #ifndef QT_NO_STYLE_CLEANLOOKS

    62 /*

    63     Notes:

    64 

    65     1) The proxy and the widget geometries are linked.

    66        proxy resize => widget resize => stop (no livelock)

    67        widget resize => proxy resize => stop (no livelock)

    68 

    69     2) As far as possible, the properties are linked.

    70        proxy enable => widget enable => stop

    71        widget disabled => proxy disabled => stop

    72 

    73     3) Windowed state is linked

    74        Windowed proxy state => windowed widget state => stop

    75        Windowed widget state => windowed proxy state => stop

    76 */

    77 

    78 class EventSpy : public QObject

    79 {

    80 public:

    81     EventSpy(QObject *receiver)

    82     {

    83         receiver->installEventFilter(this);

    84     }

    85 

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

    87 

    88 protected:

    89     bool eventFilter(QObject *, QEvent *event)

    90     {

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

    92         return false;

    93     }

    94 };

    95 

    96 class tst_QGraphicsProxyWidget : public QObject

    97 {

    98     Q_OBJECT

    99 

   100 public slots:

   101     void initTestCase();

   102     void cleanupTestCase();

   103     void init();

   104     void cleanup();

   105 

   106 private slots:

   107     void qgraphicsproxywidget_data();

   108     void qgraphicsproxywidget();

   109     void paint();

   110     void paint_2();

   111     void setWidget_data();

   112     void setWidget();

   113     void eventFilter_data();

   114     void eventFilter();

   115     void focusInEvent_data();

   116     void focusInEvent();

   117     void focusInEventNoWidget();

   118     void focusNextPrevChild_data();

   119     void focusNextPrevChild();

   120     void focusOutEvent_data();

   121     void focusOutEvent();

   122     void hoverEnterLeaveEvent_data();

   123     void hoverEnterLeaveEvent();

   124     void hoverMoveEvent_data();

   125     void hoverMoveEvent();

   126     void keyPressEvent_data();

   127     void keyPressEvent();

   128     void keyReleaseEvent_data();

   129     void keyReleaseEvent();

   130     void mouseDoubleClickEvent_data();

   131     void mouseDoubleClickEvent();

   132     void mousePressReleaseEvent_data();

   133     void mousePressReleaseEvent();

   134     void resizeEvent_data();

   135     void resizeEvent();

   136     void paintEvent();

   137     void wheelEvent();

   138     void sizeHint_data();

   139     void sizeHint();

   140     void sizePolicy();

   141     void minimumSize();

   142     void maximumSize();

   143     void scrollUpdate();

   144     void setWidget_simple();

   145     void setWidget_ownership();

   146     void resize_simple_data();

   147     void resize_simple();

   148     void symmetricMove();

   149     void symmetricResize();

   150     void symmetricEnabled();

   151     void symmetricVisible();

   152     void tabFocus_simpleWidget();

   153     void tabFocus_simpleTwoWidgets();

   154     void tabFocus_complexWidget();

   155     void tabFocus_complexTwoWidgets();

   156     void setFocus_simpleWidget();

   157     void setFocus_simpleTwoWidgets();

   158     void setFocus_complexTwoWidgets();

   159     void popup_basic();

   160     void popup_subwidget();

   161     void changingCursor_basic();

   162     void tooltip_basic();

   163     void childPos_data();

   164     void childPos();

   165     void autoShow();

   166     void windowOpacity();

   167     void stylePropagation();

   168     void palettePropagation();

   169     void fontPropagation();

   170     void dontCrashWhenDie();

   171     void createProxyForChildWidget();

   172     void actionsContextMenu();

   173     void actionsContextMenu_data();

   174     void deleteProxyForChildWidget();

   175     void bypassGraphicsProxyWidget_data();

   176     void bypassGraphicsProxyWidget();

   177     void dragDrop();

   178     void windowFlags_data();

   179     void windowFlags();

   180     void comboboxWindowFlags();

   181     void updateAndDelete();

   182     void inputMethod();

   183     void clickFocus();

   184 };

   185 

   186 // Subclass that exposes the protected functions.

   187 class SubQGraphicsProxyWidget : public QGraphicsProxyWidget

   188 {

   189 

   190 public:

   191     SubQGraphicsProxyWidget(QGraphicsItem *parent = 0) : QGraphicsProxyWidget(parent),

   192     paintCount(0), keyPress(0), focusOut(0)

   193         {}

   194 

   195     bool call_eventFilter(QObject* object, QEvent* event)

   196         { return SubQGraphicsProxyWidget::eventFilter(object, event); }

   197 

   198     void call_focusInEvent(QFocusEvent* event)

   199         { return SubQGraphicsProxyWidget::focusInEvent(event); }

   200 

   201     bool call_focusNextPrevChild(bool next)

   202         { return SubQGraphicsProxyWidget::focusNextPrevChild(next); }

   203 

   204     void call_focusOutEvent(QFocusEvent* event)

   205         { return SubQGraphicsProxyWidget::focusOutEvent(event); }

   206 

   207     void call_hideEvent(QHideEvent* event)

   208         { return SubQGraphicsProxyWidget::hideEvent(event); }

   209 

   210     void call_hoverEnterEvent(QGraphicsSceneHoverEvent* event)

   211         { return SubQGraphicsProxyWidget::hoverEnterEvent(event); }

   212 

   213     void call_hoverLeaveEvent(QGraphicsSceneHoverEvent* event)

   214         { return SubQGraphicsProxyWidget::hoverLeaveEvent(event); }

   215 

   216     void call_hoverMoveEvent(QGraphicsSceneHoverEvent* event)

   217         { return SubQGraphicsProxyWidget::hoverMoveEvent(event); }

   218 

   219     void call_keyPressEvent(QKeyEvent* event)

   220         { return SubQGraphicsProxyWidget::keyPressEvent(event); }

   221 

   222     void call_keyReleaseEvent(QKeyEvent* event)

   223         { return SubQGraphicsProxyWidget::keyReleaseEvent(event); }

   224 

   225     void call_mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event)

   226         { return SubQGraphicsProxyWidget::mouseDoubleClickEvent(event); }

   227 

   228     void call_mouseMoveEvent(QGraphicsSceneMouseEvent* event)

   229         { return SubQGraphicsProxyWidget::mouseMoveEvent(event); }

   230 

   231     void call_mousePressEvent(QGraphicsSceneMouseEvent* event)

   232         { return SubQGraphicsProxyWidget::mousePressEvent(event); }

   233 

   234     void call_mouseReleaseEvent(QGraphicsSceneMouseEvent* event)

   235         { return SubQGraphicsProxyWidget::mouseReleaseEvent(event); }

   236 

   237     void call_resizeEvent(QGraphicsSceneResizeEvent* event)

   238         { return SubQGraphicsProxyWidget::resizeEvent(event); }

   239 

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

   241         { return SubQGraphicsProxyWidget::sizeHint(which, constraint); }

   242 

   243     void call_showEvent(QShowEvent* event)

   244         { return SubQGraphicsProxyWidget::showEvent(event); }

   245 

   246     void paint (QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)    {

   247         paintCount++;

   248         QGraphicsProxyWidget::paint(painter, option, widget);

   249     }

   250 

   251     void focusOutEvent(QFocusEvent *event)

   252     {

   253         focusOut++;

   254         QGraphicsProxyWidget::focusOutEvent(event);

   255     }

   256 

   257     bool eventFilter(QObject *object, QEvent *event) {

   258         if (event->type() == QEvent::KeyPress && object == widget())

   259             keyPress++;

   260         return QGraphicsProxyWidget::eventFilter(object, event);

   261     }

   262     int paintCount;

   263     int keyPress;

   264     int focusOut;

   265 };

   266 

   267 class WheelWidget : public QWidget

   268 {

   269 public:

   270     WheelWidget() : wheelEventCalled(false) { setFocusPolicy(Qt::WheelFocus); }

   271 

   272     virtual void wheelEvent(QWheelEvent *event) { event->accept(); wheelEventCalled = true; }

   273 

   274     bool wheelEventCalled;

   275 };

   276 

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

   278 // It is only called once.

   279 void tst_QGraphicsProxyWidget::initTestCase()

   280 {

   281 #ifdef Q_OS_WINCE //disable magic for WindowsCE

   282     qApp->setAutoMaximizeThreshold(-1);

   283 #endif

   284 }

   285 

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

   287 // It is only called once.

   288 void tst_QGraphicsProxyWidget::cleanupTestCase()

   289 {

   290 }

   291 

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

   293 void tst_QGraphicsProxyWidget::init()

   294 {

   295 }

   296 

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

   298 void tst_QGraphicsProxyWidget::cleanup()

   299 {

   300 }

   301 

   302 void tst_QGraphicsProxyWidget::qgraphicsproxywidget_data()

   303 {

   304 }

   305 

   306 void tst_QGraphicsProxyWidget::qgraphicsproxywidget()

   307 {

   308     SubQGraphicsProxyWidget proxy;

   309     proxy.paint(0, 0, 0);

   310     proxy.setWidget(0);

   311     QVERIFY(proxy.type() == QGraphicsProxyWidget::Type);

   312     QVERIFY(!proxy.widget());

   313     QEvent event(QEvent::None);

   314     proxy.call_eventFilter(0, &event);

   315     QFocusEvent focusEvent(QEvent::FocusIn);

   316     focusEvent.ignore();

   317     proxy.call_focusInEvent(&focusEvent);

   318     QCOMPARE(focusEvent.isAccepted(), false);

   319     QCOMPARE(proxy.call_focusNextPrevChild(false), false);

   320     QCOMPARE(proxy.call_focusNextPrevChild(true), false);

   321     proxy.call_focusOutEvent(&focusEvent);

   322     QHideEvent hideEvent;

   323     proxy.call_hideEvent(&hideEvent);

   324     QGraphicsSceneHoverEvent hoverEvent;

   325     proxy.call_hoverEnterEvent(&hoverEvent);

   326     proxy.call_hoverLeaveEvent(&hoverEvent);

   327     proxy.call_hoverMoveEvent(&hoverEvent);

   328     QKeyEvent keyEvent(QEvent::KeyPress, 0, Qt::NoModifier);

   329     proxy.call_keyPressEvent(&keyEvent);

   330     proxy.call_keyReleaseEvent(&keyEvent);

   331     QGraphicsSceneMouseEvent mouseEvent;

   332     proxy.call_mouseDoubleClickEvent(&mouseEvent);

   333     proxy.call_mouseMoveEvent(&mouseEvent);

   334     proxy.call_mousePressEvent(&mouseEvent);

   335     proxy.call_mouseReleaseEvent(&mouseEvent);

   336     QGraphicsSceneResizeEvent resizeEvent;

   337     proxy.call_resizeEvent(&resizeEvent);

   338     QShowEvent showEvent;

   339     proxy.call_showEvent(&showEvent);

   340     proxy.call_sizeHint(Qt::PreferredSize, QSizeF());

   341 }

   342 

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

   344 void tst_QGraphicsProxyWidget::paint()

   345 {

   346     SubQGraphicsProxyWidget proxy;

   347     proxy.paint(0, 0, 0);

   348 }

   349 

   350 class MyProxyWidget : public QGraphicsProxyWidget

   351 {

   352 public:

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

   354     {

   355         // Make sure QGraphicsProxyWidget::paint does not modify the render hints set on the painter.

   356         painter->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform

   357                                 | QPainter::NonCosmeticDefaultPen | QPainter::TextAntialiasing);

   358         const QPainter::RenderHints oldRenderHints = painter->renderHints();

   359         QGraphicsProxyWidget::paint(painter, option, widget);

   360         QCOMPARE(painter->renderHints(), oldRenderHints);

   361     }

   362 };

   363 

   364 void tst_QGraphicsProxyWidget::paint_2()

   365 {

   366     MyProxyWidget *proxyWidget = new MyProxyWidget;

   367     proxyWidget->setWidget(new QLineEdit);

   368 

   369     QGraphicsScene scene;

   370     scene.addItem(proxyWidget);

   371     scene.setSceneRect(scene.itemsBoundingRect());

   372 

   373     // Trigger repaint.

   374     QPixmap pixmap(scene.sceneRect().toRect().size());

   375     QPainter painter(&pixmap);

   376     scene.render(&painter);

   377 }

   378 

   379 void tst_QGraphicsProxyWidget::setWidget_data()

   380 {

   381     QTest::addColumn<bool>("widgetExists");

   382     QTest::addColumn<bool>("insertWidget");

   383     QTest::addColumn<bool>("hasParent");

   384     QTest::addColumn<bool>("proxyHasParent");

   385 

   386     QTest::newRow("setWidget(0)") << false << false << false << false;

   387     QTest::newRow("setWidget(widget)") << false << true << false << false;

   388     QTest::newRow("setWidget(widgetWParent)") << false << true << true << false;

   389     QTest::newRow("setWidget(1), setWidget(0)") << true << false << false << false;

   390     QTest::newRow("setWidget(1), setWidget(widget)") << true << true << false << false;

   391     QTest::newRow("setWidget(1), setWidget(widgetWParent)") << true << true << true << false;

   392     QTest::newRow("p setWidget(0)") << false << false << false << true;

   393     QTest::newRow("p setWidget(widget)") << false << true << false << true;

   394     QTest::newRow("p setWidget(widgetWParent)") << false << true << true << true;

   395     QTest::newRow("p setWidget(1), setWidget(0)") << true << false << false << true;

   396     QTest::newRow("p setWidget(1), setWidget(widget)") << true << true << false << true;

   397     QTest::newRow("p setWidget(1), setWidget(widgetWParent)") << true << true << true << true;

   398 }

   399 

   400 // public void setWidget(QWidget* widget)

   401 void tst_QGraphicsProxyWidget::setWidget()

   402 {

   403     QFETCH(bool, widgetExists);

   404     QFETCH(bool, insertWidget);

   405     QFETCH(bool, hasParent);

   406     QFETCH(bool, proxyHasParent);

   407 

   408     QGraphicsScene scene;

   409     QGraphicsView view(&scene);

   410     view.show();

   411 #ifdef Q_WS_X11

   412     qt_x11_wait_for_window_manager(&view);

   413 #endif

   414     QPointer<SubQGraphicsProxyWidget> proxy = new SubQGraphicsProxyWidget;

   415     SubQGraphicsProxyWidget parentProxy;

   416     scene.addItem(proxy);

   417     scene.addItem(&parentProxy);

   418     if (proxyHasParent)

   419         proxy->setParent(&parentProxy);

   420     QPointer<QWidget> existingSubWidget = new QWidget;

   421     proxy->setVisible(false);

   422     proxy->setEnabled(false);

   423 

   424     if (widgetExists) {

   425         existingSubWidget->setAttribute(Qt::WA_QuitOnClose, true);

   426         proxy->setWidget(existingSubWidget);

   427     }

   428 

   429     QWidget *widget = new QWidget;

   430 #ifndef QT_NO_CURSOR

   431     widget->setCursor(Qt::IBeamCursor);

   432 #endif

   433     widget->setPalette(QPalette(Qt::magenta));

   434     widget->setLayoutDirection(Qt::RightToLeft);

   435     QCleanlooksStyle cleanlooksStyle;

   436     widget->setStyle(&cleanlooksStyle);

   437     widget->setFont(QFont("Times"));

   438     widget->setVisible(true);

   439     QApplication::setActiveWindow(widget);

   440     widget->activateWindow();

   441     widget->setEnabled(true);

   442     widget->resize(325, 241);

   443     widget->setMinimumSize(100, 200);

   444     widget->setMaximumSize(1000, 2000);

   445     widget->setFocusPolicy(Qt::TabFocus);

   446     widget->setContentsMargins(10, 29, 19, 81);

   447     widget->setFocus(Qt::TabFocusReason);

   448     widget->setAcceptDrops(true);

   449     QTRY_VERIFY(widget->hasFocus());

   450     QVERIFY(widget->isActiveWindow());

   451 

   452     QWidget parentWidget;

   453     if (hasParent)

   454         widget->setParent(&parentWidget);

   455 

   456     QWidget *subWidget = insertWidget ? widget : 0;

   457     bool shouldBeInsertable = !hasParent && subWidget;

   458     if (shouldBeInsertable)

   459         subWidget->setAttribute(Qt::WA_QuitOnClose, true);

   460 

   461     proxy->setWidget(subWidget);

   462 

   463     if (shouldBeInsertable) {

   464         QCOMPARE(proxy->widget(), subWidget);

   465         QVERIFY(subWidget->testAttribute(Qt::WA_DontShowOnScreen));

   466         QVERIFY(!subWidget->testAttribute(Qt::WA_QuitOnClose));

   467         QCOMPARE(proxy->acceptHoverEvents(), true);

   468 #ifndef QT_NO_CURSOR

   469         QVERIFY(proxy->hasCursor());

   470 

   471         // These should match

   472         QCOMPARE(proxy->cursor().shape(), widget->cursor().shape());

   473 #endif

   474         //###QCOMPARE(proxy->palette(), widget->palette());

   475         QCOMPARE(proxy->layoutDirection(), widget->layoutDirection());

   476         QCOMPARE(proxy->style(), widget->style());

   477         QCOMPARE(proxy->isVisible(), widget->isVisible());

   478         QCOMPARE(proxy->isEnabled(), widget->isEnabled());

   479         QVERIFY(proxy->flags() & QGraphicsItem::ItemIsFocusable);

   480         QCOMPARE(proxy->effectiveSizeHint(Qt::MinimumSize).toSize(),

   481             qSmartMinSize(widget));

   482         QCOMPARE(proxy->minimumSize().toSize(),

   483                  qSmartMinSize(widget) );

   484         QCOMPARE(proxy->maximumSize().toSize(), QSize(1000, 2000));

   485         QCOMPARE(proxy->effectiveSizeHint(Qt::PreferredSize).toSize(),

   486                 qSmartMinSize(widget));

   487         QCOMPARE(proxy->size().toSize(), widget->size());

   488         QCOMPARE(proxy->rect().toRect(), widget->rect());

   489         QCOMPARE(proxy->focusPolicy(), Qt::WheelFocus);

   490         QVERIFY(proxy->acceptDrops());

   491         QCOMPARE(proxy->acceptsHoverEvents(), true); // to get widget enter events

   492         int left, top, right, bottom;

   493         widget->getContentsMargins(&left, &top, &right, &bottom);

   494         qreal rleft, rtop, rright, rbottom;

   495         proxy->getContentsMargins(&rleft, &rtop, &rright, &rbottom);

   496         QCOMPARE((qreal)left, rleft);

   497         QCOMPARE((qreal)top, rtop);

   498         QCOMPARE((qreal)right, rright);

   499         QCOMPARE((qreal)bottom, rbottom);

   500     } else {

   501         // proxy shouldn't mess with the widget if it can't insert it.

   502         QCOMPARE(proxy->widget(), (QWidget*)0);

   503         QCOMPARE(proxy->acceptHoverEvents(), false);

   504         if (subWidget) {

   505             QVERIFY(!subWidget->testAttribute(Qt::WA_DontShowOnScreen));

   506             QVERIFY(subWidget->testAttribute(Qt::WA_QuitOnClose));

   507             // reset

   508             subWidget->setAttribute(Qt::WA_QuitOnClose, false);

   509         }

   510     }

   511 

   512     if (widgetExists) {

   513         QCOMPARE(existingSubWidget->parent(), static_cast<QObject*>(0));

   514         QVERIFY(!existingSubWidget->testAttribute(Qt::WA_DontShowOnScreen));

   515         QVERIFY(!existingSubWidget->testAttribute(Qt::WA_QuitOnClose));

   516     }

   517 

   518     if (hasParent)

   519         widget->setParent(0);

   520 

   521     delete widget;

   522     if (shouldBeInsertable)

   523         QVERIFY(!proxy);

   524     delete existingSubWidget;

   525     if (!shouldBeInsertable) {

   526         QVERIFY(proxy);

   527         delete proxy;

   528     }

   529     QVERIFY(!proxy);

   530 }

   531 

   532 Q_DECLARE_METATYPE(QEvent::Type)

   533 void tst_QGraphicsProxyWidget::eventFilter_data()

   534 {

   535     QTest::addColumn<QEvent::Type>("eventType");

   536     QTest::addColumn<bool>("fromObject"); // big grin evil

   537     QTest::newRow("none") << QEvent::None << false;

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

   539         bool fromObject = (i == 0);

   540         QTest::newRow(QString("resize %1").arg(fromObject).toLatin1()) << QEvent::Resize << fromObject;

   541         QTest::newRow(QString("move %1").arg(fromObject).toLatin1()) << QEvent::Move << fromObject;

   542         QTest::newRow(QString("hide %1").arg(fromObject).toLatin1()) << QEvent::Hide << fromObject;

   543         QTest::newRow(QString("show %1").arg(fromObject).toLatin1()) << QEvent::Show << fromObject;

   544         QTest::newRow(QString("enabled %1").arg(fromObject).toLatin1()) << QEvent::EnabledChange << fromObject;

   545         QTest::newRow(QString("focusIn %1").arg(fromObject).toLatin1()) << QEvent::FocusIn << fromObject;

   546         QTest::newRow(QString("focusOut %1").arg(fromObject).toLatin1()) << QEvent::FocusOut << fromObject;

   547         QTest::newRow(QString("keyPress %1").arg(fromObject).toLatin1()) << QEvent::KeyPress << fromObject;

   548     }

   549 }

   550 

   551 // protected bool eventFilter(QObject* object, QEvent* event)

   552 void tst_QGraphicsProxyWidget::eventFilter()

   553 {

   554     QFETCH(QEvent::Type, eventType);

   555     QFETCH(bool, fromObject);

   556 

   557     QGraphicsScene scene;

   558     QEvent windowActivate(QEvent::WindowActivate);

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

   560 

   561     SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;

   562     scene.addItem(proxy);

   563 

   564     QWidget *widget = new QWidget(0, Qt::FramelessWindowHint);

   565     widget->setFocusPolicy(Qt::TabFocus);

   566     widget->resize(10, 10);

   567     widget->show();

   568     proxy->setWidget(widget);

   569     proxy->show();

   570 

   571     // mirror whatever is happening to the widget

   572     // don't get in a loop

   573     switch (eventType) {

   574     case QEvent::None: {

   575         QEvent event(QEvent::None);

   576         proxy->call_eventFilter(widget, &event);

   577         break;

   578                        }

   579     case QEvent::Resize: {

   580         QSize oldSize = widget->size();

   581         QSize newSize = QSize(100, 100);

   582         if (fromObject) {

   583             widget->resize(newSize);

   584         } else {

   585             proxy->resize(newSize);

   586         }

   587         QCOMPARE(proxy->size().toSize(), newSize);

   588         QCOMPARE(widget->size(), newSize);

   589         break;

   590                          }

   591     case QEvent::Move: {

   592         QPoint oldPoint = widget->pos();

   593         QPoint newPoint = QPoint(100, 100);

   594         if (fromObject) {

   595             widget->move(newPoint);

   596         } else {

   597             proxy->setPos(newPoint);

   598         }

   599         QCOMPARE(proxy->pos().toPoint(), newPoint);

   600         QCOMPARE(widget->pos(), newPoint);

   601         break;

   602                          }

   603     case QEvent::Hide: {

   604         // A hide event can only come from a widget

   605         if (fromObject) {

   606             widget->setFocus(Qt::TabFocusReason);

   607             widget->hide();

   608         } else {

   609             QHideEvent event;

   610             proxy->call_eventFilter(widget, &event);

   611         }

   612         QCOMPARE(proxy->isVisible(), false);

   613         break;

   614                          }

   615     case QEvent::Show: {

   616         // A show event can either come from a widget or somewhere else

   617         widget->hide();

   618         if (fromObject) {

   619             widget->show();

   620         } else {

   621             QShowEvent event;

   622             proxy->call_eventFilter(widget, &event);

   623         }

   624         QCOMPARE(proxy->isVisible(), true);

   625         break;

   626                          }

   627     case QEvent::EnabledChange: {

   628         widget->setEnabled(false);

   629         proxy->setEnabled(false);

   630         if (fromObject) {

   631             widget->setEnabled(true);

   632             QCOMPARE(proxy->isEnabled(), true);

   633             widget->setEnabled(false);

   634             QCOMPARE(proxy->isEnabled(), false);

   635         } else {

   636             QEvent event(QEvent::EnabledChange);

   637             proxy->call_eventFilter(widget, &event);

   638             // match the widget not the event

   639             QCOMPARE(proxy->isEnabled(), false);

   640         }

   641         break;

   642                          }

   643     case QEvent::FocusIn: {

   644         if (fromObject) {

   645             widget->setFocus(Qt::TabFocusReason);

   646             QVERIFY(proxy->hasFocus());

   647         }

   648         break;

   649                          }

   650     case QEvent::FocusOut: {

   651         widget->setFocus(Qt::TabFocusReason);

   652         QVERIFY(proxy->hasFocus());

   653         QVERIFY(widget->hasFocus());

   654         if (fromObject) {

   655             widget->clearFocus();

   656             QVERIFY(!proxy->hasFocus());

   657         }

   658         break;

   659                          }

   660     case QEvent::KeyPress: {

   661         if (fromObject) {

   662             QTest::keyPress(widget, Qt::Key_A, Qt::NoModifier);

   663         } else {

   664             QKeyEvent event(QEvent::KeyPress, Qt::Key_A, Qt::NoModifier);

   665             proxy->call_eventFilter(widget, &event);

   666         }

   667         QCOMPARE(proxy->keyPress, 1);

   668         break;

   669                          }

   670     default:

   671         break;

   672     }

   673 }

   674 

   675 void tst_QGraphicsProxyWidget::focusInEvent_data()

   676 {

   677     QTest::addColumn<bool>("widgetHasFocus");

   678     QTest::addColumn<bool>("widgetCanHaveFocus");

   679     QTest::newRow("no focus, can't get") << false << false;

   680     QTest::newRow("no focus, can get") << false << true;

   681     QTest::newRow("has focus, can't get") << true << false;

   682     QTest::newRow("has focus, can get") << true << true;

   683     // ### add test for widget having a focusNextPrevChild

   684 }

   685 

   686 // protected void focusInEvent(QFocusEvent* event)

   687 void tst_QGraphicsProxyWidget::focusInEvent()

   688 {

   689     // ### This test is just plain old broken

   690     QFETCH(bool, widgetHasFocus);

   691     QFETCH(bool, widgetCanHaveFocus);

   692 

   693     QGraphicsScene scene;

   694     QEvent windowActivate(QEvent::WindowActivate);

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

   696 

   697     SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;

   698     proxy->setEnabled(true);

   699     scene.addItem(proxy);

   700     proxy->setVisible(true);

   701 

   702     QWidget *widget = new QWidget;

   703     widget->resize(100, 100);

   704     if (widgetCanHaveFocus)

   705         widget->setFocusPolicy(Qt::WheelFocus);

   706     widget->show();

   707 

   708     if (widgetHasFocus)

   709         widget->setFocus(Qt::TabFocusReason);

   710 

   711     proxy->setWidget(widget);

   712     proxy->setFlag(QGraphicsItem::ItemIsFocusable, true); // <- shouldn't need to do this

   713 

   714     // ### This test is just plain old broken - sending a focus in event

   715     // does not cause items to gain input focus. The widget has focus

   716     // because the proxy has focus, not because it got this event.

   717 

   718     QFocusEvent event(QEvent::FocusIn, Qt::TabFocusReason);

   719     event.ignore();

   720     proxy->call_focusInEvent(&event);

   721     QTRY_COMPARE(widget->hasFocus(), widgetCanHaveFocus);

   722 }

   723 

   724 void tst_QGraphicsProxyWidget::focusInEventNoWidget()

   725 {

   726     QGraphicsView view;

   727     QGraphicsScene scene(&view);

   728     SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;

   729     proxy->setEnabled(true);

   730     scene.addItem(proxy);

   731     proxy->setVisible(true);

   732     view.show();

   733 

   734     proxy->setFlag(QGraphicsItem::ItemIsFocusable, true); // <- shouldn't need to do this

   735     QFocusEvent event(QEvent::FocusIn, Qt::TabFocusReason);

   736     event.ignore();

   737     //should not crash

   738     proxy->call_focusInEvent(&event);

   739 }

   740 

   741 void tst_QGraphicsProxyWidget::focusNextPrevChild_data()

   742 {

   743     QTest::addColumn<bool>("hasWidget");

   744     QTest::addColumn<bool>("hasScene");

   745     QTest::addColumn<bool>("next");

   746     QTest::addColumn<bool>("focusNextPrevChild");

   747 

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

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

   750             for (int k = 0; k < 2; ++k) {

   751                 bool next = (i == 0);

   752                 bool hasWidget = (j == 0);

   753                 bool hasScene = (k == 0);

   754                 bool result = hasScene && hasWidget;

   755                 QString name = QString("Forward: %1, hasWidget: %2, hasScene: %3, result: %4").arg(next).arg(hasWidget).arg(hasScene).arg(result);

   756                 QTest::newRow(name.toLatin1()) << hasWidget << hasScene << next << result;

   757             }

   758         }

   759     }

   760 }

   761 

   762 // protected bool focusNextPrevChild(bool next)

   763 void tst_QGraphicsProxyWidget::focusNextPrevChild()

   764 {

   765     QFETCH(bool, next);

   766     QFETCH(bool, focusNextPrevChild);

   767     QFETCH(bool, hasWidget);

   768     QFETCH(bool, hasScene);

   769 

   770     // If a widget has its own focusNextPrevChild we need to respect it

   771     // otherwise respect the scene

   772     // Respect the widget over the scene!

   773 

   774     SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;

   775 

   776     QLabel *widget = new QLabel;

   777     // I can't believe designer adds this much junk!

   778     widget->setText("<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\"> p, li { white-space: pre-wrap; } </style></head><body style=\" font-family:'Sans Serif'; font-size:9pt; font-weight:400; font-style:normal;\"> <p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><a href=\"http://www.slashdot.org\"><span style=\" text-decoration: underline; color:#0000ff;\">old</span></a> foo <a href=\"http://www.reddit.org\"><span style=\" text-decoration: underline; color:#0000ff;\">new</span></a></p></body></html>");

   779     widget->setTextInteractionFlags(Qt::TextBrowserInteraction);

   780 

   781     if (hasWidget)

   782         proxy->setWidget(widget);

   783 

   784     QGraphicsScene scene;

   785     QGraphicsView view(&scene);

   786     view.show();

   787     QApplication::setActiveWindow(&view);

   788     QTest::qWaitForWindowShown(&view);

   789     QApplication::processEvents();

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

   791     if (hasScene) {

   792         scene.addItem(proxy);

   793         proxy->show();

   794 

   795         // widget should take precedence over scene so make scene.focusNextPrevChild return false

   796         // so we know that a true can only come from the widget

   797         if (!(hasWidget && hasScene)) {

   798             QGraphicsTextItem *item = new QGraphicsTextItem("Foo");

   799             item->setTextInteractionFlags(Qt::TextBrowserInteraction);

   800             scene.addItem(item);

   801             item->setPos(50, 40);

   802         }

   803         scene.setFocusItem(proxy);

   804         QVERIFY(proxy->hasFocus());

   805     }

   806 

   807     QCOMPARE(proxy->call_focusNextPrevChild(next), focusNextPrevChild);

   808 

   809     if (!hasScene)

   810         delete proxy;

   811 }

   812 

   813 void tst_QGraphicsProxyWidget::focusOutEvent_data()

   814 {

   815     QTest::addColumn<bool>("hasWidget");

   816     QTest::addColumn<bool>("call");

   817     QTest::newRow("no widget, focus to other widget") << false << false;

   818     QTest::newRow("no widget, focusOutCalled") << false << true;

   819     QTest::newRow("widget, focus to other widget") << true << false;

   820     QTest::newRow("widget, focusOutCalled") << true << true;

   821 }

   822 

   823 // protected void focusOutEvent(QFocusEvent* event)

   824 void tst_QGraphicsProxyWidget::focusOutEvent()

   825 {

   826     QFETCH(bool, hasWidget);

   827     QFETCH(bool, call);

   828 

   829     QGraphicsScene scene;

   830     QGraphicsView view(&scene);

   831     SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;

   832     scene.addItem(proxy);

   833     view.show();

   834     QApplication::setActiveWindow(&view);

   835     view.activateWindow();

   836     view.setFocus();

   837     QTest::qWaitForWindowShown(&view);

   838     QApplication::processEvents();

   839     QTRY_VERIFY(view.isVisible());

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

   841 

   842     QWidget *widget = new QWidget;

   843     widget->setFocusPolicy(Qt::WheelFocus);

   844     if (hasWidget)

   845         proxy->setWidget(widget);

   846     proxy->show();

   847     proxy->setFocus();

   848     QVERIFY(proxy->hasFocus());

   849     QEXPECT_FAIL("widget, focus to other widget", "Widget should have focus but doesn't", Continue);

   850     QEXPECT_FAIL("widget, focusOutCalled", "Widget should have focus but doesn't", Continue);

   851     QCOMPARE(widget->hasFocus(), hasWidget);

   852 

   853     if (!call) {

   854         QWidget *other = new QLineEdit(&view);

   855         other->show();

   856         QApplication::processEvents();

   857         QTRY_VERIFY(other->isVisible());

   858         other->setFocus();

   859         QTRY_VERIFY(other->hasFocus());

   860         qApp->processEvents();

   861         QTRY_COMPARE(proxy->hasFocus(), false);

   862         QVERIFY(proxy->focusOut);

   863         QCOMPARE(widget->hasFocus(), false);

   864     } else {

   865         {

   866             /*

   867             ### Test doesn't make sense

   868             QFocusEvent focusEvent(QEvent::FocusOut);

   869             proxy->call_focusOutEvent(&focusEvent);

   870             QCOMPARE(focusEvent.isAccepted(), hasWidget);

   871             qApp->processEvents();

   872             QCOMPARE(proxy->paintCount, hasWidget ? 1 : 0);

   873             */

   874         }

   875         {

   876             /*

   877             ### Test doesn't make sense

   878             proxy->setFlag(QGraphicsItem::ItemIsFocusable, false);

   879             QFocusEvent focusEvent(QEvent::FocusOut);

   880             proxy->call_focusOutEvent(&focusEvent);

   881             QCOMPARE(focusEvent.isAccepted(), hasWidget);

   882             qApp->processEvents();

   883             QCOMPARE(proxy->paintCount, 0);

   884             */

   885         }

   886     }

   887 }

   888 

   889 class EventLogger : public QWidget

   890 {

   891 public:

   892     EventLogger() : QWidget(), enterCount(0), leaveCount(0), moveCount(0),

   893         hoverEnter(0), hoverLeave(0), hoverMove(0)

   894     {

   895         installEventFilter(this);

   896     }

   897 

   898     void enterEvent(QEvent *event)

   899     {

   900         enterCount++;

   901         QWidget::enterEvent(event);

   902     }

   903 

   904     void leaveEvent(QEvent *event )

   905     {

   906         leaveCount++;

   907         QWidget::leaveEvent(event);

   908     }

   909 

   910     void mouseMoveEvent(QMouseEvent *event)

   911     {

   912         event->setAccepted(true);

   913         moveCount++;

   914         QWidget::mouseMoveEvent(event);

   915     }

   916 

   917     int enterCount;

   918     int leaveCount;

   919     int moveCount;

   920 

   921     int hoverEnter;

   922     int hoverLeave;

   923     int hoverMove;

   924 protected:

   925     bool eventFilter(QObject *object, QEvent *event)

   926     {

   927         switch (event->type()) {

   928         case QEvent::HoverEnter:

   929              hoverEnter++;

   930              break;

   931         case QEvent::HoverLeave:

   932              hoverLeave++;

   933              break;

   934         case QEvent::HoverMove:

   935              hoverMove++;

   936              break;

   937         default:

   938              break;

   939         }

   940         return QWidget::eventFilter(object, event);

   941     }

   942 };

   943 

   944 void tst_QGraphicsProxyWidget::hoverEnterLeaveEvent_data()

   945 {

   946     QTest::addColumn<bool>("hasWidget");

   947     QTest::addColumn<bool>("hoverEnabled");

   948     QTest::newRow("widget, no hover") << true << false;

   949     QTest::newRow("no widget, no hover") << false << false;

   950     QTest::newRow("widget, hover") << true << true;

   951     QTest::newRow("no widget, hover") << false << true;

   952 }

   953 

   954 // protected void hoverEnterEvent(QGraphicsSceneHoverEvent* event)

   955 void tst_QGraphicsProxyWidget::hoverEnterLeaveEvent()

   956 {

   957     QFETCH(bool, hasWidget);

   958     QFETCH(bool, hoverEnabled);

   959 

   960 #if defined(Q_OS_WINCE) && (!defined(GWES_ICONCURS) || defined(QT_NO_CURSOR))

   961     QSKIP("hover events not supported on this platform", SkipAll);

   962 #endif

   963 

   964     // proxy should translate this into events that the widget would expect

   965 

   966     QGraphicsScene scene;

   967     QGraphicsView view(&scene);

   968     //do not let the window manager move the window while we are moving the mouse on it

   969     view.setWindowFlags(Qt::X11BypassWindowManagerHint);

   970     view.show();

   971 #ifdef Q_WS_X11

   972     qt_x11_wait_for_window_manager(&view);

   973 #endif

   974 

   975     SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;

   976     EventLogger *widget = new EventLogger;

   977     widget->resize(50, 50);

   978     widget->setAttribute(Qt::WA_Hover, hoverEnabled);

   979     widget->setMouseTracking(true);

   980     view.resize(100, 100);

   981     if (hasWidget)

   982         proxy->setWidget(widget);

   983     proxy->setPos(50, 0);

   984     scene.addItem(proxy);

   985     QTest::qWait(30);

   986     QTest::mouseMove(&view, QPoint(10, 10));

   987     QTest::qWait(30);

   988 

   989     // in

   990     QTest::mouseMove(&view, QPoint(50, 50));

   991     QTest::qWait(25);

   992     QTRY_COMPARE(widget->testAttribute(Qt::WA_UnderMouse), hasWidget ? true : false);

   993     // ### this attribute isn't supported

   994     QCOMPARE(widget->enterCount, hasWidget ? 1 : 0);

   995     QCOMPARE(widget->hoverEnter, (hasWidget && hoverEnabled) ? 1 : 0);

   996     // does not work on all platforms

   997     //QCOMPARE(widget->moveCount, 0);

   998 

   999     // out

  1000     QTest::mouseMove(&view, QPoint(10, 10));

  1001     QTest::qWait(25);

  1002     // QTRY_COMPARE(widget->testAttribute(Qt::WA_UnderMouse), false);

  1003     // ### this attribute isn't supported

  1004     QCOMPARE(widget->leaveCount, hasWidget ? 1 : 0);

  1005     QCOMPARE(widget->hoverLeave, (hasWidget && hoverEnabled) ? 1 : 0);

  1006     // does not work on all platforms

  1007     //QCOMPARE(widget->moveCount, 0);

  1008 

  1009     if (!hasWidget)

  1010         delete widget;

  1011 }

  1012 

  1013 void tst_QGraphicsProxyWidget::hoverMoveEvent_data()

  1014 {

  1015     QTest::addColumn<bool>("hasWidget");

  1016     QTest::addColumn<bool>("hoverEnabled");

  1017     QTest::addColumn<bool>("mouseTracking");

  1018     QTest::addColumn<bool>("mouseDown");

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

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

  1021             for (int k = 0; k < 2; ++k) {

  1022                 for (int l = 0; l < 2; ++l) {

  1023                     bool hasWidget = (i == 0);

  1024                     bool hoverEnabled = (j == 0);

  1025                     bool mouseTracking = (k == 0);

  1026                     bool mouseDown = (l == 0);

  1027                     QString name = QString("hasWidget:%1, hover:%2, mouseTracking:%3, mouseDown: %4").arg(hasWidget).arg(hoverEnabled).arg(mouseTracking).arg(mouseDown);

  1028                     QTest::newRow(name.toLatin1()) << hasWidget << hoverEnabled << mouseTracking << mouseDown;

  1029                 }

  1030             }

  1031         }

  1032     }

  1033 }

  1034 

  1035 // protected void hoverMoveEvent(QGraphicsSceneHoverEvent* event)

  1036 void tst_QGraphicsProxyWidget::hoverMoveEvent()

  1037 {

  1038     QFETCH(bool, hasWidget);

  1039     QFETCH(bool, hoverEnabled);

  1040     QFETCH(bool, mouseTracking);

  1041     QFETCH(bool, mouseDown);

  1042 

  1043     QSKIP("Ambiguous test...", SkipAll);

  1044 

  1045     // proxy should translate the move events to what the widget would expect

  1046 

  1047     QGraphicsScene scene;

  1048     QGraphicsView view(&scene);

  1049     view.show();

  1050 

  1051     SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;

  1052     proxy->setFlag(QGraphicsItem::ItemIsFocusable, true); // ### remove me!!!

  1053     EventLogger *widget = new EventLogger;

  1054     widget->resize(50, 50);

  1055     widget->setAttribute(Qt::WA_Hover, hoverEnabled);

  1056     if (mouseTracking)

  1057         widget->setMouseTracking(true);

  1058     view.resize(100, 100);

  1059     if (hasWidget)

  1060         proxy->setWidget(widget);

  1061     proxy->setPos(50, 0);

  1062     scene.addItem(proxy);

  1063 

  1064     // in

  1065     QTest::mouseMove(&view, QPoint(50, 50));

  1066     QTest::qWait(12);

  1067 

  1068     if (mouseDown)

  1069         QTest::mousePress(view.viewport(), Qt::LeftButton);

  1070 

  1071     // move a little bit

  1072     QTest::mouseMove(&view, QPoint(60, 60));

  1073     QTest::qWait(12);

  1074     QTRY_COMPARE(widget->hoverEnter, (hasWidget && hoverEnabled) ? 1 : 0);

  1075     QCOMPARE(widget->moveCount, (hasWidget && mouseTracking) || (hasWidget && mouseDown) ? 1 : 0);

  1076 

  1077     if (!hasWidget)

  1078         delete widget;

  1079 }

  1080 

  1081 void tst_QGraphicsProxyWidget::keyPressEvent_data()

  1082 {

  1083     QTest::addColumn<bool>("hasWidget");

  1084     QTest::newRow("widget") << true;

  1085     QTest::newRow("no widget") << false;

  1086 }

  1087 

  1088 // protected void keyPressEvent(QKeyEvent* event)

  1089 void tst_QGraphicsProxyWidget::keyPressEvent()

  1090 {

  1091     QFETCH(bool, hasWidget);

  1092 

  1093     QGraphicsScene scene;

  1094     QGraphicsView view(&scene);

  1095     view.show();

  1096     view.viewport()->setFocus();

  1097     QApplication::setActiveWindow(&view);

  1098     QTest::qWaitForWindowShown(&view);

  1099     QApplication::processEvents();

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

  1101 

  1102     SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;

  1103     proxy->setFlag(QGraphicsItem::ItemIsFocusable, true); // ### remove me!!!

  1104 

  1105     QLineEdit *widget = new QLineEdit;

  1106     widget->resize(50, 50);

  1107     view.resize(100, 100);

  1108     if (hasWidget) {

  1109         proxy->setWidget(widget);

  1110         proxy->show();

  1111     }

  1112     proxy->setPos(50, 0);

  1113     scene.addItem(proxy);

  1114     proxy->setFocus();

  1115 

  1116     QTest::keyPress(view.viewport(), 'x');

  1117 

  1118     QTRY_COMPARE(widget->text(), hasWidget ? QString("x") : QString());

  1119 

  1120     if (!hasWidget)

  1121         delete widget;

  1122 }

  1123 

  1124 void tst_QGraphicsProxyWidget::keyReleaseEvent_data()

  1125 {

  1126     QTest::addColumn<bool>("hasWidget");

  1127     QTest::newRow("widget") << true;

  1128     QTest::newRow("no widget") << false;

  1129 }

  1130 

  1131 // protected void keyReleaseEvent(QKeyEvent* event)

  1132 void tst_QGraphicsProxyWidget::keyReleaseEvent()

  1133 {

  1134     QFETCH(bool, hasWidget);