← Back to branch summary

~ubuntu-sdk-team/ubuntu-ui-toolkit/trunk

« back to all changes in this revision

Viewing changes to tests/unit_x11/tst_swipearea/tst_swipearea.cpp

  • Committer: CI Train Bot
  • Author(s): Christian Dywan, Zsombor Egri, Zoltán Balogh, Tim Peeters, Albert Astals Cid, Michael Sheldon, Benjamin Zeller
  • Date: 2015-12-17 17:13:49 UTC
  • mfrom: (1000.739.27 OTA9-landing-2015-12-16)
  • Revision ID: ci-train-bot@canonical.com-20151217171349-8xwclnhnx8v9oz4m
OTA9-landing-2015-12-16
Approved by: Zoltan Balogh

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit_x11/tst_swipearea/tst_swipearea.cpp
38
38
 
39
39
// Because QSignalSpy(UCSwipeArea, SIGNAL(UCSwipeArea::Status)) simply
40
40
// doesn't work
41
 
class StatusSpy : public QObject {
42
 
    Q_OBJECT
 
41
class StatusSpy : public UCSwipeAreaStatusListener
 
42
{
43
43
public:
44
 
    StatusSpy(UCSwipeArea *edgeDragArea) {
45
 
        m_recognized = false;
46
 
        connect(edgeDragArea->d, &UCSwipeAreaPrivate::statusChanged,
47
 
                this, &StatusSpy::onStatusChanged);
48
 
    }
 
44
    StatusSpy(UCSwipeArea *edgeDragArea)
 
45
        : m_edgeDragArea(edgeDragArea)
 
46
        , m_recognized(false)
 
47
    {
 
48
        UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(m_edgeDragArea);
 
49
        d->addStatusChangeListener(this);
 
50
    }
 
51
    virtual ~StatusSpy()
 
52
    {
 
53
        UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(m_edgeDragArea);
 
54
        d->removeStatusChangeListener(this);
 
55
    }
 
56
 
49
57
    bool recognized() {
50
58
        return m_recognized;
51
59
    }
52
60
 
53
 
private Q_SLOTS:
54
 
    void onStatusChanged(UCSwipeAreaPrivate::Status status) {
 
61
private:
 
62
    void swipeStatusChanged(UCSwipeAreaPrivate::Status, UCSwipeAreaPrivate::Status status) override
 
63
    {
55
64
        m_recognized |= status == UCSwipeAreaPrivate::Recognized;
56
65
    }
57
66
 
58
67
private:
 
68
    UCSwipeArea *m_edgeDragArea;
59
69
    bool m_recognized;
60
70
};
61
71
 
207
217
    UCSwipeArea *edgeDragArea =
208
218
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
209
219
    QVERIFY(edgeDragArea != 0);
210
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
211
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
220
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
221
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
222
    d->setTimeSource(m_fakeTimerFactory->timeSource());
212
223
 
213
224
    QPointF initialtouchPosition = calculateInitialtouchPosition(edgeDragArea);
214
225
    QPointF touchPoint = initialtouchPosition;
215
226
 
216
 
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0;
 
227
    qreal desiredDragDistance = d->distanceThreshold * 2.0;
217
228
    QPointF dragDirectionVector(1.0, 0.0);
218
 
    qreal touchStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
 
229
    qreal touchStepDistance = d->distanceThreshold * 0.1f;
219
230
    // make sure we are above maximum time
220
 
    int touchStepTimeMs = edgeDragArea->d->maxTime / 20. ;
 
231
    int touchStepTimeMs = d->maxTime / 20. ;
221
232
    QPointF touchMovement = dragDirectionVector * touchStepDistance;
222
233
 
223
234
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
241
252
        passTime(touchStepTimeMs);
242
253
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
243
254
    } while ((touchPoint - initialtouchPosition).manhattanLength() < desiredDragDistance
244
 
            || m_fakeTimerFactory->timeSource()->msecsSinceReference() < (edgeDragArea->d->compositionTime * 1.5f));
 
255
            || m_fakeTimerFactory->timeSource()->msecsSinceReference() < (d->compositionTime * 1.5f));
245
256
 
246
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Recognized);
 
