6872f77 · unity8 · git.iko.soy

git.iko.soy/unity8

on xenial help sign in

Make DirectionalDragArea work when rotated

6872f77Daniel d'Andrada13 years ago

plugins/Ubuntu/Gestures/DirectionalDragArea.cpp+88−35

compare with xenial

unifiedsplit

@@ -114,6 +114,7 @@ DirectionalDragArea::DirectionalDragArea(QQuickItem *parent)

114 , m_wideningAngle(0)

115 , m_wideningFactor(0)

116 , m_distanceThreshold(0)

117+ , m_distanceThresholdSquared(0.)

117 , m_minSpeed(0)

118 , m_minSpeed(0)

118 , m_maxSilenceTime(200)

119 , m_maxSilenceTime(200)

119 , m_silenceTime(0)

120 , m_silenceTime(0)

@@ -162,7 +163,14 @@ void DirectionalDragArea::setWideningAngle(qreal angle)

162 return;

163 return;

163

164

164 m_wideningAngle = angle;

165 m_wideningAngle = angle;

166+

167+ // wideningFactor = pow(cosine(angle), 2)

168+ {

165− m_wideningFactor = qTan(angle * M_PI / 180.0);

169+ qreal angleRadians = angle * M_PI / 180.0;

170+ m_wideningFactor = qCos(angleRadians);

171+ m_wideningFactor = m_wideningFactor * m_wideningFactor;

172+ }

173+

166 Q_EMIT wideningAngleChanged(angle);

174 Q_EMIT wideningAngleChanged(angle);

167}

175}

168

176

@@ -170,6 +178,7 @@ void DirectionalDragArea::setDistanceThreshold(qreal value)

170{

178{

171 if (m_distanceThreshold != value) {

179 if (m_distanceThreshold != value) {

172 m_distanceThreshold = value;

180 m_distanceThreshold = value;

181+ m_distanceThresholdSquared = m_distanceThreshold * m_distanceThreshold;

173 Q_EMIT distanceThresholdChanged(value);

182 Q_EMIT distanceThresholdChanged(value);

174 }

183 }

175}

184}

@@ -335,12 +344,13 @@ void DirectionalDragArea::touchEvent_absent(QTouchEvent *event)

335 m_startScenePos = newTouchPoint->scenePos();

344 m_startScenePos = newTouchPoint->scenePos();

336 m_touchId = newTouchPoint->id();

345 m_touchId = newTouchPoint->id();

337 m_dampedScenePos.reset(m_startScenePos);

346 m_dampedScenePos.reset(m_startScenePos);

338− updateVelocityCalculator(m_startScenePos);

347+ m_velocityCalculator->setTrackedPosition(0.);

339 m_velocityCalculator->reset();

348 m_velocityCalculator->reset();

340 m_numSamplesOnLastSpeedCheck = 0;

349 m_numSamplesOnLastSpeedCheck = 0;

341 m_silenceTime = 0;

350 m_silenceTime = 0;

342 setPreviousPos(m_startPos);

351 setPreviousPos(m_startPos);

343 setPreviousScenePos(m_startScenePos);

352 setPreviousScenePos(m_startScenePos);

353+ updateSceneDirectionVector();

344

354

345 setStatus(Undecided);

355 setStatus(Undecided);

346}

356}

