plugins/Ubuntu/Gestures/DirectionalDragArea.cpp · unity8

git.iko.soy/unity8

on a17a20f help sign in

unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.cpp

420 lines 12 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 "DirectionalDragArea.h"

19#include <QtCore/qmath.h>

20#include <QtCore/QTimer>

22// Essentially a QTimer wrapper

23class RecognitionTimer : public UbuntuGestures::AbstractTimer

24{

25 Q_OBJECT

26public:

27 RecognitionTimer(QObject *parent) : UbuntuGestures::AbstractTimer(parent) {

28 m_timer.setSingleShot(false);

29 connect(&m_timer, &QTimer::timeout,

30 this, &UbuntuGestures::AbstractTimer::timeout);

31 }

32 virtual int interval() const { return m_timer.interval(); }

33 virtual void setInterval(int msecs) { m_timer.setInterval(msecs); }

34 virtual void start() { m_timer.start(); UbuntuGestures::AbstractTimer::start(); }

35 virtual void stop() { m_timer.stop(); UbuntuGestures::AbstractTimer::stop(); }

36private:

37 QTimer m_timer;

38};

40DirectionalDragArea::DirectionalDragArea(QQuickItem *parent)

41 : QQuickItem(parent)

42 , m_status(WaitingForTouch)

43 , m_touchId(-1)

44 , m_direction(DirectionalDragArea::Rightwards)

45 , m_wideningAngle(0)

46 , m_wideningFactor(0)

47 , m_distanceThreshold(0)

48 , m_minSpeed(0)

49 , m_maxSilenceTime(200)

50 , m_silenceTime(0)

51 , m_numSamplesOnLastSpeedCheck(0)

52 , m_recognitionTimer(0)

53 , m_velocityCalculator(0)

54{

55 setRecognitionTimer(new RecognitionTimer(this));

56 m_recognitionTimer->setInterval(60);

58 m_velocityCalculator = new AxisVelocityCalculator(this);

59}

61DirectionalDragArea::Direction DirectionalDragArea::direction() const

62{

63 return m_direction;

64}

66void DirectionalDragArea::setDirection(DirectionalDragArea::Direction direction)

67{

68 if (direction != m_direction) {

69 m_direction = direction;

70 Q_EMIT directionChanged(m_direction);

71 }

72}

74void DirectionalDragArea::setMaxDeviation(qreal value)

75{

76 if (m_dampedPos.maxDelta() != value) {

77 m_dampedPos.setMaxDelta(value);

78 Q_EMIT maxDeviationChanged(value);

79 }

80}

82qreal DirectionalDragArea::wideningAngle() const

83{

84 return m_wideningAngle;

85}

87void DirectionalDragArea::setWideningAngle(qreal angle)

88{

89 if (angle == m_wideningAngle)

90 return;

92 m_wideningAngle = angle;

93 m_wideningFactor = qTan(angle * M_PI / 180.0);

94 Q_EMIT wideningAngleChanged(angle);

95}

97void DirectionalDragArea::setDistanceThreshold(qreal value)

98{

99 if (m_distanceThreshold != value) {

100 m_distanceThreshold = value;

101 Q_EMIT distanceThresholdChanged(value);

102 }

103}

104

105void DirectionalDragArea::setMinSpeed(qreal value)

106{

107 if (m_minSpeed != value) {

108 m_minSpeed = value;

109 Q_EMIT minSpeedChanged(value);

110 }

111}

112

113void DirectionalDragArea::setMaxSilenceTime(int value)

114{

115 if (m_maxSilenceTime != value) {

116 m_maxSilenceTime = value;

117 Q_EMIT maxSilenceTimeChanged(value);

118 }

119}

120

121void DirectionalDragArea::setRecognitionTimer(UbuntuGestures::AbstractTimer *timer)

122{

123 int interval = 0;

124 bool timerWasRunning = false;

125

126 // can be null when called from the constructor

127 if (m_recognitionTimer) {

128 interval = m_recognitionTimer->interval();

129 timerWasRunning = m_recognitionTimer->isRunning();

130 if (m_recognitionTimer->parent() == this) {

131 delete m_recognitionTimer;

132 }

133 }

134

135 m_recognitionTimer = timer;

136 timer->setInterval(interval);

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

138 this, &DirectionalDragArea::checkSpeed);

