tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp · unity8

git.iko.soy/unity8

on 3d70741 help sign in

unity8/tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp

740 lines 26 kB history raw

1/*

3 *

4 * This program is free software; you can redistribute it and/or modify

5 * it under the terms of the GNU General Public License as published by

6 * the Free Software Foundation; version 3.

7 *

8 * This program is distributed in the hope that it will be useful,

9 * but WITHOUT ANY WARRANTY; without even the implied warranty of

10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11 * GNU General Public License for more details.

12 *

13 * You should have received a copy of the GNU General Public License

14 * along with this program. If not, see <http://www.gnu.org/licenses/>.

15 */

17#include <QtTest/QtTest>

18#include <QtCore/QObject>

19#include <qpa/qwindowsysteminterface.h>

20#include <QtQuick/QQuickView>

21#include <QtQml/QQmlEngine>

22#include <QPointer>

24#include <DirectionalDragArea.h>

26using namespace UbuntuGestures;

28class FakeTimer : public AbstractTimer

29{

30 Q_OBJECT

31public:

32 FakeTimer(const SharedTimeSource &timeSource, QObject *parent = 0)

33 : UbuntuGestures::AbstractTimer(parent),

34 m_timeSource(timeSource)

35 {}

37 int interval() const override { return m_interval; }

38 void setInterval(int msecs) override { m_interval = msecs; }

39 void start() override {

40 AbstractTimer::start();

41 m_nextTimeoutTime = m_timeSource->msecsSinceReference() + (qint64)m_interval;

42 }

44 void emitTimeout() {

45 m_nextTimeoutTime += m_interval;

46 Q_EMIT timeout();

47 }

49 qint64 nextTimeoutTime() const { return m_nextTimeoutTime; }

50private:

51 int m_interval;

52 SharedTimeSource m_timeSource;

53 qint64 m_nextTimeoutTime;

54};

56class FakeTimeSource : public UbuntuGestures::TimeSource

57{

58public:

59 FakeTimeSource() { m_msecsSinceReference = 0; }

60 virtual qint64 msecsSinceReference() {return m_msecsSinceReference;}

61 qint64 m_msecsSinceReference;

62};

64class tst_DirectionalDragArea: public QObject

65{

66 Q_OBJECT

67public:

68 tst_DirectionalDragArea() : device(0) { }

69private Q_SLOTS:

70 void initTestCase(); // will be called before the first test function is executed

71 void cleanupTestCase(); // will be called after the last test function was executed.

73 void init(); // called right before each and every test function is executed

74 void cleanup(); // called right after each and every test function is executed

76 void edgeDrag();

77 void edgeDrag_data();

78 void dragWithShortDirectionChange();

79 void minSpeed();

80 void minSpeed_data();

81 void recognitionTimerUsage();

82 void maxSilenceTime();

83 void sceneXAndX();

84 void sceneYAndY();

85 void twoFingerTap();

86 void movingDDA();

87 void ignoreOldFinger();

89private:

90 QQuickView *createView();

91 void passTime(qint64 timeSpan);

92 QQuickView *view;

93 QTouchDevice *device;

94 FakeTimer *fakeTimer;

95 QSharedPointer<FakeTimeSource> fakeTimeSource;

96};

98void tst_DirectionalDragArea::initTestCase()

99{

100 if (!device) {

101 device = new QTouchDevice;

102 device->setType(QTouchDevice::TouchScreen);

103 QWindowSystemInterface::registerTouchDevice(device);

104 }

105

106 view = 0;

107}

108

109void tst_DirectionalDragArea::cleanupTestCase()

110{

111}

112

113void tst_DirectionalDragArea::init()

114{

115 view = createView();

116 view->setSource(QUrl::fromLocalFile("edgeDragExample.qml"));

117 view->show();

118 QVERIFY(QTest::qWaitForWindowExposed(view));

119 QVERIFY(view->rootObject() != 0);

120 qApp->processEvents();

121

122 fakeTimeSource.reset(new FakeTimeSource);

123 fakeTimer = new FakeTimer(fakeTimeSource);

124}

