plugins/Ubuntu/Gestures/DirectionalDragArea.cpp · unity8

git.iko.soy/unity8

on a60d486 help sign in

unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.cpp

872 lines 28 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#define ACTIVETOUCHESINFO_DEBUG 0

18#define DIRECTIONALDRAGAREA_DEBUG 0

20#include "DirectionalDragArea.h"

22#include <QQuickWindow>

23#include <QtCore/qmath.h>

24#include <QScreen>

25#include <QDebug>

27#pragma GCC diagnostic push

28#pragma GCC diagnostic ignored "-pedantic"

29#include <private/qquickwindow_p.h>

30#pragma GCC diagnostic pop

32// local

33#include "TouchOwnershipEvent.h"

34#include "TouchRegistry.h"

35#include "UnownedTouchEvent.h"

37#include "DirectionalDragArea_p.h"

39using namespace UbuntuGestures;

41#if DIRECTIONALDRAGAREA_DEBUG

42#define ddaDebug(params) qDebug().nospace() << "[DDA(" << qPrintable(objectName()) << ")] " << params

43#include "DebugHelpers.h"

45namespace {

46const char *statusToString(DirectionalDragAreaPrivate::Status status)

47{

48 if (status == DirectionalDragAreaPrivate::WaitingForTouch) {

49 return "WaitingForTouch";

50 } else if (status == DirectionalDragAreaPrivate::Undecided) {

51 return "Undecided";

52 } else {

53 return "Recognized";

54 }

55}

57} // namespace {

58#else // DIRECTIONALDRAGAREA_DEBUG

59#define ddaDebug(params) ((void)0)

60#endif // DIRECTIONALDRAGAREA_DEBUG

62DirectionalDragArea::DirectionalDragArea(QQuickItem *parent)

63 : QQuickItem(parent)

64 , d(new DirectionalDragAreaPrivate(this))

65{

66 d->setRecognitionTimer(new Timer(this));

67 d->recognitionTimer->setInterval(d->maxTime);

68 d->recognitionTimer->setSingleShot(true);

70 connect(this, &QQuickItem::enabledChanged, d, &DirectionalDragAreaPrivate::giveUpIfDisabledOrInvisible);

71 connect(this, &QQuickItem::visibleChanged, d, &DirectionalDragAreaPrivate::giveUpIfDisabledOrInvisible);

72}

74Direction::Type DirectionalDragArea::direction() const

75{

76 return d->direction;

77}

79void DirectionalDragArea::setDirection(Direction::Type direction)

80{

81 if (direction != d->direction) {

82 d->direction = direction;

83 Q_EMIT directionChanged(d->direction);

84 }

85}

87void DirectionalDragAreaPrivate::setDistanceThreshold(qreal value)

88{

89 if (distanceThreshold != value) {

90 distanceThreshold = value;

91 distanceThresholdSquared = distanceThreshold * distanceThreshold;

92 }

93}

95void DirectionalDragAreaPrivate::setMaxTime(int value)

96{

97 if (maxTime != value) {

98 maxTime = value;

99 recognitionTimer->setInterval(maxTime);

100 }

101}

102

103void DirectionalDragAreaPrivate::setRecognitionTimer(UbuntuGestures::AbstractTimer *timer)

104{

105 int interval = 0;

106 bool timerWasRunning = false;

107 bool wasSingleShot = false;

108

109 // can be null when called from the constructor

110 if (recognitionTimer) {

111 interval = recognitionTimer->interval();

112 timerWasRunning = recognitionTimer->isRunning();

113 if (recognitionTimer->parent() == this) {

114 delete recognitionTimer;

115 }

116 }

117

118 recognitionTimer = timer;

119 timer->setInterval(interval);

120 timer->setSingleShot(wasSingleShot);

121 connect(timer, &UbuntuGestures::AbstractTimer::timeout,

122 this, &DirectionalDragAreaPrivate::rejectGesture);

123 if (timerWasRunning) {

124 recognitionTimer->start();

125 }

126}

127

128void DirectionalDragAreaPrivate::setTimeSource(const SharedTimeSource &timeSource)

129{

130 this->timeSource = timeSource;

131 activeTouches.m_timeSource = timeSource;

132}

133

134qreal DirectionalDragArea::distance() const

