diff options
author | Bea Lam <bea.lam@nokia.com> | 2012-06-04 13:34:57 +1000 |
---|---|---|
committer | Qt by Nokia <qt-info@nokia.com> | 2012-06-06 10:14:01 +0200 |
commit | c37c4215b0cfd31967b5799ebb0f0e78a55f7e85 (patch) | |
tree | e4bc695f80093b598c325ab530ed61605b79a943 /tests/auto/quick/qquickflickable | |
parent | 734c8ffbd361467d01eb278e9e289795f7139e94 (diff) |
Don't emit moving and flicking signals unnecessarily
The moving and flicking signals should only be emitted once when
the view has been moved/flicked both vertically and horizontally. (This
was already done correctly for the dragging signals.)
Also changes QQuickFlickable::flick() to return bool instead of void.
Subclasses no longer emit the flicking signals but call
flickingStarted() instead.
Also splits the tst_qquickflickable::movingAndDragging() test up into
several tests.
Change-Id: Ie527568a9702049dd0bcda18c2eb3e43d8938a18
Reviewed-by: Martin Jones <martin.jones@nokia.com>
Diffstat (limited to 'tests/auto/quick/qquickflickable')
-rw-r--r-- | tests/auto/quick/qquickflickable/data/flickable03.qml | 2 | ||||
-rw-r--r-- | tests/auto/quick/qquickflickable/tst_qquickflickable.cpp | 434 |
2 files changed, 365 insertions, 71 deletions
diff --git a/tests/auto/quick/qquickflickable/data/flickable03.qml b/tests/auto/quick/qquickflickable/data/flickable03.qml index 719c682ee6..a3e9d6fd59 100644 --- a/tests/auto/quick/qquickflickable/data/flickable03.qml +++ b/tests/auto/quick/qquickflickable/data/flickable03.qml @@ -8,7 +8,7 @@ Flickable { id: column Repeater { model: 20 - Rectangle { width: 200; height: 300; color: "blue" } + Rectangle { width: 200; height: 300; border.width: 1; color: "yellow" } } } } diff --git a/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp b/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp index 39d1075e53..7438320b9b 100644 --- a/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp +++ b/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp @@ -73,7 +73,12 @@ private slots: void resizeContent(); void returnToBounds(); void wheel(); + void movingAndFlicking(); + void movingAndFlicking_data(); void movingAndDragging(); + void movingAndDragging_data(); + void flickOnRelease(); + void pressWhileFlicking(); void disabled(); void flickVelocity(); void margins(); @@ -382,12 +387,206 @@ void tst_qquickflickable::wheel() delete canvas; } +void tst_qquickflickable::movingAndFlicking_data() +{ + QTest::addColumn<bool>("verticalEnabled"); + QTest::addColumn<bool>("horizontalEnabled"); + QTest::addColumn<QPoint>("flickToWithoutSnapBack"); + QTest::addColumn<QPoint>("flickToWithSnapBack"); + + QTest::newRow("vertical") + << true << false + << QPoint(50, 100) + << QPoint(50, 300); + + QTest::newRow("horizontal") + << false << true + << QPoint(-50, 200) + << QPoint(150, 200); + + QTest::newRow("both") + << true << true + << QPoint(-50, 100) + << QPoint(150, 300); +} + +void tst_qquickflickable::movingAndFlicking() +{ +#ifdef Q_OS_MAC + QSKIP("Producing flicks on Mac CI impossible due to timing problems"); +#endif + + QFETCH(bool, verticalEnabled); + QFETCH(bool, horizontalEnabled); + QFETCH(QPoint, flickToWithoutSnapBack); + QFETCH(QPoint, flickToWithSnapBack); + + const QPoint flickFrom(50, 200); // centre + + QQuickView *canvas = new QQuickView; + canvas->setSource(testFileUrl("flickable03.qml")); + canvas->show(); + canvas->requestActivateWindow(); + QTest::qWaitForWindowShown(canvas); + QVERIFY(canvas->rootObject() != 0); + + QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject()); + QVERIFY(flickable != 0); + + QSignalSpy vMoveSpy(flickable, SIGNAL(movingVerticallyChanged())); + QSignalSpy hMoveSpy(flickable, SIGNAL(movingHorizontallyChanged())); + QSignalSpy moveSpy(flickable, SIGNAL(movingChanged())); + QSignalSpy vFlickSpy(flickable, SIGNAL(flickingVerticallyChanged())); + QSignalSpy hFlickSpy(flickable, SIGNAL(flickingHorizontallyChanged())); + QSignalSpy flickSpy(flickable, SIGNAL(flickingChanged())); + + QSignalSpy moveStartSpy(flickable, SIGNAL(movementStarted())); + QSignalSpy moveEndSpy(flickable, SIGNAL(movementEnded())); + QSignalSpy flickStartSpy(flickable, SIGNAL(flickStarted())); + QSignalSpy flickEndSpy(flickable, SIGNAL(flickEnded())); + + // do a flick that keeps the view within the bounds + flick(canvas, flickFrom, flickToWithoutSnapBack, 200); + + QVERIFY(flickable->isMoving()); + QCOMPARE(flickable->isMovingHorizontally(), horizontalEnabled); + QCOMPARE(flickable->isMovingVertically(), verticalEnabled); + QVERIFY(flickable->isFlicking()); + QCOMPARE(flickable->isFlickingHorizontally(), horizontalEnabled); + QCOMPARE(flickable->isFlickingVertically(), verticalEnabled); + + QCOMPARE(moveSpy.count(), 1); + QCOMPARE(vMoveSpy.count(), verticalEnabled ? 1 : 0); + QCOMPARE(hMoveSpy.count(), horizontalEnabled ? 1 : 0); + QCOMPARE(flickSpy.count(), 1); + QCOMPARE(vFlickSpy.count(), verticalEnabled ? 1 : 0); + QCOMPARE(hFlickSpy.count(), horizontalEnabled ? 1 : 0); + + QCOMPARE(moveStartSpy.count(), 1); + QCOMPARE(flickStartSpy.count(), 1); + + // wait for any motion to end + QTRY_VERIFY(!flickable->isMoving()); + + QVERIFY(!flickable->isMovingHorizontally()); + QVERIFY(!flickable->isMovingVertically()); + QVERIFY(!flickable->isFlicking()); + QVERIFY(!flickable->isFlickingHorizontally()); + QVERIFY(!flickable->isFlickingVertically()); + + QCOMPARE(moveSpy.count(), 2); + QCOMPARE(vMoveSpy.count(), verticalEnabled ? 2 : 0); + QCOMPARE(hMoveSpy.count(), horizontalEnabled ? 2 : 0); + QCOMPARE(flickSpy.count(), 2); + QCOMPARE(vFlickSpy.count(), verticalEnabled ? 2 : 0); + QCOMPARE(hFlickSpy.count(), horizontalEnabled ? 2 : 0); + + QCOMPARE(moveStartSpy.count(), 1); + QCOMPARE(moveEndSpy.count(), 1); + QCOMPARE(flickStartSpy.count(), 1); + QCOMPARE(flickEndSpy.count(), 1); + + // Stop on a full pixel after user interaction + if (verticalEnabled) + QCOMPARE(flickable->contentY(), (qreal)qRound(flickable->contentY())); + if (horizontalEnabled) + QCOMPARE(flickable->contentX(), (qreal)qRound(flickable->contentX())); + + // clear for next flick + vMoveSpy.clear(); hMoveSpy.clear(); moveSpy.clear(); + vFlickSpy.clear(); hFlickSpy.clear(); flickSpy.clear(); + moveStartSpy.clear(); moveEndSpy.clear(); + flickStartSpy.clear(); flickEndSpy.clear(); + + // do a flick that flicks the view out of bounds + flickable->setContentX(0); + flickable->setContentY(0); + QTRY_VERIFY(!flickable->isMoving()); + flick(canvas, flickFrom, flickToWithSnapBack, 200); + + QVERIFY(flickable->isMoving()); + QCOMPARE(flickable->isMovingHorizontally(), horizontalEnabled); + QCOMPARE(flickable->isMovingVertically(), verticalEnabled); + QVERIFY(flickable->isFlicking()); + QCOMPARE(flickable->isFlickingHorizontally(), horizontalEnabled); + QCOMPARE(flickable->isFlickingVertically(), verticalEnabled); + + QCOMPARE(moveSpy.count(), 1); + QCOMPARE(vMoveSpy.count(), verticalEnabled ? 1 : 0); + QCOMPARE(hMoveSpy.count(), horizontalEnabled ? 1 : 0); + QCOMPARE(flickSpy.count(), 1); + QCOMPARE(vFlickSpy.count(), verticalEnabled ? 1 : 0); + QCOMPARE(hFlickSpy.count(), horizontalEnabled ? 1 : 0); + + QCOMPARE(moveStartSpy.count(), 1); + QCOMPARE(moveEndSpy.count(), 0); + QCOMPARE(flickStartSpy.count(), 1); + QCOMPARE(flickEndSpy.count(), 0); + + // wait for any motion to end + QTRY_VERIFY(!flickable->isMoving()); + + QVERIFY(!flickable->isMovingHorizontally()); + QVERIFY(!flickable->isMovingVertically()); + QVERIFY(!flickable->isFlicking()); + QVERIFY(!flickable->isFlickingHorizontally()); + QVERIFY(!flickable->isFlickingVertically()); + + QCOMPARE(moveSpy.count(), 2); + QCOMPARE(vMoveSpy.count(), verticalEnabled ? 2 : 0); + QCOMPARE(hMoveSpy.count(), horizontalEnabled ? 2 : 0); + QCOMPARE(flickSpy.count(), 2); + QCOMPARE(vFlickSpy.count(), verticalEnabled ? 2 : 0); + QCOMPARE(hFlickSpy.count(), horizontalEnabled ? 2 : 0); + + QCOMPARE(moveStartSpy.count(), 1); + QCOMPARE(moveEndSpy.count(), 1); + QCOMPARE(flickStartSpy.count(), 1); + QCOMPARE(flickEndSpy.count(), 1); + + QCOMPARE(flickable->contentX(), 0.0); + QCOMPARE(flickable->contentY(), 0.0); + + delete canvas; +} + + +void tst_qquickflickable::movingAndDragging_data() +{ + QTest::addColumn<bool>("verticalEnabled"); + QTest::addColumn<bool>("horizontalEnabled"); + QTest::addColumn<QPoint>("moveByWithoutSnapBack"); + QTest::addColumn<QPoint>("moveByWithSnapBack"); + + QTest::newRow("vertical") + << true << false + << QPoint(0, -10) + << QPoint(0, 20); + + QTest::newRow("horizontal") + << false << true + << QPoint(-10, 0) + << QPoint(20, 0); + + QTest::newRow("both") + << true << true + << QPoint(-10, -10) + << QPoint(20, 20); +} + void tst_qquickflickable::movingAndDragging() { #ifdef Q_OS_MAC QSKIP("Producing flicks on Mac CI impossible due to timing problems"); #endif + QFETCH(bool, verticalEnabled); + QFETCH(bool, horizontalEnabled); + QFETCH(QPoint, moveByWithoutSnapBack); + QFETCH(QPoint, moveByWithSnapBack); + + const QPoint moveFrom(50, 200); // centre + QQuickView *canvas = new QQuickView; canvas->setSource(testFileUrl("flickable03.qml")); canvas->show(); @@ -404,47 +603,170 @@ void tst_qquickflickable::movingAndDragging() QSignalSpy vMoveSpy(flickable, SIGNAL(movingVerticallyChanged())); QSignalSpy hMoveSpy(flickable, SIGNAL(movingHorizontallyChanged())); QSignalSpy moveSpy(flickable, SIGNAL(movingChanged())); + QSignalSpy dragStartSpy(flickable, SIGNAL(dragStarted())); QSignalSpy dragEndSpy(flickable, SIGNAL(dragEnded())); + QSignalSpy moveStartSpy(flickable, SIGNAL(movementStarted())); + QSignalSpy moveEndSpy(flickable, SIGNAL(movementEnded())); - //Vertical - QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50, 90)); + // start the drag + QTest::mousePress(canvas, Qt::LeftButton, 0, moveFrom); + QTest::mouseMove(canvas, moveFrom + moveByWithoutSnapBack); + QTest::mouseMove(canvas, moveFrom + moveByWithoutSnapBack*2); + QTest::mouseMove(canvas, moveFrom + moveByWithoutSnapBack*3); - QTest::mouseMove(canvas, QPoint(50, 80)); - QTest::mouseMove(canvas, QPoint(50, 70)); - QTest::mouseMove(canvas, QPoint(50, 60)); - - QVERIFY(!flickable->isDraggingHorizontally()); - QVERIFY(flickable->isDraggingVertically()); + QVERIFY(flickable->isMoving()); + QCOMPARE(flickable->isMovingHorizontally(), horizontalEnabled); + QCOMPARE(flickable->isMovingVertically(), verticalEnabled); QVERIFY(flickable->isDragging()); - QCOMPARE(vDragSpy.count(), 1); - QCOMPARE(dragSpy.count(), 1); - QCOMPARE(hDragSpy.count(), 0); - QCOMPARE(dragStartSpy.count(), 1); - QCOMPARE(dragEndSpy.count(), 0); + QCOMPARE(flickable->isDraggingHorizontally(), horizontalEnabled); + QCOMPARE(flickable->isDraggingVertically(), verticalEnabled); - QVERIFY(!flickable->isMovingHorizontally()); - QVERIFY(flickable->isMovingVertically()); - QVERIFY(flickable->isMoving()); - QCOMPARE(vMoveSpy.count(), 1); QCOMPARE(moveSpy.count(), 1); - QCOMPARE(hMoveSpy.count(), 0); + QCOMPARE(vMoveSpy.count(), verticalEnabled ? 1 : 0); + QCOMPARE(hMoveSpy.count(), horizontalEnabled ? 1 : 0); + QCOMPARE(dragSpy.count(), 1); + QCOMPARE(vDragSpy.count(), verticalEnabled ? 1 : 0); + QCOMPARE(hDragSpy.count(), horizontalEnabled ? 1 : 0); - QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50, 60)); + QCOMPARE(moveStartSpy.count(), 1); + QCOMPARE(dragStartSpy.count(), 1); + + QTest::mouseRelease(canvas, Qt::LeftButton, 0, moveFrom + moveByWithoutSnapBack*3); - QTRY_VERIFY(!flickable->isDraggingVertically()); QVERIFY(!flickable->isDragging()); - QCOMPARE(vDragSpy.count(), 2); + QVERIFY(!flickable->isDraggingHorizontally()); + QVERIFY(!flickable->isDraggingVertically()); QCOMPARE(dragSpy.count(), 2); - QCOMPARE(hDragSpy.count(), 0); + QCOMPARE(vDragSpy.count(), verticalEnabled ? 2 : 0); + QCOMPARE(hDragSpy.count(), horizontalEnabled ? 2 : 0); QCOMPARE(dragStartSpy.count(), 1); QCOMPARE(dragEndSpy.count(), 1); + // Don't test whether moving finished because a flick could occur // wait for any motion to end QTRY_VERIFY(flickable->isMoving() == false); + QVERIFY(!flickable->isMovingHorizontally()); + QVERIFY(!flickable->isMovingVertically()); + QVERIFY(!flickable->isDragging()); + QVERIFY(!flickable->isDraggingHorizontally()); + QVERIFY(!flickable->isDraggingVertically()); + + QCOMPARE(dragSpy.count(), 2); + QCOMPARE(vDragSpy.count(), verticalEnabled ? 2 : 0); + QCOMPARE(hDragSpy.count(), horizontalEnabled ? 2 : 0); + QCOMPARE(moveSpy.count(), 2); + QCOMPARE(vMoveSpy.count(), verticalEnabled ? 2 : 0); + QCOMPARE(hMoveSpy.count(), horizontalEnabled ? 2 : 0); + + QCOMPARE(dragStartSpy.count(), 1); + QCOMPARE(dragEndSpy.count(), 1); + QCOMPARE(moveStartSpy.count(), 1); + QCOMPARE(moveEndSpy.count(), 1); + // Stop on a full pixel after user interaction - QCOMPARE(flickable->contentY(), (qreal)qRound(flickable->contentY())); + if (verticalEnabled) + QCOMPARE(flickable->contentY(), (qreal)qRound(flickable->contentY())); + if (horizontalEnabled) + QCOMPARE(flickable->contentX(), (qreal)qRound(flickable->contentX())); + + // clear for next drag + vMoveSpy.clear(); hMoveSpy.clear(); moveSpy.clear(); + vDragSpy.clear(); hDragSpy.clear(); dragSpy.clear(); + moveStartSpy.clear(); moveEndSpy.clear(); + dragStartSpy.clear(); dragEndSpy.clear(); + + // do a drag that drags the view out of bounds + flickable->setContentX(0); + flickable->setContentY(0); + QTRY_VERIFY(!flickable->isMoving()); + QTest::mousePress(canvas, Qt::LeftButton, 0, moveFrom); + QTest::mouseMove(canvas, moveFrom + moveByWithSnapBack); + QTest::mouseMove(canvas, moveFrom + moveByWithSnapBack*2); + QTest::mouseMove(canvas, moveFrom + moveByWithSnapBack*3); + + QVERIFY(flickable->isMoving()); + QCOMPARE(flickable->isMovingHorizontally(), horizontalEnabled); + QCOMPARE(flickable->isMovingVertically(), verticalEnabled); + QVERIFY(flickable->isDragging()); + QCOMPARE(flickable->isDraggingHorizontally(), horizontalEnabled); + QCOMPARE(flickable->isDraggingVertically(), verticalEnabled); + + QCOMPARE(moveSpy.count(), 1); + QCOMPARE(vMoveSpy.count(), verticalEnabled ? 1 : 0); + QCOMPARE(hMoveSpy.count(), horizontalEnabled ? 1 : 0); + QCOMPARE(dragSpy.count(), 1); + QCOMPARE(vDragSpy.count(), verticalEnabled ? 1 : 0); + QCOMPARE(hDragSpy.count(), horizontalEnabled ? 1 : 0); + + QCOMPARE(moveStartSpy.count(), 1); + QCOMPARE(moveEndSpy.count(), 0); + QCOMPARE(dragStartSpy.count(), 1); + QCOMPARE(dragEndSpy.count(), 0); + + QTest::mouseRelease(canvas, Qt::LeftButton, 0, moveFrom + moveByWithSnapBack*3); + + // should now start snapping back to bounds (moving but not dragging) + QVERIFY(flickable->isMoving()); + QCOMPARE(flickable->isMovingHorizontally(), horizontalEnabled); + QCOMPARE(flickable->isMovingVertically(), verticalEnabled); + QVERIFY(!flickable->isDragging()); + QVERIFY(!flickable->isDraggingHorizontally()); + QVERIFY(!flickable->isDraggingVertically()); + + QCOMPARE(moveSpy.count(), 1); + QCOMPARE(vMoveSpy.count(), verticalEnabled ? 1 : 0); + QCOMPARE(hMoveSpy.count(), horizontalEnabled ? 1 : 0); + QCOMPARE(dragSpy.count(), 2); + QCOMPARE(vDragSpy.count(), verticalEnabled ? 2 : 0); + QCOMPARE(hDragSpy.count(), horizontalEnabled ? 2 : 0); + + QCOMPARE(moveStartSpy.count(), 1); + QCOMPARE(moveEndSpy.count(), 0); + + // wait for any motion to end + QTRY_VERIFY(!flickable->isMoving()); + + QVERIFY(!flickable->isMovingHorizontally()); + QVERIFY(!flickable->isMovingVertically()); + QVERIFY(!flickable->isDragging()); + QVERIFY(!flickable->isDraggingHorizontally()); + QVERIFY(!flickable->isDraggingVertically()); + + QCOMPARE(moveSpy.count(), 2); + QCOMPARE(vMoveSpy.count(), verticalEnabled ? 2 : 0); + QCOMPARE(hMoveSpy.count(), horizontalEnabled ? 2 : 0); + QCOMPARE(dragSpy.count(), 2); + QCOMPARE(vDragSpy.count(), verticalEnabled ? 2 : 0); + QCOMPARE(hDragSpy.count(), horizontalEnabled ? 2 : 0); + + QCOMPARE(moveStartSpy.count(), 1); + QCOMPARE(moveEndSpy.count(), 1); + QCOMPARE(dragStartSpy.count(), 1); + QCOMPARE(dragEndSpy.count(), 1); + + QCOMPARE(flickable->contentX(), 0.0); + QCOMPARE(flickable->contentY(), 0.0); + + delete canvas; +} + +void tst_qquickflickable::flickOnRelease() +{ +#ifdef Q_OS_MAC + QSKIP("Producing flicks on Mac CI impossible due to timing problems"); +#endif + + QQuickView *canvas = new QQuickView; + canvas->setSource(testFileUrl("flickable03.qml")); + canvas->show(); + canvas->requestActivateWindow(); + QTest::qWaitForWindowShown(canvas); + QVERIFY(canvas->rootObject() != 0); + + QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject()); + QVERIFY(flickable != 0); // Vertical with a quick press-move-release: should cause a flick in release. QSignalSpy vFlickSpy(flickable, SIGNAL(flickingVerticallyChanged())); @@ -465,58 +787,30 @@ void tst_qquickflickable::movingAndDragging() // Stop on a full pixel after user interaction QCOMPARE(flickable->contentY(), (qreal)qRound(flickable->contentY())); - //Horizontal - vDragSpy.clear(); - hDragSpy.clear(); - dragSpy.clear(); - vMoveSpy.clear(); - hMoveSpy.clear(); - moveSpy.clear(); - dragStartSpy.clear(); - dragEndSpy.clear(); - - QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(90, 50)); - - QTest::mouseMove(canvas, QPoint(80, 50)); - QTest::mouseMove(canvas, QPoint(70, 50)); - QTest::mouseMove(canvas, QPoint(60, 50)); - - QVERIFY(!flickable->isDraggingVertically()); - QVERIFY(flickable->isDraggingHorizontally()); - QVERIFY(flickable->isDragging()); - QCOMPARE(vDragSpy.count(), 0); - QCOMPARE(dragSpy.count(), 1); - QCOMPARE(hDragSpy.count(), 1); - QCOMPARE(dragStartSpy.count(), 1); - QCOMPARE(dragEndSpy.count(), 0); - - QVERIFY(!flickable->isMovingVertically()); - QVERIFY(flickable->isMovingHorizontally()); - QVERIFY(flickable->isMoving()); - QCOMPARE(vMoveSpy.count(), 0); - QCOMPARE(moveSpy.count(), 1); - QCOMPARE(hMoveSpy.count(), 1); + delete canvas; +} - QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(60, 50)); +void tst_qquickflickable::pressWhileFlicking() +{ +#ifdef Q_OS_MAC + QSKIP("Producing flicks on Mac CI impossible due to timing problems"); +#endif - QTRY_VERIFY(!flickable->isDraggingHorizontally()); - QVERIFY(!flickable->isDragging()); - QCOMPARE(vDragSpy.count(), 0); - QCOMPARE(dragSpy.count(), 2); - QCOMPARE(hDragSpy.count(), 2); - QCOMPARE(dragStartSpy.count(), 1); - QCOMPARE(dragEndSpy.count(), 1); - // Don't test moving because a flick could occur + QQuickView *canvas = new QQuickView; + canvas->setSource(testFileUrl("flickable03.qml")); + canvas->show(); + canvas->requestActivateWindow(); + QTest::qWaitForWindowShown(canvas); + QVERIFY(canvas->rootObject() != 0); - QTRY_VERIFY(!flickable->isMoving()); - // Stop on a full pixel after user interaction - QCOMPARE(flickable->contentX(), (qreal)qRound(flickable->contentX())); + QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject()); + QVERIFY(flickable != 0); - vMoveSpy.clear(); - hMoveSpy.clear(); - moveSpy.clear(); - vFlickSpy.clear(); + QSignalSpy vMoveSpy(flickable, SIGNAL(movingVerticallyChanged())); + QSignalSpy hMoveSpy(flickable, SIGNAL(movingHorizontallyChanged())); + QSignalSpy moveSpy(flickable, SIGNAL(movingChanged())); QSignalSpy hFlickSpy(flickable, SIGNAL(flickingHorizontallyChanged())); + QSignalSpy vFlickSpy(flickable, SIGNAL(flickingVerticallyChanged())); QSignalSpy flickSpy(flickable, SIGNAL(flickingChanged())); // flick then press while it is still moving |