125

126void tst_DirectionalDragArea::cleanup()

127{

128 delete view;

129 view = 0;

130

131 delete fakeTimer;

132 fakeTimer = 0;

133

134 fakeTimeSource.reset();

135}

136

137QQuickView *tst_DirectionalDragArea::createView()

138{

139 QQuickView *window = new QQuickView(0);

140 window->setResizeMode(QQuickView::SizeRootObjectToView);

141 window->resize(600, 600);

142 window->engine()->addImportPath(QLatin1String(UBUNTU_GESTURES_PLUGIN_DIR));

143

144 return window;

145}

146

147void tst_DirectionalDragArea::passTime(qint64 timeSpan)

148{

149 qint64 finalTime = fakeTimeSource->m_msecsSinceReference + timeSpan;

150

151 if (fakeTimer->isRunning() && finalTime >= fakeTimer->nextTimeoutTime()) {

152 fakeTimeSource->m_msecsSinceReference = fakeTimer->nextTimeoutTime();

153 fakeTimer->emitTimeout();

154

155 qint64 timeSpanRemainder = finalTime - fakeTimeSource->m_msecsSinceReference;

156 if (timeSpanRemainder > 0) {

157 passTime(timeSpanRemainder);

158 }

159 } else {

160 fakeTimeSource->m_msecsSinceReference = finalTime;

161 }

162}

163

164namespace {

165QPointF calculateInitialTouchPos(DirectionalDragArea *edgeDragArea, QQuickView *view)

166{

167 switch (edgeDragArea->direction()) {

168 case Direction::Upwards:

169 return QPointF(view->width()/2.0f, view->height() - (edgeDragArea->height()/2.0f));

170 case Direction::Downwards:

171 return QPointF(view->width()/2.0f, edgeDragArea->height()/2.0f);

172 case Direction::Leftwards:

173 return QPointF(view->width() - (edgeDragArea->width()/2.0f), view->height()/2.0f);

174 default: // Direction::Rightwards:

175 return QPointF(edgeDragArea->width()/2.0f, view->height()/2.0f);

176 }

177}

178

179QPointF calculateDirectionVector(DirectionalDragArea *edgeDragArea,

180 qreal wideningAngleMultiplier)

181{

182 qreal angleRadians = edgeDragArea->wideningAngle() * wideningAngleMultiplier

183 * M_PI / 180.0;

184

185 qreal angleCos = qCos(angleRadians);

186 qreal angleSin = qSin(angleRadians);

187

188 switch (edgeDragArea->direction()) {

189 case Direction::Upwards:

190 return QPointF(angleSin, -angleCos);

191 case Direction::Downwards:

192 return QPointF(angleSin, angleCos);

193 case Direction::Leftwards:

194 return QPointF(-angleCos, angleSin);

195 default: // Direction::Rightwards:

196 return QPointF(angleCos, angleSin);

197 }

198}

199

200QPointF createTouchDeviation(DirectionalDragArea *edgeDragArea)

201{

202 qreal deviation = edgeDragArea->maxDeviation() * 0.8;

203

204 if (Direction::isHorizontal(edgeDragArea->direction())) {

205 return QPointF(0, deviation);

206 } else {

207 return QPointF(deviation, 0);

208 }

209}

210}

211

212void tst_DirectionalDragArea::edgeDrag()

213{

214 QFETCH(QString, dragAreaObjectName);

215 QFETCH(qreal, wideningAngleMultiplier);

216 QFETCH(qreal, dragDistanceFactor);

217 QFETCH(bool, expectGestureRecognition);

218

219 DirectionalDragArea *edgeDragArea =

220 view->rootObject()->findChild<DirectionalDragArea*>(dragAreaObjectName);

221 QVERIFY(edgeDragArea != 0);

222 edgeDragArea->setRecognitionTimer(fakeTimer);

223 edgeDragArea->setTimeSource(fakeTimeSource);

224

225 QSignalSpy draggingSpy(edgeDragArea, SIGNAL(draggingChanged(bool)));

226

227 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);