135{

136 if (Direction::isHorizontal(d->direction)) {

137 return d->publicPos.x() - d->startPos.x();

138 } else {

139 return d->publicPos.y() - d->startPos.y();

140 }

141}

142

143void DirectionalDragAreaPrivate::updateSceneDistance()

144{

145 QPointF totalMovement = publicScenePos - startScenePos;

146 sceneDistance = projectOntoDirectionVector(totalMovement);

147}

148

149qreal DirectionalDragArea::sceneDistance() const

150{

151 return d->sceneDistance;

152}

153

154qreal DirectionalDragArea::touchX() const

155{

156 return d->publicPos.x();

157}

158

159qreal DirectionalDragArea::touchY() const

160{

161 return d->publicPos.y();

162}

163

164qreal DirectionalDragArea::touchSceneX() const

165{

166 return d->publicScenePos.x();

167}

168

169qreal DirectionalDragArea::touchSceneY() const

170{

171 return d->publicScenePos.y();

172}

173

174bool DirectionalDragArea::dragging() const

175{

176 return d->status == DirectionalDragAreaPrivate::Recognized;

177}

178

179bool DirectionalDragArea::immediateRecognition() const

180{

181 return d->immediateRecognition;

182}

183

184void DirectionalDragArea::setImmediateRecognition(bool enabled)

185{

186 if (d->immediateRecognition != enabled) {

187 d->immediateRecognition = enabled;

188 Q_EMIT immediateRecognitionChanged(enabled);

189 }

190}

191

192bool DirectionalDragArea::event(QEvent *event)

193{

194 if (event->type() == TouchOwnershipEvent::touchOwnershipEventType()) {

195 d->touchOwnershipEvent(static_cast<TouchOwnershipEvent *>(event));

196 return true;

197 } else if (event->type() == UnownedTouchEvent::unownedTouchEventType()) {

198 d->unownedTouchEvent(static_cast<UnownedTouchEvent *>(event));

199 return true;

200 } else {

201 return QQuickItem::event(event);

202 }

203}

204

205void DirectionalDragAreaPrivate::touchOwnershipEvent(TouchOwnershipEvent *event)

206{

207 if (event->gained()) {

208 QVector<int> ids;

209 ids.append(event->touchId());

210 ddaDebug("grabbing touch");

211 q->grabTouchPoints(ids);

212

213 // Work around for Qt bug. If we grab a touch that is being used for mouse pointer

214 // emulation it will cause the emulation logic to go nuts.

215 // Thus we have to also grab the mouse in this case.

216 //

217 // The fix for this bug has landed in Qt 5.4 (https://codereview.qt-project.org/96887)

218 // TODO: Remove this workaround once we start using Qt 5.4

219 if (q->window()) {

220 QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(q->window());

221 if (windowPrivate->touchMouseId == event->touchId() && q->window()->mouseGrabberItem()) {

222 ddaDebug("removing mouse grabber");

223 q->window()->mouseGrabberItem()->ungrabMouse();

224 }

225 }

226 } else {

227 // We still wanna know when it ends for keeping the composition time window up-to-date

228 TouchRegistry::instance()->addTouchWatcher(touchId, q);

229

230 setStatus(WaitingForTouch);

231 }

232}

233

234void DirectionalDragAreaPrivate::unownedTouchEvent(UnownedTouchEvent *unownedTouchEvent)

235{

236 QTouchEvent *event = unownedTouchEvent->touchEvent();

237

238 Q_ASSERT(!event->touchPointStates().testFlag(Qt::TouchPointPressed));

239

240 ddaDebug("Unowned " << timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));

241

242 switch (status) {

243 case WaitingForTouch:

244 // do nothing

245 break;

246 case Undecided:

247 Q_ASSERT(q->isEnabled() && q->isVisible());

248 unownedTouchEvent_undecided(unownedTouchEvent);

249 break;

250 default: // Recognized:

251 // do nothing

252 break;

253 }

254

255 activeTouches.update(event);

256}

257

258void DirectionalDragAreaPrivate::unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent)

259{

260 const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(unownedTouchEvent->touchEvent());

261 if (!touchPoint) {

262 qCritical() << "DirectionalDragArea[status=Undecided]: touch " << touchId

263 << "missing from UnownedTouchEvent without first reaching state Qt::TouchPointReleased. "

264 "Considering it as released.";

265

266 TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);

267 setStatus(WaitingForTouch);

268 return;

269 }