139 if (timerWasRunning) {

140 m_recognitionTimer->start();

141 }

142}

143

144void DirectionalDragArea::setAxisVelocityCalculator(AxisVelocityCalculator *newVelCalc)

145{

146 if (m_velocityCalculator->parent() == this)

147 delete m_velocityCalculator;

148

149 m_velocityCalculator = newVelCalc;

150}

151

152qreal DirectionalDragArea::distance() const

153{

154 if (directionIsHorizontal()) {

155 return m_previousPos.x() - m_startPos.x();

156 } else {

157 return m_previousPos.y() - m_startPos.y();

158 }

159}

160

161qreal DirectionalDragArea::touchX() const

162{

163 return m_previousPos.x();

164}

165

166qreal DirectionalDragArea::touchY() const

167{

168 return m_previousPos.y();

169}

170

171void DirectionalDragArea::touchEvent(QTouchEvent *event)

172{

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

174 QQuickItem::touchEvent(event);

175 return;

176 }

177

178 switch (m_status) {

179 case WaitingForTouch:

180 touchEvent_absent(event);

181 break;

182 case Undecided:

183 touchEvent_undecided(event);

184 break;

185 case Recognized:

186 touchEvent_recognized(event);

187 break;

188 default: // Rejected

189 touchEvent_rejected(event);

190 break;

191 }

192}

193

194void DirectionalDragArea::touchEvent_absent(QTouchEvent *event)

195{

196 if ((event->touchPointStates() && (Qt::TouchPointPressed || Qt::TouchPointMoved))

197 && event->touchPoints().count() == 1) {

198 m_startPos = event->touchPoints()[0].pos();

199 m_touchId = event->touchPoints()[0].id();

200 m_dampedPos.reset(m_startPos);

201 updateVelocityCalculator(m_startPos);

202 m_velocityCalculator->reset();

203 m_numSamplesOnLastSpeedCheck = 0;

204 m_silenceTime = 0;

205 setPreviousPos(m_startPos);

206 setStatus(Undecided);

207 }

208}

209

210void DirectionalDragArea::touchEvent_undecided(QTouchEvent *event)

211{

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

213 const QPointF &touchPos = touchPoint->pos();

214

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

216 // touch has ended before recognition concluded

217 setStatus(WaitingForTouch);

218 return;

219 }

220

221 if (event->touchPointStates().testFlag(Qt::TouchPointPressed)

222 || event->touchPoints().count() > 1) {

223 // multi-finger drags are not accepted

224 setStatus(Rejected);

225 return;

226 }

227

228 m_previousDampedPos.setX(m_dampedPos.x());

229 m_previousDampedPos.setY(m_dampedPos.y());

230 m_dampedPos.update(touchPos);

231 updateVelocityCalculator(touchPos);

232

233 if (!pointInsideAllowedArea()) {

234 setStatus(Rejected);

235 return;

236 }

237

238 if (!movingInRightDirection()) {

239 setStatus(Rejected);

240 return;

241 }

242

243 setPreviousPos(touchPos);

244

245 if (movedFarEnough(touchPos)) {

246 setStatus(Recognized);

247 }

248}

249

250void DirectionalDragArea::touchEvent_recognized(QTouchEvent *event)

251{

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

253

254 setPreviousPos(touchPoint->pos());

255

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

257 setStatus(WaitingForTouch);

258 }

259}

260

261void DirectionalDragArea::touchEvent_rejected(QTouchEvent *event)

262{

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

264

265 if (!touchPoint || touchPoint->state() == Qt::TouchPointReleased) {

266 setStatus(WaitingForTouch);

267 }

268}

269

270const QTouchEvent::TouchPoint *DirectionalDragArea::fetchTargetTouchPoint(QTouchEvent *event)

271{

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

273 const QTouchEvent::TouchPoint *touchPoint = 0;

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

275 if (touchPoints.at(i).id() == m_touchId) {

276 touchPoint = &touchPoints.at(i);

277 break;

278 }

279 }

280 return touchPoint;

281}

282