228 QPointF touchPoint = initialTouchPos;

229

230 qreal desiredDragDistance = edgeDragArea->distanceThreshold()*dragDistanceFactor;

231 QPointF dragDirectionVector = calculateDirectionVector(edgeDragArea,

232 wideningAngleMultiplier);

233 qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;

234 QPointF touchMovement = dragDirectionVector * movementStepDistance;

235 int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);

236 int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;

237

238 QTest::touchEvent(view, device).press(0, touchPoint.toPoint());

239

240 QCOMPARE(draggingSpy.count(), 1);

241 QCOMPARE(edgeDragArea->dragging(), true);

242

243 if (wideningAngleMultiplier > 0) {

244 // go close to the border of the valid area for this touch point

245 // in order to make it easier to leave it by dragging at an angle

246 // slightly bigger than the widening angle

247 touchPoint += createTouchDeviation(edgeDragArea);

248 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

249 }

250

251 for (int i = 0; i < totalMovementSteps; ++i) {

252 touchPoint += touchMovement;

253 passTime(movementTimeStepMs);

254 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

255 }

256

257 if (expectGestureRecognition)

258 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);

259

260 if (edgeDragArea->status() == DirectionalDragArea::WaitingForTouch) {

261 QCOMPARE(edgeDragArea->dragging(), false);

262 QCOMPARE(draggingSpy.count(), 2);

263 }

264

265 QTest::touchEvent(view, device).release(0, touchPoint.toPoint());

266

267 QCOMPARE(draggingSpy.count(), 2);

268 QCOMPARE(edgeDragArea->dragging(), false);

269}

270

271void tst_DirectionalDragArea::edgeDrag_data()

272{

273 QTest::addColumn<QString>("dragAreaObjectName");

274 QTest::addColumn<qreal>("wideningAngleMultiplier");

275 QTest::addColumn<qreal>("dragDistanceFactor");

276 QTest::addColumn<bool>("expectGestureRecognition");

277

278 QTest::newRow("rightwards, tiny drag")

279 << "hpDragArea" << 0.0 << 0.2 << false;

280

281 QTest::newRow("rightwards, straight drag")

282 << "hpDragArea" << 0.0 << 3.0 << true;

283

284 QTest::newRow("rightwards, diagonal drag")

285 << "hpDragArea" << 0.9 << 3.0 << true;

286

287 QTest::newRow("rightwards, overly diagonal drag")

288 << "hpDragArea" << 2.0 << 3.0 << false;

289

290 QTest::newRow("leftwards, tiny drag")

291 << "hnDragArea" << 0.0 << 0.2 << false;

292

293 QTest::newRow("leftwards, straight drag")

294 << "hnDragArea" << 0.0 << 3.0 << true;

295

296 QTest::newRow("leftwards, diagonal drag")

297 << "hnDragArea" << 0.9 << 3.0 << true;

298

299 QTest::newRow("downwards, tiny drag")

300 << "vpDragArea" << 0.0 << 0.2 << false;

301

302 QTest::newRow("downwards, straight drag")

303 << "vpDragArea" << 0.0 << 3.0 << true;

304

305 QTest::newRow("downwards, diagonal drag")

306 << "vpDragArea" << 0.9 << 3.0 << true;

307

308 QTest::newRow("upwards, tiny drag")

309 << "vnDragArea" << 0.0 << 0.2 << false;

310

311 QTest::newRow("upwards, straight drag")

312 << "vnDragArea" << 0.0 << 3.0 << true;

313

314 QTest::newRow("upwards, diagonal drag")

315 << "vnDragArea" << 0.9 << 3.0 << true;

316

317 QTest::newRow("upwards, overly diagonal drag")

318 << "vnDragArea" << 2.0 << 3.0 << false;

319}

320

321/*

322 A directional drag should still be recognized if there is a momentaneous, small,

323 change in the direction of a drag. That should be accounted as input noise and

324 therefore ignored.

325 */