270

271 const QPointF &touchScenePos = touchPoint->scenePos();

272

273 if (touchPoint->state() == Qt::TouchPointReleased) {

274 // touch has ended before recognition concluded

275 ddaDebug("Touch has ended before recognition concluded");

276 TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);

277 setStatus(WaitingForTouch);

278 return;

279 }

280

281 previousDampedScenePos.setX(dampedScenePos.x());

282 previousDampedScenePos.setY(dampedScenePos.y());

283 dampedScenePos.update(touchScenePos);

284

285 if (!movingInRightDirection()) {

286 ddaDebug("Rejecting gesture because touch point is moving in the wrong direction.");

287 TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);

288 // We still wanna know when it ends for keeping the composition time window up-to-date

289 TouchRegistry::instance()->addTouchWatcher(touchId, q);

290 setStatus(WaitingForTouch);

291 return;

292 }

293

294 if (isWithinTouchCompositionWindow()) {

295 // There's still time for some new touch to appear and ruin our party as it would be combined

296 // with our touchId one and therefore deny the possibility of a single-finger gesture.

297 ddaDebug("Sill within composition window. Let's wait more.");

298 return;

299 }

300

301 if (movedFarEnoughAlongGestureAxis()) {

302 TouchRegistry::instance()->requestTouchOwnership(touchId, q);

303 setStatus(Recognized);

304 setPublicPos(touchPoint->pos());

305 setPublicScenePos(touchScenePos);

306 } else if (isPastMaxDistance()) {

307 ddaDebug("Rejecting gesture because it went farther than maxDistance without getting recognized.");

308 TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);

309 // We still wanna know when it ends for keeping the composition time window up-to-date

310 TouchRegistry::instance()->addTouchWatcher(touchId, q);

311 setStatus(WaitingForTouch);

312 } else {

313 ddaDebug("Didn't move far enough yet. Let's wait more.");

314 }

315}

316

317void DirectionalDragArea::touchEvent(QTouchEvent *event)

318{

319 // TODO: Consider when more than one touch starts in the same event (although it's not possible

320 // with Mir's android-input). Have to track them all. Consider it a plus/bonus.

321

322 ddaDebug(d->timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));

323

324 if (!isEnabled() || !isVisible()) {

325 QQuickItem::touchEvent(event);

326 return;

327 }

328

329 switch (d->status) {

330 case DirectionalDragAreaPrivate::WaitingForTouch:

331 d->touchEvent_absent(event);

332 break;

333 case DirectionalDragAreaPrivate::Undecided:

334 d->touchEvent_undecided(event);

335 break;

336 default: // Recognized:

337 d->touchEvent_recognized(event);

338 break;

339 }

340

341 d->activeTouches.update(event);

342}

343

344void DirectionalDragAreaPrivate::touchEvent_absent(QTouchEvent *event)

345{

346 // TODO: accept/reject is for the whole event, not per touch id. See how that affects us.

347

348 if (!event->touchPointStates().testFlag(Qt::TouchPointPressed)) {

349 // Nothing to see here. No touch starting in this event.

350 return;

351 }

352

353 // to be proven wrong, if that's the case

354 bool allGood = true;

355

356 if (isWithinTouchCompositionWindow()) {

357 // too close to the last touch start. So we consider them as starting roughly at the same time.

358 // Can't be a single-touch gesture.

359 ddaDebug("A new touch point came in but we're still within time composition window. Ignoring it.");

360 allGood = false;

361 }

362

363 const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();

364

365 const QTouchEvent::TouchPoint *newTouchPoint = nullptr;

366 for (int i = 0; i < touchPoints.count() && allGood; ++i) {

367 const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);

368 if (touchPoint.state() == Qt::TouchPointPressed) {

369 if (newTouchPoint) {

370 // more than one touch starting in this QTouchEvent. Can't be a single-touch gesture

371 allGood = false;

372 } else {

373 // that's our candidate

374 touchId = touchPoint.id();

375 newTouchPoint = &touchPoint;

376 }

377 }

378 }

379

380 if (allGood) {

381 allGood = sanityCheckRecognitionProperties();

382 if (!allGood) {

383 qWarning("DirectionalDragArea: recognition properties are wrongly set. Gesture recognition"

384 " is impossible");

385 }

386 }

