Mercurial Mercurial > oss > FCL > sf > mw > qt / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
tests/auto/gestures/tst_gestures.cpp
changeset 3 41300fa6a67c
parent 0 1918ee327afb
child 4 3b1da2848fc7
child 7 f7bc934e204c
equal deleted inserted replaced
2:56cd8111b7f7 3:41300fa6a67c 
   101 int CustomEvent::EventType = 0;
 
   101 int CustomEvent::EventType = 0;
 
   102 
   102 
   103 class CustomGestureRecognizer : public QGestureRecognizer
 
   103 class CustomGestureRecognizer : public QGestureRecognizer
 
   104 {
 
   104 {
 
   105 public:
 
   105 public:
 
       
   106     static bool ConsumeEvents;
 
       
   107 
   106     CustomGestureRecognizer()
 
   108     CustomGestureRecognizer()
 
   107     {
 
   109     {
 
   108         if (!CustomEvent::EventType)
 
   110         if (!CustomEvent::EventType)
 
   109             CustomEvent::EventType = QEvent::registerEventType();
 
   111             CustomEvent::EventType = QEvent::registerEventType();
 
   110     }
 
   112     }
 
   111 
   113 
   112     QGesture* createGesture(QObject *)
 
   114     QGesture* create(QObject *)
 
   113     {
 
   115     {
 
   114         return new CustomGesture;
 
   116         return new CustomGesture;
 
   115     }
 
   117     }
 
   116 
   118 
   117     QGestureRecognizer::Result filterEvent(QGesture *state, QObject*, QEvent *event)
 
   119     QGestureRecognizer::Result recognize(QGesture *state, QObject*, QEvent *event)
 
   118     {
 
   120     {
 
   119         if (event->type() == CustomEvent::EventType) {
 
   121         if (event->type() == CustomEvent::EventType) {
 
   120             QGestureRecognizer::Result result = QGestureRecognizer::ConsumeEventHint;
 
   122             QGestureRecognizer::Result result = 0;
 
       
   123             if (CustomGestureRecognizer::ConsumeEvents)
 
       
   124                 result |= QGestureRecognizer::ConsumeEventHint;
 
   121             CustomGesture *g = static_cast<CustomGesture*>(state);
 
   125             CustomGesture *g = static_cast<CustomGesture*>(state);
 
   122             CustomEvent *e = static_cast<CustomEvent*>(event);
 
   126             CustomEvent *e = static_cast<CustomEvent*>(event);
 
   123             g->serial = e->serial;
 
   127             g->serial = e->serial;
 
   124             if (e->hasHotSpot)
 
   128             if (e->hasHotSpot)
 
   125                 g->setHotSpot(e->hotSpot);
 
   129                 g->setHotSpot(e->hotSpot);
 
   126             if (g->serial >= CustomGesture::SerialFinishedThreshold)
 
   130             if (g->serial >= CustomGesture::SerialFinishedThreshold)
 
   127                 result |= QGestureRecognizer::GestureFinished;
 
   131                 result |= QGestureRecognizer::FinishGesture;
 
   128             else if (g->serial >= CustomGesture::SerialStartedThreshold)
 
   132             else if (g->serial >= CustomGesture::SerialStartedThreshold)
 
   129                 result |= QGestureRecognizer::GestureTriggered;
 
   133                 result |= QGestureRecognizer::TriggerGesture;
 
   130             else if (g->serial >= CustomGesture::SerialMaybeThreshold)
 
   134             else if (g->serial >= CustomGesture::SerialMaybeThreshold)
 
   131                 result |= QGestureRecognizer::MaybeGesture;
 
   135                 result |= QGestureRecognizer::MayBeGesture;
 
   132             else
 
   136             else
 
   133                 result = QGestureRecognizer::NotGesture;
 
   137                 result = QGestureRecognizer::CancelGesture;
 
   134             return result;
 
   138             return result;
 
   135         }
 
   139         }
 
   136         return QGestureRecognizer::Ignore;
 
   140         return QGestureRecognizer::Ignore;
 
   137     }
 
   141     }
 
   138 
   142 
   139     void reset(QGesture *state)
 
   143     void reset(QGesture *state)
 
   140     {
 
   144     {
 
   141         CustomGesture *g = static_cast<CustomGesture*>(state);
 
   145         CustomGesture *g = static_cast<CustomGesture *>(state);
 
   142         g->serial = 0;
 
   146         g->serial = 0;
 
   143         QGestureRecognizer::reset(state);
 
   147         QGestureRecognizer::reset(state);
 
   144     }
 
   148     }
 
   145 };
 
   149 };
 
       
   150 bool CustomGestureRecognizer::ConsumeEvents = false;
 
   146 
   151 
   147 // same as CustomGestureRecognizer but triggers early without the maybe state
 
   152 // same as CustomGestureRecognizer but triggers early without the maybe state
 
   148 class CustomContinuousGestureRecognizer : public QGestureRecognizer
 
   153 class CustomContinuousGestureRecognizer : public QGestureRecognizer
 
   149 {
 
   154 {
 
   150 public:
 
   155 public:
 
   152     {
 
   157     {
 
   153         if (!CustomEvent::EventType)
 
   158         if (!CustomEvent::EventType)
 
   154             CustomEvent::EventType = QEvent::registerEventType();
 
   159             CustomEvent::EventType = QEvent::registerEventType();
 
   155     }
 
   160     }
 
   156 
   161 
   157     QGesture* createGesture(QObject *)
 
   162     QGesture* create(QObject *)
 
   158     {
 
   163     {
 
   159         return new CustomGesture;
 
   164         return new CustomGesture;
 
   160     }
 
   165     }
 
   161 
   166 
   162     QGestureRecognizer::Result filterEvent(QGesture *state, QObject*, QEvent *event)
 
   167     QGestureRecognizer::Result recognize(QGesture *state, QObject*, QEvent *event)
 
   163     {
 
   168     {
 
   164         if (event->type() == CustomEvent::EventType) {
 
   169         if (event->type() == CustomEvent::EventType) {
 
   165             QGestureRecognizer::Result result = QGestureRecognizer::ConsumeEventHint;
 
   170             QGestureRecognizer::Result result = QGestureRecognizer::ConsumeEventHint;
 
   166             CustomGesture *g = static_cast<CustomGesture*>(state);
 
   171             CustomGesture *g = static_cast<CustomGesture *>(state);
 
   167             CustomEvent *e = static_cast<CustomEvent*>(event);
 
   172             CustomEvent *e = static_cast<CustomEvent *>(event);
 
   168             g->serial = e->serial;
 
   173             g->serial = e->serial;
 
   169             if (e->hasHotSpot)
 
   174             if (e->hasHotSpot)
 
   170                 g->setHotSpot(e->hotSpot);
 
   175                 g->setHotSpot(e->hotSpot);
 
   171             if (g->serial >= CustomGesture::SerialFinishedThreshold)
 
   176             if (g->serial >= CustomGesture::SerialFinishedThreshold)
 
   172                 result |= QGestureRecognizer::GestureFinished;
 
   177                 result |= QGestureRecognizer::FinishGesture;
 
   173             else if (g->serial >= CustomGesture::SerialMaybeThreshold)
 
   178             else if (g->serial >= CustomGesture::SerialMaybeThreshold)
 
   174                 result |= QGestureRecognizer::GestureTriggered;
 
   179                 result |= QGestureRecognizer::TriggerGesture;
 
   175             else
 
   180             else
 
   176                 result = QGestureRecognizer::NotGesture;
 
   181                 result = QGestureRecognizer::CancelGesture;
 
   177             return result;
 
   182             return result;
 
   178         }
 
   183         }
 
   179         return QGestureRecognizer::Ignore;
 
   184         return QGestureRecognizer::Ignore;
 
   180     }
 
   185     }
 
   181 
   186 
   182     void reset(QGesture *state)
 
   187     void reset(QGesture *state)
 
   183     {
 
   188     {
 
   184         CustomGesture *g = static_cast<CustomGesture*>(state);
 
   189         CustomGesture *g = static_cast<CustomGesture *>(state);
 
   185         g->serial = 0;
 
   190         g->serial = 0;
 
   186         QGestureRecognizer::reset(state);
 
   191         QGestureRecognizer::reset(state);
 
   187     }
 
   192     }
 
   188 };
 
   193 };
 
   189 
   194 
   249             if (acceptGestureOverride)
 
   254             if (acceptGestureOverride)
 
   250                 event->accept();
 
   255                 event->accept();
 
   251         }
 
   256         }
 
   252         if (eventsPtr) {
 
   257         if (eventsPtr) {
 
   253             QGestureEvent *e = static_cast<QGestureEvent*>(event);
 
   258             QGestureEvent *e = static_cast<QGestureEvent*>(event);
 
   254             QList<QGesture*> gestures = e->allGestures();
 
   259             QList<QGesture*> gestures = e->gestures();
 
   255             foreach(QGesture *g, gestures) {
 
   260             foreach(QGesture *g, gestures) {
 
   256                 eventsPtr->all << g->gestureType();
 
   261                 eventsPtr->all << g->gestureType();
 
   257                 switch(g->state()) {
 
   262                 switch(g->state()) {
 
   258                 case Qt::GestureStarted:
 
   263                 case Qt::GestureStarted:
 
   259                     eventsPtr->started << g->gestureType();
 
   264                     eventsPtr->started << g->gestureType();
 
   278         }
 
   283         }
 
   279         return true;
 
   284         return true;
 
   280     }
 
   285     }
 
   281 };
 
   286 };
 
   282 
   287 
       
   288 // TODO rename to sendGestureSequence
 
   283 static void sendCustomGesture(CustomEvent *event, QObject *object, QGraphicsScene *scene = 0)
 
   289 static void sendCustomGesture(CustomEvent *event, QObject *object, QGraphicsScene *scene = 0)
 
   284 {
 
   290 {
 
   285     for (int i = CustomGesture::SerialMaybeThreshold;
 
   291     for (int i = CustomGesture::SerialMaybeThreshold;
 
   286          i <= CustomGesture::SerialFinishedThreshold; ++i) {
 
   292          i <= CustomGesture::SerialFinishedThreshold; ++i) {
 
   287         event->serial = i;
 
   293         event->serial = i;
 
   320     void gestureOverChildGraphicsItem();
 
   326     void gestureOverChildGraphicsItem();
 
   321     void twoGesturesOnDifferentLevel();
 
   327     void twoGesturesOnDifferentLevel();
 
   322     void multipleGesturesInTree();
 
   328     void multipleGesturesInTree();
 
   323     void multipleGesturesInComplexTree();
 
   329     void multipleGesturesInComplexTree();
 
   324     void testMapToScene();
 
   330     void testMapToScene();
 
       
   331     void ungrabGesture();
 
       
   332     void consumeEventHint();
 
       
   333     void unregisterRecognizer();
 
       
   334     void autoCancelGestures();
 
       
   335     void autoCancelGestures2();
 
   325 };
 
   336 };
 
   326 
   337 
   327 tst_Gestures::tst_Gestures()
 
   338 tst_Gestures::tst_Gestures()
 
   328 {
 
   339 {
 
   329 }
 
   340 }
 
   332 {
 
   343 {
 
   333 }
 
   344 }
 
   334 
   345 
   335 void tst_Gestures::initTestCase()
 
   346 void tst_Gestures::initTestCase()
 
   336 {
 
   347 {
 
   337     CustomGesture::GestureType = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
 
   348     CustomGesture::GestureType = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
 
   338     QVERIFY(CustomGesture::GestureType != Qt::GestureType(0));
 
   349     QVERIFY(CustomGesture::GestureType != Qt::GestureType(0));
 
   339     QVERIFY(CustomGesture::GestureType != Qt::CustomGesture);
 
   350     QVERIFY(CustomGesture::GestureType != Qt::CustomGesture);
 
   340 }
 
   351 }
 
   341 
   352 
   342 void tst_Gestures::cleanupTestCase()
 
   353 void tst_Gestures::cleanupTestCase()
 
   343 {
 
   354 {
 
       
   355     QGestureRecognizer::unregisterRecognizer(CustomGesture::GestureType);
 
   344 }
 
   356 }
 
   345 
   357 
   346 void tst_Gestures::init()
 
   358 void tst_Gestures::init()
 
   347 {
 
   359 {
 
   348 }
 
   360 }
 
   352 }
 
   364 }
 
   353 
   365 
   354 void tst_Gestures::customGesture()
 
   366 void tst_Gestures::customGesture()
 
   355 {
 
   367 {
 
   356     GestureWidget widget;
 
   368     GestureWidget widget;
 
   357     widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
 
   369     widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   358     CustomEvent event;
 
   370     CustomEvent event;
 
   359     sendCustomGesture(&event, &widget);
 
   371     sendCustomGesture(&event, &widget);
 
   360 
   372 
   361     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   373     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   362     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
   374     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
   370     QCOMPARE(widget.events.updated.size(), TotalGestureEventsCount - 2);
 
   382     QCOMPARE(widget.events.updated.size(), TotalGestureEventsCount - 2);
 
   371     QCOMPARE(widget.events.finished.size(), 1);
 
   383     QCOMPARE(widget.events.finished.size(), 1);
 
   372     QCOMPARE(widget.events.canceled.size(), 0);
 
   384     QCOMPARE(widget.events.canceled.size(), 0);
 
   373 }
 
   385 }
 
   374 
   386 
       
   387 void tst_Gestures::consumeEventHint()
 
       
   388 {
 
       
   389     GestureWidget widget;
 
       
   390     widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
       
   391 
       
   392     CustomGestureRecognizer::ConsumeEvents = true;
 
       
   393     CustomEvent event;
 
       
   394     sendCustomGesture(&event, &widget);
 
       
   395     CustomGestureRecognizer::ConsumeEvents = false;
 
       
   396 
       
   397     QCOMPARE(widget.customEventsReceived, 0);
 
       
   398 }
 
       
   399 
   375 void tst_Gestures::autoCancelingGestures()
 
   400 void tst_Gestures::autoCancelingGestures()
 
   376 {
 
   401 {
 
   377     GestureWidget widget;
 
   402     GestureWidget widget;
 
   378     widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
 
   403     widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   379     // send partial gesture. The gesture will be in the "maybe" state, but will
 
   404     // send partial gesture. The gesture will be in the "maybe" state, but will
 
   380     // never get enough events to fire, so Qt will have to kill it.
 
   405     // never get enough events to fire, so Qt will have to kill it.
 
   381     CustomEvent ev;
 
   406     CustomEvent ev;
 
   382     for (int i = CustomGesture::SerialMaybeThreshold;
 
   407     for (int i = CustomGesture::SerialMaybeThreshold;
 
   383          i < CustomGesture::SerialStartedThreshold; ++i) {
 
   408          i < CustomGesture::SerialStartedThreshold; ++i) {
 
   397     GestureWidget widget("widget");
 
   422     GestureWidget widget("widget");
 
   398     QVBoxLayout *l = new QVBoxLayout(&widget);
 
   423     QVBoxLayout *l = new QVBoxLayout(&widget);
 
   399     GestureWidget *child = new GestureWidget("child");
 
   424     GestureWidget *child = new GestureWidget("child");
 
   400     l->addWidget(child);
 
   425     l->addWidget(child);
 
   401 
   426 
   402     widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
 
   427     widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   403 
   428 
   404     CustomEvent event;
 
   429     CustomEvent event;
 
   405     sendCustomGesture(&event, child);
 
   430     sendCustomGesture(&event, child);
 
   406 
   431 
   407     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   432     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   413     QCOMPARE(child->gestureOverrideEventsReceived, 0);
 
   438     QCOMPARE(child->gestureOverrideEventsReceived, 0);
 
   414     QCOMPARE(widget.gestureEventsReceived, 0);
 
   439     QCOMPARE(widget.gestureEventsReceived, 0);
 
   415     QCOMPARE(widget.gestureOverrideEventsReceived, 0);
 
   440     QCOMPARE(widget.gestureOverrideEventsReceived, 0);
 
   416 
   441 
   417     // enable gestures over the children
 
   442     // enable gestures over the children
 
   418     widget.grabGesture(CustomGesture::GestureType, Qt::WidgetWithChildrenGesture);
 
   443     widget.grabGesture(CustomGesture::GestureType);
 
   419 
   444 
   420     widget.reset();
 
   445     widget.reset();
 
   421     child->reset();
 
   446     child->reset();
 
   422 
   447 
   423     sendCustomGesture(&event, child);
 
   448     sendCustomGesture(&event, child);
 
   442     GestureWidget parent("parent");
 
   467     GestureWidget parent("parent");
 
   443     QVBoxLayout *l = new QVBoxLayout(&parent);
 
   468     QVBoxLayout *l = new QVBoxLayout(&parent);
 
   444     GestureWidget *child = new GestureWidget("child");
 
   469     GestureWidget *child = new GestureWidget("child");
 
   445     l->addWidget(child);
 
   470     l->addWidget(child);
 
   446 
   471 
   447     parent.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
 
   472     parent.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   448     child->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
 
   473     child->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   449 
   474 
   450     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   475     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   451     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
   476     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
   452 
   477 
   453     // sending events to the child and making sure there is no conflict
 
   478     // sending events to the child and making sure there is no conflict
 
   480     GestureWidget parent("parent");
 
   505     GestureWidget parent("parent");
 
   481     QVBoxLayout *l = new QVBoxLayout(&parent);
 
   506     QVBoxLayout *l = new QVBoxLayout(&parent);
 
   482     GestureWidget *child = new GestureWidget("child");
 
   507     GestureWidget *child = new GestureWidget("child");
 
   483     l->addWidget(child);
 
   508     l->addWidget(child);
 
   484 
   509 
   485     parent.grabGesture(CustomGesture::GestureType, Qt::WidgetWithChildrenGesture);
 
   510     parent.grabGesture(CustomGesture::GestureType);
 
   486     child->grabGesture(CustomGesture::GestureType, Qt::WidgetWithChildrenGesture);
 
   511     child->grabGesture(CustomGesture::GestureType);
 
   487 
   512 
   488     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   513     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   489 
   514 
   490     // child accepts the override, parent will not receive anything
 
   515     // child accepts the override, parent will not receive anything
 
   491     parent.acceptGestureOverride = false;
 
   516     parent.acceptGestureOverride = false;
 
   516     QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
 
   541     QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
 
   517 
   542 
   518     parent.reset();
 
   543     parent.reset();
 
   519     child->reset();
 
   544     child->reset();
 
   520 
   545 
   521     // nobody accepts the override, we will send normal events to the closest context (to the child)
 
   546     // nobody accepts the override, we will send normal events to the closest
 
       
   547     // context (i.e. to the child widget) and it will be propagated and
 
       
   548     // accepted by the parent widget
 
   522     parent.acceptGestureOverride = false;
 
   549     parent.acceptGestureOverride = false;
 
   523     child->acceptGestureOverride = false;
 
   550     child->acceptGestureOverride = false;
 
       
   551     child->ignoredGestures << CustomGesture::GestureType;
 
       
   552 
       
   553     // sending events to the child and making sure there is no conflict
 
       
   554     sendCustomGesture(&event, child);
 
       
   555 
       
   556     QCOMPARE(child->gestureOverrideEventsReceived, 1);
 
       
   557     QCOMPARE(child->gestureEventsReceived, 1);
 
       
   558     QCOMPARE(parent.gestureOverrideEventsReceived, 1);
 
       
   559     QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
 
       
   560 
       
   561     parent.reset();
 
       
   562     child->reset();
 
       
   563 
       
   564     // nobody accepts the override, and nobody accepts the gesture event
 
       
   565     parent.acceptGestureOverride = false;
 
       
   566     child->acceptGestureOverride = false;
 
       
   567     parent.ignoredGestures << CustomGesture::GestureType;
 
       
   568     child->ignoredGestures << CustomGesture::GestureType;
 
       
   569 
       
   570     // sending events to the child and making sure there is no conflict
 
       
   571     sendCustomGesture(&event, child);
 
       
   572 
       
   573     QCOMPARE(child->gestureOverrideEventsReceived, 1);
 
       
   574     QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);
 
       
   575     QCOMPARE(parent.gestureOverrideEventsReceived, 1);
 
       
   576     QCOMPARE(parent.gestureEventsReceived, 1);
 
       
   577 
       
   578     parent.reset();
 
       
   579     child->reset();
 
       
   580 
       
   581     // we set an attribute to make sure all gesture events are propagated
 
       
   582     parent.grabGesture(CustomGesture::GestureType, Qt::ReceivePartialGestures);
 
       
   583     parent.acceptGestureOverride = false;
 
       
   584     child->acceptGestureOverride = false;
 
       
   585     parent.ignoredGestures << CustomGesture::GestureType;
 
   524     child->ignoredGestures << CustomGesture::GestureType;
 
   586     child->ignoredGestures << CustomGesture::GestureType;
 
   525 
   587 
   526     // sending events to the child and making sure there is no conflict
 
   588     // sending events to the child and making sure there is no conflict
 
   527     sendCustomGesture(&event, child);
 
   589     sendCustomGesture(&event, child);
 
   528 
   590 
   532     QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
 
   594     QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
 
   533 
   595 
   534     parent.reset();
 
   596     parent.reset();
 
   535     child->reset();
 
   597     child->reset();
 
   536 
   598 
   537     Qt::GestureType ContinuousGesture = qApp->registerGestureRecognizer(new CustomContinuousGestureRecognizer);
 
   599     Qt::GestureType ContinuousGesture = QGestureRecognizer::registerRecognizer(new CustomContinuousGestureRecognizer);
 
   538     static const int ContinuousGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
   600     static const int ContinuousGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
   539     child->grabGesture(ContinuousGesture);
 
   601     child->grabGesture(ContinuousGesture);
 
   540     // child accepts override. And it also receives another custom gesture.
 
   602     // child accepts override. And it also receives another custom gesture.
 
   541     parent.acceptGestureOverride = false;
 
   603     parent.acceptGestureOverride = false;
 
   542     child->acceptGestureOverride = true;
 
   604     child->acceptGestureOverride = true;
 
   545     QCOMPARE(child->gestureOverrideEventsReceived, 1);
 
   607     QCOMPARE(child->gestureOverrideEventsReceived, 1);
 
   546     QVERIFY(child->gestureEventsReceived > TotalGestureEventsCount);
 
   608     QVERIFY(child->gestureEventsReceived > TotalGestureEventsCount);
 
   547     QCOMPARE(child->events.all.count(), TotalGestureEventsCount + ContinuousGestureEventsCount);
 
   609     QCOMPARE(child->events.all.count(), TotalGestureEventsCount + ContinuousGestureEventsCount);
 
   548     QCOMPARE(parent.gestureOverrideEventsReceived, 0);
 
   610     QCOMPARE(parent.gestureOverrideEventsReceived, 0);
 
   549     QCOMPARE(parent.gestureEventsReceived, 0);
 
   611     QCOMPARE(parent.gestureEventsReceived, 0);
 
       
   612 
       
   613     QGestureRecognizer::unregisterRecognizer(ContinuousGesture);
 
   550 }
 
   614 }
 
   551 
   615 
   552 void tst_Gestures::finishedWithoutStarted()
 
   616 void tst_Gestures::finishedWithoutStarted()
 
   553 {
 
   617 {
 
   554     GestureWidget widget;
 
   618     GestureWidget widget;
 
   555     widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
 
   619     widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   556 
   620 
   557     // the gesture will claim it finished, but it was never started.
 
   621     // the gesture will claim it finished, but it was never started.
 
   558     CustomEvent ev;
 
   622     CustomEvent ev;
 
   559     ev.serial = CustomGesture::SerialFinishedThreshold;
 
   623     ev.serial = CustomGesture::SerialFinishedThreshold;
 
   560     QApplication::sendEvent(&widget, &ev);
 
   624     QApplication::sendEvent(&widget, &ev);
 
   570 }
 
   634 }
 
   571 
   635 
   572 void tst_Gestures::unknownGesture()
 
   636 void tst_Gestures::unknownGesture()
 
   573 {
 
   637 {
 
   574     GestureWidget widget;
 
   638     GestureWidget widget;
 
   575     widget.grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
 
   639     widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   576     widget.grabGesture(Qt::CustomGesture, Qt::WidgetGesture);
 
   640     widget.grabGesture(Qt::CustomGesture, Qt::DontStartGestureOnChildren);
 
   577     widget.grabGesture(Qt::GestureType(Qt::PanGesture+512), Qt::WidgetGesture);
 
   641     widget.grabGesture(Qt::GestureType(Qt::PanGesture+512), Qt::DontStartGestureOnChildren);
 
   578 
   642 
   579     CustomEvent event;
 
   643     CustomEvent event;
 
   580     sendCustomGesture(&event, &widget);
 
   644     sendCustomGesture(&event, &widget);
 
   581 
   645 
   582     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   646     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   674             if (acceptGestureOverride)
 
   738             if (acceptGestureOverride)
 
   675                 event->accept();
 
   739                 event->accept();
 
   676         }
 
   740         }
 
   677         if (eventsPtr) {
 
   741         if (eventsPtr) {
 
   678             QGestureEvent *e = static_cast<QGestureEvent*>(event);
 
   742             QGestureEvent *e = static_cast<QGestureEvent*>(event);
 
   679             QList<QGesture*> gestures = e->allGestures();
 
   743             QList<QGesture*> gestures = e->gestures();
 
   680             foreach(QGesture *g, gestures) {
 
   744             foreach(QGesture *g, gestures) {
 
   681                 eventsPtr->all << g->gestureType();
 
   745                 eventsPtr->all << g->gestureType();
 
   682                 switch(g->state()) {
 
   746                 switch(g->state()) {
 
   683                 case Qt::GestureStarted:
 
   747                 case Qt::GestureStarted:
 
   684                     eventsPtr->started << g->gestureType();
 
   748                     eventsPtr->started << g->gestureType();
 
   708 
   772 
   709 void tst_Gestures::graphicsItemGesture()
 
   773 void tst_Gestures::graphicsItemGesture()
 
   710 {
 
   774 {
 
   711     QGraphicsScene scene;
 
   775     QGraphicsScene scene;
 
   712     QGraphicsView view(&scene);
 
   776     QGraphicsView view(&scene);
 
       
   777     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
   713 
   778 
   714     GestureItem *item = new GestureItem("item");
 
   779     GestureItem *item = new GestureItem("item");
 
   715     scene.addItem(item);
 
   780     scene.addItem(item);
 
   716     item->setPos(100, 100);
 
   781     item->setPos(100, 100);
 
   717 
   782 
   718     view.show();
 
   783     view.show();
 
   719     QTest::qWaitForWindowShown(&view);
 
   784     QTest::qWaitForWindowShown(&view);
 
   720     view.ensureVisible(scene.sceneRect());
 
   785     view.ensureVisible(scene.sceneRect());
 
   721 
   786 
   722     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
 
   787     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   723     item->grabGesture(CustomGesture::GestureType);
 
   788     item->grabGesture(CustomGesture::GestureType);
 
   724 
   789 
   725     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   790     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   726     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
   791     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
   727 
   792 
   770 
   835 
   771 void tst_Gestures::graphicsItemTreeGesture()
 
   836 void tst_Gestures::graphicsItemTreeGesture()
 
   772 {
 
   837 {
 
   773     QGraphicsScene scene;
 
   838     QGraphicsScene scene;
 
   774     QGraphicsView view(&scene);
 
   839     QGraphicsView view(&scene);
 
       
   840     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
   775 
   841 
   776     GestureItem *item1 = new GestureItem("item1");
 
   842     GestureItem *item1 = new GestureItem("item1");
 
   777     item1->setPos(100, 100);
 
   843     item1->setPos(100, 100);
 
   778     item1->size = QRectF(0, 0, 350, 200);
 
   844     item1->size = QRectF(0, 0, 350, 200);
 
   779     scene.addItem(item1);
 
   845     scene.addItem(item1);
 
   790 
   856 
   791     view.show();
 
   857     view.show();
 
   792     QTest::qWaitForWindowShown(&view);
 
   858     QTest::qWaitForWindowShown(&view);
 
   793     view.ensureVisible(scene.sceneRect());
 
   859     view.ensureVisible(scene.sceneRect());
 
   794 
   860 
   795     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
 
   861     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   796     item1->grabGesture(CustomGesture::GestureType);
 
   862     item1->grabGesture(CustomGesture::GestureType);
 
   797 
   863 
   798     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   864     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   799 
   865 
   800     CustomEvent event;
 
   866     CustomEvent event;
 
   820     QCOMPARE(item1_child1->gestureOverrideEventsReceived, 1);
 
   886     QCOMPARE(item1_child1->gestureOverrideEventsReceived, 1);
 
   821     QCOMPARE(item1_child1->gestureEventsReceived, TotalGestureEventsCount);
 
   887     QCOMPARE(item1_child1->gestureEventsReceived, TotalGestureEventsCount);
 
   822     QCOMPARE(item1_child2->gestureEventsReceived, 0);
 
   888     QCOMPARE(item1_child2->gestureEventsReceived, 0);
 
   823     QCOMPARE(item1_child2->gestureOverrideEventsReceived, 0);
 
   889     QCOMPARE(item1_child2->gestureOverrideEventsReceived, 0);
 
   824     QCOMPARE(item1->gestureOverrideEventsReceived, 1);
 
   890     QCOMPARE(item1->gestureOverrideEventsReceived, 1);
 
   825     QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
 
   891     QCOMPARE(item1->gestureEventsReceived, 1);
 
   826 }
 
   892 }
 
   827 
   893 
   828 void tst_Gestures::explicitGraphicsObjectTarget()
 
   894 void tst_Gestures::explicitGraphicsObjectTarget()
 
   829 {
 
   895 {
 
   830     QGraphicsScene scene;
 
   896     QGraphicsScene scene;
 
   831     QGraphicsView view(&scene);
 
   897     QGraphicsView view(&scene);
 
       
   898     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
   832 
   899 
   833     GestureItem *item1 = new GestureItem("item1");
 
   900     GestureItem *item1 = new GestureItem("item1");
 
   834     scene.addItem(item1);
 
   901     scene.addItem(item1);
 
   835     item1->setPos(100, 100);
 
   902     item1->setPos(100, 100);
 
   836     item1->setZValue(1);
 
   903     item1->setZValue(1);
 
   847 
   914 
   848     view.show();
 
   915     view.show();
 
   849     QTest::qWaitForWindowShown(&view);
 
   916     QTest::qWaitForWindowShown(&view);
 
   850     view.ensureVisible(scene.sceneRect());
 
   917     view.ensureVisible(scene.sceneRect());
 
   851 
   918 
   852     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
 
   919     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   853     item1->grabGesture(CustomGesture::GestureType, Qt::ItemGesture);
 
   920     item1->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   854     item2->grabGesture(CustomGesture::GestureType, Qt::ItemGesture);
 
   921     item2->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   855     item2_child1->grabGesture(CustomGesture::GestureType, Qt::ItemGesture);
 
   922     item2_child1->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   856 
   923 
   857     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   924     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   858 
   925 
   859     // sending events to item1, but the hotSpot is set to item2
 
   926     // sending events to item1, but the hotSpot is set to item2
 
   860     CustomEvent event;
 
   927     CustomEvent event;
 
   880 
   947 
   881 void tst_Gestures::gestureOverChildGraphicsItem()
 
   948 void tst_Gestures::gestureOverChildGraphicsItem()
 
   882 {
 
   949 {
 
   883     QGraphicsScene scene;
 
   950     QGraphicsScene scene;
 
   884     QGraphicsView view(&scene);
 
   951     QGraphicsView view(&scene);
 
       
   952     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
   885 
   953 
   886     GestureItem *item0 = new GestureItem("item0");
 
   954     GestureItem *item0 = new GestureItem("item0");
 
   887     scene.addItem(item0);
 
   955     scene.addItem(item0);
 
   888     item0->setPos(0, 0);
 
   956     item0->setPos(0, 0);
 
   889     item0->grabGesture(CustomGesture::GestureType);
 
   957     item0->grabGesture(CustomGesture::GestureType);
 
   906 
   974 
   907     view.show();
 
   975     view.show();
 
   908     QTest::qWaitForWindowShown(&view);
 
   976     QTest::qWaitForWindowShown(&view);
 
   909     view.ensureVisible(scene.sceneRect());
 
   977     view.ensureVisible(scene.sceneRect());
 
   910 
   978 
   911     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::WidgetGesture);
 
   979     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   912     item1->grabGesture(CustomGesture::GestureType);
 
   980     item1->grabGesture(CustomGesture::GestureType);
 
   913 
   981 
   914     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   982     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   915     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
   983     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
   916 
   984 
   933 
  1001 
   934     event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);
 
  1002     event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);
 
   935     event.hasHotSpot = true;
 
  1003     event.hasHotSpot = true;
 
   936     sendCustomGesture(&event, item0, &scene);
 
  1004     sendCustomGesture(&event, item0, &scene);
 
   937 
  1005 
   938     QCOMPARE(item0->customEventsReceived, TotalCustomEventsCount);
 
  1006     QCOMPARE(item2_child1->gestureEventsReceived, 0);
 
       
  1007     QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);
 
       
  1008     QCOMPARE(item2->gestureEventsReceived, 1);
 
       
  1009     QCOMPARE(item2->gestureOverrideEventsReceived, 1);
 
       
  1010     QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
 
       
  1011     QCOMPARE(item1->gestureOverrideEventsReceived, 1);
 
       
  1012 
       
  1013     item0->reset(); item1->reset(); item2->reset(); item2_child1->reset();
 
       
  1014     item2->grabGesture(CustomGesture::GestureType);
 
       
  1015     item2->ignoredGestures << CustomGesture::GestureType;
 
       
  1016     item1->ignoredGestures << CustomGesture::GestureType;
 
       
  1017 
       
  1018     event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);
 
       
  1019     event.hasHotSpot = true;
 
       
  1020     sendCustomGesture(&event, item0, &scene);
 
       
  1021 
       
  1022     QCOMPARE(item2_child1->gestureEventsReceived, 0);
 
       
  1023     QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);
 
       
  1024     QCOMPARE(item2->gestureEventsReceived, TotalGestureEventsCount);
 
       
  1025     QCOMPARE(item2->gestureOverrideEventsReceived, 1);
 
       
  1026     QCOMPARE(item1->gestureEventsReceived, 1);
 
       
  1027     QCOMPARE(item1->gestureOverrideEventsReceived, 1);
 
       
  1028 
       
  1029     item0->reset(); item1->reset(); item2->reset(); item2_child1->reset();
 
       
  1030     item2->grabGesture(CustomGesture::GestureType);
 
       
  1031     item2->ignoredGestures << CustomGesture::GestureType;
 
       
  1032     item1->ignoredGestures << CustomGesture::GestureType;
 
       
  1033     item1->grabGesture(CustomGesture::GestureType, Qt::ReceivePartialGestures);
 
       
  1034 
       
  1035     event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);
 
       
  1036     event.hasHotSpot = true;
 
       
  1037     sendCustomGesture(&event, item0, &scene);
 
       
  1038 
   939     QCOMPARE(item2_child1->gestureEventsReceived, 0);
 
  1039     QCOMPARE(item2_child1->gestureEventsReceived, 0);
 
   940     QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);
 
  1040     QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);
 
   941     QCOMPARE(item2->gestureEventsReceived, TotalGestureEventsCount);
 
  1041     QCOMPARE(item2->gestureEventsReceived, TotalGestureEventsCount);
 
   942     QCOMPARE(item2->gestureOverrideEventsReceived, 1);
 
  1042     QCOMPARE(item2->gestureOverrideEventsReceived, 1);
 
   943     QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
 
  1043     QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
 
   949     GestureWidget parent("parent");
 
  1049     GestureWidget parent("parent");
 
   950     QVBoxLayout *l = new QVBoxLayout(&parent);
 
  1050     QVBoxLayout *l = new QVBoxLayout(&parent);
 
   951     GestureWidget *child = new GestureWidget("child");
 
  1051     GestureWidget *child = new GestureWidget("child");
 
   952     l->addWidget(child);
 
  1052     l->addWidget(child);
 
   953 
  1053 
   954     Qt::GestureType SecondGesture = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
 
  1054     Qt::GestureType SecondGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
 
   955 
  1055 
   956     parent.grabGesture(CustomGesture::GestureType, Qt::WidgetWithChildrenGesture);
 
  1056     parent.grabGesture(CustomGesture::GestureType);
 
   957     child->grabGesture(SecondGesture, Qt::WidgetWithChildrenGesture);
 
  1057     child->grabGesture(SecondGesture);
 
   958 
  1058 
   959     CustomEvent event;
 
  1059     CustomEvent event;
 
   960     // sending events that form a gesture to one widget, but they will be
 
  1060     // sending events that form a gesture to one widget, but they will be
 
   961     // filtered by two different gesture recognizers and will generate two
 
  1061     // filtered by two different gesture recognizers and will generate two
 
   962     // QGesture objects. Check that those gesture objects are delivered to
 
  1062     // QGesture objects. Check that those gesture objects are delivered to
 
   976     QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
 
  1076     QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
 
   977     QCOMPARE(parent.gestureOverrideEventsReceived, 0);
 
  1077     QCOMPARE(parent.gestureOverrideEventsReceived, 0);
 
   978     QCOMPARE(parent.events.all.size(), TotalGestureEventsCount);
 
  1078     QCOMPARE(parent.events.all.size(), TotalGestureEventsCount);
 
   979     for(int i = 0; i < child->events.all.size(); ++i)
 
  1079     for(int i = 0; i < child->events.all.size(); ++i)
 
   980         QCOMPARE(parent.events.all.at(i), CustomGesture::GestureType);
 
  1080         QCOMPARE(parent.events.all.at(i), CustomGesture::GestureType);
 
       
  1081 
       
  1082     QGestureRecognizer::unregisterRecognizer(SecondGesture);
 
   981 }
 
  1083 }
 
   982 
  1084 
   983 void tst_Gestures::multipleGesturesInTree()
 
  1085 void tst_Gestures::multipleGesturesInTree()
 
   984 {
 
  1086 {
 
   985     GestureWidget a("A");
 
  1087     GestureWidget a("A");
 
   987     GestureWidget *B = new GestureWidget("B", A);
 
  1089     GestureWidget *B = new GestureWidget("B", A);
 
   988     GestureWidget *C = new GestureWidget("C", B);
 
  1090     GestureWidget *C = new GestureWidget("C", B);
 
   989     GestureWidget *D = new GestureWidget("D", C);
 
  1091     GestureWidget *D = new GestureWidget("D", C);
 
   990 
  1092 
   991     Qt::GestureType FirstGesture  = CustomGesture::GestureType;
 
  1093     Qt::GestureType FirstGesture  = CustomGesture::GestureType;
 
   992     Qt::GestureType SecondGesture = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
 
  1094     Qt::GestureType SecondGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
 
   993     Qt::GestureType ThirdGesture  = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
 
  1095     Qt::GestureType ThirdGesture  = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
 
   994 
  1096 
   995     A->grabGesture(FirstGesture, Qt::WidgetWithChildrenGesture);   // A [1   3]
 
  1097     Qt::GestureFlags flags = Qt::ReceivePartialGestures;
 
   996     A->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);   // |
 
  1098     A->grabGesture(FirstGesture,  flags);   // A [1   3]
 
   997     B->grabGesture(SecondGesture, Qt::WidgetWithChildrenGesture);  // B [  2 3]
 
  1099     A->grabGesture(ThirdGesture,  flags);   // |
 
   998     B->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);   // |
 
  1100     B->grabGesture(SecondGesture, flags);   // B [  2 3]
 
   999     C->grabGesture(FirstGesture, Qt::WidgetWithChildrenGesture);   // C [1 2 3]
 
  1101     B->grabGesture(ThirdGesture,  flags);   // |
 
  1000     C->grabGesture(SecondGesture, Qt::WidgetWithChildrenGesture);  // |
 
  1102     C->grabGesture(FirstGesture,  flags);   // C [1 2 3]
 
  1001     C->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);   // D [1   3]
 
  1103     C->grabGesture(SecondGesture, flags);   // |
 
  1002     D->grabGesture(FirstGesture, Qt::WidgetWithChildrenGesture);
 
  1104     C->grabGesture(ThirdGesture,  flags);   // D [1   3]
 
  1003     D->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);
 
  1105     D->grabGesture(FirstGesture,  flags);
 
       
  1106     D->grabGesture(ThirdGesture,  flags);
 
  1004 
  1107 
  1005     // make sure all widgets ignore events, so they get propagated.
 
  1108     // make sure all widgets ignore events, so they get propagated.
 
  1006     A->ignoredGestures << FirstGesture << ThirdGesture;
 
  1109     A->ignoredGestures << FirstGesture << ThirdGesture;
 
  1007     B->ignoredGestures << SecondGesture << ThirdGesture;
 
  1110     B->ignoredGestures << SecondGesture << ThirdGesture;
 
  1008     C->ignoredGestures << FirstGesture << SecondGesture << ThirdGesture;
 
  1111     C->ignoredGestures << FirstGesture << SecondGesture << ThirdGesture;
 
  1044     QCOMPARE(B->events.all.count(ThirdGesture), TotalGestureEventsCount);
 
  1147     QCOMPARE(B->events.all.count(ThirdGesture), TotalGestureEventsCount);
 
  1045 
  1148 
  1046     QCOMPARE(A->events.all.count(FirstGesture), TotalGestureEventsCount);
 
  1149     QCOMPARE(A->events.all.count(FirstGesture), TotalGestureEventsCount);
 
  1047     QCOMPARE(A->events.all.count(SecondGesture), 0);
 
  1150     QCOMPARE(A->events.all.count(SecondGesture), 0);
 
  1048     QCOMPARE(A->events.all.count(ThirdGesture), TotalGestureEventsCount);
 
  1151     QCOMPARE(A->events.all.count(ThirdGesture), TotalGestureEventsCount);
 
       
  1152 
       
  1153     QGestureRecognizer::unregisterRecognizer(SecondGesture);
 
       
  1154     QGestureRecognizer::unregisterRecognizer(ThirdGesture);
 
  1049 }
 
  1155 }
 
  1050 
  1156 
  1051 void tst_Gestures::multipleGesturesInComplexTree()
 
  1157 void tst_Gestures::multipleGesturesInComplexTree()
 
  1052 {
 
  1158 {
 
  1053     GestureWidget a("A");
 
  1159     GestureWidget a("A");
 
  1055     GestureWidget *B = new GestureWidget("B", A);
 
  1161     GestureWidget *B = new GestureWidget("B", A);
 
  1056     GestureWidget *C = new GestureWidget("C", B);
 
  1162     GestureWidget *C = new GestureWidget("C", B);
 
  1057     GestureWidget *D = new GestureWidget("D", C);
 
  1163     GestureWidget *D = new GestureWidget("D", C);
 
  1058 
  1164 
  1059     Qt::GestureType FirstGesture   = CustomGesture::GestureType;
 
  1165     Qt::GestureType FirstGesture   = CustomGesture::GestureType;
 
  1060     Qt::GestureType SecondGesture  = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
 
  1166     Qt::GestureType SecondGesture  = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
 
  1061     Qt::GestureType ThirdGesture   = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
 
  1167     Qt::GestureType ThirdGesture   = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
 
  1062     Qt::GestureType FourthGesture  = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
 
  1168     Qt::GestureType FourthGesture  = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
 
  1063     Qt::GestureType FifthGesture   = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
 
  1169     Qt::GestureType FifthGesture   = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
 
  1064     Qt::GestureType SixthGesture   = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
 
  1170     Qt::GestureType SixthGesture   = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
 
  1065     Qt::GestureType SeventhGesture = qApp->registerGestureRecognizer(new CustomGestureRecognizer);
 
  1171     Qt::GestureType SeventhGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
 
  1066 
  1172 
  1067     A->grabGesture(FirstGesture, Qt::WidgetWithChildrenGesture);   // A [1,3,4]
 
  1173     Qt::GestureFlags flags = Qt::ReceivePartialGestures;
 
  1068     A->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);   // |
 
  1174     A->grabGesture(FirstGesture,   flags); // A [1,3,4]
 
  1069     A->grabGesture(FourthGesture, Qt::WidgetWithChildrenGesture);  // B [2,3,5]
 
  1175     A->grabGesture(ThirdGesture,   flags); // |
 
  1070     B->grabGesture(SecondGesture, Qt::WidgetWithChildrenGesture);  // |
 
  1176     A->grabGesture(FourthGesture,  flags); // B [2,3,5]
 
  1071     B->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);   // C [1,2,3,6]
 
  1177     B->grabGesture(SecondGesture,  flags); // |
 
  1072     B->grabGesture(FifthGesture, Qt::WidgetWithChildrenGesture);   // |
 
  1178     B->grabGesture(ThirdGesture,   flags); // C [1,2,3,6]
 
  1073     C->grabGesture(FirstGesture, Qt::WidgetWithChildrenGesture);   // D [1,3,7]
 
  1179     B->grabGesture(FifthGesture,   flags); // |
 
  1074     C->grabGesture(SecondGesture, Qt::WidgetWithChildrenGesture);
 
  1180     C->grabGesture(FirstGesture,   flags); // D [1,3,7]
 
  1075     C->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);
 
  1181     C->grabGesture(SecondGesture,  flags);
 
  1076     C->grabGesture(SixthGesture, Qt::WidgetWithChildrenGesture);
 
  1182     C->grabGesture(ThirdGesture,   flags);
 
  1077     D->grabGesture(FirstGesture, Qt::WidgetWithChildrenGesture);
 
  1183     C->grabGesture(SixthGesture,   flags);
 
  1078     D->grabGesture(ThirdGesture, Qt::WidgetWithChildrenGesture);
 
  1184     D->grabGesture(FirstGesture,   flags);
 
  1079     D->grabGesture(SeventhGesture, Qt::WidgetWithChildrenGesture);
 
  1185     D->grabGesture(ThirdGesture,   flags);
 
       
  1186     D->grabGesture(SeventhGesture, flags);
 
  1080 
  1187 
  1081     // make sure all widgets ignore events, so they get propagated.
 
  1188     // make sure all widgets ignore events, so they get propagated.
 
  1082     QSet<Qt::GestureType> allGestureTypes;
 
  1189     QSet<Qt::GestureType> allGestureTypes;
 
  1083     allGestureTypes << FirstGesture << SecondGesture << ThirdGesture
 
  1190     allGestureTypes << FirstGesture << SecondGesture << ThirdGesture
 
  1084             << FourthGesture << FifthGesture << SixthGesture << SeventhGesture;
 
  1191             << FourthGesture << FifthGesture << SixthGesture << SeventhGesture;
 
  1137     QCOMPARE(A->events.all.count(ThirdGesture), TotalGestureEventsCount);
 
  1244     QCOMPARE(A->events.all.count(ThirdGesture), TotalGestureEventsCount);
 
  1138     QCOMPARE(A->events.all.count(FourthGesture), TotalGestureEventsCount);
 
  1245     QCOMPARE(A->events.all.count(FourthGesture), TotalGestureEventsCount);
 
  1139     QCOMPARE(A->events.all.count(FifthGesture), 0);
 
  1246     QCOMPARE(A->events.all.count(FifthGesture), 0);
 
  1140     QCOMPARE(A->events.all.count(SixthGesture), 0);
 
  1247     QCOMPARE(A->events.all.count(SixthGesture), 0);
 
  1141     QCOMPARE(A->events.all.count(SeventhGesture), 0);
 
  1248     QCOMPARE(A->events.all.count(SeventhGesture), 0);
 
       
  1249 
       
  1250     QGestureRecognizer::unregisterRecognizer(SecondGesture);
 
       
  1251     QGestureRecognizer::unregisterRecognizer(ThirdGesture);
 
       
  1252     QGestureRecognizer::unregisterRecognizer(FourthGesture);
 
       
  1253     QGestureRecognizer::unregisterRecognizer(FifthGesture);
 
       
  1254     QGestureRecognizer::unregisterRecognizer(SixthGesture);
 
       
  1255     QGestureRecognizer::unregisterRecognizer(SeventhGesture);
 
  1142 }
 
  1256 }
 
  1143 
  1257 
  1144 void tst_Gestures::testMapToScene()
 
  1258 void tst_Gestures::testMapToScene()
 
  1145 {
 
  1259 {
 
  1146     QGesture gesture;
 
  1260     QGesture gesture;
 
  1147     QList<QGesture*> list;
 
  1261     QList<QGesture*> list;
 
  1148     list << &gesture;
 
  1262     list << &gesture;
 
  1149     QGestureEvent event(list);
 
  1263     QGestureEvent event(list);
 
  1150     QCOMPARE(event.mapToScene(gesture.hotSpot()), QPointF()); // not set, can't do much
 
  1264     QCOMPARE(event.mapToGraphicsScene(gesture.hotSpot()), QPointF()); // not set, can't do much
 
  1151 
  1265 
  1152     QGraphicsScene scene;
 
  1266     QGraphicsScene scene;
 
  1153     QGraphicsView view(&scene);
 
  1267     QGraphicsView view(&scene);
 
       
  1268     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
  1154 
  1269 
  1155     GestureItem *item0 = new GestureItem;
 
  1270     GestureItem *item0 = new GestureItem;
 
  1156     scene.addItem(item0);
 
  1271     scene.addItem(item0);
 
  1157     item0->setPos(14, 16);
 
  1272     item0->setPos(14, 16);
 
  1158 
  1273 
  1161     view.ensureVisible(scene.sceneRect());
 
  1276     view.ensureVisible(scene.sceneRect());
 
  1162 
  1277 
  1163     QPoint origin = view.mapToGlobal(QPoint());
 
  1278     QPoint origin = view.mapToGlobal(QPoint());
 
  1164     event.setWidget(view.viewport());
 
  1279     event.setWidget(view.viewport());
 
  1165 
  1280 
  1166     QCOMPARE(event.mapToScene(origin + QPoint(100, 200)), view.mapToScene(QPoint(100, 200)));
 
  1281     QCOMPARE(event.mapToGraphicsScene(origin + QPoint(100, 200)), view.mapToScene(QPoint(100, 200)));
 
       
  1282 }
 
       
  1283 
       
  1284 void tst_Gestures::ungrabGesture() // a method on QWidget
 
       
  1285 {
 
       
  1286     class MockGestureWidget : public GestureWidget {
 
       
  1287     public:
 
       
  1288         MockGestureWidget(const char *name = 0, QWidget *parent = 0)
 
       
  1289             : GestureWidget(name, parent) { }
 
       
  1290 
       
  1291 
       
  1292         QSet<QGesture*> gestures;
 
       
  1293     protected:
 
       
  1294         bool event(QEvent *event)
 
       
  1295         {
 
       
  1296             if (event->type() == QEvent::Gesture) {
 
       
  1297                 QGestureEvent *gestureEvent = static_cast<QGestureEvent*>(event);
 
       
  1298                 if (gestureEvent)
 
       
  1299                     foreach (QGesture *g, gestureEvent->gestures())
 
       
  1300                         gestures.insert(g);
 
       
  1301             }
 
       
  1302             return GestureWidget::event(event);
 
       
  1303         }
 
       
  1304     };
 
       
  1305 
       
  1306     MockGestureWidget parent("A");
 
       
  1307     MockGestureWidget *a = &parent;
 
       
  1308     MockGestureWidget *b = new MockGestureWidget("B", a);
 
       
  1309 
       
  1310     a->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
       
  1311     b->grabGesture(CustomGesture::GestureType);
 
       
  1312     b->ignoredGestures << CustomGesture::GestureType;
 
       
  1313 
       
  1314     CustomEvent event;
 
       
  1315     // sending an event will cause the QGesture objects to be instantiated for the widgets
 
       
  1316     sendCustomGesture(&event, b);
 
       
  1317 
       
  1318     QCOMPARE(a->gestures.count(), 1);
 
       
  1319     QPointer<QGesture> customGestureA;
 
       
  1320     customGestureA = *(a->gestures.begin());
 
       
  1321     QVERIFY(!customGestureA.isNull());
 
       
  1322     QCOMPARE(customGestureA->gestureType(), CustomGesture::GestureType);
 
       
  1323 
       
  1324     QCOMPARE(b->gestures.count(), 1);
 
       
  1325     QPointer<QGesture> customGestureB;
 
       
  1326     customGestureB = *(b->gestures.begin());
 
       
  1327     QVERIFY(!customGestureB.isNull());
 
       
  1328     QVERIFY(customGestureA.data() == customGestureB.data());
 
       
  1329     QCOMPARE(customGestureB->gestureType(), CustomGesture::GestureType);
 
       
  1330 
       
  1331     a->gestures.clear();
 
       
  1332     // sending an event will cause the QGesture objects to be instantiated for the widget
 
       
  1333     sendCustomGesture(&event, a);
 
       
  1334 
       
  1335     QCOMPARE(a->gestures.count(), 1);
 
       
  1336     customGestureA = *(a->gestures.begin());
 
       
  1337     QVERIFY(!customGestureA.isNull());
 
       
  1338     QCOMPARE(customGestureA->gestureType(), CustomGesture::GestureType);
 
       
  1339     QVERIFY(customGestureA.data() != customGestureB.data());
 
       
  1340 
       
  1341     a->ungrabGesture(CustomGesture::GestureType);
 
       
  1342     QVERIFY(customGestureA.isNull());
 
       
  1343     QVERIFY(!customGestureB.isNull());
 
       
  1344 
       
  1345     a->gestures.clear();
 
       
  1346     a->reset();
 
       
  1347     // send again to 'b' and make sure a never gets it.
 
       
  1348     sendCustomGesture(&event, b);
 
       
  1349     QCOMPARE(a->gestureEventsReceived, 0);
 
       
  1350     QCOMPARE(a->gestureOverrideEventsReceived, 0);
 
       
  1351 }
 
       
  1352 
       
  1353 void tst_Gestures::unregisterRecognizer() // a method on QApplication
 
       
  1354 {
 
       
  1355     /*
 
       
  1356      The hardest usecase to get right is when we remove a recognizer while several
 
       
  1357      of the gestures it created are in active state and we immediately add a new recognizer
 
       
  1358      for the same type (thus replacing the old one).
 
       
  1359      The expected result is that all old gestures continue till they are finished/cancelled
 
       
  1360      and the new recognizer starts creating gestures immediately at registration.
 
       
  1361 
       
  1362      This implies that deleting of the recognizer happens only when there are no more gestures
 
       
  1363      that it created. (since gestures might have a pointer to the recognizer)
 
       
  1364      */
 
       
  1365 
       
  1366 }
 
       
  1367 
       
  1368 void tst_Gestures::autoCancelGestures()
 
       
  1369 {
 
       
  1370     class MockWidget : public GestureWidget {
 
       
  1371       public:
 
       
  1372         MockWidget(const char *name) : GestureWidget(name) { }
 
       
  1373 
       
  1374         bool event(QEvent *event)
 
       
  1375         {
 
       
  1376             if (event->type() == QEvent::Gesture) {
 
       
  1377                 QGestureEvent *ge = static_cast<QGestureEvent*>(event);
 
       
  1378                 Q_ASSERT(ge->gestures().count() == 1); // can't use QCOMPARE here...
 
       
  1379                 ge->gestures().first()->setGestureCancelPolicy(QGesture::CancelAllInContext);
 
       
  1380             }
 
       
  1381             return GestureWidget::event(event);
 
       
  1382         }
 
       
  1383     };
 
       
  1384 
       
  1385     const Qt::GestureType secondGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
 
       
  1386 
       
  1387     MockWidget parent("parent"); // this one sets the cancel policy to CancelAllInContext
 
       
  1388     parent.resize(300, 100);
 
       
  1389     parent.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
       
  1390     GestureWidget *child = new GestureWidget("child", &parent);
 
       
  1391     child->setGeometry(10, 10, 100, 80);
 
       
  1392 
       
  1393     parent.grabGesture(CustomGesture::GestureType);
 
       
  1394     child->grabGesture(secondGesture);
 
       
  1395     parent.show();
 
       
  1396     QTest::qWaitForWindowShown(&parent);
 
       
  1397 
       
  1398     /*
 
       
  1399       An event is send to both the child and the parent, when the child gets it a gesture is triggered
 
       
  1400       and send to the child.
 
       
  1401       When the parent gets the event a new gesture is triggered and delivered to the parent. When the
 
       
  1402       parent gets it he accepts it and that causes the cancel policy to activate.
 
       
  1403       The cause of that is the gesture for the child is cancelled and send to the child as such.
 
       
  1404     */
 
       
  1405     CustomEvent event;
 
       
  1406     event.serial = CustomGesture::SerialStartedThreshold;
 
       
  1407     QApplication::sendEvent(child, &event);
 
       
  1408     QCOMPARE(child->events.all.count(), 2);
 
       
  1409     QCOMPARE(child->events.started.count(), 1);
 
       
  1410     QCOMPARE(child->events.canceled.count(), 1);
 
       
  1411     QCOMPARE(parent.events.all.count(), 1);
 
       
  1412 
       
  1413     // clean up, make the parent gesture finish
 
       
  1414     event.serial = CustomGesture::SerialFinishedThreshold;
 
       
  1415     QApplication::sendEvent(child, &event);
 
       
  1416     QCOMPARE(parent.events.all.count(), 2);
 
       
  1417 }
 
       
  1418 
       
  1419 void tst_Gestures::autoCancelGestures2()
 
       
  1420 {
 
       
  1421     class MockItem : public GestureItem {
 
       
  1422       public:
 
       
  1423         MockItem(const char *name) : GestureItem(name) { }
 
       
  1424 
       
  1425         bool event(QEvent *event) {
 
       
  1426             if (event->type() == QEvent::Gesture) {
 
       
  1427                 QGestureEvent *ge = static_cast<QGestureEvent*>(event);
 
       
  1428                 Q_ASSERT(ge->gestures().count() == 1); // can't use QCOMPARE here...
 
       
  1429                 ge->gestures().first()->setGestureCancelPolicy(QGesture::CancelAllInContext);
 
       
  1430             }
 
       
  1431             return GestureItem::event(event);
 
       
  1432         }
 
       
  1433     };
 
       
  1434 
       
  1435     const Qt::GestureType secondGesture = QGestureRecognizer ::registerRecognizer(new CustomGestureRecognizer);
 
       
  1436 
       
  1437     QGraphicsScene scene;
 
       
  1438     QGraphicsView view(&scene);
 
       
  1439     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
       
  1440 
       
  1441     MockItem *parent = new MockItem("parent");
 
       
  1442     GestureItem *child = new GestureItem("child");
 
       
  1443     child->setParentItem(parent);
 
       
  1444     parent->setPos(0, 0);
 
       
  1445     child->setPos(10, 10);
 
       
  1446     scene.addItem(parent);
 
       
  1447     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
       
  1448     view.viewport()->grabGesture(secondGesture, Qt::DontStartGestureOnChildren);
 
       
  1449     parent->grabGesture(CustomGesture::GestureType);
 
       
  1450     child->grabGesture(secondGesture);
 
       
  1451 
       
  1452     view.show();
 
       
  1453     QTest::qWaitForWindowShown(&view);
 
       
  1454     view.ensureVisible(scene.sceneRect());
 
       
  1455 
       
  1456     CustomEvent event;
 
       
  1457     event.serial = CustomGesture::SerialStartedThreshold;
 
       
  1458     event.hasHotSpot = true;
 
       
  1459     event.hotSpot = mapToGlobal(QPointF(5, 5), child, &view);
 
       
  1460     // qDebug() << event.hotSpot;
 
       
  1461     scene.sendEvent(child, &event);
 
       
  1462     //QEventLoop().exec();
 
       
  1463     QCOMPARE(parent->events.all.count(), 1);
 
       
  1464     QCOMPARE(child->events.started.count(), 1);
 
       
  1465     QCOMPARE(child->events.canceled.count(), 1);
 
       
  1466     QCOMPARE(child->events.all.count(), 2);
 
       
  1467 
       
  1468     // clean up, make the parent gesture finish
 
       
  1469     event.serial = CustomGesture::SerialFinishedThreshold;
 
       
  1470     scene.sendEvent(child, &event);
 
       
  1471     QCOMPARE(parent->events.all.count(), 2);
 
  1167 }
 
  1472 }
 
  1168 
  1473 
  1169 QTEST_MAIN(tst_Gestures)
 
  1474 QTEST_MAIN(tst_Gestures)
 
  1170 #include "tst_gestures.moc"
 
  1475 #include "tst_gestures.moc"
FCL/sf/mw/qt