326void tst_DirectionalDragArea::dragWithShortDirectionChange()

327{

328 DirectionalDragArea *edgeDragArea =

329 view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

330 QVERIFY(edgeDragArea != 0);

331 edgeDragArea->setRecognitionTimer(fakeTimer);

332 edgeDragArea->setTimeSource(fakeTimeSource);

333

334 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);

335 QPointF touchPoint = initialTouchPos;

336

337 qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0;

338 QPointF dragDirectionVector(1.0, 0.0);

339 qreal touchStepDistance = edgeDragArea->distanceThreshold() * 0.1f;

340 // make sure we are above minimum speed

341 int touchStepTimeMs = (touchStepDistance / (edgeDragArea->minSpeed() * 5.0f)) * 1000.0f;

342 QPointF touchMovement = dragDirectionVector * touchStepDistance;

343

344 QTest::touchEvent(view, device).press(0, touchPoint.toPoint());

345

346 // Move a bit in the proper direction

347 for (int i=0; i < 3; ++i) {

348 touchPoint += touchMovement;

349 passTime(touchStepTimeMs);

350 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

351 }

352

353 // Then a sudden and small movement to the opposite direction

354 touchPoint -= touchMovement*0.2;

355 passTime(touchStepTimeMs*0.2);

356 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

357

358 // And then resume movment in the correct direction until it crosses the distance and time

359 // thresholds.

360 do {

361 touchPoint += touchMovement;

362 passTime(touchStepTimeMs);

363 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

364 } while ((touchPoint - initialTouchPos).manhattanLength() < desiredDragDistance

365 || fakeTimeSource->m_msecsSinceReference < (edgeDragArea->compositionTime() * 1.5f));

366

367 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);

368

369 QTest::touchEvent(view, device).release(0, touchPoint.toPoint());

370}

371

372/*

373 Checks that a gesture will be rejected if it's slower than minSpeed while

374 status is Undecided.

375 */

376void tst_DirectionalDragArea::minSpeed()

377{

378 QFETCH(qreal, minSpeed);

379 QFETCH(qreal, speed);

380 QFETCH(int, expectedStatusAfterSpeedCheck);

381

382 DirectionalDragArea *edgeDragArea =

383 view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

384 QVERIFY(edgeDragArea != 0);

385 edgeDragArea->setRecognitionTimer(fakeTimer);

386 edgeDragArea->setTimeSource(fakeTimeSource);

387

388 // A really long, unattainable, number. We don't want it getting recognized before

389 // the speed checks we want have been performed

390 edgeDragArea->setDistanceThreshold(500000);

391

392 edgeDragArea->setMinSpeed(minSpeed);

393

394 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);

395 QPointF touchPoint = initialTouchPos;

396

397 QPointF dragDirectionVector(1.0, 0.0);

398 qint64 timeStepMsecs = 10;

399 qreal distanceStep = (speed / 1000.0f) * timeStepMsecs;

400 QPointF touchMovement = dragDirectionVector * distanceStep;

401

402 QTest::touchEvent(view, device).press(0, touchPoint.toPoint());

403

404 // Move for a while to ensure our speed check is performed a couple of times

405 for (int i=0; i < 20; ++i) {

406 touchPoint += touchMovement;

407 passTime(timeStepMsecs);

408 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

409 }

410

411 QCOMPARE((int)edgeDragArea->status(), expectedStatusAfterSpeedCheck);

412}

413

414void tst_DirectionalDragArea::minSpeed_data()

415{

416 QTest::addColumn<qreal>("minSpeed");

417 QTest::addColumn<qreal>("speed");

418 QTest::addColumn<int>("expectedStatusAfterSpeedCheck");

419

420 QTest::newRow("slower than minSpeed") << 100.0 << 50.0 << (int)DirectionalDragArea::WaitingForTouch;

421 QTest::newRow("faster than minSpeed") << 100.0 << 150.0 << (int)DirectionalDragArea::Undecided;

422}