387

388 if (allGood) {

389 Q_ASSERT(newTouchPoint);

390

391 startPos = newTouchPoint->pos();

392 startScenePos = newTouchPoint->scenePos();

393 touchId = newTouchPoint->id();

394 dampedScenePos.reset(startScenePos);

395 setPublicPos(startPos);

396

397 setPublicScenePos(startScenePos);

398 updateSceneDirectionVector();

399

400 if (recognitionIsDisabled()) {

401 // Behave like a dumb TouchArea

402 ddaDebug("Gesture recognition is disabled. Requesting touch ownership immediately.");

403 TouchRegistry::instance()->requestTouchOwnership(touchId, q);

404 setStatus(Recognized);

405 event->accept();

406 } else {

407 // just monitor the touch points for now.

408 TouchRegistry::instance()->addCandidateOwnerForTouch(touchId, q);

409

410 setStatus(Undecided);

411 // Let the item below have it. We will monitor it and grab it later if a gesture

412 // gets recognized.

413 event->ignore();

414 }

415 } else {

416 watchPressedTouchPoints(touchPoints);

417 event->ignore();

418 }

419}

420

421void DirectionalDragAreaPrivate::touchEvent_undecided(QTouchEvent *event)

422{

423 Q_ASSERT(fetchTargetTouchPoint(event) == nullptr);

424

425 // We're not interested in new touch points. We already have our candidate (touchId).

426 // But we do want to know when those new touches end for keeping the composition time

427 // window up-to-date

428 event->ignore();

429 watchPressedTouchPoints(event->touchPoints());

430

431 if (event->touchPointStates().testFlag(Qt::TouchPointPressed) && isWithinTouchCompositionWindow()) {

432 // multi-finger drags are not accepted

433 ddaDebug("Multi-finger drags are not accepted");

434

435 TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);

436 // We still wanna know when it ends for keeping the composition time window up-to-date

437 TouchRegistry::instance()->addTouchWatcher(touchId, q);

438

439 setStatus(WaitingForTouch);

440 }

441}

442

443void DirectionalDragAreaPrivate::touchEvent_recognized(QTouchEvent *event)

444{

445 const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);

446

447 if (!touchPoint) {

448 qCritical() << "DirectionalDragArea[status=Recognized]: touch " << touchId

449 << "missing from QTouchEvent without first reaching state Qt::TouchPointReleased. "

450 "Considering it as released.";

451 setStatus(WaitingForTouch);

452 } else {

453 setPublicPos(touchPoint->pos());

454 setPublicScenePos(touchPoint->scenePos());

455

456 if (touchPoint->state() == Qt::TouchPointReleased) {

457 setStatus(WaitingForTouch);

458 }

459 }

460}

461

462void DirectionalDragAreaPrivate::watchPressedTouchPoints(const QList<QTouchEvent::TouchPoint> &touchPoints)

463{

464 for (int i = 0; i < touchPoints.count(); ++i) {

465 const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);

466 if (touchPoint.state() == Qt::TouchPointPressed) {

467 TouchRegistry::instance()->addTouchWatcher(touchPoint.id(), q);

468 }

469 }

470}

471

472bool DirectionalDragAreaPrivate::recognitionIsDisabled() const

473{

474 return immediateRecognition || (distanceThreshold <= 0 && compositionTime <= 0);

475}

476

477bool DirectionalDragAreaPrivate::sanityCheckRecognitionProperties()

478{

479 return recognitionIsDisabled()

480 || (distanceThreshold < maxDistance && compositionTime < maxTime);

481}

482

483const QTouchEvent::TouchPoint *DirectionalDragAreaPrivate::fetchTargetTouchPoint(QTouchEvent *event)

484{

485 const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();

486 const QTouchEvent::TouchPoint *touchPoint = 0;

487 for (int i = 0; i < touchPoints.size(); ++i) {

488 if (touchPoints.at(i).id() == touchId) {

489 touchPoint = &touchPoints.at(i);

490 break;

491 }

492 }

493 return touchPoint;

494}

495

496bool DirectionalDragAreaPrivate::movingInRightDirection() const