257
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Recognized);
247
258
 
248
259
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
249
260
}
259
270
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
260
271
    QVERIFY(edgeDragArea != 0);
261
272
    AbstractTimer *fakeTimer = m_fakeTimerFactory->createTimer();
262
 
    edgeDragArea->d->setRecognitionTimer(fakeTimer);
263
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
273
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
274
    d->setRecognitionTimer(fakeTimer);
 
275
    d->setTimeSource(m_fakeTimerFactory->timeSource());
264
276
 
265
277
    int timeStepMs = 5; // some arbitrary small value.
266
278
 
268
280
    QPointF touchPoint = initialtouchPosition;
269
281
 
270
282
    QPointF dragDirectionVector(1.0, 0.0);
271
 
    QPointF touchMovement = dragDirectionVector * (edgeDragArea->d->distanceThreshold * 0.2f);
 
283
    QPointF touchMovement = dragDirectionVector * (d->distanceThreshold * 0.2f);
272
284
 
273
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
285
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
274
286
    QVERIFY(!fakeTimer->isRunning());
275
287
 
276
288
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
277
289
 
278
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Undecided);
 
290
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Undecided);
279
291
    QVERIFY(fakeTimer->isRunning());
280
292
 
281
293
    // Move beyond distance threshold and composition time to ensure recognition
282
 
    while (m_fakeTimerFactory->timeSource()->msecsSinceReference() <= edgeDragArea->d->compositionTime ||
283
 
           (touchPoint - initialtouchPosition).manhattanLength() <= edgeDragArea->d->distanceThreshold) {
 
294
    while (m_fakeTimerFactory->timeSource()->msecsSinceReference() <= d->compositionTime ||
 
295
           (touchPoint - initialtouchPosition).manhattanLength() <= d->distanceThreshold) {
284
296
 
285
 
        QCOMPARE(edgeDragArea->d->status == UCSwipeAreaPrivate::Undecided, fakeTimer->isRunning());
 
297
        QCOMPARE(d->status == UCSwipeAreaPrivate::Undecided, fakeTimer->isRunning());
286
298
 
287
299
        touchPoint += touchMovement;
288
300
        passTime(timeStepMs);
289
301
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
290
302
    }
291
303
 
292
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Recognized);
 
304
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Recognized);
293
305
    QVERIFY(!fakeTimer->isRunning());
294
306
}
295
307
 
302
314
    UCSwipeArea *edgeDragArea =
303
315
        m_view->rootObject()->findChild<UCSwipeArea*>("hnDragArea");
304
316
    QVERIFY(edgeDragArea != 0);
305
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
306
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
317
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
318
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
319
    d->setTimeSource(m_fakeTimerFactory->timeSource());
307
320
    edgeDragArea->setImmediateRecognition(true);
308
321
 
309
322
    QPointF touchScenePosition(m_view->width() - (edgeDragArea->width()/2.0f), m_view->height()/2.0f);
328
341
    UCSwipeArea *edgeDragArea =
329
342
        m_view->rootObject()->findChild<UCSwipeArea*>("vnDragArea");
330
343
    QVERIFY(edgeDragArea != 0);
331
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
332
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
344
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
345
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
346
    d->setTimeSource(m_fakeTimerFactory->timeSource());
333
347
    edgeDragArea->setImmediateRecognition(true);
334
348
 
335
349
    QPointF touchScenePosition(m_view->width()/2.0f, m_view->height() - (edgeDragArea->height()/2.0f));
356
370
    UCSwipeArea *edgeDragArea =
357
371
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
358
372
    QVERIFY(edgeDragArea != 0);
359
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
360
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
373
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
374
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
375
    d->setTimeSource(m_fakeTimerFactory->timeSource());
361
376
 
362
377
    // Make touches evenly spaced along the edgeDragArea
363
378
    QPoint touchAPos(edgeDragArea->width()/2.0f, m_view->height()*0.33f);
371
386
    QTest::touchEvent(m_view, m_device)
372
387
        .press(0, touchAPos);
373
388
 
374
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Undecided);
 
389
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Undecided);
375
390
 
376
391
    passTime(timeStepMsecs);