@@ -441,44 +451,53 @@ const QTouchEvent::TouchPoint *DirectionalDragArea::fetchTargetTouchPoint(QTouch

441

451

442bool DirectionalDragArea::pointInsideAllowedArea() const

452bool DirectionalDragArea::pointInsideAllowedArea() const

443{

453{

444− qreal dX = m_dampedScenePos.x() - m_startScenePos.x();

454+ // NB: Using squared values to avoid computing the square root to find

445− qreal dY = m_dampedScenePos.y() - m_startScenePos.y();

455+ // the length totalMovement

446

456

447− switch (m_direction) {

457+ QPointF totalMovement(m_dampedScenePos.x() - m_startScenePos.x(),

448− case Direction::Upwards:

458+ m_dampedScenePos.y() - m_startScenePos.y());

449− return dY <= 0 && qFabs(dX) <= qFabs(dY) * m_wideningFactor;

459+

450− case Direction::Downwards:

460+ qreal squaredTotalMovSize = totalMovement.x() * totalMovement.x() +

451− return dY >= 0 && qFabs(dX) <= dY * m_wideningFactor;

461+ totalMovement.y() * totalMovement.y();

452− case Direction::Leftwards:

462+

453− return dX <= 0 && qFabs(dY) <= qFabs(dX) * m_wideningFactor;

463+ if (squaredTotalMovSize == 0.) {

454− default: // Direction::Rightwards:

464+ // didn't move

455− return dX >= 0 && qFabs(dY) <= dX * m_wideningFactor;

465+ return true;

456 }

466 }

467+

468+ qreal projectedMovement = projectOntoDirectionVector(totalMovement);

469+

470+

471+ qreal cosineAngleSquared = (projectedMovement * projectedMovement) / squaredTotalMovSize;

472+

473+ // Same as:

474+ // angle_between_movement_vector_and_gesture_direction_vector <= widening_angle

475+ return cosineAngleSquared >= m_wideningFactor;

457}

476}

458

477

459bool DirectionalDragArea::movingInRightDirection() const

478bool DirectionalDragArea::movingInRightDirection() const

460{

479{

461− switch (m_direction) {

462− case Direction::Upwards:

463− return m_dampedScenePos.y() <= m_previousDampedScenePos.y();

480+ QPointF movementVector(m_dampedScenePos.x() - m_previousDampedScenePos.x(),

464− case Direction::Downwards:

465− return m_dampedScenePos.y() >= m_previousDampedScenePos.y();

481+ m_dampedScenePos.y() - m_previousDampedScenePos.y());

466− case Direction::Leftwards:

482+

467− return m_dampedScenePos.x() <= m_previousDampedScenePos.x();

483+ qreal scalarProjection = projectOntoDirectionVector(movementVector);

468− default: // Direction::Rightwards:

484+

469− return m_dampedScenePos.x() >= m_previousDampedScenePos.x();

485+ return scalarProjection >= 0.;

470− }

471}

486}

472

487

473bool DirectionalDragArea::movedFarEnough(const QPointF &point) const

488bool DirectionalDragArea::movedFarEnough(const QPointF &point) const

474{

489{

475− if (m_distanceThreshold > 0) {

490+ if (m_distanceThreshold <= 0.) {

476− if (Direction::isHorizontal(m_direction))

491+ // distance threshold check is disabled

477− return qFabs(point.x() - m_startScenePos.x()) > m_distanceThreshold;

478− else

479− return qFabs(point.y() - m_startScenePos.y()) > m_distanceThreshold;

480− } else {

481 return true;

492 return true;

493+ } else {

494+ QPointF totalMovement(point.x() - m_startScenePos.x(),

495+ point.y() - m_startScenePos.y());

496+

497+ qreal squaredTotalMovSize = totalMovement.x() * totalMovement.x() +

498+ totalMovement.y() * totalMovement.y();

499+

500+ return squaredTotalMovSize > m_distanceThresholdSquared;

482 }

501 }

483}

502}

484

503

@@ -583,13 +602,13 @@ void DirectionalDragArea::setPreviousScenePos(const QPointF &point)

583 }

602 }

584}

603}

585

604

586−void DirectionalDragArea::updateVelocityCalculator(const QPointF &point)

605+void DirectionalDragArea::updateVelocityCalculator(const QPointF &scenePos)

587{

606{

588− if (Direction::isHorizontal(m_direction)) {

607+ QPointF totalSceneMovement = scenePos - m_startScenePos;

589− m_velocityCalculator->setTrackedPosition(point.x());

608+

590− } else {

609+ qreal scalarProjection = projectOntoDirectionVector(totalSceneMovement);

610+

591− m_velocityCalculator->setTrackedPosition(point.y());

611+ m_velocityCalculator->setTrackedPosition(scalarProjection);

592− }

593}

612}