497{

498 if (direction == Direction::Horizontal) {

499 return true;

500 } else {

501 QPointF movementVector(dampedScenePos.x() - previousDampedScenePos.x(),

502 dampedScenePos.y() - previousDampedScenePos.y());

503

504 qreal scalarProjection = projectOntoDirectionVector(movementVector);

505

506 return scalarProjection >= 0.;

507 }

508}

509

510bool DirectionalDragAreaPrivate::movedFarEnoughAlongGestureAxis() const

511{

512 if (distanceThreshold <= 0.) {

513 // distance threshold check is disabled

514 return true;

515 } else {

516 QPointF totalMovement(dampedScenePos.x() - startScenePos.x(),

517 dampedScenePos.y() - startScenePos.y());

518

519 qreal scalarProjection = projectOntoDirectionVector(totalMovement);

520

521 ddaDebug(" movedFarEnoughAlongGestureAxis: scalarProjection=" << scalarProjection

522 << ", distanceThreshold=" << distanceThreshold);

523

524 if (direction == Direction::Horizontal) {

525 return qAbs(scalarProjection) > distanceThreshold;

526 } else {

527 return scalarProjection > distanceThreshold;

528 }

529 }

530}

531

532bool DirectionalDragAreaPrivate::isPastMaxDistance() const

533{

534 QPointF totalMovement(dampedScenePos.x() - startScenePos.x(),

535 dampedScenePos.y() - startScenePos.y());

536

537 qreal squaredDistance = totalMovement.x()*totalMovement.x() + totalMovement.y()*totalMovement.y();

538 return squaredDistance > maxDistance*maxDistance;

539}

540

541void DirectionalDragAreaPrivate::giveUpIfDisabledOrInvisible()

542{

543 if (!q->isEnabled() || !q->isVisible()) {

544 if (status == Undecided) {

545 TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);

546 // We still wanna know when it ends for keeping the composition time window up-to-date

547 TouchRegistry::instance()->addTouchWatcher(touchId, q);

548 }

549

550 if (status != WaitingForTouch) {

551 ddaDebug("Resetting status because got disabled or made invisible");

552 setStatus(WaitingForTouch);

553 }

554 }

555}

556

557void DirectionalDragAreaPrivate::rejectGesture()

558{

559 if (status == Undecided) {

560 ddaDebug("Rejecting gesture because it's taking too long to drag beyond the threshold.");

561

562 TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);

563 // We still wanna know when it ends for keeping the composition time window up-to-date

564 TouchRegistry::instance()->addTouchWatcher(touchId, q);

565

566 setStatus(WaitingForTouch);

567 }

568}

569

570void DirectionalDragAreaPrivate::setStatus(Status newStatus)

571{

572 if (newStatus == status)

573 return;

574

575 Status oldStatus = status;

576

577 if (oldStatus == Undecided) {

578 recognitionTimer->stop();

579 }

580

581 status = newStatus;

582 Q_EMIT statusChanged(status);

583

584 ddaDebug(statusToString(oldStatus) << " -> " << statusToString(newStatus));

585

586 switch (newStatus) {

587 case WaitingForTouch:

588 if (oldStatus == Recognized) {

589 Q_EMIT q->draggingChanged(false);

590 }

591 break;

592 case Undecided:

593 recognitionTimer->start();

594 break;

595 case Recognized:

596 Q_EMIT q->draggingChanged(true);

597 break;

598 default:

599 // no-op

600 break;

601 }

602}

603

604void DirectionalDragAreaPrivate::setPublicPos(const QPointF &point)

605{

606 bool xChanged = publicPos.x() != point.x();

607 bool yChanged = publicPos.y() != point.y();

608

609 // Public position should not get updated while the gesture is still being recognized

610 // (ie, Undecided status).

611 Q_ASSERT(status == WaitingForTouch || status == Recognized);

612

613 if (status == Recognized && !recognitionIsDisabled()) {

614 // When the gesture finally gets recognized, the finger will likely be

615 // reasonably far from the edge. If we made the contentX immediately

616 // follow the finger position it would be visually unpleasant as it

617 // would appear right next to the user's finger out of nowhere (ie,

618 // it would jump). Instead, we make contentX go towards the user's

619 // finger in several steps. ie., in an animated way.

620 QPointF delta = point - publicPos;

621 // the trick is not to go all the way (1.0) as it would cause a sudden jump

622 publicPos.rx() += 0.4 * delta.x();

623 publicPos.ry() += 0.4 * delta.y();

624 } else {

625 // no smoothing when initializing or if gesture recognition was immediate as there will

626 // be no jump.

627 publicPos = point;

628 }

629

630 if (xChanged) {

631 Q_EMIT q->touchXChanged(publicPos.x());

632 if (Direction::isHorizontal(direction))

633 Q_EMIT q->distanceChanged(q->distance());

634 }

635

636 if (yChanged) {

637 Q_EMIT q->touchYChanged(publicPos.y());

638 if (Direction::isVertical(direction))

639 Q_EMIT q->distanceChanged(q->distance());

640 }

641}