283bool DirectionalDragArea::pointInsideAllowedArea() const

284{

285 qreal dX = m_dampedPos.x() - m_startPos.x();

286 qreal dY = m_dampedPos.y() - m_startPos.y();

287

288 switch (m_direction) {

289 case Upwards:

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

291 case Downwards:

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

293 case Leftwards:

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

295 default: // Rightwards:

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

297 }

298}

299

300bool DirectionalDragArea::movingInRightDirection() const

301{

302 switch (m_direction) {

303 case Upwards:

304 return m_dampedPos.y() <= m_previousDampedPos.y();

305 case Downwards:

306 return m_dampedPos.y() >= m_previousDampedPos.y();

307 case Leftwards:

308 return m_dampedPos.x() <= m_previousDampedPos.x();

309 default: // Rightwards:

310 return m_dampedPos.x() >= m_previousDampedPos.x();

311 }

312}

313

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

315{

316 if (directionIsHorizontal())

317 return qFabs(point.x() - m_startPos.x()) > m_distanceThreshold;

318 else

319 return qFabs(point.y() - m_startPos.y()) > m_distanceThreshold;

320}

321

322void DirectionalDragArea::checkSpeed()

323{

324 if (m_velocityCalculator->numSamples() >= AxisVelocityCalculator::MIN_SAMPLES_NEEDED) {

325 qreal speed = qFabs(m_velocityCalculator->calculate());

326 qreal minSpeedMsecs = m_minSpeed / 1000.0;

327

328 if (speed < minSpeedMsecs) {

329 setStatus(Rejected);

330 }

331 }

332

333 if (m_velocityCalculator->numSamples() == m_numSamplesOnLastSpeedCheck) {

334 m_silenceTime += m_recognitionTimer->interval();

335

336 if (m_silenceTime > m_maxSilenceTime) {

337 setStatus(Rejected);

338 }

339 } else {

340 m_silenceTime = 0;

341 }

342 m_numSamplesOnLastSpeedCheck = m_velocityCalculator->numSamples();

343}

344

345void DirectionalDragArea::setStatus(DirectionalDragArea::Status newStatus)

346{

347 if (newStatus == m_status)

348 return;

349

350 DirectionalDragArea::Status oldStatus = m_status;

351

352 if (oldStatus == Undecided) {

353 m_recognitionTimer->stop();

354 }

355

356 m_status = newStatus;

357 Q_EMIT statusChanged(m_status);

358

359 switch (newStatus) {

360 case WaitingForTouch:

361 if (oldStatus != DirectionalDragArea::Rejected) {

362 Q_EMIT draggingChanged(false);

363 }

364 break;

365 case Undecided:

366 m_recognitionTimer->start();

367 Q_EMIT draggingChanged(true);

368 break;

369 case Rejected:

370 Q_EMIT draggingChanged(false);

371 break;

372 default:

373 // no-op

374 break;

375 }

376}

377

378void DirectionalDragArea::setPreviousPos(QPointF point)

379{

380 Q_ASSERT(m_status != Rejected);

381

382 bool xChanged = m_previousPos.x() != point.x();

383 bool yChanged = m_previousPos.y() != point.y();

384

385 m_previousPos = point;

386

387 if (xChanged) {

388 Q_EMIT touchXChanged(point.x());

389 if (directionIsHorizontal())

390 Q_EMIT distanceChanged(distance());

391 }

392

393 if (yChanged) {

394 Q_EMIT touchYChanged(point.y());

395 if (directionIsVertical())

396 Q_EMIT distanceChanged(distance());

397 }

398}

399

400void DirectionalDragArea::updateVelocityCalculator(QPointF point)

401{

402 if (directionIsHorizontal()) {

403 m_velocityCalculator->setTrackedPosition(point.x());

404 } else {

405 m_velocityCalculator->setTrackedPosition(point.y());

406 }

407}

408

409bool DirectionalDragArea::directionIsHorizontal() const

410{

411 return m_direction == Leftwards || m_direction == Rightwards;

412}

413

414bool DirectionalDragArea::directionIsVertical() const

415{

416 return m_direction == Upwards || m_direction == Downwards;

417}

418

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

420#include "DirectionalDragArea.moc"