594

613

595bool DirectionalDragArea::isWithinTouchCompositionWindow()

614bool DirectionalDragArea::isWithinTouchCompositionWindow()

@@ -693,5 +712,39 @@ qint64 DirectionalDragArea::ActiveTouchesInfo::mostRecentStartTime()

693 return highestStartTime;

712 return highestStartTime;

694}

713}

695

714

715+void DirectionalDragArea::updateSceneDirectionVector()

716+{

717+ QPointF localOrigin(0., 0.);

718+ QPointF localDirection;

719+ switch (m_direction) {

720+ case Direction::Upwards:

721+ localDirection.rx() = 0.;

722+ localDirection.ry() = -1.;

723+ break;

724+ case Direction::Downwards:

725+ localDirection.rx() = 0.;

726+ localDirection.ry() = 1;

727+ break;

728+ case Direction::Leftwards:

729+ localDirection.rx() = -1.;

730+ localDirection.ry() = 0.;

731+ break;

732+ default: // Direction::Rightwards:

733+ localDirection.rx() = 1.;

734+ localDirection.ry() = 0.;

735+ break;

736+ }

737+ QPointF sceneOrigin = mapToScene(localOrigin);

738+ QPointF sceneDirection = mapToScene(localDirection);

739+ m_sceneDirectionVector = sceneDirection - sceneOrigin;

740+}

741+

742+qreal DirectionalDragArea::projectOntoDirectionVector(const QPointF &sceneVector) const

743+{

744+ // same as dot product as m_sceneDirectionVector is a unit vector

745+ return sceneVector.x() * m_sceneDirectionVector.x() +

746+ sceneVector.y() * m_sceneDirectionVector.y();

747+}

748+

696// Because we are defining a new QObject-based class (RecognitionTimer) here.

749// Because we are defining a new QObject-based class (RecognitionTimer) here.

697#include "DirectionalDragArea.moc"

750#include "DirectionalDragArea.moc"

plugins/Ubuntu/Gestures/DirectionalDragArea.h+9−1

@@ -231,6 +231,10 @@ private:

231 void setPreviousScenePos(const QPointF &point);

232 void updateVelocityCalculator(const QPointF &point);

233 bool isWithinTouchCompositionWindow();

234+ void updateSceneDirectionVector();

235+ // returns the scalar projection between the given vector (in scene coordinates)

236+ // and m_sceneDirectionVector

237+ qreal projectOntoDirectionVector(const QPointF &sceneVector) const;

234

238

235 Status m_status;

239 Status m_status;

236

240

@@ -245,10 +249,14 @@ private:

245 DampedPointF m_dampedScenePos;

249 DampedPointF m_dampedScenePos;

246 QPointF m_previousDampedScenePos;

250 QPointF m_previousDampedScenePos;

247

251

252+ // Unit vector in scene coordinates describing the direction of the gesture recognition

253+ QPointF m_sceneDirectionVector;

254+

248 Direction::Type m_direction;

255 Direction::Type m_direction;

249 qreal m_wideningAngle; // in degrees

256 qreal m_wideningAngle; // in degrees

250− qreal m_wideningFactor; // it's tan(degreesToRadian(m_wideningAngle))

257+ qreal m_wideningFactor; // it's pow(cosine(m_wideningAngle), 2)

251 qreal m_distanceThreshold;

258 qreal m_distanceThreshold;

259+ qreal m_distanceThresholdSquared; // it's pow(m_distanceThreshold, 2)

252 qreal m_minSpeed;

260 qreal m_minSpeed;

253 int m_maxSilenceTime; // in milliseconds

261 int m_maxSilenceTime; // in milliseconds

254 int m_silenceTime; // in milliseconds

262 int m_silenceTime; // in milliseconds