642

643void DirectionalDragAreaPrivate::setPublicScenePos(const QPointF &point)

644{

645 bool xChanged = publicScenePos.x() != point.x();

646 bool yChanged = publicScenePos.y() != point.y();

647

648 if (!xChanged && !yChanged)

649 return;

650

651 // Public position should not get updated while the gesture is still being recognized

652 // (ie, Undecided status).

653 Q_ASSERT(status == WaitingForTouch || status == Recognized);

654

655 qreal oldSceneDistance = sceneDistance;

656

657 if (status == Recognized && !recognitionIsDisabled()) {

658 // When the gesture finally gets recognized, the finger will likely be

659 // reasonably far from the edge. If we made the contentX immediately

660 // follow the finger position it would be visually unpleasant as it

661 // would appear right next to the user's finger out of nowhere (ie,

662 // it would jump). Instead, we make contentX go towards the user's

663 // finger in several steps. ie., in an animated way.

664 QPointF delta = point - publicScenePos;

665 // the trick is not to go all the way (1.0) as it would cause a sudden jump

666 publicScenePos.rx() += 0.4 * delta.x();

667 publicScenePos.ry() += 0.4 * delta.y();

668 } else {

669 // no smoothing when initializing or if gesture recognition was immediate as there will

670 // be no jump.

671 publicScenePos = point;

672 }

673

674 updateSceneDistance();

675

676 if (oldSceneDistance != sceneDistance) {

677 Q_EMIT q->sceneDistanceChanged(sceneDistance);

678 }

679

680 if (xChanged) {

681 Q_EMIT q->touchSceneXChanged(publicScenePos.x());

682 }

683

684 if (yChanged) {

685 Q_EMIT q->touchSceneYChanged(publicScenePos.y());

686 }

687}

688

689bool DirectionalDragAreaPrivate::isWithinTouchCompositionWindow()

690{

691 return

692 compositionTime > 0 &&

693 !activeTouches.isEmpty() &&

694 timeSource->msecsSinceReference() <=

695 activeTouches.mostRecentStartTime() + (qint64)compositionTime;

696}

697

698void DirectionalDragArea::itemChange(ItemChange change, const ItemChangeData &value)

699{

700 if (change == QQuickItem::ItemSceneChange) {

701 if (value.window != nullptr) {

702 // TODO: Handle window->screen() changes (ie window changing screens)

703 qreal pixelsPerMm = value.window->screen()->physicalDotsPerInch() / 25.4;

704 d->setPixelsPerMm(pixelsPerMm);

705 }

706 }

707}

708

709void DirectionalDragAreaPrivate::setPixelsPerMm(qreal pixelsPerMm)

710{

711 dampedScenePos.setMaxDelta(1. * pixelsPerMm);

712 setDistanceThreshold(4. * pixelsPerMm);

713 maxDistance = 10. * pixelsPerMm;

714}

715

716//************************** ActiveTouchesInfo **************************

717

718ActiveTouchesInfo::ActiveTouchesInfo(const SharedTimeSource &timeSource)

719 : m_timeSource(timeSource)

720{

721}

722

723void ActiveTouchesInfo::update(QTouchEvent *event)

724{

725 if (!(event->touchPointStates() & (Qt::TouchPointPressed | Qt::TouchPointReleased))) {

726 // nothing to update

727 #if ACTIVETOUCHESINFO_DEBUG

728 qDebug("[DDA::ActiveTouchesInfo] Nothing to Update");

729 #endif

730 return;

731 }

732

733 const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();

734 for (int i = 0; i < touchPoints.count(); ++i) {

735 const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);

736 if (touchPoint.state() == Qt::TouchPointPressed) {

737 addTouchPoint(touchPoint.id());

738 } else if (touchPoint.state() == Qt::TouchPointReleased) {

739 removeTouchPoint(touchPoint.id());

740 }

741 }

