1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 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 "../shared/util.h"

    45 

    46 #include <qevent.h>

    47 #include <qwidget.h>

    48 #include <qlayout.h>

    49 #include <qgesture.h>

    50 #include <qgesturerecognizer.h>

    51 #include <qgraphicsitem.h>

    52 #include <qgraphicsview.h>

    53 

    54 #include <qdebug.h>

    55 

    56 //TESTED_CLASS=

    57 //TESTED_FILES=

    58 

    59 static QPointF mapToGlobal(const QPointF &pt, QGraphicsItem *item, QGraphicsView *view)

    60 {

    61     return view->mapToGlobal(view->mapFromScene(item->mapToScene(pt)));

    62 }

    63 

    64 class CustomGesture : public QGesture

    65 {

    66     Q_OBJECT

    67 public:

    68     static Qt::GestureType GestureType;

    69 

    70     CustomGesture(QObject *parent = 0)

    71         : QGesture(parent), serial(0)

    72     {

    73     }

    74 

    75     int serial;

    76 

    77     static const int SerialMaybeThreshold;

    78     static const int SerialStartedThreshold;

    79     static const int SerialFinishedThreshold;

    80 };

    81 Qt::GestureType CustomGesture::GestureType = Qt::CustomGesture;

    82 const int CustomGesture::SerialMaybeThreshold = 1;

    83 const int CustomGesture::SerialStartedThreshold = 3;

    84 const int CustomGesture::SerialFinishedThreshold = 6;

    85 

    86 class CustomEvent : public QEvent

    87 {

    88 public:

    89     static int EventType;

    90 

    91     CustomEvent(int serial_ = 0)

    92         : QEvent(QEvent::Type(CustomEvent::EventType)),

    93           serial(serial_), hasHotSpot(false)

    94     {

    95     }

    96 

    97     int serial;

    98     QPointF hotSpot;

    99     bool hasHotSpot;

   100 };

   101 int CustomEvent::EventType = 0;

   102 

   103 class CustomGestureRecognizer : public QGestureRecognizer

   104 {

   105 public:

   106     static bool ConsumeEvents;

   107 

   108     CustomGestureRecognizer()

   109     {

   110         if (!CustomEvent::EventType)

   111             CustomEvent::EventType = QEvent::registerEventType();

   112     }

   113 

   114     QGesture* create(QObject *)

   115     {

   116         return new CustomGesture;

   117     }

   118 

   119     QGestureRecognizer::Result recognize(QGesture *state, QObject*, QEvent *event)

   120     {

   121         if (event->type() == CustomEvent::EventType) {

   122             QGestureRecognizer::Result result = 0;

   123             if (CustomGestureRecognizer::ConsumeEvents)

   124                 result |= QGestureRecognizer::ConsumeEventHint;

   125             CustomGesture *g = static_cast<CustomGesture*>(state);

   126             CustomEvent *e = static_cast<CustomEvent*>(event);

   127             g->serial = e->serial;

   128             if (e->hasHotSpot)

   129                 g->setHotSpot(e->hotSpot);

   130             if (g->serial >= CustomGesture::SerialFinishedThreshold)

   131                 result |= QGestureRecognizer::FinishGesture;

   132             else if (g->serial >= CustomGesture::SerialStartedThreshold)

   133                 result |= QGestureRecognizer::TriggerGesture;

   134             else if (g->serial >= CustomGesture::SerialMaybeThreshold)

   135                 result |= QGestureRecognizer::MayBeGesture;

   136             else

   137                 result = QGestureRecognizer::CancelGesture;

   138             return result;

   139         }

   140         return QGestureRecognizer::Ignore;

   141     }

   142 

   143     void reset(QGesture *state)

   144     {

   145         CustomGesture *g = static_cast<CustomGesture *>(state);

   146         g->serial = 0;

   147         QGestureRecognizer::reset(state);

   148     }

   149 };

   150 bool CustomGestureRecognizer::ConsumeEvents = false;

   151 

   152 // same as CustomGestureRecognizer but triggers early without the maybe state

   153 class CustomContinuousGestureRecognizer : public QGestureRecognizer

   154 {

   155 public:

   156     CustomContinuousGestureRecognizer()

   157     {

   158         if (!CustomEvent::EventType)

   159             CustomEvent::EventType = QEvent::registerEventType();

   160     }

   161 

   162     QGesture* create(QObject *)

   163     {

   164         return new CustomGesture;

   165     }

   166 

   167     QGestureRecognizer::Result recognize(QGesture *state, QObject*, QEvent *event)

   168     {

   169         if (event->type() == CustomEvent::EventType) {

   170             QGestureRecognizer::Result result = QGestureRecognizer::ConsumeEventHint;

   171             CustomGesture *g = static_cast<CustomGesture *>(state);

   172             CustomEvent *e = static_cast<CustomEvent *>(event);

   173             g->serial = e->serial;

   174             if (e->hasHotSpot)

   175                 g->setHotSpot(e->hotSpot);

   176             if (g->serial >= CustomGesture::SerialFinishedThreshold)

   177                 result |= QGestureRecognizer::FinishGesture;

   178             else if (g->serial >= CustomGesture::SerialMaybeThreshold)

   179                 result |= QGestureRecognizer::TriggerGesture;

   180             else

   181                 result = QGestureRecognizer::CancelGesture;

   182             return result;

   183         }

   184         return QGestureRecognizer::Ignore;

   185     }

   186 

   187     void reset(QGesture *state)

   188     {

   189         CustomGesture *g = static_cast<CustomGesture *>(state);

   190         g->serial = 0;

   191         QGestureRecognizer::reset(state);

   192     }

   193 };

   194 

   195 class GestureWidget : public QWidget

   196 {

   197     Q_OBJECT

   198 public:

   199     GestureWidget(const char *name = 0, QWidget *parent = 0)

   200         : QWidget(parent)

   201     {

   202         if (name)

   203             setObjectName(QLatin1String(name));

   204         reset();

   205         acceptGestureOverride = false;

   206     }

   207     void reset()

   208     {

   209         customEventsReceived = 0;

   210         gestureEventsReceived = 0;

   211         gestureOverrideEventsReceived = 0;

   212         events.clear();

   213         overrideEvents.clear();

   214         ignoredGestures.clear();

   215     }

   216 

   217     int customEventsReceived;

   218     int gestureEventsReceived;

   219     int gestureOverrideEventsReceived;

   220     struct Events

   221     {

   222         QList<Qt::GestureType> all;

   223         QList<Qt::GestureType> started;

   224         QList<Qt::GestureType> updated;

   225         QList<Qt::GestureType> finished;

   226         QList<Qt::GestureType> canceled;

   227 

   228         void clear()

   229         {

   230             all.clear();

   231             started.clear();

   232             updated.clear();

   233             finished.clear();

   234             canceled.clear();

   235         }

   236     } events, overrideEvents;

   237 

   238     bool acceptGestureOverride;

   239     QSet<Qt::GestureType> ignoredGestures;

   240 

   241 protected:

   242     bool event(QEvent *event)

   243     {

   244         Events *eventsPtr = 0;

   245         if (event->type() == QEvent::Gesture) {

   246             QGestureEvent *e = static_cast<QGestureEvent*>(event);

   247             ++gestureEventsReceived;

   248             eventsPtr = &events;

   249             foreach(Qt::GestureType type, ignoredGestures)

   250                 e->ignore(e->gesture(type));

   251         } else if (event->type() == QEvent::GestureOverride) {

   252             ++gestureOverrideEventsReceived;

   253             eventsPtr = &overrideEvents;

   254             if (acceptGestureOverride)

   255                 event->accept();

   256         }

   257         if (eventsPtr) {

   258             QGestureEvent *e = static_cast<QGestureEvent*>(event);

   259             QList<QGesture*> gestures = e->gestures();

   260             foreach(QGesture *g, gestures) {

   261                 eventsPtr->all << g->gestureType();

   262                 switch(g->state()) {

   263                 case Qt::GestureStarted:

   264                     eventsPtr->started << g->gestureType();

   265                     break;

   266                 case Qt::GestureUpdated:

   267                     eventsPtr->updated << g->gestureType();

   268                     break;

   269                 case Qt::GestureFinished:

   270                     eventsPtr->finished << g->gestureType();

   271                     break;

   272                 case Qt::GestureCanceled:

   273                     eventsPtr->canceled << g->gestureType();

   274                     break;

   275                 default:

   276                     Q_ASSERT(false);

   277                 }

   278             }

   279         } else if (event->type() == CustomEvent::EventType) {

   280             ++customEventsReceived;

   281         } else {

   282             return QWidget::event(event);

   283         }

   284         return true;

   285     }

   286 };

   287 

   288 // TODO rename to sendGestureSequence

   289 static void sendCustomGesture(CustomEvent *event, QObject *object, QGraphicsScene *scene = 0)

   290 {

   291     for (int i = CustomGesture::SerialMaybeThreshold;

   292          i <= CustomGesture::SerialFinishedThreshold; ++i) {

   293         event->serial = i;

   294         if (scene)

   295             scene->sendEvent(qobject_cast<QGraphicsObject *>(object), event);

   296         else

   297             QApplication::sendEvent(object, event);

   298     }

   299 }

   300 

   301 class tst_Gestures : public QObject

   302 {

   303 Q_OBJECT

   304 

   305 public:

   306     tst_Gestures();

   307     virtual ~tst_Gestures();

   308 

   309 public slots:

   310     void initTestCase();

   311     void cleanupTestCase();

   312     void init();

   313     void cleanup();

   314 

   315 private slots:

   316     void customGesture();

   317 	/*

   318     void autoCancelingGestures();

   319     void gestureOverChild();

   320     void multipleWidgetOnlyGestureInTree();

   321     void conflictingGestures();

   322     void finishedWithoutStarted();

   323     void unknownGesture();

   324     void graphicsItemGesture();

   325     void graphicsItemTreeGesture();

   326     void explicitGraphicsObjectTarget();

   327     void gestureOverChildGraphicsItem();

   328     void twoGesturesOnDifferentLevel();

   329     void multipleGesturesInTree();

   330     void multipleGesturesInComplexTree();

   331     void testMapToScene();

   332     void ungrabGesture();

   333     void consumeEventHint();

   334     void unregisterRecognizer();

   335     void autoCancelGestures();

   336     void autoCancelGestures2();

   337     void panelPropagation();

   338     void panelStacksBehindParent();

   339 	*/

   340 };

   341 

   342 tst_Gestures::tst_Gestures()

   343 {

   344 }

   345 

   346 tst_Gestures::~tst_Gestures()

   347 {

   348 }

   349 

   350 void tst_Gestures::initTestCase()

   351 {

   352     CustomGesture::GestureType = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);

   353     QVERIFY(CustomGesture::GestureType != Qt::GestureType(0));

   354     QVERIFY(CustomGesture::GestureType != Qt::CustomGesture);

   355 }

   356 

   357 void tst_Gestures::cleanupTestCase()

   358 {

   359     QGestureRecognizer::unregisterRecognizer(CustomGesture::GestureType);

   360 }

   361 

   362 void tst_Gestures::init()

   363 {

   364 }

   365 

   366 void tst_Gestures::cleanup()

   367 {

   368 }

   369 

   370 void tst_Gestures::customGesture()

   371 {

   372     GestureWidget widget;

   373     widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   374     CustomEvent event;

   375     sendCustomGesture(&event, &widget);

   376 

   377     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;

   378     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;

   379     QCOMPARE(widget.customEventsReceived, TotalCustomEventsCount);

   380     QCOMPARE(widget.gestureEventsReceived, TotalGestureEventsCount);

   381     QCOMPARE(widget.gestureOverrideEventsReceived, 0);

   382     QCOMPARE(widget.events.all.size(), TotalGestureEventsCount);

   383     for(int i = 0; i < widget.events.all.size(); ++i)

   384         QCOMPARE(widget.events.all.at(i), CustomGesture::GestureType);

   385     QCOMPARE(widget.events.started.size(), 1);

   386     QCOMPARE(widget.events.updated.size(), TotalGestureEventsCount - 2);

   387     QCOMPARE(widget.events.finished.size(), 1);

   388     QCOMPARE(widget.events.canceled.size(), 0);

   389 }

   390 

   391 /*

   392 void tst_Gestures::consumeEventHint()

   393 {

   394     GestureWidget widget;

   395     widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   396 

   397     CustomGestureRecognizer::ConsumeEvents = true;

   398     CustomEvent event;

   399     sendCustomGesture(&event, &widget);

   400     CustomGestureRecognizer::ConsumeEvents = false;

   401 

   402     QCOMPARE(widget.customEventsReceived, 0);

   403 }

   404 */

   405 

   406 /*

   407 

   408 void tst_Gestures::autoCancelingGestures()

   409 {

   410     GestureWidget widget;

   411     widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   412     // send partial gesture. The gesture will be in the "maybe" state, but will

   413     // never get enough events to fire, so Qt will have to kill it.

   414     CustomEvent ev;

   415     for (int i = CustomGesture::SerialMaybeThreshold;

   416          i < CustomGesture::SerialStartedThreshold; ++i) {

   417         ev.serial = i;

   418         QApplication::sendEvent(&widget, &ev);

   419     }

   420     // wait long enough so the gesture manager will cancel the gesture

   421     QTest::qWait(5000);

   422     QCOMPARE(widget.customEventsReceived, CustomGesture::SerialStartedThreshold - CustomGesture::SerialMaybeThreshold);

   423     QCOMPARE(widget.gestureEventsReceived, 0);

   424     QCOMPARE(widget.gestureOverrideEventsReceived, 0);

   425     QCOMPARE(widget.events.all.size(), 0);

   426 }

   427 

   428 void tst_Gestures::gestureOverChild()

   429 {

   430     GestureWidget widget("widget");

   431     QVBoxLayout *l = new QVBoxLayout(&widget);

   432     GestureWidget *child = new GestureWidget("child");

   433     l->addWidget(child);

   434 

   435     widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   436 

   437     CustomEvent event;

   438     sendCustomGesture(&event, child);

   439 

   440     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;

   441     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;

   442 

   443     QCOMPARE(child->customEventsReceived, TotalCustomEventsCount);

   444     QCOMPARE(widget.customEventsReceived, 0);

   445     QCOMPARE(child->gestureEventsReceived, 0);

   446     QCOMPARE(child->gestureOverrideEventsReceived, 0);

   447     QCOMPARE(widget.gestureEventsReceived, 0);

   448     QCOMPARE(widget.gestureOverrideEventsReceived, 0);

   449 

   450     // enable gestures over the children

   451     widget.grabGesture(CustomGesture::GestureType);

   452 

   453     widget.reset();

   454     child->reset();

   455 

   456     sendCustomGesture(&event, child);

   457 

   458     QCOMPARE(child->customEventsReceived, TotalCustomEventsCount);

   459     QCOMPARE(widget.customEventsReceived, 0);

   460 

   461     QCOMPARE(child->gestureEventsReceived, 0);

   462     QCOMPARE(child->gestureOverrideEventsReceived, 0);

   463     QCOMPARE(widget.gestureEventsReceived, TotalGestureEventsCount);

   464     QCOMPARE(widget.gestureOverrideEventsReceived, 0);

   465     for(int i = 0; i < widget.events.all.size(); ++i)

   466         QCOMPARE(widget.events.all.at(i), CustomGesture::GestureType);

   467     QCOMPARE(widget.events.started.size(), 1);

   468     QCOMPARE(widget.events.updated.size(), TotalGestureEventsCount - 2);

   469     QCOMPARE(widget.events.finished.size(), 1);

   470     QCOMPARE(widget.events.canceled.size(), 0);

   471 }

   472 

   473 void tst_Gestures::multipleWidgetOnlyGestureInTree()

   474 {

   475     GestureWidget parent("parent");

   476     QVBoxLayout *l = new QVBoxLayout(&parent);

   477     GestureWidget *child = new GestureWidget("child");

   478     l->addWidget(child);

   479 

   480     parent.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   481     child->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   482 

   483     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;

   484     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;

   485 

   486     // sending events to the child and making sure there is no conflict

   487     CustomEvent event;

   488     sendCustomGesture(&event, child);

   489 

   490     QCOMPARE(child->customEventsReceived, TotalCustomEventsCount);

   491     QCOMPARE(parent.customEventsReceived, 0);

   492     QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);

   493     QCOMPARE(child->gestureOverrideEventsReceived, 0);

   494     QCOMPARE(parent.gestureEventsReceived, 0);

   495     QCOMPARE(parent.gestureOverrideEventsReceived, 0);

   496 

   497     parent.reset();

   498     child->reset();

   499 

   500     // same for the parent widget

   501     sendCustomGesture(&event, &parent);

   502 

   503     QCOMPARE(child->customEventsReceived, 0);

   504     QCOMPARE(parent.customEventsReceived, TotalCustomEventsCount);

   505     QCOMPARE(child->gestureEventsReceived, 0);

   506     QCOMPARE(child->gestureOverrideEventsReceived, 0);

   507     QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);

   508     QCOMPARE(parent.gestureOverrideEventsReceived, 0);

   509 }

   510 

   511 void tst_Gestures::conflictingGestures()

   512 {

   513     GestureWidget parent("parent");

   514     QVBoxLayout *l = new QVBoxLayout(&parent);

   515     GestureWidget *child = new GestureWidget("child");

   516     l->addWidget(child);

   517 

   518     parent.grabGesture(CustomGesture::GestureType);

   519     child->grabGesture(CustomGesture::GestureType);

   520 

   521     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;

   522 

   523     // child accepts the override, parent will not receive anything

   524     parent.acceptGestureOverride = false;

   525     child->acceptGestureOverride = true;

   526 

   527     // sending events to the child and making sure there is no conflict

   528     CustomEvent event;

   529     sendCustomGesture(&event, child);

   530 

   531     QCOMPARE(child->gestureOverrideEventsReceived, 1);

   532     QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);

   533     QCOMPARE(parent.gestureOverrideEventsReceived, 0);

   534     QCOMPARE(parent.gestureEventsReceived, 0);

   535 

   536     parent.reset();

   537     child->reset();

   538 

   539     // parent accepts the override

   540     parent.acceptGestureOverride = true;

   541     child->acceptGestureOverride = false;

   542 

   543     // sending events to the child and making sure there is no conflict

   544     sendCustomGesture(&event, child);

   545 

   546     QCOMPARE(child->gestureOverrideEventsReceived, 1);

   547     QCOMPARE(child->gestureEventsReceived, 0);

   548     QCOMPARE(parent.gestureOverrideEventsReceived, 1);

   549     QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);

   550 

   551     parent.reset();

   552     child->reset();

   553 

   554     // nobody accepts the override, we will send normal events to the closest

   555     // context (i.e. to the child widget) and it will be propagated and

   556     // accepted by the parent widget

   557     parent.acceptGestureOverride = false;

   558     child->acceptGestureOverride = false;

   559     child->ignoredGestures << CustomGesture::GestureType;

   560 

   561     // sending events to the child and making sure there is no conflict

   562     sendCustomGesture(&event, child);

   563 

   564     QCOMPARE(child->gestureOverrideEventsReceived, 1);

   565     QCOMPARE(child->gestureEventsReceived, 1);

   566     QCOMPARE(parent.gestureOverrideEventsReceived, 1);

   567     QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);

   568 

   569     parent.reset();

   570     child->reset();

   571 

   572     // nobody accepts the override, and nobody accepts the gesture event

   573     parent.acceptGestureOverride = false;

   574     child->acceptGestureOverride = false;

   575     parent.ignoredGestures << CustomGesture::GestureType;

   576     child->ignoredGestures << CustomGesture::GestureType;

   577 

   578     // sending events to the child and making sure there is no conflict

   579     sendCustomGesture(&event, child);

   580 

   581     QCOMPARE(child->gestureOverrideEventsReceived, 1);

   582     QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);

   583     QCOMPARE(parent.gestureOverrideEventsReceived, 1);

   584     QCOMPARE(parent.gestureEventsReceived, 1);

   585 

   586     parent.reset();

   587     child->reset();

   588 

   589     // we set an attribute to make sure all gesture events are propagated

   590     parent.grabGesture(CustomGesture::GestureType, Qt::ReceivePartialGestures);

   591     parent.acceptGestureOverride = false;

   592     child->acceptGestureOverride = false;

   593     parent.ignoredGestures << CustomGesture::GestureType;

   594     child->ignoredGestures << CustomGesture::GestureType;

   595 

   596     // sending events to the child and making sure there is no conflict

   597     sendCustomGesture(&event, child);

   598 

   599     QCOMPARE(child->gestureOverrideEventsReceived, 1);

   600     QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);

   601     QCOMPARE(parent.gestureOverrideEventsReceived, 1);

   602     QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);

   603 

   604     parent.reset();

   605     child->reset();

   606 

   607     Qt::GestureType ContinuousGesture = QGestureRecognizer::registerRecognizer(new CustomContinuousGestureRecognizer);

   608     static const int ContinuousGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;

   609     child->grabGesture(ContinuousGesture);

   610     // child accepts override. And it also receives another custom gesture.

   611     parent.acceptGestureOverride = false;

   612     child->acceptGestureOverride = true;

   613     sendCustomGesture(&event, child);

   614 

   615     QCOMPARE(child->gestureOverrideEventsReceived, 1);

   616     QVERIFY(child->gestureEventsReceived > TotalGestureEventsCount);

   617     QCOMPARE(child->events.all.count(), TotalGestureEventsCount + ContinuousGestureEventsCount);

   618     QCOMPARE(parent.gestureOverrideEventsReceived, 0);

   619     QCOMPARE(parent.gestureEventsReceived, 0);

   620 

   621     QGestureRecognizer::unregisterRecognizer(ContinuousGesture);

   622 }

   623 

   624 void tst_Gestures::finishedWithoutStarted()

   625 {

   626     GestureWidget widget;

   627     widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   628 

   629     // the gesture will claim it finished, but it was never started.

   630     CustomEvent ev;

   631     ev.serial = CustomGesture::SerialFinishedThreshold;

   632     QApplication::sendEvent(&widget, &ev);

   633 

   634     QCOMPARE(widget.customEventsReceived, 1);

   635     QCOMPARE(widget.gestureEventsReceived, 2);

   636     QCOMPARE(widget.gestureOverrideEventsReceived, 0);

   637     QCOMPARE(widget.events.all.size(), 2);

   638     QCOMPARE(widget.events.started.size(), 1);

   639     QCOMPARE(widget.events.updated.size(), 0);

   640     QCOMPARE(widget.events.finished.size(), 1);

   641     QCOMPARE(widget.events.canceled.size(), 0);

   642 }

   643 

   644 */

   645 

   646 /*

   647 void tst_Gestures::unknownGesture()

   648 {

   649     GestureWidget widget;

   650     widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   651     widget.grabGesture(Qt::CustomGesture, Qt::DontStartGestureOnChildren);

   652     widget.grabGesture(Qt::GestureType(Qt::PanGesture+512), Qt::DontStartGestureOnChildren);

   653 

   654     CustomEvent event;

   655     sendCustomGesture(&event, &widget);

   656 

   657     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;

   658 

   659     QCOMPARE(widget.gestureEventsReceived, TotalGestureEventsCount);

   660 }

   661 */

   662 

   663 static const QColor InstanceColors[] = {

   664     Qt::blue, Qt::red, Qt::green, Qt::gray, Qt::yellow

   665 };

   666 

   667 class GestureItem : public QGraphicsObject

   668 {

   669     static int InstanceCount;

   670 

   671 public:

   672     GestureItem(const char *name = 0)

   673     {

   674         instanceNumber = InstanceCount++;

   675         if (name)

   676             setObjectName(QLatin1String(name));

   677         size = QRectF(0, 0, 100, 100);

   678         customEventsReceived = 0;

   679         gestureEventsReceived = 0;

   680         gestureOverrideEventsReceived = 0;

   681         events.clear();

   682         overrideEvents.clear();

   683         acceptGestureOverride = false;

   684     }

   685     ~GestureItem()

   686     {

   687         --InstanceCount;

   688     }

   689 

   690     int customEventsReceived;

   691     int gestureEventsReceived;

   692     int gestureOverrideEventsReceived;

   693     struct Events

   694     {

   695         QList<Qt::GestureType> all;

   696         QList<Qt::GestureType> started;

   697         QList<Qt::GestureType> updated;

   698         QList<Qt::GestureType> finished;

   699         QList<Qt::GestureType> canceled;

   700 

   701         void clear()

   702         {

   703             all.clear();

   704             started.clear();

   705             updated.clear();

   706             finished.clear();

   707             canceled.clear();

   708         }

   709     } events, overrideEvents;

   710 

   711     bool acceptGestureOverride;

   712     QSet<Qt::GestureType> ignoredGestures;

   713 

   714     QRectF size;

   715     int instanceNumber;

   716 

   717     void reset()

   718     {

   719         customEventsReceived = 0;

   720         gestureEventsReceived = 0;

   721         gestureOverrideEventsReceived = 0;

   722         events.clear();

   723         overrideEvents.clear();

   724         ignoredGestures.clear();

   725     }

   726 

   727 protected:

   728     QRectF boundingRect() const

   729     {

   730         return size;

   731     }

   732     void paint(QPainter *p, const QStyleOptionGraphicsItem *, QWidget *)

   733     {

   734         QColor color = InstanceColors[instanceNumber % (sizeof(InstanceColors)/sizeof(InstanceColors[0]))];

   735         p->fillRect(boundingRect(), color);

   736     }

   737 

   738     bool event(QEvent *event)

   739     {

   740         Events *eventsPtr = 0;

   741         if (event->type() == QEvent::Gesture) {

   742             ++gestureEventsReceived;

   743             eventsPtr = &events;

   744             QGestureEvent *e = static_cast<QGestureEvent *>(event);

   745             foreach(Qt::GestureType type, ignoredGestures)

   746                 e->ignore(e->gesture(type));

   747         } else if (event->type() == QEvent::GestureOverride) {

   748             ++gestureOverrideEventsReceived;

   749             eventsPtr = &overrideEvents;

   750             if (acceptGestureOverride)

   751                 event->accept();

   752         }

   753         if (eventsPtr) {

   754             QGestureEvent *e = static_cast<QGestureEvent*>(event);

   755             QList<QGesture*> gestures = e->gestures();

   756             foreach(QGesture *g, gestures) {

   757                 eventsPtr->all << g->gestureType();

   758                 switch(g->state()) {

   759                 case Qt::GestureStarted:

   760                     eventsPtr->started << g->gestureType();

   761                     break;

   762                 case Qt::GestureUpdated:

   763                     eventsPtr->updated << g->gestureType();

   764                     break;

   765                 case Qt::GestureFinished:

   766                     eventsPtr->finished << g->gestureType();

   767                     break;

   768                 case Qt::GestureCanceled:

   769                     eventsPtr->canceled << g->gestureType();

   770                     break;

   771                 default:

   772                     Q_ASSERT(false);

   773                 }

   774             }

   775         } else if (event->type() == CustomEvent::EventType) {

   776             ++customEventsReceived;

   777         } else {

   778             return QGraphicsObject::event(event);

   779         }

   780         return true;

   781     }

   782 };

   783 int GestureItem::InstanceCount = 0;

   784 

   785 /*

   786 void tst_Gestures::graphicsItemGesture()

   787 {

   788     QGraphicsScene scene;

   789     QGraphicsView view(&scene);

   790     view.setWindowFlags(Qt::X11BypassWindowManagerHint);

   791 

   792     GestureItem *item = new GestureItem("item");

   793     scene.addItem(item);

   794     item->setPos(100, 100);

   795 

   796     view.show();

   797     QTest::qWaitForWindowShown(&view);

   798     view.ensureVisible(scene.sceneRect());

   799 

   800     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   801     item->grabGesture(CustomGesture::GestureType);

   802 

   803     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;

   804     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;

   805 

   806     CustomEvent event;

   807     // gesture without hotspot should not be delivered to items in the view

   808     QTest::ignoreMessage(QtWarningMsg, "QGestureManager::deliverEvent: could not find the target for gesture");

   809     QTest::ignoreMessage(QtWarningMsg, "QGestureManager::deliverEvent: could not find the target for gesture");

   810     QTest::ignoreMessage(QtWarningMsg, "QGestureManager::deliverEvent: could not find the target for gesture");

   811     QTest::ignoreMessage(QtWarningMsg, "QGestureManager::deliverEvent: could not find the target for gesture");

   812     sendCustomGesture(&event, item, &scene);

   813 

   814     QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);

   815     QCOMPARE(item->gestureEventsReceived, 0);

   816     QCOMPARE(item->gestureOverrideEventsReceived, 0);

   817 

   818     item->reset();

   819 

   820     // make sure the event is properly delivered if only the hotspot is set.

   821     event.hotSpot = mapToGlobal(QPointF(10, 10), item, &view);

   822     event.hasHotSpot = true;

   823     sendCustomGesture(&event, item, &scene);

   824 

   825     QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);

   826     QCOMPARE(item->gestureEventsReceived, TotalGestureEventsCount);

   827     QCOMPARE(item->gestureOverrideEventsReceived, 0);

   828     QCOMPARE(item->events.all.size(), TotalGestureEventsCount);

   829     for(int i = 0; i < item->events.all.size(); ++i)

   830         QCOMPARE(item->events.all.at(i), CustomGesture::GestureType);

   831     QCOMPARE(item->events.started.size(), 1);

   832     QCOMPARE(item->events.updated.size(), TotalGestureEventsCount - 2);

   833     QCOMPARE(item->events.finished.size(), 1);

   834     QCOMPARE(item->events.canceled.size(), 0);

   835 

   836     item->reset();

   837 

   838     // send gesture to the item which ignores it.

   839     item->ignoredGestures << CustomGesture::GestureType;

   840 

   841     event.hotSpot = mapToGlobal(QPointF(10, 10), item, &view);

   842     event.hasHotSpot = true;

   843     sendCustomGesture(&event, item, &scene);

   844     QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);

   845     QCOMPARE(item->gestureEventsReceived, TotalGestureEventsCount);

   846     QCOMPARE(item->gestureOverrideEventsReceived, 0);

   847 }

   848 

   849 void tst_Gestures::graphicsItemTreeGesture()

   850 {

   851     QGraphicsScene scene;

   852     QGraphicsView view(&scene);

   853     view.setWindowFlags(Qt::X11BypassWindowManagerHint);

   854 

   855     GestureItem *item1 = new GestureItem("item1");

   856     item1->setPos(100, 100);

   857     item1->size = QRectF(0, 0, 350, 200);

   858     scene.addItem(item1);

   859 

   860     GestureItem *item1_child1 = new GestureItem("item1_child1");

   861     item1_child1->setPos(50, 50);

   862     item1_child1->size = QRectF(0, 0, 100, 100);

   863     item1_child1->setParentItem(item1);

   864 

   865     GestureItem *item1_child2 = new GestureItem("item1_child2");

   866     item1_child2->size = QRectF(0, 0, 100, 100);

   867     item1_child2->setPos(200, 50);

   868     item1_child2->setParentItem(item1);

   869 

   870     view.show();

   871     QTest::qWaitForWindowShown(&view);

   872     view.ensureVisible(scene.sceneRect());

   873 

   874     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   875     item1->grabGesture(CustomGesture::GestureType);

   876 

   877     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;

   878 

   879     CustomEvent event;

   880     event.hotSpot = mapToGlobal(QPointF(10, 10), item1_child1, &view);

   881     event.hasHotSpot = true;

   882 

   883     item1->ignoredGestures << CustomGesture::GestureType;

   884     sendCustomGesture(&event, item1_child1, &scene);

   885     QCOMPARE(item1_child1->gestureOverrideEventsReceived, 0);

   886     QCOMPARE(item1_child1->gestureEventsReceived, 0);

   887     QCOMPARE(item1_child2->gestureEventsReceived, 0);

   888     QCOMPARE(item1_child2->gestureOverrideEventsReceived, 0);

   889     QCOMPARE(item1->gestureOverrideEventsReceived, 0);

   890     QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);

   891 

   892     item1->reset(); item1_child1->reset(); item1_child2->reset();

   893 

   894     item1_child1->grabGesture(CustomGesture::GestureType);

   895 

   896     item1->ignoredGestures << CustomGesture::GestureType;

   897     item1_child1->ignoredGestures << CustomGesture::GestureType;

   898     sendCustomGesture(&event, item1_child1, &scene);

   899     QCOMPARE(item1_child1->gestureOverrideEventsReceived, 1);

   900     QCOMPARE(item1_child1->gestureEventsReceived, TotalGestureEventsCount);

   901     QCOMPARE(item1_child2->gestureEventsReceived, 0);

   902     QCOMPARE(item1_child2->gestureOverrideEventsReceived, 0);

   903     QCOMPARE(item1->gestureOverrideEventsReceived, 1);

   904     QCOMPARE(item1->gestureEventsReceived, 1);

   905 }

   906 

   907 void tst_Gestures::explicitGraphicsObjectTarget()

   908 {

   909     QGraphicsScene scene;

   910     QGraphicsView view(&scene);

   911     view.setWindowFlags(Qt::X11BypassWindowManagerHint);

   912 

   913     GestureItem *item1 = new GestureItem("item1");

   914     scene.addItem(item1);

   915     item1->setPos(100, 100);

   916     item1->setZValue(1);

   917 

   918     GestureItem *item2 = new GestureItem("item2");

   919     scene.addItem(item2);

   920     item2->setPos(100, 100);

   921     item2->setZValue(5);

   922 

   923     GestureItem *item2_child1 = new GestureItem("item2_child1");

   924     scene.addItem(item2_child1);

   925     item2_child1->setParentItem(item2);

   926     item2_child1->setPos(10, 10);

   927 

   928     view.show();

   929     QTest::qWaitForWindowShown(&view);

   930     view.ensureVisible(scene.sceneRect());

   931 

   932     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   933     item1->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   934     item2->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   935     item2_child1->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   936 

   937     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;

   938 

   939     // sending events to item1, but the hotSpot is set to item2

   940     CustomEvent event;

   941     event.hotSpot = mapToGlobal(QPointF(15, 15), item2, &view);

   942     event.hasHotSpot = true;

   943 

   944     sendCustomGesture(&event, item1, &scene);

   945 

   946     QCOMPARE(item1->gestureEventsReceived, 0);

   947     QCOMPARE(item1->gestureOverrideEventsReceived, 1);

   948     QCOMPARE(item2_child1->gestureEventsReceived, TotalGestureEventsCount);

   949     QCOMPARE(item2_child1->gestureOverrideEventsReceived, 1);

   950     QCOMPARE(item2_child1->events.all.size(), TotalGestureEventsCount);

   951     for(int i = 0; i < item2_child1->events.all.size(); ++i)

   952         QCOMPARE(item2_child1->events.all.at(i), CustomGesture::GestureType);

   953     QCOMPARE(item2_child1->events.started.size(), 1);

   954     QCOMPARE(item2_child1->events.updated.size(), TotalGestureEventsCount - 2);

   955     QCOMPARE(item2_child1->events.finished.size(), 1);

   956     QCOMPARE(item2_child1->events.canceled.size(), 0);

   957     QCOMPARE(item2->gestureEventsReceived, 0);

   958     QCOMPARE(item2->gestureOverrideEventsReceived, 1);

   959 }

   960 

   961 void tst_Gestures::gestureOverChildGraphicsItem()

   962 {

   963     QGraphicsScene scene;

   964     QGraphicsView view(&scene);

   965     view.setWindowFlags(Qt::X11BypassWindowManagerHint);

   966 

   967     GestureItem *item0 = new GestureItem("item0");

   968     scene.addItem(item0);

   969     item0->setPos(0, 0);

   970     item0->grabGesture(CustomGesture::GestureType);

   971     item0->setZValue(1);

   972 

   973     GestureItem *item1 = new GestureItem("item1");

   974     scene.addItem(item1);

   975     item1->setPos(100, 100);

   976     item1->setZValue(5);

   977 

   978     GestureItem *item2 = new GestureItem("item2");

   979     scene.addItem(item2);

   980     item2->setPos(100, 100);

   981     item2->setZValue(10);

   982 

   983     GestureItem *item2_child1 = new GestureItem("item2_child1");

   984     scene.addItem(item2_child1);

   985     item2_child1->setParentItem(item2);

   986     item2_child1->setPos(0, 0);

   987 

   988     view.show();

   989     QTest::qWaitForWindowShown(&view);

   990     view.ensureVisible(scene.sceneRect());

   991 

   992     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);

   993     item1->grabGesture(CustomGesture::GestureType);

   994 

   995     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;

   996     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;

   997 

   998     CustomEvent event;

   999     event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);

  1000     event.hasHotSpot = true;

  1001     sendCustomGesture(&event, item0, &scene);

  1002 

  1003     QCOMPARE(item0->customEventsReceived, TotalCustomEventsCount);

  1004     QCOMPARE(item2_child1->gestureEventsReceived, 0);

  1005     QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);

  1006     QCOMPARE(item2->gestureEventsReceived, 0);

  1007     QCOMPARE(item2->gestureOverrideEventsReceived, 0);

  1008     QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);

  1009     QCOMPARE(item1->gestureOverrideEventsReceived, 0);

  1010 

  1011     item0->reset(); item1->reset(); item2->reset(); item2_child1->reset();

  1012     item2->grabGesture(CustomGesture::GestureType);

  1013     item2->ignoredGestures << CustomGesture::GestureType;

  1014 

  1015     event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);

  1016     event.hasHotSpot = true;

  1017     sendCustomGesture(&event, item0, &scene);

  1018 

  1019     QCOMPARE(item2_child1->gestureEventsReceived, 0);

  1020     QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);

  1021     QCOMPARE(item2->gestureEventsReceived, 1);

  1022     QCOMPARE(item2->gestureOverrideEventsReceived, 1);

  1023     QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);

  1024     QCOMPARE(item1->gestureOverrideEventsReceived, 1);

  1025 

  1026     item0->reset(); item1->reset(); item2->reset(); item2_child1->reset();

  1027     item2->grabGesture(CustomGesture::GestureType);

  1028     item2->ignoredGestures << CustomGesture::GestureType;

  1029     item1->ignoredGestures << CustomGesture::GestureType;

  1030 

  1031     event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);

  1032     event.hasHotSpot = true;

  1033     sendCustomGesture(&event, item0, &scene);

  1034 

  1035     QCOMPARE(item2_child1->gestureEventsReceived, 0);

  1036     QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);

  1037     QCOMPARE(item2->gestureEventsReceived, TotalGestureEventsCount);

  1038     QCOMPARE(item2->gestureOverrideEventsReceived, 1);

  1039     QCOMPARE(item1->gestureEventsReceived, 1);

  1040     QCOMPARE(item1->gestureOverrideEventsReceived, 1);

  1041 

  1042     item0->reset(); item1->reset(); item2->reset(); item2_child1->reset();

  1043     item2->grabGesture(CustomGesture::GestureType);

  1044     item2->ignoredGestures << CustomGesture::GestureType;

  1045     item1->ignoredGestures << CustomGesture::GestureType;

  1046     item1->grabGesture(CustomGesture::GestureType, Qt::ReceivePartialGestures);

  1047 

  1048     event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);

  1049     event.hasHotSpot = true;

  1050     sendCustomGesture(&event, item0, &scene);

  1051 

  1052     QCOMPARE(item2_child1->gestureEventsReceived, 0);

  1053     QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);

  1054     QCOMPARE(item2->gestureEventsReceived, TotalGestureEventsCount);

  1055     QCOMPARE(item2->gestureOverrideEventsReceived, 1);

  1056     QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);

  1057     QCOMPARE(item1->gestureOverrideEventsReceived, 1);

  1058 }

  1059 

  1060 void tst_Gestures::twoGesturesOnDifferentLevel()

  1061 {

  1062     GestureWidget parent("parent");

  1063     QVBoxLayout *l = new QVBoxLayout(&parent);

  1064     GestureWidget *child = new GestureWidget("child");

  1065     l->addWidget(child);

  1066 

  1067     Qt::GestureType SecondGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);

  1068 

  1069     parent.grabGesture(CustomGesture::GestureType);

  1070     child->grabGesture(SecondGesture);

  1071 

  1072     CustomEvent event;

  1073     // sending events that form a gesture to one widget, but they will be

  1074     // filtered by two different gesture recognizers and will generate two

  1075     // QGesture objects. Check that those gesture objects are delivered to

  1076     // different widgets properly.

  1077     sendCustomGesture(&event, child);

  1078 

  1079     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;

  1080     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;

  1081 

  1082     QCOMPARE(child->customEventsReceived, TotalCustomEventsCount);

  1083     QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);

  1084     QCOMPARE(child->gestureOverrideEventsReceived, 0);

  1085     QCOMPARE(child->events.all.size(), TotalGestureEventsCount);

  1086     for(int i = 0; i < child->events.all.size(); ++i)

  1087         QCOMPARE(child->events.all.at(i), SecondGesture);

  1088 

  1089     QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);

  1090     QCOMPARE(parent.gestureOverrideEventsReceived, 0);

  1091     QCOMPARE(parent.events.all.size(), TotalGestureEventsCount);

  1092     for(int i = 0; i < child->events.all.size(); ++i)

  1093         QCOMPARE(parent.events.all.at(i), CustomGesture::GestureType);

  1094 

  1095     QGestureRecognizer::unregisterRecognizer(SecondGesture);

  1096 }

  1097 

  1098 void tst_Gestures::multipleGesturesInTree()

  1099 {

  1100     GestureWidget a("A");

  1101     GestureWidget *A = &a;

  1102     GestureWidget *B = new GestureWidget("B", A);

  1103     GestureWidget *C = new GestureWidget("C", B);

  1104     GestureWidget *D = new GestureWidget("D", C);

  1105 

  1106     Qt::GestureType FirstGesture  = CustomGesture::GestureType;

  1107     Qt::GestureType SecondGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);

  1108     Qt::GestureType ThirdGesture  = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);

  1109 

  1110     Qt::GestureFlags flags = Qt::ReceivePartialGestures;

  1111     A->grabGesture(FirstGesture,  flags);   // A [1   3]

  1112     A->grabGesture(ThirdGesture,  flags);   // |

  1113     B->grabGesture(SecondGesture, flags);   // B [  2 3]

  1114     B->grabGesture(ThirdGesture,  flags);   // |

  1115     C->grabGesture(FirstGesture,  flags);   // C [1 2 3]

  1116     C->grabGesture(SecondGesture, flags);   // |

  1117     C->grabGesture(ThirdGesture,  flags);   // D [1   3]

  1118     D->grabGesture(FirstGesture,  flags);

  1119     D->grabGesture(ThirdGesture,  flags);

  1120 

  1121     // make sure all widgets ignore events, so they get propagated.

  1122     A->ignoredGestures << FirstGesture << ThirdGesture;

  1123     B->ignoredGestures << SecondGesture << ThirdGesture;

  1124     C->ignoredGestures << FirstGesture << SecondGesture << ThirdGesture;

  1125     D->ignoredGestures << FirstGesture << ThirdGesture;

  1126 

  1127     CustomEvent event;

  1128     sendCustomGesture(&event, D);

  1129 

  1130     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;

  1131 

  1132     // gesture override events

  1133     QCOMPARE(D->overrideEvents.all.count(FirstGesture), 1);

  1134     QCOMPARE(D->overrideEvents.all.count(SecondGesture), 0);