377
392
    QTest::touchEvent(m_view, m_device)
380
395
 
381
396
    // A second touch point appeared during recognition, reject immediately as this
382
397
    // can't be a single-touch gesture anymore.
383
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
398
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
384
399
 
385
400
    passTime(timeStepMsecs);
386
401
    QTest::touchEvent(m_view, m_device)
387
402
        .release(0, touchAPos)
388
403
        .move(1, touchBPos);
389
404
 
390
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
405
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
391
406
 
392
407
    passTime(timeStepMsecs);
393
408
    QTest::touchEvent(m_view, m_device)
394
409
        .release(1, touchBPos);
395
410
 
396
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
411
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
397
412
 
398
413
    // Perform the second two-finger tap
399
414
 
401
416
    QTest::touchEvent(m_view, m_device)
402
417
        .press(0, touchAPos);
403
418
 
404
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Undecided);
 
419
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Undecided);
405
420
 
406
421
    passTime(timeStepMsecs);
407
422
    QTest::touchEvent(m_view, m_device)
408
423
        .move(0, touchAPos)
409
424
        .press(1, touchBPos);
410
425
 
411
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
426
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
412
427
 
413
428
    passTime(timeStepMsecs);
414
429
    QTest::touchEvent(m_view, m_device)
415
430
        .release(0, touchAPos)
416
431
        .move(1, touchBPos);
417
432
 
418
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
433
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
419
434
 
420
435
    passTime(timeStepMsecs);
421
436
    QTest::touchEvent(m_view, m_device)
422
437
        .release(1, touchBPos);
423
438
 
424
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
439
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
425
440
}
426
441
 