423

424/*

425 Checks that the recognition timer is started and stopped appropriately.

426 I.e., check that it's running only while gesture recognition is taking place

427 (status == Undecided)

428 */

429void tst_DirectionalDragArea::recognitionTimerUsage()

430{

431 DirectionalDragArea *edgeDragArea =

432 view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

433 QVERIFY(edgeDragArea != 0);

434 edgeDragArea->setRecognitionTimer(fakeTimer);

435 edgeDragArea->setTimeSource(fakeTimeSource);

436

437 // don't let it interfere with our test

438 edgeDragArea->setMinSpeed(0.0);

439

440 int timeStepMs = 5; // some arbitrary small value.

441

442 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);

443 QPointF touchPoint = initialTouchPos;

444

445 QPointF dragDirectionVector(1.0, 0.0);

446 QPointF touchMovement = dragDirectionVector * (edgeDragArea->distanceThreshold() * 0.2f);

447

448 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);

449 QVERIFY(!fakeTimer->isRunning());

450

451 QTest::touchEvent(view, device).press(0, touchPoint.toPoint());

452

453 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);

454 QVERIFY(fakeTimer->isRunning());

455

456 // Move beyond distance threshold and composition time to ensure recognition

457 while (fakeTimeSource->m_msecsSinceReference <= edgeDragArea->compositionTime() ||

458 (touchPoint - initialTouchPos).manhattanLength() <= edgeDragArea->distanceThreshold()) {

459

460 QCOMPARE(edgeDragArea->status() == DirectionalDragArea::Undecided, fakeTimer->isRunning());

461

462 touchPoint += touchMovement;

463 passTime(timeStepMs);

464 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

465 }

466

467 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);

468 QVERIFY(!fakeTimer->isRunning());

469}

470

471/*

472 A gesture should be rejected if too much time has passed without any new input

473 events from it.

474 */

475void tst_DirectionalDragArea::maxSilenceTime()

476{

477 DirectionalDragArea *edgeDragArea =

478 view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

479 QVERIFY(edgeDragArea != 0);

480 edgeDragArea->setRecognitionTimer(fakeTimer);

481 edgeDragArea->setTimeSource(fakeTimeSource);

482

483 // Make sure this property is not disabled

484 edgeDragArea->setMaxSilenceTime(100);

485

486 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);

487 QPointF touchPoint = initialTouchPos;

488

489 QTest::touchEvent(view, device).press(0, touchPoint.toPoint());

490

491 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);

492 QVERIFY(fakeTimer->isRunning());

493

494 // Force timer to timeout until after maxSilenceTime has been reached

495 while (fakeTimeSource->m_msecsSinceReference < edgeDragArea->maxSilenceTime()) {

496 passTime(fakeTimer->interval());

497 }

498

499 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);

500}

501

502/*

503 Checks that it informs the X coordinate of the touch point in local and scene coordinates

504 correctly.

505 */

506void tst_DirectionalDragArea::sceneXAndX()

507{

508 DirectionalDragArea *edgeDragArea =

509 view->rootObject()->findChild<DirectionalDragArea*>("hnDragArea");

510 QVERIFY(edgeDragArea != 0);

511 edgeDragArea->setRecognitionTimer(fakeTimer);

512 edgeDragArea->setTimeSource(fakeTimeSource);

513

514 QPointF touchScenePos(view->width() - (edgeDragArea->width()/2.0f), view->height()/2.0f);

515

516 QTest::touchEvent(view, device).press(0, touchScenePos.toPoint());

517

518 QSignalSpy touchXSpy(edgeDragArea, SIGNAL(touchXChanged(qreal)));

519 QSignalSpy touchSceneXSpy(edgeDragArea, SIGNAL(touchSceneXChanged(qreal)));

520

521 touchScenePos.rx() = view->width() / 2;

522 QTest::touchEvent(view, device).move(0, touchScenePos.toPoint());

523

524 QCOMPARE(touchXSpy.count(), 1);

525 QCOMPARE(touchSceneXSpy.count(), 1);

526 QCOMPARE(edgeDragArea->touchX(), touchScenePos.x() - edgeDragArea->x());

527 QCOMPARE(edgeDragArea->touchSceneX(), touchScenePos.x());

528}

