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
branchGCC_SURGE
changeset 31 5daf16870df6
parent 30 5dc02b23752f
child 33 3e2da88830cd
equal deleted inserted replaced
27:93b982ccede2 31:5daf16870df6 
    48 #include <qlayout.h>
 
    48 #include <qlayout.h>
 
    49 #include <qgesture.h>
 
    49 #include <qgesture.h>
 
    50 #include <qgesturerecognizer.h>
 
    50 #include <qgesturerecognizer.h>
 
    51 #include <qgraphicsitem.h>
 
    51 #include <qgraphicsitem.h>
 
    52 #include <qgraphicsview.h>
 
    52 #include <qgraphicsview.h>
 
       
    53 #include <qmainwindow.h>
 
    53 
    54 
    54 #include <qdebug.h>
 
    55 #include <qdebug.h>
 
    55 
    56 
    56 //TESTED_CLASS=
 
    57 //TESTED_CLASS=
 
    57 //TESTED_FILES=
 
    58 //TESTED_FILES=
 
    58 
    59 
    59 static QPointF mapToGlobal(const QPointF &pt, QGraphicsItem *item, QGraphicsView *view)
 
    60 static QPointF mapToGlobal(const QPointF &pt, QGraphicsItem *item, QGraphicsView *view)
 
    60 {
 
    61 {
 
    61     return view->mapToGlobal(view->mapFromScene(item->mapToScene(pt)));
 
    62     return view->viewport()->mapToGlobal(view->mapFromScene(item->mapToScene(pt)));
 
    62 }
 
    63 }
 
    63 
    64 
    64 class CustomGesture : public QGesture
 
    65 class CustomGesture : public QGesture
 
    65 {
 
    66 {
 
    66     Q_OBJECT
 
    67     Q_OBJECT
 
   259             QList<QGesture*> gestures = e->gestures();
 
   260             QList<QGesture*> gestures = e->gestures();
 
   260             foreach(QGesture *g, gestures) {
 
   261             foreach(QGesture *g, gestures) {
 
   261                 eventsPtr->all << g->gestureType();
 
   262                 eventsPtr->all << g->gestureType();
 
   262                 switch(g->state()) {
 
   263                 switch(g->state()) {
 
   263                 case Qt::GestureStarted:
 
   264                 case Qt::GestureStarted:
 
       
   265                     emit gestureStarted(e->type(), g);
 
   264                     eventsPtr->started << g->gestureType();
 
   266                     eventsPtr->started << g->gestureType();
 
   265                     break;
 
   267                     break;
 
   266                 case Qt::GestureUpdated:
 
   268                 case Qt::GestureUpdated:
 
       
   269                     emit gestureUpdated(e->type(), g);
 
   267                     eventsPtr->updated << g->gestureType();
 
   270                     eventsPtr->updated << g->gestureType();
 
   268                     break;
 
   271                     break;
 
   269                 case Qt::GestureFinished:
 
   272                 case Qt::GestureFinished:
 
       
   273                     emit gestureFinished(e->type(), g);
 
   270                     eventsPtr->finished << g->gestureType();
 
   274                     eventsPtr->finished << g->gestureType();
 
   271                     break;
 
   275                     break;
 
   272                 case Qt::GestureCanceled:
 
   276                 case Qt::GestureCanceled:
 
       
   277                     emit gestureCanceled(e->type(), g);
 
   273                     eventsPtr->canceled << g->gestureType();
 
   278                     eventsPtr->canceled << g->gestureType();
 
   274                     break;
 
   279                     break;
 
   275                 default:
 
   280                 default:
 
   276                     Q_ASSERT(false);
 
   281                     Q_ASSERT(false);
 
   277                 }
 
   282                 }
 
   281         } else {
 
   286         } else {
 
   282             return QWidget::event(event);
 
   287             return QWidget::event(event);
 
   283         }
 
   288         }
 
   284         return true;
 
   289         return true;
 
   285     }
 
   290     }
 
       
   291 
       
   292 Q_SIGNALS:
 
       
   293     void gestureStarted(QEvent::Type, QGesture *);
 
       
   294     void gestureUpdated(QEvent::Type, QGesture *);
 
       
   295     void gestureFinished(QEvent::Type, QGesture *);
 
       
   296     void gestureCanceled(QEvent::Type, QGesture *);
 
       
   297 
       
   298 public Q_SLOTS:
 
       
   299     void deleteThis() { delete this; }
 
   286 };
 
   300 };
 
   287 
   301 
   288 // TODO rename to sendGestureSequence
 
   302 // TODO rename to sendGestureSequence
 
   289 static void sendCustomGesture(CustomEvent *event, QObject *object, QGraphicsScene *scene = 0)
 
   303 static void sendCustomGesture(CustomEvent *event, QObject *object, QGraphicsScene *scene = 0)
 
   290 {
 
   304 {
 
       
   305     QWeakPointer<QObject> receiver(object);
 
   291     for (int i = CustomGesture::SerialMaybeThreshold;
 
   306     for (int i = CustomGesture::SerialMaybeThreshold;
 
   292          i <= CustomGesture::SerialFinishedThreshold; ++i) {
 
   307          i <= CustomGesture::SerialFinishedThreshold && receiver; ++i) {
 
   293         event->serial = i;
 
   308         event->serial = i;
 
   294         if (scene)
 
   309         if (scene)
 
   295             scene->sendEvent(qobject_cast<QGraphicsObject *>(object), event);
 
   310             scene->sendEvent(qobject_cast<QGraphicsObject *>(object), event);
 
   296         else
 
   311         else
 
   297             QApplication::sendEvent(object, event);
 
   312             QApplication::sendEvent(object, event);
 
   319     void multipleWidgetOnlyGestureInTree();
 
   334     void multipleWidgetOnlyGestureInTree();
 
   320     void conflictingGestures();
 
   335     void conflictingGestures();
 
   321     void finishedWithoutStarted();
 
   336     void finishedWithoutStarted();
 
   322     void unknownGesture();
 
   337     void unknownGesture();
 
   323     void graphicsItemGesture();
 
   338     void graphicsItemGesture();
 
       
   339     void graphicsView();
 
   324     void graphicsItemTreeGesture();
 
   340     void graphicsItemTreeGesture();
 
   325     void explicitGraphicsObjectTarget();
 
   341     void explicitGraphicsObjectTarget();
 
   326     void gestureOverChildGraphicsItem();
 
   342     void gestureOverChildGraphicsItem();
 
   327     void twoGesturesOnDifferentLevel();
 
   343     void twoGesturesOnDifferentLevel();
 
   328     void multipleGesturesInTree();
 
   344     void multipleGesturesInTree();
 
   331     void ungrabGesture();
 
   347     void ungrabGesture();
 
   332     void consumeEventHint();
 
   348     void consumeEventHint();
 
   333     void unregisterRecognizer();
 
   349     void unregisterRecognizer();
 
   334     void autoCancelGestures();
 
   350     void autoCancelGestures();
 
   335     void autoCancelGestures2();
 
   351     void autoCancelGestures2();
 
       
   352     void graphicsViewParentPropagation();
 
   336     void panelPropagation();
 
   353     void panelPropagation();
 
   337     void panelStacksBehindParent();
 
   354     void panelStacksBehindParent();
 
       
   355     void deleteGestureTargetWidget();
 
       
   356     void deleteGestureTargetItem_data();
 
       
   357     void deleteGestureTargetItem();
 
       
   358     void viewportCoordinates();
 
       
   359     void partialGesturePropagation();
 
       
   360     void testQGestureRecognizerCleanup();
 
   338 };
 
   361 };
 
   339 
   362 
   340 tst_Gestures::tst_Gestures()
 
   363 tst_Gestures::tst_Gestures()
 
   341 {
 
   364 {
 
   342 }
 
   365 }
 
   654     Qt::blue, Qt::red, Qt::green, Qt::gray, Qt::yellow
 
   677     Qt::blue, Qt::red, Qt::green, Qt::gray, Qt::yellow
 
   655 };
 
   678 };
 
   656 
   679 
   657 class GestureItem : public QGraphicsObject
 
   680 class GestureItem : public QGraphicsObject
 
   658 {
 
   681 {
 
       
   682     Q_OBJECT
 
   659     static int InstanceCount;
 
   683     static int InstanceCount;
 
   660 
       
   661 public:
 
   684 public:
 
   662     GestureItem(const char *name = 0)
 
   685     GestureItem(const char *name = 0)
 
   663     {
 
   686     {
 
   664         instanceNumber = InstanceCount++;
 
   687         instanceNumber = InstanceCount++;
 
   665         if (name)
 
   688         if (name) {
 
   666             setObjectName(QLatin1String(name));
 
   689             setObjectName(QLatin1String(name));
 
       
   690             setToolTip(name);
 
       
   691         }
 
   667         size = QRectF(0, 0, 100, 100);
 
   692         size = QRectF(0, 0, 100, 100);
 
   668         customEventsReceived = 0;
 
   693         customEventsReceived = 0;
 
   669         gestureEventsReceived = 0;
 
   694         gestureEventsReceived = 0;
 
   670         gestureOverrideEventsReceived = 0;
 
   695         gestureOverrideEventsReceived = 0;
 
   671         events.clear();
 
   696         events.clear();
 
   672         overrideEvents.clear();
 
   697         overrideEvents.clear();
 
   673         acceptGestureOverride = false;
 
   698         acceptGestureOverride = false;
 
       
   699 
       
   700         scene = 0;
 
   674     }
 
   701     }
 
   675     ~GestureItem()
 
   702     ~GestureItem()
 
   676     {
 
   703     {
 
   677         --InstanceCount;
 
   704         --InstanceCount;
 
   678     }
 
   705     }
 
   698         }
 
   725         }
 
   699     } events, overrideEvents;
 
   726     } events, overrideEvents;
 
   700 
   727 
   701     bool acceptGestureOverride;
 
   728     bool acceptGestureOverride;
 
   702     QSet<Qt::GestureType> ignoredGestures;
 
   729     QSet<Qt::GestureType> ignoredGestures;
 
       
   730     QSet<Qt::GestureType> ignoredStartedGestures;
 
       
   731     QSet<Qt::GestureType> ignoredUpdatedGestures;
 
       
   732     QSet<Qt::GestureType> ignoredFinishedGestures;
 
   703 
   733 
   704     QRectF size;
 
   734     QRectF size;
 
   705     int instanceNumber;
 
   735     int instanceNumber;
 
   706 
   736 
   707     void reset()
 
   737     void reset()
 
   710         gestureEventsReceived = 0;
 
   740         gestureEventsReceived = 0;
 
   711         gestureOverrideEventsReceived = 0;
 
   741         gestureOverrideEventsReceived = 0;
 
   712         events.clear();
 
   742         events.clear();
 
   713         overrideEvents.clear();
 
   743         overrideEvents.clear();
 
   714         ignoredGestures.clear();
 
   744         ignoredGestures.clear();
 
   715     }
 
   745         ignoredStartedGestures.clear();
 
   716 
   746         ignoredUpdatedGestures.clear();
 
   717 protected:
 
   747         ignoredFinishedGestures.clear();
 
       
   748     }
 
       
   749 
   718     QRectF boundingRect() const
 
   750     QRectF boundingRect() const
 
   719     {
 
   751     {
 
   720         return size;
 
   752         return size;
 
   721     }
 
   753     }
 
   722     void paint(QPainter *p, const QStyleOptionGraphicsItem *, QWidget *)
 
   754     void paint(QPainter *p, const QStyleOptionGraphicsItem *, QWidget *)
 
   732             ++gestureEventsReceived;
 
   764             ++gestureEventsReceived;
 
   733             eventsPtr = &events;
 
   765             eventsPtr = &events;
 
   734             QGestureEvent *e = static_cast<QGestureEvent *>(event);
 
   766             QGestureEvent *e = static_cast<QGestureEvent *>(event);
 
   735             foreach(Qt::GestureType type, ignoredGestures)
 
   767             foreach(Qt::GestureType type, ignoredGestures)
 
   736                 e->ignore(e->gesture(type));
 
   768                 e->ignore(e->gesture(type));
 
       
   769             foreach(QGesture *g, e->gestures()) {
 
       
   770                 switch (g->state()) {
 
       
   771                 case Qt::GestureStarted:
 
       
   772                     if (ignoredStartedGestures.contains(g->gestureType()))
 
       
   773                         e->ignore(g);
 
       
   774                     break;
 
       
   775                 case Qt::GestureUpdated:
 
       
   776                     if (ignoredUpdatedGestures.contains(g->gestureType()))
 
       
   777                         e->ignore(g);
 
       
   778                     break;
 
       
   779                 case Qt::GestureFinished:
 
       
   780                     if (ignoredFinishedGestures.contains(g->gestureType()))
 
       
   781                         e->ignore(g);
 
       
   782                     break;
 
       
   783                 default:
 
       
   784                     break;
 
       
   785                 }
 
       
   786             }
 
   737         } else if (event->type() == QEvent::GestureOverride) {
 
   787         } else if (event->type() == QEvent::GestureOverride) {
 
   738             ++gestureOverrideEventsReceived;
 
   788             ++gestureOverrideEventsReceived;
 
   739             eventsPtr = &overrideEvents;
 
   789             eventsPtr = &overrideEvents;
 
   740             if (acceptGestureOverride)
 
   790             if (acceptGestureOverride)
 
   741                 event->accept();
 
   791                 event->accept();
 
   746             foreach(QGesture *g, gestures) {
 
   796             foreach(QGesture *g, gestures) {
 
   747                 eventsPtr->all << g->gestureType();
 
   797                 eventsPtr->all << g->gestureType();
 
   748                 switch(g->state()) {
 
   798                 switch(g->state()) {
 
   749                 case Qt::GestureStarted:
 
   799                 case Qt::GestureStarted:
 
   750                     eventsPtr->started << g->gestureType();
 
   800                     eventsPtr->started << g->gestureType();
 
       
   801                     emit gestureStarted(e->type(), g);
 
   751                     break;
 
   802                     break;
 
   752                 case Qt::GestureUpdated:
 
   803                 case Qt::GestureUpdated:
 
   753                     eventsPtr->updated << g->gestureType();
 
   804                     eventsPtr->updated << g->gestureType();
 
       
   805                     emit gestureUpdated(e->type(), g);
 
   754                     break;
 
   806                     break;
 
   755                 case Qt::GestureFinished:
 
   807                 case Qt::GestureFinished:
 
   756                     eventsPtr->finished << g->gestureType();
 
   808                     eventsPtr->finished << g->gestureType();
 
       
   809                     emit gestureFinished(e->type(), g);
 
   757                     break;
 
   810                     break;
 
   758                 case Qt::GestureCanceled:
 
   811                 case Qt::GestureCanceled:
 
   759                     eventsPtr->canceled << g->gestureType();
 
   812                     eventsPtr->canceled << g->gestureType();
 
       
   813                     emit gestureCanceled(e->type(), g);
 
   760                     break;
 
   814                     break;
 
   761                 default:
 
   815                 default:
 
   762                     Q_ASSERT(false);
 
   816                     Q_ASSERT(false);
 
   763                 }
 
   817                 }
 
   764             }
 
   818             }
 
   767         } else {
 
   821         } else {
 
   768             return QGraphicsObject::event(event);
 
   822             return QGraphicsObject::event(event);
 
   769         }
 
   823         }
 
   770         return true;
 
   824         return true;
 
   771     }
 
   825     }
 
       
   826 
       
   827 Q_SIGNALS:
 
       
   828     void gestureStarted(QEvent::Type, QGesture *);
 
       
   829     void gestureUpdated(QEvent::Type, QGesture *);
 
       
   830     void gestureFinished(QEvent::Type, QGesture *);
 
       
   831     void gestureCanceled(QEvent::Type, QGesture *);
 
       
   832 
       
   833 public:
 
       
   834     // some arguments for the slots below:
 
       
   835     QGraphicsScene *scene;
 
       
   836 
       
   837 public Q_SLOTS:
 
       
   838     void deleteThis() { delete this; }
 
       
   839     void addSelfToScene(QEvent::Type eventType, QGesture *)
 
       
   840     {
 
       
   841         if (eventType == QEvent::Gesture) {
 
       
   842             disconnect(sender(), 0, this, SLOT(addSelfToScene(QEvent::Type,QGesture*)));
 
       
   843             scene->addItem(this);
 
       
   844         }
 
       
   845     }
 
   772 };
 
   846 };
 
   773 int GestureItem::InstanceCount = 0;
 
   847 int GestureItem::InstanceCount = 0;
 
   774 
   848 
   775 void tst_Gestures::graphicsItemGesture()
 
   849 void tst_Gestures::graphicsItemGesture()
 
   776 {
 
   850 {
 
   784 
   858 
   785     view.show();
 
   859     view.show();
 
   786     QTest::qWaitForWindowShown(&view);
 
   860     QTest::qWaitForWindowShown(&view);
 
   787     view.ensureVisible(scene.sceneRect());
 
   861     view.ensureVisible(scene.sceneRect());
 
   788 
   862 
   789     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
       
   790     item->grabGesture(CustomGesture::GestureType);
 
   863     item->grabGesture(CustomGesture::GestureType);
 
   791 
   864 
   792     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   865     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   793     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
   866     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
   794 
   867 
   833     QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);
 
   906     QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);
 
   834     QCOMPARE(item->gestureEventsReceived, TotalGestureEventsCount);
 
   907     QCOMPARE(item->gestureEventsReceived, TotalGestureEventsCount);
 
   835     QCOMPARE(item->gestureOverrideEventsReceived, 0);
 
   908     QCOMPARE(item->gestureOverrideEventsReceived, 0);
 
   836 }
 
   909 }
 
   837 
   910 
       
   911 void tst_Gestures::graphicsView()
 
       
   912 {
 
       
   913     QGraphicsScene scene;
 
       
   914     QGraphicsView view(&scene);
 
       
   915     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
       
   916 
       
   917     GestureItem *item = new GestureItem("item");
 
       
   918     scene.addItem(item);
 
       
   919     item->setPos(100, 100);
 
       
   920 
       
   921     view.show();
 
       
   922     QTest::qWaitForWindowShown(&view);
 
       
   923     view.ensureVisible(scene.sceneRect());
 
       
   924 
       
   925     item->grabGesture(CustomGesture::GestureType);
 
       
   926 
       
   927     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
       
   928     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
       
   929 
       
   930     CustomEvent event;
 
       
   931     // make sure the event is properly delivered if only the hotspot is set.
 
       
   932     event.hotSpot = mapToGlobal(QPointF(10, 10), item, &view);
 
       
   933     event.hasHotSpot = true;
 
       
   934     sendCustomGesture(&event, item, &scene);
 
       
   935 
       
   936     QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);
 
       
   937     QCOMPARE(item->gestureEventsReceived, TotalGestureEventsCount);
 
       
   938     QCOMPARE(item->gestureOverrideEventsReceived, 0);
 
       
   939 
       
   940     // change the viewport and try again
 
       
   941     QWidget *newViewport = new QWidget;
 
       
   942     view.setViewport(newViewport);
 
       
   943 
       
   944     item->reset();
 
       
   945     sendCustomGesture(&event, item, &scene);
 
       
   946 
       
   947     QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);
 
       
   948     QCOMPARE(item->gestureEventsReceived, TotalGestureEventsCount);
 
       
   949     QCOMPARE(item->gestureOverrideEventsReceived, 0);
 
       
   950 
       
   951     // change the scene and try again
 
       
   952     QGraphicsScene newScene;
 
       
   953     item = new GestureItem("newItem");
 
       
   954     newScene.addItem(item);
 
       
   955     item->setPos(100, 100);
 
       
   956     view.setScene(&newScene);
 
       
   957 
       
   958     item->reset();
 
       
   959     // first without a gesture
 
       
   960     sendCustomGesture(&event, item, &newScene);
 
       
   961 
       
   962     QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);
 
       
   963     QCOMPARE(item->gestureEventsReceived, 0);
 
       
   964     QCOMPARE(item->gestureOverrideEventsReceived, 0);
 
       
   965 
       
   966     // then grab the gesture and try again
 
       
   967     item->reset();
 
       
   968     item->grabGesture(CustomGesture::GestureType);
 
       
   969     sendCustomGesture(&event, item, &newScene);
 
       
   970 
       
   971     QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);
 
       
   972     QCOMPARE(item->gestureEventsReceived, TotalGestureEventsCount);
 
       
   973     QCOMPARE(item->gestureOverrideEventsReceived, 0);
 
       
   974 }
 
       
   975 
   838 void tst_Gestures::graphicsItemTreeGesture()
 
   976 void tst_Gestures::graphicsItemTreeGesture()
 
   839 {
 
   977 {
 
   840     QGraphicsScene scene;
 
   978     QGraphicsScene scene;
 
   841     QGraphicsView view(&scene);
 
   979     QGraphicsView view(&scene);
 
   842     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
   980     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
   858 
   996 
   859     view.show();
 
   997     view.show();
 
   860     QTest::qWaitForWindowShown(&view);
 
   998     QTest::qWaitForWindowShown(&view);
 
   861     view.ensureVisible(scene.sceneRect());
 
   999     view.ensureVisible(scene.sceneRect());
 
   862 
  1000 
   863     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
       
   864     item1->grabGesture(CustomGesture::GestureType);
 
  1001     item1->grabGesture(CustomGesture::GestureType);
 
   865 
  1002 
   866     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
  1003     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   867 
  1004 
   868     CustomEvent event;
 
  1005     CustomEvent event;
 
   916 
  1053 
   917     view.show();
 
  1054     view.show();
 
   918     QTest::qWaitForWindowShown(&view);
 
  1055     QTest::qWaitForWindowShown(&view);
 
   919     view.ensureVisible(scene.sceneRect());
 
  1056     view.ensureVisible(scene.sceneRect());
 
   920 
  1057 
   921     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
       
   922     item1->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
  1058     item1->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   923     item2->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
  1059     item2->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   924     item2_child1->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
  1060     item2_child1->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
   925 
  1061 
   926     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
  1062     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   976 
  1112 
   977     view.show();
 
  1113     view.show();
 
   978     QTest::qWaitForWindowShown(&view);
 
  1114     QTest::qWaitForWindowShown(&view);
 
   979     view.ensureVisible(scene.sceneRect());
 
  1115     view.ensureVisible(scene.sceneRect());
 
   980 
  1116 
   981     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
       
   982     item1->grabGesture(CustomGesture::GestureType);
 
  1117     item1->grabGesture(CustomGesture::GestureType);
 
   983 
  1118 
   984     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
  1119     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
   985     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
  1120     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
   986 
  1121 
  1444     GestureItem *child = new GestureItem("child");
 
  1579     GestureItem *child = new GestureItem("child");
 
  1445     child->setParentItem(parent);
 
  1580     child->setParentItem(parent);
 
  1446     parent->setPos(0, 0);
 
  1581     parent->setPos(0, 0);
 
  1447     child->setPos(10, 10);
 
  1582     child->setPos(10, 10);
 
  1448     scene.addItem(parent);
 
  1583     scene.addItem(parent);
 
  1449     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
       
  1450     view.viewport()->grabGesture(secondGesture, Qt::DontStartGestureOnChildren);
 
       
  1451     parent->grabGesture(CustomGesture::GestureType);
 
  1584     parent->grabGesture(CustomGesture::GestureType);
 
  1452     child->grabGesture(secondGesture);
 
  1585     child->grabGesture(secondGesture);
 
  1453 
  1586 
  1454     view.show();
 
  1587     view.show();
 
  1455     QTest::qWaitForWindowShown(&view);
 
  1588     QTest::qWaitForWindowShown(&view);
 
  1469     event.serial = CustomGesture::SerialFinishedThreshold;
 
  1602     event.serial = CustomGesture::SerialFinishedThreshold;
 
  1470     scene.sendEvent(child, &event);
 
  1603     scene.sendEvent(child, &event);
 
  1471     QCOMPARE(parent->events.all.count(), 2);
 
  1604     QCOMPARE(parent->events.all.count(), 2);
 
  1472 }
 
  1605 }
 
  1473 
  1606 
       
  1607 void tst_Gestures::graphicsViewParentPropagation()
 
       
  1608 {
 
       
  1609     QGraphicsScene scene;
 
       
  1610     QGraphicsView view(&scene);
 
       
  1611     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
       
  1612 
       
  1613     GestureItem *item0 = new GestureItem("item0");
 
       
  1614     scene.addItem(item0);
 
       
  1615     item0->setPos(0, 0);
 
       
  1616     item0->grabGesture(CustomGesture::GestureType);
 
       
  1617     item0->setZValue(1);
 
       
  1618 
       
  1619     GestureItem *item1 = new GestureItem("item1");
 
       
  1620     scene.addItem(item1);
 
       
  1621     item1->setPos(0, 0);
 
       
  1622     item1->setZValue(5);
 
       
  1623 
       
  1624     GestureItem *item1_c1 = new GestureItem("item1_child1");
 
       
  1625     item1_c1->setParentItem(item1);
 
       
  1626     item1_c1->setPos(0, 0);
 
       
  1627 
       
  1628     GestureItem *item1_c1_c1 = new GestureItem("item1_child1_child1");
 
       
  1629     item1_c1_c1->setParentItem(item1_c1);
 
       
  1630     item1_c1_c1->setPos(0, 0);
 
       
  1631 
       
  1632     view.show();
 
       
  1633     QTest::qWaitForWindowShown(&view);
 
       
  1634     view.ensureVisible(scene.sceneRect());
 
       
  1635 
       
  1636     item0->grabGesture(CustomGesture::GestureType, Qt::ReceivePartialGestures | Qt::IgnoredGesturesPropagateToParent);
 
       
  1637     item1->grabGesture(CustomGesture::GestureType, Qt::ReceivePartialGestures | Qt::IgnoredGesturesPropagateToParent);
 
       
  1638     item1_c1->grabGesture(CustomGesture::GestureType, Qt::IgnoredGesturesPropagateToParent);
 
       
  1639     item1_c1_c1->grabGesture(CustomGesture::GestureType, Qt::ReceivePartialGestures | Qt::IgnoredGesturesPropagateToParent);
 
       
  1640 
       
  1641     item0->ignoredUpdatedGestures << CustomGesture::GestureType;
 
       
  1642     item0->ignoredFinishedGestures << CustomGesture::GestureType;
 
       
  1643     item1->ignoredUpdatedGestures << CustomGesture::GestureType;
 
       
  1644     item1->ignoredFinishedGestures << CustomGesture::GestureType;
 
       
  1645     item1_c1->ignoredUpdatedGestures << CustomGesture::GestureType;
 
       
  1646     item1_c1->ignoredFinishedGestures << CustomGesture::GestureType;
 
       
  1647     item1_c1_c1->ignoredUpdatedGestures << CustomGesture::GestureType;
 
       
  1648     item1_c1_c1->ignoredFinishedGestures << CustomGesture::GestureType;
 
       
  1649 
       
  1650     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
       
  1651 
       
  1652     CustomEvent event;
 
       
  1653     event.hotSpot = mapToGlobal(QPointF(10, 10), item1_c1, &view);
 
       
  1654     event.hasHotSpot = true;
 
       
  1655     sendCustomGesture(&event, item0, &scene);
 
       
  1656 
       
  1657     QCOMPARE(item1_c1_c1->gestureEventsReceived, TotalGestureEventsCount);
 
       
  1658     QCOMPARE(item1_c1_c1->gestureOverrideEventsReceived, 1);
 
       
  1659     QCOMPARE(item1_c1->gestureEventsReceived, TotalGestureEventsCount-1);
 
       
  1660     QCOMPARE(item1_c1->gestureOverrideEventsReceived, 1);
 
       
  1661     QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount-1);
 
       
  1662     QCOMPARE(item1->gestureOverrideEventsReceived, 1);
 
       
  1663     QCOMPARE(item0->gestureEventsReceived, 0);
 
       
  1664     QCOMPARE(item0->gestureOverrideEventsReceived, 1);
 
       
  1665 }
 
       
  1666 
  1474 void tst_Gestures::panelPropagation()
 
  1667 void tst_Gestures::panelPropagation()
 
  1475 {
 
  1668 {
 
  1476     QGraphicsScene scene;
 
  1669     QGraphicsScene scene;
 
  1477     QGraphicsView view(&scene);
 
  1670     QGraphicsView view(&scene);
 
  1478     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
  1671     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
  1507     item1_child1_child1->setZValue(10);
 
  1700     item1_child1_child1->setZValue(10);
 
  1508 
  1701 
  1509     view.show();
 
  1702     view.show();
 
  1510     QTest::qWaitForWindowShown(&view);
 
  1703     QTest::qWaitForWindowShown(&view);
 
  1511     view.ensureVisible(scene.sceneRect());
 
  1704     view.ensureVisible(scene.sceneRect());
 
  1512 
       
  1513     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
       
  1514 
  1705 
  1515     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
  1706     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
  1516     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
  1707     static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
 
  1517 
  1708 
  1518     CustomEvent event;
 
  1709     CustomEvent event;
 
  1621 
  1812 
  1622     view.show();
 
  1813     view.show();
 
  1623     QTest::qWaitForWindowShown(&view);
 
  1814     QTest::qWaitForWindowShown(&view);
 
  1624     view.ensureVisible(scene.sceneRect());
 
  1815     view.ensureVisible(scene.sceneRect());
 
  1625 
  1816 
  1626     view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
 
       
  1627 
       
  1628     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
  1817     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
  1629 
  1818 
  1630     CustomEvent event;
 
  1819     CustomEvent event;
 
  1631     event.hotSpot = mapToGlobal(QPointF(5, 5), item1, &view);
 
  1820     event.hotSpot = mapToGlobal(QPointF(5, 5), item1, &view);
 
  1632     event.hasHotSpot = true;
 
  1821     event.hasHotSpot = true;
 
  1636     QCOMPARE(item1->gestureOverrideEventsReceived, 0);
 
  1825     QCOMPARE(item1->gestureOverrideEventsReceived, 0);
 
  1637     QCOMPARE(panel->gestureEventsReceived, TotalGestureEventsCount);
 
  1826     QCOMPARE(panel->gestureEventsReceived, TotalGestureEventsCount);
 
  1638     QCOMPARE(panel->gestureOverrideEventsReceived, 0);
 
  1827     QCOMPARE(panel->gestureOverrideEventsReceived, 0);
 
  1639 }
 
  1828 }
 
  1640 
  1829 
       
  1830 void tst_Gestures::deleteGestureTargetWidget()
 
       
  1831 {
 
       
  1832 }
 
       
  1833 
       
  1834 void tst_Gestures::deleteGestureTargetItem_data()
 
       
  1835 {
 
       
  1836     QTest::addColumn<bool>("propagateUpdateGesture");
 
       
  1837     QTest::addColumn<QString>("emitter");
 
       
  1838     QTest::addColumn<QString>("receiver");
 
       
  1839     QTest::addColumn<QByteArray>("signalName");
 
       
  1840     QTest::addColumn<QByteArray>("slotName");
 
       
  1841 
       
  1842     QByteArray gestureUpdated = SIGNAL(gestureUpdated(QEvent::Type,QGesture*));
 
       
  1843     QByteArray gestureFinished = SIGNAL(gestureFinished(QEvent::Type,QGesture*));
 
       
  1844     QByteArray deleteThis = SLOT(deleteThis());
 
       
  1845     QByteArray deleteLater = SLOT(deleteLater());
 
       
  1846 
       
  1847     QTest::newRow("delete1")
 
       
  1848             << false << "item1" << "item1" << gestureUpdated << deleteThis;
 
       
  1849     QTest::newRow("delete2")
 
       
  1850             << false << "item2" << "item2" << gestureUpdated << deleteThis;
 
       
  1851     QTest::newRow("delete3")
 
       
  1852             << false << "item1" << "item2" << gestureUpdated << deleteThis;
 
       
  1853 
       
  1854     QTest::newRow("deleteLater1")
 
       
  1855             << false << "item1" << "item1" << gestureUpdated << deleteLater;
 
       
  1856     QTest::newRow("deleteLater2")
 
       
  1857             << false << "item2" << "item2" << gestureUpdated << deleteLater;
 
       
  1858     QTest::newRow("deleteLater3")
 
       
  1859             << false << "item1" << "item2" << gestureUpdated << deleteLater;
 
       
  1860     QTest::newRow("deleteLater4")
 
       
  1861             << false << "item2" << "item1" << gestureUpdated << deleteLater;
 
       
  1862 
       
  1863     QTest::newRow("delete-self-and-propagate")
 
       
  1864             << true << "item2" << "item2" << gestureUpdated << deleteThis;
 
       
  1865     QTest::newRow("deleteLater-self-and-propagate")
 
       
  1866             << true << "item2" << "item2" << gestureUpdated << deleteLater;
 
       
  1867     QTest::newRow("propagate-to-deletedLater")
 
       
  1868             << true << "item2" << "item1" << gestureUpdated << deleteLater;
 
       
  1869 }
 
       
  1870 
       
  1871 void tst_Gestures::deleteGestureTargetItem()
 
       
  1872 {
 
       
  1873     QFETCH(bool, propagateUpdateGesture);
 
       
  1874     QFETCH(QString, emitter);
 
       
  1875     QFETCH(QString, receiver);
 
       
  1876     QFETCH(QByteArray, signalName);
 
       
  1877     QFETCH(QByteArray, slotName);
 
       
  1878 
       
  1879     QGraphicsScene scene;
 
       
  1880     QGraphicsView view(&scene);
 
       
  1881     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
       
  1882 
       
  1883     GestureItem *item1 = new GestureItem("item1");
 
       
  1884     item1->grabGesture(CustomGesture::GestureType);
 
       
  1885     item1->setZValue(2);
 
       
  1886     scene.addItem(item1);
 
       
  1887 
       
  1888     GestureItem *item2 = new GestureItem("item2");
 
       
  1889     item2->grabGesture(CustomGesture::GestureType);
 
       
  1890     item2->setZValue(5);
 
       
  1891     scene.addItem(item2);
 
       
  1892 
       
  1893     QMap<QString, GestureItem *> items;
 
       
  1894     items.insert(item1->objectName(), item1);
 
       
  1895     items.insert(item2->objectName(), item2);
 
       
  1896 
       
  1897     view.show();
 
       
  1898     QTest::qWaitForWindowShown(&view);
 
       
  1899     view.ensureVisible(scene.sceneRect());
 
       
  1900 
       
  1901     if (propagateUpdateGesture)
 
       
  1902         item2->ignoredUpdatedGestures << CustomGesture::GestureType;
 
       
  1903     connect(items.value(emitter, 0), signalName, items.value(receiver, 0), slotName);
 
       
  1904 
       
  1905     // some debug output to see the current test data tag, so if we crash
 
       
  1906     // we know which one caused the crash.
 
       
  1907     qDebug() << "<-- testing";
 
       
  1908 
       
  1909     CustomEvent event;
 
       
  1910     event.hotSpot = mapToGlobal(QPointF(5, 5), item2, &view);
 
       
  1911     event.hasHotSpot = true;
 
       
  1912     sendCustomGesture(&event, item1, &scene);
 
       
  1913 }
 
       
  1914 
       
  1915 class GraphicsView : public QGraphicsView
 
       
  1916 {
 
       
  1917 public:
 
       
  1918     GraphicsView(QGraphicsScene *scene, QWidget *parent = 0)
 
       
  1919         : QGraphicsView(scene, parent)
 
       
  1920     {
 
       
  1921     }
 
       
  1922 
       
  1923     using QGraphicsView::setViewportMargins;
 
       
  1924 };
 
       
  1925 
       
  1926 // just making sure that even if the graphicsview has margins hotspot still
 
       
  1927 // works properly. It should use viewport for converting global coordinates to
 
       
  1928 // scene coordinates.
 
       
  1929 void tst_Gestures::viewportCoordinates()
 
       
  1930 {
 
       
  1931     QGraphicsScene scene;
 
       
  1932     GraphicsView view(&scene);
 
       
  1933     view.setViewportMargins(10,20,15,25);
 
       
  1934     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
       
  1935 
       
  1936     GestureItem *item1 = new GestureItem("item1");
 
       
  1937     item1->grabGesture(CustomGesture::GestureType);
 
       
  1938     item1->size = QRectF(0, 0, 3, 3);
 
       
  1939     item1->setZValue(2);
 
       
  1940     scene.addItem(item1);
 
       
  1941 
       
  1942     view.show();
 
       
  1943     QTest::qWaitForWindowShown(&view);
 
       
  1944     view.ensureVisible(scene.sceneRect());
 
       
  1945 
       
  1946     CustomEvent event;
 
       
  1947     event.hotSpot = mapToGlobal(item1->boundingRect().center(), item1, &view);
 
       
  1948     event.hasHotSpot = true;
 
       
  1949     sendCustomGesture(&event, item1, &scene);
 
       
  1950     QVERIFY(item1->gestureEventsReceived != 0);
 
       
  1951 }
 
       
  1952 
       
  1953 void tst_Gestures::partialGesturePropagation()
 
       
  1954 {
 
       
  1955     QGraphicsScene scene;
 
       
  1956     QGraphicsView view(&scene);
 
       
  1957     view.setWindowFlags(Qt::X11BypassWindowManagerHint);
 
       
  1958 
       
  1959     GestureItem *item1 = new GestureItem("item1");
 
       
  1960     item1->grabGesture(CustomGesture::GestureType);
 
       
  1961     item1->setZValue(8);
 
       
  1962     scene.addItem(item1);
 
       
  1963 
       
  1964     GestureItem *item2 = new GestureItem("item2[partial]");
 
       
  1965     item2->grabGesture(CustomGesture::GestureType, Qt::ReceivePartialGestures);
 
       
  1966     item2->setZValue(6);
 
       
  1967     scene.addItem(item2);
 
       
  1968 
       
  1969     GestureItem *item3 = new GestureItem("item3");
 
       
  1970     item3->grabGesture(CustomGesture::GestureType);
 
       
  1971     item3->setZValue(4);
 
       
  1972     scene.addItem(item3);
 
       
  1973 
       
  1974     GestureItem *item4 = new GestureItem("item4[partial]");
 
       
  1975     item4->grabGesture(CustomGesture::GestureType, Qt::ReceivePartialGestures);
 
       
  1976     item4->setZValue(2);
 
       
  1977     scene.addItem(item4);
 
       
  1978 
       
  1979     view.show();
 
       
  1980     QTest::qWaitForWindowShown(&view);
 
       
  1981     view.ensureVisible(scene.sceneRect());
 
       
  1982 
       
  1983     item1->ignoredUpdatedGestures << CustomGesture::GestureType;
 
       
  1984 
       
  1985     CustomEvent event;
 
       
  1986     event.hotSpot = mapToGlobal(QPointF(5, 5), item1, &view);
 
       
  1987     event.hasHotSpot = true;
 
       
  1988     sendCustomGesture(&event, item1, &scene);
 
       
  1989 
       
  1990     static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
 
       
  1991 
       
  1992     QCOMPARE(item1->gestureOverrideEventsReceived, 1);
 
       
  1993     QCOMPARE(item2->gestureOverrideEventsReceived, 1);
 
       
  1994     QCOMPARE(item3->gestureOverrideEventsReceived, 1);
 
       
  1995     QCOMPARE(item4->gestureOverrideEventsReceived, 1);
 
       
  1996 
       
  1997     QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
 
       
  1998     QCOMPARE(item2->gestureEventsReceived, TotalGestureEventsCount-2); // except for started and finished
 
       
  1999     QCOMPARE(item3->gestureEventsReceived, 0);
 
       
  2000     QCOMPARE(item4->gestureEventsReceived, 0);
 
       
  2001 }
 
       
  2002 
       
  2003 class WinNativePan : public QPanGesture {
 
       
  2004 public:
 
       
  2005     WinNativePan() {}
 
       
  2006 };
 
       
  2007 
       
  2008 class Pan : public QPanGesture {
 
       
  2009 public:
 
       
  2010     Pan() {}
 
       
  2011 };
 
       
  2012 
       
  2013 class CustomPan : public QPanGesture {
 
       
  2014 public:
 
       
  2015     CustomPan() {}
 
       
  2016 };
 
       
  2017 
       
  2018 // Recognizer for active gesture triggers on mouse press
 
       
  2019 class PanRecognizer : public QGestureRecognizer {
 
       
  2020 public:
 
       
  2021     enum PanType { Platform, Default, Custom };
 
       
  2022 
       
  2023     PanRecognizer(int id) : m_id(id) {}
 
       
  2024     QGesture *create(QObject *) {
 
       
  2025         switch(m_id) {
 
       
  2026         case Platform: return new WinNativePan();
 
       
  2027         case Default:  return new Pan();
 
       
  2028         default:       return new CustomPan();
 
       
  2029         }
 
       
  2030     }
 
       
  2031 
       
  2032     Result recognize(QGesture *, QObject *, QEvent *) { return QGestureRecognizer::Ignore; }
 
       
  2033 
       
  2034     const int m_id;
 
       
  2035 };
 
       
  2036 
       
  2037 void tst_Gestures::testQGestureRecognizerCleanup()
 
       
  2038 {
 
       
  2039     // Clean first the current recognizers in QGManager
 
       
  2040     QGestureRecognizer::unregisterRecognizer(Qt::PanGesture);
 
       
  2041 
       
  2042     // v-- Qt singleton QGManager initialization
 
       
  2043 
       
  2044     // Mimic QGestureManager: register both default and "platform" recognizers
 
       
  2045     // (this is done in windows when QT_NO_NATIVE_GESTURES is not defined)
 
       
  2046     PanRecognizer *def = new PanRecognizer(PanRecognizer::Default);
 
       
  2047     QGestureRecognizer::registerRecognizer(def);
 
       
  2048     PanRecognizer *plt = new PanRecognizer(PanRecognizer::Platform);
 
       
  2049     QGestureRecognizer::registerRecognizer(plt);
 
       
  2050     qDebug () << "register: default =" << def << "; platform =" << plt;
 
       
  2051 
       
  2052     // ^-- Qt singleton QGManager initialization
 
       
  2053 
       
  2054     // Here, application code would start
 
       
  2055 
       
  2056     // Create QGV (has a QAScrollArea, which uses Qt::PanGesture)
 
       
  2057     QMainWindow    *w = new QMainWindow;
 
       
  2058     QGraphicsView  *v = new QGraphicsView();
 
       
  2059     w->setCentralWidget(v);
 
       
  2060 
       
  2061     // Unregister Qt recognizers
 
       
  2062     QGestureRecognizer::unregisterRecognizer(Qt::PanGesture);
 
       
  2063 
       
  2064     // Register a custom Pan recognizer
 
       
  2065     //QGestureRecognizer::registerRecognizer(new PanRecognizer(PanRecognizer::Custom));
 
       
  2066 
       
  2067     w->show();
 
       
  2068     QTest::qWaitForWindowShown(w);
 
       
  2069     delete w;
 
       
  2070 }
 
       
  2071 
  1641 QTEST_MAIN(tst_Gestures)
 
  2072 QTEST_MAIN(tst_Gestures)
 
  1642 #include "tst_gestures.moc"
 
  2073 #include "tst_gestures.moc"
FCL/sf/mw/qt