427
442
/*
438
453
    UCSwipeArea *edgeDragArea =
439
454
        rightwardsLauncher->findChild<UCSwipeArea*>("hpDragArea");
440
455
    Q_ASSERT(edgeDragArea != 0);
441
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
442
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
456
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
457
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
458
    d->setTimeSource(m_fakeTimerFactory->timeSource());
443
459
 
444
460
    QPointF initialtouchPosition = calculateInitialtouchPosition(edgeDragArea);
445
461
    QPointF touchPoint = initialtouchPosition;
446
462
 
447
 
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
 
463
    qreal desiredDragDistance = d->distanceThreshold * 2.0f;
448
464
    QPointF dragDirectionVector(1.0f, 0.0f);
449
465
 
450
 
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
 
466
    qreal movementStepDistance = d->distanceThreshold * 0.1f;
451
467
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
452
468
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
453
 
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
 
469
    int movementTimeStepMs = (d->compositionTime * 1.5f) / totalMovementSteps;
454
470
 
455
471
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
456
472
 
457
473
    // Move it far ahead along the direction of the gesture
458
474
    // rightwardsLauncher is a parent of our UCSwipeArea. So moving it will move our DDA
459
 
    rightwardsLauncher->setX(rightwardsLauncher->x() + edgeDragArea->d->distanceThreshold * 5.0f);
 
475
    rightwardsLauncher->setX(rightwardsLauncher->x() + d->distanceThreshold * 5.0f);
460
476
 
461
477
    for (int i = 0; i < totalMovementSteps; ++i) {
462
478
        touchPoint += touchMovement;
464
480
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
465
481
    }
466
482
 
467
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Recognized);
 
483
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Recognized);
468
484
 
469
485
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
470
486
}
478
494
    UCSwipeArea *edgeDragArea =
479
495
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
480
496
    Q_ASSERT(edgeDragArea != 0);
481
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
482
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
497
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
498
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
499
    d->setTimeSource(m_fakeTimerFactory->timeSource());
483
500
 
484
501
    // Make touches evenly spaced along the edgeDragArea
485
502
    QPoint touch0Pos(edgeDragArea->width()/2.0f, m_view->height()*0.33f);
487
504
 
488
505
    QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
489
506
 
490
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Undecided);
 
507
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Undecided);
491
508
 
492
509
    // leave it lying around for some time
493
 
    passTime(edgeDragArea->d->maxTime * 10);
494
 
 
495
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
496
 
 
497
 
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
 
510
    passTime(d->maxTime * 10);
 
511
 
 
512
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
513
 
 
514
    qreal desiredDragDistance = d->distanceThreshold * 2.0f;
498
515
    QPointF dragDirectionVector(1.0f, 0.0f);
499
516
 
500
 
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
 
517
    qreal movementStepDistance = d->distanceThreshold * 0.1f;
501
518
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
502
519
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
503
 
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
 
520
    int movementTimeStepMs = (d->compositionTime * 1.5f) / totalMovementSteps;
504
521
 
505
522
    QTest::touchEvent(m_view, m_device)
506
523
        .move(0, touch0Pos)
507
524
        .press(1, touch1Pos);
508
525
 
509
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Undecided);
 
526
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Undecided);
510
527
 
511
528
    for (int i = 0; i < totalMovementSteps; ++i) {
512
529
        touch1Pos += touchMovement.toPoint();
516
533
            .move(1, touch1Pos);
517
534
    }
518
535
 
519
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Recognized);
 
536
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Recognized);
520
537
 
521
538
    QTest::touchEvent(m_view, m_device)
522
539
        .move(0, touch0Pos)
523
540
        .release(1, touch1Pos);
524
541
 
525
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
542
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
526
543
}
527
544
 
528
545
/*
541
558
    UCSwipeArea *edgeDragArea =
542
559
        rightwardsLauncher->findChild<UCSwipeArea*>("hpDragArea");
543
560
    Q_ASSERT(edgeDragArea != 0);
544
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
545
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
561
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
562
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
563
    d->setTimeSource(m_fakeTimerFactory->timeSource());
546
564
 
547
565
    QPointF initialtouchPosition = calculateInitialtouchPosition(edgeDragArea);
548
566
    QPointF touchPoint = initialtouchPosition;
549
567
 
550
 
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
 
568
    qreal desiredDragDistance = d->distanceThreshold * 2.0f;
551
569
    QPointF dragDirectionVector(0.0f, 1.0f);
552
570
 
553
 
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
 
571
    qreal movementStepDistance = d->distanceThreshold * 0.1f;
554
572
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
555
573
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
556
 
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
 
574
    int movementTimeStepMs = (d->compositionTime * 1.5f) / totalMovementSteps;
557
575
 
558
576
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
559
577
 
563
581
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
564
582
    }
565
583
 
566
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Recognized);
 
584
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Recognized);
567
585
 
568
586
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
569
587
}
581
599
    UCSwipeArea *edgeDragArea =
582
600
        rightwardsLauncher->findChild<UCSwipeArea*>("hpDragArea");
583
601
    Q_ASSERT(edgeDragArea != 0);
584
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
585
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
602
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
603
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
604
    d->setTimeSource(m_fakeTimerFactory->timeSource());
586
605
 
587
606
    // to disable the position smoothing so that we can more easily check distance values
588
607
    edgeDragArea->setImmediateRecognition(true);
590
609
    QPointF initialtouchPosition = calculateInitialtouchPosition(edgeDragArea);
591
610
    QPointF touchPoint = initialtouchPosition;
592
611
 
593
 
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
 
612
    qreal desiredDragDistance = d->distanceThreshold * 2.0f;
594
613
 
595
 
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
 
614
    qreal movementStepDistance = d->distanceThreshold * 0.1f;
596
615
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
597
616
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
598
 
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
 
617
    int movementTimeStepMs = (d->compositionTime * 1.5f) / totalMovementSteps;
599
618
 
600
619
    qint64 timestamp = 0;
601
620
 
639
658
    UCSwipeArea *edgeDragArea =
640
659
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
641
660
    Q_ASSERT(edgeDragArea != 0);
642
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
643
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
661
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
662
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
663
    d->setTimeSource(m_fakeTimerFactory->timeSource());
644
664
 
645
665
    QPointF touchPoint = calculateInitialtouchPosition(edgeDragArea);
646
666
 
647
 
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
 
667
    qreal desiredDragDistance = d->distanceThreshold * 2.0f;
648
668
    QPointF dragDirectionVector(1., 0.); // horizontal positive
649
669
 
650
 
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
 
670
    qreal movementStepDistance = d->distanceThreshold * 0.1f;
651
671
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
652
672
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
653
 
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
 
673
    int movementTimeStepMs = (d->compositionTime * 1.5f) / totalMovementSteps;
654
674
 
655
675
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
656
676
 
660
680
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
661
681
    }
662
682
 
663
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Recognized);
 
683
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Recognized);
664
684
    QCOMPARE(edgeDragArea->dragging(), true);
665
685
 
666
686
    // disable the swipeArea while it's being dragged.
667
687
    edgeDragArea->setEnabled(false);
668
688
 
669
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
689
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
670
690
    QCOMPARE(edgeDragArea->dragging(), false);
671
691
 
672
692
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
677
697
    UCSwipeArea *edgeDragArea =
678
698
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
679
699
    Q_ASSERT(edgeDragArea != 0);
680
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
681
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
700
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
701
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
702
    d->setTimeSource(m_fakeTimerFactory->timeSource());
682
703
 
683
704
    // Disable some constraints we're not interested in
684
 
    edgeDragArea->d->setMaxTime(60 * 1000);
 
705
    d->setMaxTime(60 * 1000);
685
706
 
686
707
    // And ensure others have the values we want
687
 
    edgeDragArea->d->compositionTime = 60;
 
708
    d->compositionTime = 60;
688
709
 
689
710
    // Put an item right behind edgeDragArea to receive the touches ignored by it
690
711
    DummyItem *dummyItem = new DummyItem;
701
722
 
702
723
    QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
703
724
 
704
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Undecided);
 
725
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Undecided);
705
726
 
706
727
    // We are now going to be way beyond compositionTime
707
 
    passTime(edgeDragArea->d->compositionTime*3);
 
728
    passTime(d->compositionTime*3);
708
729
 
709
730
    QTest::touchEvent(m_view, m_device)
710
731
        .move(0, touch0Pos)
726
747
        .move(0, touch0Pos)
727
748
        .move(1, touch1Pos);
728
749
 
729
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Undecided);
 
750
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Undecided);
730
751
 
731
752
    passTime(5);
732
753
 
734
755
        .release(0, touch0Pos)
735
756
        .move(1, touch1Pos);
736
757
 
737
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
758
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
738
759
 
739
760
    passTime(5);
740
761
 
742
763
        .release(1, touch1Pos);
743
764
 
744
765
    // Shouldn't be keepping info about touches that no longer exist or interest us
745
 
    QVERIFY(edgeDragArea->d->activeTouches.isEmpty());
 
766
    QVERIFY(d->activeTouches.isEmpty());
746
767
 
747
768
    delete dummyItem;
748
769
}
752
773
    UCSwipeArea *edgeDragArea =
753
774
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
754
775
    Q_ASSERT(edgeDragArea != 0);
755
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
756
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
776
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
777
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
778
    d->setTimeSource(m_fakeTimerFactory->timeSource());
757
779
 
758
780
    // Disable some constraints we're not interested in
759
 
    edgeDragArea->d->setMaxTime(60 * 1000);
 
781
    d->setMaxTime(60 * 1000);
760
782
 
761
783
    // Put an item right in front of edgeDragArea
762
784
    DummyItem *dummyItem = new DummyItem(edgeDragArea->parentItem());
775
797
 
776
798
    QTest::touchEvent(m_view, m_device).press(0, touchPosition);
777
799
 
778
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Undecided);
 
800
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Undecided);
779
801
 
780
802
    m_touchRegistry->requestTouchOwnership(0, dummyItem);
781
803
 
782
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
804
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
783
805
 
784
806
    dummyItem->grabTouchPoints({0});
785
807
    dummyItem->touchEventHandler = [&](QTouchEvent *event) { event->accept(); };
787
809
    passTime(5);
788
810
    QTest::touchEvent(m_view, m_device).release(0, touchPosition);
789
811
 
790
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
812
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
791
813
 
792
 
    QVERIFY(edgeDragArea->d->activeTouches.isEmpty());
 
814
    QVERIFY(d->activeTouches.isEmpty());
793
815
}
794
816
 
795
817
void tst_UCSwipeArea::threeFingerDrag()
797
819
    UCSwipeArea *edgeDragArea =
798
820
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
799
821
    Q_ASSERT(edgeDragArea != 0);
800
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
801
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
822
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
823
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
824
    d->setTimeSource(m_fakeTimerFactory->timeSource());
802
825
 
803
826
    // Disable some constraints we're not interested in
804
 
    edgeDragArea->d->setMaxTime(60 * 1000);
 
827
    d->setMaxTime(60 * 1000);
805
828
 
806
829
    // And ensure others have the values we want
807
 
    edgeDragArea->d->compositionTime = 60;
 
830
    d->compositionTime = 60;
808
831
 
809
832
    // Make touches evenly spaced along the edgeDragArea
810
833
    QPoint touch0Pos(edgeDragArea->width()/2.0f, m_view->height()*0.25f);
814
837
    QTest::touchEvent(m_view, m_device)
815
838
        .press(0, touch0Pos);
816
839
 
817
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Undecided);
 
840
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Undecided);
818
841
 
819
842
    passTime(5);
820
843
    QTest::touchEvent(m_view, m_device)
821
844
        .move(0, touch0Pos)
822
845
        .press(1, touch1Pos);
823
846
 
824
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
847
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
825
848
 
826
849
    passTime(5);
827
850
    QTest::touchEvent(m_view, m_device)
829
852
        .move(1, touch1Pos)
830
853
        .press(2, touch2Pos);
831
854
 
832
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
855
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
833
856
 
834
857
    passTime(10);
835
858
    QTest::touchEvent(m_view, m_device)
853
876
        .release(0, touch0Pos);
854
877
 
855
878
    // Shouldn't be keepping info about touches that no longer exist or interest us
856
 
    QVERIFY(edgeDragArea->d->activeTouches.isEmpty());
 
879
    QVERIFY(d->activeTouches.isEmpty());
857
880
}
858
881
 
859
882
/*
866
889
    UCSwipeArea *edgeDragArea =
867
890
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
868
891
    Q_ASSERT(edgeDragArea != 0);
869
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
870
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
892
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
893
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
894
    d->setTimeSource(m_fakeTimerFactory->timeSource());
871
895
 
872
896
    // Disable the minimum amount of constraints to ensure immediate recognition
873
 
    edgeDragArea->d->setDistanceThreshold(0);
874
 
    edgeDragArea->d->compositionTime = 0;
 
897
    d->setDistanceThreshold(0);
 
898
    d->compositionTime = 0;
875
899
 
876
900
    // Put an item right behind edgeDragArea to receive the touches ignored by it
877
901
    DummyItem *dummyItem = new DummyItem;
890
914
    QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
891
915
 
892
916
    // check for immediate recognition
893
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Recognized);
 
917
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Recognized);
894
918
 
895
919
    // and it is pressed
896
920
    QCOMPARE(edgeDragArea->pressed(), true);
906
930
    UCSwipeArea *edgeDragArea =
907
931
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
908
932
    Q_ASSERT(edgeDragArea != 0);
909
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
910
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
933
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
934
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
935
    d->setTimeSource(m_fakeTimerFactory->timeSource());
911
936
 
912
937
    QPointF touchPoint = calculateInitialtouchPosition(edgeDragArea);
913
938
 
914
939
    // Move less than the minimum needed for the drag gesture recognition
915
 
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 0.5f;
 
940
    qreal desiredDragDistance = d->distanceThreshold * 0.5f;
916
941
    QPointF dragDirectionVector(1., 0.); // horizontal positive
917
942
 
918
 
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
 
943
    qreal movementStepDistance = d->distanceThreshold * 0.1f;
919
944
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
920
945
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
921
 
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 0.8f) / totalMovementSteps;
 
946
    int movementTimeStepMs = (d->compositionTime * 0.8f) / totalMovementSteps;
922
947
 
923
948
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
924
949
 
928
953
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
929
954
    }
930
955
 
931
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Undecided);
 
956
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Undecided);
932
957
 
933
958
    // edgeDragArea should be an undecided candidate
934
959
    {
952
977
        QCOMPARE(touchInfo->candidates.size(), 0);
953
978
    }
954
979
 
955
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
980
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
956
981
 
957
982
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
958
983
}
970
995
    UCSwipeArea *edgeDragArea =
971
996
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
972
997
    QVERIFY(edgeDragArea != nullptr);
973
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
974
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
998
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
999
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
1000
    d->setTimeSource(m_fakeTimerFactory->timeSource());
975
1001
 
976
1002
    QQuickMouseArea *mouseArea =
977
1003
        m_view->rootObject()->findChild<QQuickMouseArea*>("mouseArea");
982
1008
    QPointF initialtouchPosition = calculateInitialtouchPosition(edgeDragArea);
983
1009
    QPointF touchPoint = initialtouchPosition;
984
1010
 
985
 
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2;
 
1011
    qreal desiredDragDistance = d->distanceThreshold * 2;
986
1012
    QPointF dragDirectionVector(1.0f, 0.0f); // rightwards
987
 
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
 
1013
    qreal movementStepDistance = d->distanceThreshold * 0.1f;
988
1014
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
989
1015
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
990
 
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
 
1016
    int movementTimeStepMs = (d->compositionTime * 1.5f) / totalMovementSteps;
991
1017
 
992
1018
    QCOMPARE(mouseArea->pressed(), false);
993
1019
 
1008
1034
    // As the UCSwipeArea recognizes the gesture, it grabs the touch from the MouseArea,
1009
1035
    // which should make the MouseArea get a cancelation event, which will then cause it to
1010
1036
    // reset its state (going back to "unpressed"/"released").
1011
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Recognized);
 
1037
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Recognized);
1012
1038
    QCOMPARE(mouseArea->pressed(), false);
1013
1039
    QCOMPARE(mouseAreaSpy.canceledCount, 1);
1014
1040
 
1020
1046
    UCSwipeArea *edgeDragArea =
1021
1047
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
1022
1048
    QVERIFY(edgeDragArea != 0);
1023
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
1024
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
1049
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
1050
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
1051
    d->setTimeSource(m_fakeTimerFactory->timeSource());
1025
1052
 
1026
1053
    QPointF touch0 = edgeDragArea->mapToScene(
1027
1054
            QPointF(edgeDragArea->width()*0.5, edgeDragArea->height()*0.3));
1028
1055
 
1029
 
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2;
 
1056
    qreal desiredDragDistance = d->distanceThreshold * 2;
1030
1057
    QPointF dragDirectionVector(1.0f, 0.0f); // rightwards
1031
 
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
 
1058
    qreal movementStepDistance = d->distanceThreshold * 0.1f;
1032
1059
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
1033
1060
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
1034
 
    int movementTimeStepMs = (edgeDragArea->d->maxTime * 0.4f) / totalMovementSteps;
 
1061
    int movementTimeStepMs = (d->maxTime * 0.4f) / totalMovementSteps;
1035
1062
 
1036
1063
    QTest::touchEvent(m_view, m_device).press(0, touch0.toPoint());
1037
1064
    for (int i = 0; i < totalMovementSteps; ++i) {
1039
1066
        passTime(movementTimeStepMs);
1040
1067
        QTest::touchEvent(m_view, m_device).move(0, touch0.toPoint());
1041
1068
    }
1042
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Recognized);
 
1069
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Recognized);
1043
1070
 
1044
1071
    QPointF touch1 = edgeDragArea->mapToScene(
1045
1072
            QPointF(edgeDragArea->width()*0.5, edgeDragArea->height()*0.6));
1054
1081
        .move(0, touch0.toPoint())
1055
1082
        .move(1, touch1.toPoint());
1056
1083
 
1057
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Recognized);
 
1084
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Recognized);
1058
1085
 
1059
1086
    QTest::touchEvent(m_view, m_device)
1060
1087
        .release(0, touch0.toPoint())
1061
1088
        .move(1, touch1.toPoint());
1062
1089
 
1063
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
1090
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
1064
1091
 
1065
1092
    touch1 += touchMovement;
1066
1093
    passTime(movementTimeStepMs);
1067
1094
    QTest::touchEvent(m_view, m_device)
1068
1095
        .move(1, touch1.toPoint());
1069
1096
 
1070
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
1097
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
1071
1098
 
1072
1099
    QPointF touch2 = edgeDragArea->mapToScene(
1073
1100
            QPointF(edgeDragArea->width()*0.5, edgeDragArea->height()*0.9));
1074
1101
 
1075
 
    passTime(edgeDragArea->d->compositionTime + movementTimeStepMs);
 
1102
    passTime(d->compositionTime + movementTimeStepMs);
1076
1103
    QTest::touchEvent(m_view, m_device)
1077
1104
        .move(1, touch1.toPoint())
1078
1105
        .press(2, touch2.toPoint());
1079
1106
 
1080
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::Undecided);
1081
 
    QCOMPARE(edgeDragArea->d->touchId, 2);
 
1107
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::Undecided);
 
1108
    QCOMPARE(d->touchId, 2);
1082
1109
 
1083
1110
    touch2 += touchMovement;
1084
1111
    passTime(movementTimeStepMs);
1101
1128
    QTest::touchEvent(m_view, m_device)
1102
1129
        .release(2, touch2.toPoint());
1103
1130
 
1104
 
    QCOMPARE((int)edgeDragArea->d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
 
1131
    QCOMPARE((int)d->status, (int)UCSwipeAreaPrivate::WaitingForTouch);
1105
1132
}
1106
1133
 
1107
1134
/*
1115
1142
    UCSwipeArea *edgeDragArea =
1116
1143
        m_view->rootObject()->findChild<UCSwipeArea*>("hnDragArea");
1117
1144
    QVERIFY(edgeDragArea != nullptr);
1118
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
1119
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
1145
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
1146
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
1147
    d->setTimeSource(m_fakeTimerFactory->timeSource());
1120
1148
 
1121
1149
    StatusSpy *statusSpy = new StatusSpy(edgeDragArea);
1122
1150
 
1123
 
    edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
 
1151
    d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
1124
1152
 
1125
1153
    sendTouchPress(319744, 0, QPointF(767.001, 719.719));
1126
1154
    sendTouchUpdate(319765, 0, QPointF(765.744,729.973));
1141
1169
    sendTouchUpdate(320171, 0, QPointF(447.232,1012.08));
1142
1170
    sendTouchRelease(320171, 0, QPointF(447.232,1012.08));
1143
1171
 
1144
 
    QCOMPARE(statusSpy->recognized(), true);
 
1172
    QTRY_COMPARE_WITH_TIMEOUT(statusSpy->recognized(), true, 500);
1145
1173
 
1146
1174
    delete statusSpy;
1147
1175
}
1160
1188
    UCSwipeArea *edgeDragArea =
1161
1189
        m_view->rootObject()->findChild<UCSwipeArea*>("hnDragArea");
1162
1190
    QVERIFY(edgeDragArea != nullptr);
1163
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
1164
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
1191
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
1192
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
1193
    d->setTimeSource(m_fakeTimerFactory->timeSource());
1165
1194
 
1166
 
    edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
 
1195
    d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
1167
1196
 
1168
1197
    StatusSpy *statusSpy = new StatusSpy(edgeDragArea);
1169
1198
 
1204
1233
    UCSwipeArea *edgeDragArea =
1205
1234
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
1206
1235
    QVERIFY(edgeDragArea != nullptr);
1207
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
1208
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
1236
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
1237
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
1238
    d->setTimeSource(m_fakeTimerFactory->timeSource());
1209
1239
 
1210
 
    edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
 
1240
    d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
1211
1241
 
1212
1242
    StatusSpy *statusSpy = new StatusSpy(edgeDragArea);
1213
1243
 
1268
1298
    UCSwipeArea *edgeDragArea =
1269
1299
        m_view->rootObject()->findChild<UCSwipeArea*>("hpDragArea");
1270
1300
    QVERIFY(edgeDragArea != nullptr);
1271
 
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
1272
 
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
1301
    UCSwipeAreaPrivate *d = UCSwipeAreaPrivate::get(edgeDragArea);
 
1302
    d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));
 
1303
    d->setTimeSource(m_fakeTimerFactory->timeSource());
1273
1304
 
1274
 
    edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
 
1305
    d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
1275
1306
 
1276
1307
    StatusSpy *statusSpy = new StatusSpy(edgeDragArea);
1277
1308