742}

743

744#if ACTIVETOUCHESINFO_DEBUG

745QString ActiveTouchesInfo::toString()

746{

747 QString string = "(";

748

749 {

750 QTextStream stream(&string);

751 m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &touchInfo) {

752 stream << "(id=" << touchInfo->id << ",startTime=" << touchInfo->startTime << ")";

753 return true;

754 });

755 }

756

757 string.append(")");

758

759 return string;

760}

761#endif // ACTIVETOUCHESINFO_DEBUG

762

763void ActiveTouchesInfo::addTouchPoint(int touchId)

764{

765 ActiveTouchInfo &activeTouchInfo = m_touchInfoPool.getEmptySlot();

766 activeTouchInfo.id = touchId;

767 activeTouchInfo.startTime = m_timeSource->msecsSinceReference();

768

769 #if ACTIVETOUCHESINFO_DEBUG

770 qDebug() << "[DDA::ActiveTouchesInfo]" << qPrintable(toString());

771 #endif

772}

773

774qint64 ActiveTouchesInfo::touchStartTime(int touchId)

775{

776 qint64 result = -1;

777

778 m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &touchInfo) {

779 if (touchId == touchInfo->id) {

780 result = touchInfo->startTime;

781 return false;

782 } else {

783 return true;

784 }

785 });

786

787 Q_ASSERT(result != -1);

788 return result;

789}

790

791void ActiveTouchesInfo::removeTouchPoint(int touchId)

792{

793 m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &touchInfo) {

794 if (touchId == touchInfo->id) {

795 m_touchInfoPool.freeSlot(touchInfo);

796 return false;

797 } else {

798 return true;

799 }

800 });

801

802 #if ACTIVETOUCHESINFO_DEBUG

803 qDebug() << "[DDA::ActiveTouchesInfo]" << qPrintable(toString());

804 #endif

805}

806

807qint64 ActiveTouchesInfo::mostRecentStartTime()

808{

809 Q_ASSERT(!m_touchInfoPool.isEmpty());

810

811 qint64 highestStartTime = -1;

812

813 m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &activeTouchInfo) {

814 if (activeTouchInfo->startTime > highestStartTime) {

815 highestStartTime = activeTouchInfo->startTime;

816 }

817 return true;

818 });

819

820 return highestStartTime;

821}

822

823void DirectionalDragAreaPrivate::updateSceneDirectionVector()

824{

825 QPointF localOrigin(0., 0.);

826 QPointF localDirection;

827 switch (direction) {

828 case Direction::Upwards:

829 localDirection.rx() = 0.;

830 localDirection.ry() = -1.;

831 break;

832 case Direction::Downwards:

833 localDirection.rx() = 0.;

834 localDirection.ry() = 1;

835 break;

836 case Direction::Leftwards:

837 localDirection.rx() = -1.;

838 localDirection.ry() = 0.;

839 break;

840 default: // Direction::Rightwards || Direction.Horizontal

841 localDirection.rx() = 1.;

842 localDirection.ry() = 0.;

843 break;

844 }

845 QPointF sceneOrigin = q->mapToScene(localOrigin);

846 QPointF sceneDirection = q->mapToScene(localDirection);

847 sceneDirectionVector = sceneDirection - sceneOrigin;

848}

849

850qreal DirectionalDragAreaPrivate::projectOntoDirectionVector(const QPointF &sceneVector) const

851{

852 // same as dot product as sceneDirectionVector is a unit vector

853 return sceneVector.x() * sceneDirectionVector.x() +

854 sceneVector.y() * sceneDirectionVector.y();

855}

856

857DirectionalDragAreaPrivate::DirectionalDragAreaPrivate(DirectionalDragArea *q)

858 : q(q)

859 , status(WaitingForTouch)

860 , sceneDistance(0)

861 , touchId(-1)

862 , direction(Direction::Rightwards)

863 , distanceThreshold(0)

864 , distanceThresholdSquared(0.)

865 , maxTime(400)

866 , compositionTime(60)

867 , immediateRecognition(false)

868 , recognitionTimer(nullptr)

869 , timeSource(new RealTimeSource)

870 , activeTouches(timeSource)

871{

872}