529

530/*

531 Checks that it informs the Y coordinate of the touch point in local and scene coordinates

532 correctly.

533 */

534void tst_DirectionalDragArea::sceneYAndY()

535{

536 DirectionalDragArea *edgeDragArea =

537 view->rootObject()->findChild<DirectionalDragArea*>("vnDragArea");

538 QVERIFY(edgeDragArea != 0);

539 edgeDragArea->setRecognitionTimer(fakeTimer);

540 edgeDragArea->setTimeSource(fakeTimeSource);

541

542 QPointF touchScenePos(view->width()/2.0f, view->height() - (edgeDragArea->height()/2.0f));

543

544 QTest::touchEvent(view, device).press(0, touchScenePos.toPoint());

545

546 QSignalSpy touchYSpy(edgeDragArea, SIGNAL(touchYChanged(qreal)));

547 QSignalSpy touchSceneYSpy(edgeDragArea, SIGNAL(touchSceneYChanged(qreal)));

548

549 touchScenePos.ry() = view->height() / 2;

550 QTest::touchEvent(view, device).move(0, touchScenePos.toPoint());

551

552 QCOMPARE(touchYSpy.count(), 1);

553 QCOMPARE(touchSceneYSpy.count(), 1);

554 QCOMPARE(edgeDragArea->touchY(), touchScenePos.y() - edgeDragArea->y());

555 QCOMPARE(edgeDragArea->touchSceneY(), touchScenePos.y());

556}

557

558/*

559 Regression test for https://bugs.launchpad.net/bugs/1228336

560

561 Perform a quick two-finger double-tap and check that DirectionalDragArea properly

562 rejects those touch points. In the bug above it got confused and crashed.

563 */

564void tst_DirectionalDragArea::twoFingerTap()

565{

566 DirectionalDragArea *edgeDragArea =

567 view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

568 QVERIFY(edgeDragArea != 0);

569 edgeDragArea->setRecognitionTimer(fakeTimer);

570 edgeDragArea->setTimeSource(fakeTimeSource);

571

572 // Make touches evenly spaced along the edgeDragArea

573 QPoint touchAPos(edgeDragArea->width()/2.0f, view->height()*0.33f);

574 QPoint touchBPos(edgeDragArea->width()/2.0f, view->height()*0.66f);

575

576 qint64 timeStepMsecs = 5; // some arbitrary, small value

577

578 // Perform the first two-finger tap

579 // NB: using move() instead of stationary() becasue in the latter you cannot provide

580 // the touch position and therefore it's left with some garbage numbers.

581 QTest::touchEvent(view, device)

582 .press(0, touchAPos);

583

584 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);

585

586 passTime(timeStepMsecs);

587 QTest::touchEvent(view, device)

588 .move(0, touchAPos)

589 .press(1, touchBPos);

590

591 // A second touch point appeared during recognition, reject immediately as this

592 // can't be a single-touch gesture anymore.

593 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);

594

595 passTime(timeStepMsecs);

596 QTest::touchEvent(view, device)

597 .release(0, touchAPos)

598 .move(1, touchBPos);

599

600 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);

601

602 passTime(timeStepMsecs);

603 QTest::touchEvent(view, device)

604 .release(1, touchBPos);

605

606 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);

607

608 // Perform the second two-finger tap

609

610 passTime(timeStepMsecs);

611 QTest::touchEvent(view, device)

612 .press(0, touchAPos);

613

614 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);

615

616 passTime(timeStepMsecs);

617 QTest::touchEvent(view, device)

618 .move(0, touchAPos)

619 .press(1, touchBPos);

620

621 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);

622

623 passTime(timeStepMsecs);

624 QTest::touchEvent(view, device)

625 .release(0, touchAPos)

626 .move(1, touchBPos);

627

628 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);

629

630 passTime(timeStepMsecs);

631 QTest::touchEvent(view, device)

632 .release(1, touchBPos);

633

634 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);

635}

636

637/*

638 Tests that gesture recognition works normally even if the DirectionalDragArea moves

639 during recognition.

640 This effectively means that we have to do gesture recognition with scene coordinates

641 instead of local item coordinates.

642 */

643void tst_DirectionalDragArea::movingDDA()

644{

645 QQuickItem *rightwardsLauncher = view->rootObject()->findChild<QQuickItem*>("rightwardsLauncher");

646 Q_ASSERT(rightwardsLauncher != 0);

647

648 DirectionalDragArea *edgeDragArea =

649 rightwardsLauncher->findChild<DirectionalDragArea*>("hpDragArea");

650 Q_ASSERT(edgeDragArea != 0);

651 edgeDragArea->setRecognitionTimer(fakeTimer);

652 edgeDragArea->setTimeSource(fakeTimeSource);

653

654 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);

655 QPointF touchPoint = initialTouchPos;

656

657 qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;

658 QPointF dragDirectionVector(1.0f, 0.0f);

659

660 qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;

661 QPointF touchMovement = dragDirectionVector * movementStepDistance;

662 int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);

663 int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;

664

665 QTest::touchEvent(view, device).press(0, touchPoint.toPoint());

666

667 // Move it far ahead along the direction of the gesture

668 // rightwardsLauncher is a parent of our DirectionalDragArea. So moving it will move our DDA

669 rightwardsLauncher->setX(rightwardsLauncher->x() + edgeDragArea->distanceThreshold() * 5.0f);

670

671 for (int i = 0; i < totalMovementSteps; ++i) {

672 touchPoint += touchMovement;

673 passTime(movementTimeStepMs);

674 QTest::touchEvent(view, device).move(0, touchPoint.toPoint());

675 }

676

677 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);

678

679 QTest::touchEvent(view, device).release(0, touchPoint.toPoint());

680}

681

682/*

683 The presence of and old, rejected, touch point lying on the DirectionalDragArea

684 shouldn't impede the recognition of a gesture from a new touch point.

685 */

686void tst_DirectionalDragArea::ignoreOldFinger()

687{

688 DirectionalDragArea *edgeDragArea =

689 view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

690 Q_ASSERT(edgeDragArea != 0);

691 edgeDragArea->setRecognitionTimer(fakeTimer);

692 edgeDragArea->setTimeSource(fakeTimeSource);

693

694 // Make touches evenly spaced along the edgeDragArea

695 QPoint touch0Pos(edgeDragArea->width()/2.0f, view->height()*0.33f);

696 QPoint touch1Pos(edgeDragArea->width()/2.0f, view->height()*0.66f);

697

698 QTest::touchEvent(view, device).press(0, touch0Pos);

699

700 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);

701

702 // leave it lying around for some time

703 passTime(qMax(edgeDragArea->maxSilenceTime(), edgeDragArea->compositionTime()) * 10);

704

705 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);

706

707 qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;

708 QPointF dragDirectionVector(1.0f, 0.0f);

709

710 qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;

711 QPointF touchMovement = dragDirectionVector * movementStepDistance;

712 int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);

713 int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;

714

715 QTest::touchEvent(view, device)

716 .move(0, touch0Pos)

717 .press(1, touch1Pos);

718

719 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);

720

721 for (int i = 0; i < totalMovementSteps; ++i) {

722 touch1Pos += touchMovement.toPoint();

723 passTime(movementTimeStepMs);

724 QTest::touchEvent(view, device)

725 .move(0, touch0Pos)

726 .move(1, touch1Pos);

727 }

728

729 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);

730

731 QTest::touchEvent(view, device)

732 .move(0, touch0Pos)

733 .release(1, touch1Pos);

734

735 QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);

736}

737

738QTEST_MAIN(tst_DirectionalDragArea)

739

740#include "tst_DirectionalDragArea.moc"