12fdb5f · unity8 · git.iko.soy

git.iko.soy/unity8

on xenial help sign in

Make Ubuntu.Gestures components install TouchRegistry by themselves

12fdb5fDaniel d'Andrada11 years ago

libs/UbuntuGestures/CandidateInactivityTimer.cpp+7−2

compare with xenial

unifiedsplit

@@ -19,12 +19,12 @@

19namespace UbuntuGestures {

21CandidateInactivityTimer::CandidateInactivityTimer(int touchId, QQuickItem *candidate,

22− AbstractTimerFactory &timerFactory, QObject *parent)

22+ AbstractTimer *timer, QObject *parent)

23 : QObject(parent)

24+ , m_timer(timer)

24 , m_touchId(touchId)

25 , m_touchId(touchId)

25 , m_candidate(candidate)

26 , m_candidate(candidate)

26{

27{

27− m_timer = timerFactory.createTimer(this);

28 connect(m_timer, &AbstractTimer::timeout,

29 this, &CandidateInactivityTimer::onTimeout);

30 m_timer->setInterval(durationMs);

@@ -32,6 +32,11 @@ CandidateInactivityTimer::CandidateInactivityTimer(int touchId, QQuickItem *cand

32 m_timer->start();

33}

35+CandidateInactivityTimer::~CandidateInactivityTimer()

36+{

37+ delete m_timer;

38+}

39+

35void CandidateInactivityTimer::onTimeout()

40void CandidateInactivityTimer::onTimeout()

36{

41{

37 qWarning("[TouchRegistry] Candidate for touch %d defaulted!", m_touchId);

42 qWarning("[TouchRegistry] Candidate for touch %d defaulted!", m_touchId);

libs/UbuntuGestures/CandidateInactivityTimer.h+3−1

@@ -29,9 +29,11 @@ class UBUNTUGESTURES_EXPORT CandidateInactivityTimer : public QObject {

29 Q_OBJECT

30public:

31 CandidateInactivityTimer(int touchId, QQuickItem *candidate,

32− AbstractTimerFactory &timerFactory,

32+ AbstractTimer *timer,

33 QObject *parent = nullptr);

35+ virtual ~CandidateInactivityTimer();

36+

35 const int durationMs = 1000;

37 const int durationMs = 1000;

37Q_SIGNALS:

39Q_SIGNALS:

libs/UbuntuGestures/Timer.cpp−10

@@ -115,16 +115,6 @@ FakeTimerFactory::FakeTimerFactory()

115 m_timeSource.reset(new FakeTimeSource);

116}

117

118−FakeTimerFactory::~FakeTimerFactory()

119−{

120− for (int i = 0; i < timers.count(); ++i) {

121− FakeTimer *timer = timers[i].data();

122− if (timer) {

123− delete timer;

124− }

125− }

126−}

127−

128void FakeTimerFactory::updateTime(qint64 targetTime)

118void FakeTimerFactory::updateTime(qint64 targetTime)

129{

119{

130 qint64 minTimeoutTime = targetTime;

120 qint64 minTimeoutTime = targetTime;

libs/UbuntuGestures/Timer.h+1−1

@@ -101,7 +101,7 @@ class UBUNTUGESTURES_EXPORT FakeTimerFactory : public AbstractTimerFactory

101{

102public:

103 FakeTimerFactory();

104− virtual ~FakeTimerFactory();

104+ virtual ~FakeTimerFactory() {}

105

106 void updateTime(qint64 msecsSinceReference);

107 QSharedPointer<TimeSource> timeSource() { return m_timeSource; }

libs/UbuntuGestures/TouchRegistry.cpp+16−12

@@ -41,20 +41,10 @@ using namespace UbuntuGestures;

41TouchRegistry *TouchRegistry::m_instance = nullptr;

43TouchRegistry::TouchRegistry(QObject *parent)

44− : TouchRegistry(parent, new TimerFactory)

45−{

46−}

47−

48−TouchRegistry::TouchRegistry(QObject *parent, AbstractTimerFactory *timerFactory)

49 : QObject(parent)

44 : QObject(parent)

50 , m_inDispatchLoop(false)

45 , m_inDispatchLoop(false)

51− , m_timerFactory(timerFactory)

46+ , m_timerFactory(new TimerFactory)

52{

47{

53− if (m_instance == nullptr) {

54− m_instance = this;

55− } else {

56− qFatal("Cannot have more than one instance of TouchRegistry. It must be a singleton.");

57− }

58}

48}

60TouchRegistry::~TouchRegistry()

50TouchRegistry::~TouchRegistry()

@@ -64,6 +54,20 @@ TouchRegistry::~TouchRegistry()

64 delete m_timerFactory;

54 delete m_timerFactory;

65}

55}

57+TouchRegistry *TouchRegistry::instance()

58+{

59+ if (m_instance == nullptr) {

60+ m_instance = new TouchRegistry;

61+ }

62+ return m_instance;

63+}

64+

65+void TouchRegistry::setTimerFactory(AbstractTimerFactory *timerFactory)

66+{

67+ delete m_timerFactory;

68+ m_timerFactory = timerFactory;

69+}

70+

67void TouchRegistry::update(const QTouchEvent *event)

71void TouchRegistry::update(const QTouchEvent *event)

68{

72{

69 #if TOUCHREGISTRY_DEBUG

73 #if TOUCHREGISTRY_DEBUG

@@ -261,7 +265,7 @@ void TouchRegistry::addCandidateOwnerForTouch(int id, QQuickItem *candidate)

261 candidateInfo.state = CandidateInfo::Undecided;

265 candidateInfo.state = CandidateInfo::Undecided;

262 candidateInfo.item = candidate;

266 candidateInfo.item = candidate;

263 candidateInfo.inactivityTimer = new CandidateInactivityTimer(id, candidate,

267 candidateInfo.inactivityTimer = new CandidateInactivityTimer(id, candidate,

264− *m_timerFactory,

268+ m_timerFactory->createTimer(),

265 this);

269 this);

266 connect(candidateInfo.inactivityTimer, &CandidateInactivityTimer::candidateDefaulted,

270 connect(candidateInfo.inactivityTimer, &CandidateInactivityTimer::candidateDefaulted,

267 this, &TouchRegistry::rejectCandidateOwnerForTouch);

271 this, &TouchRegistry::rejectCandidateOwnerForTouch);

libs/UbuntuGestures/TouchRegistry.h+8−6

@@ -25,6 +25,7 @@

26#include "UbuntuGesturesGlobal.h"

27#include "CandidateInactivityTimer.h"

28+#include "Timer.h"

28#include "Pool.h"

29#include "Pool.h"

30namespace UbuntuGestures {

31namespace UbuntuGestures {

@@ -93,15 +94,10 @@ class UBUNTUGESTURES_EXPORT TouchRegistry : public QObject

93{

94{

94 Q_OBJECT

95 Q_OBJECT

95public:

96public:

96− TouchRegistry(QObject *parent = nullptr);

97− // Useful for tests, where you should feed a fake timer

98− TouchRegistry(QObject *parent, UbuntuGestures::AbstractTimerFactory *timerFactory);

99−

100 virtual ~TouchRegistry();

97 virtual ~TouchRegistry();

101

102 // Returns a pointer to the application's TouchRegistry instance.

99 // Returns a pointer to the application's TouchRegistry instance.

103− // If no instance has been allocated, null is returned.

104− static TouchRegistry *instance() { return m_instance; }

100+ static TouchRegistry *instance();

105

101

106 void update(const QTouchEvent *event);

102 void update(const QTouchEvent *event);

107

103

@@ -128,10 +124,16 @@ public:

128 // but would nonetheless like to be kept up-to-date on its state.

124 // but would nonetheless like to be kept up-to-date on its state.

129 void addTouchWatcher(int touchId, QQuickItem *watcherItem);

125 void addTouchWatcher(int touchId, QQuickItem *watcherItem);

130

126

127+ // Useful for tests, where you should use fake timers

128+ void setTimerFactory(UbuntuGestures::AbstractTimerFactory *timerFactory);

129+

131private Q_SLOTS:

130private Q_SLOTS:

132 void rejectCandidateOwnerForTouch(int id, QQuickItem *candidate);

131 void rejectCandidateOwnerForTouch(int id, QQuickItem *candidate);

133

132

134private:

133private:

134+ // Only instance() can cronstruct one

135+ TouchRegistry(QObject *parent = nullptr);

136+

135 class CandidateInfo {

137 class CandidateInfo {

136 public:

138 public:

137 enum {

139 enum {

plugins/Ubuntu/Gestures/DirectionalDragArea.cpp+2

@@ -712,6 +712,8 @@ void DirectionalDragArea::itemChange(ItemChange change, const ItemChangeData &va

712{

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

714 if (value.window != nullptr) {

715+ value.window->installEventFilter(TouchRegistry::instance());

716+

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

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

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

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

717 d->setPixelsPerMm(pixelsPerMm);

719 d->setPixelsPerMm(pixelsPerMm);

plugins/Ubuntu/Gestures/TouchGate.cpp+10

@@ -18,6 +18,7 @@

19#include <QCoreApplication>

20#include <QDebug>

21+#include <QQuickWindow>

22#include <TouchOwnershipEvent.h>

23#include <TouchOwnershipEvent.h>

23#include <TouchRegistry.h>

24#include <TouchRegistry.h>

@@ -102,6 +103,15 @@ void TouchGate::touchEvent(QTouchEvent *event)

102 }

103 }

103}

104}

104

105

106+void TouchGate::itemChange(ItemChange change, const ItemChangeData &value)

107+{

108+ if (change == QQuickItem::ItemSceneChange) {

109+ if (value.window != nullptr) {

110+ value.window->installEventFilter(TouchRegistry::instance());

111+ }

112+ }

113+}

114+

105void TouchGate::touchOwnershipEvent(TouchOwnershipEvent *event)

115void TouchGate::touchOwnershipEvent(TouchOwnershipEvent *event)

106{

116{

107 // TODO: Optimization: batch those actions as TouchOwnershipEvents

117 // TODO: Optimization: batch those actions as TouchOwnershipEvents

plugins/Ubuntu/Gestures/TouchGate.h+1

@@ -57,6 +57,7 @@ Q_SIGNALS:

58protected:

59 void touchEvent(QTouchEvent *event) override;

60+ void itemChange(ItemChange change, const ItemChangeData &value) override;

61private Q_SLOTS:

62private Q_SLOTS:

62 void onEnabledChanged();

63 void onEnabledChanged();

src/Dash/main.cpp−6

@@ -31,9 +31,6 @@

31#include "../ApplicationArguments.h"

32#include "../CachingNetworkManagerFactory.h"

34−// Ubuntu Gestures

35−#include <TouchRegistry.h>

36−

37int main(int argc, const char *argv[])

34int main(int argc, const char *argv[])

38{

35{

39 QGuiApplication *application = new QGuiApplication(argc, (char**)argv);

36 QGuiApplication *application = new QGuiApplication(argc, (char**)argv);

@@ -91,9 +88,6 @@ int main(int argc, const char *argv[])

91 view->setTitle("Scopes");

88 view->setTitle("Scopes");

92 view->rootContext()->setContextProperty("applicationArguments", &qmlArgs);

89 view->rootContext()->setContextProperty("applicationArguments", &qmlArgs);

94− TouchRegistry touchRegistry;

95− view->installEventFilter(&touchRegistry);

96−

97 // You will need this if you want to interact with touch-only components using a mouse

91 // You will need this if you want to interact with touch-only components using a mouse

98 // Needed only when manually testing on a desktop.

92 // Needed only when manually testing on a desktop.

99 MouseTouchAdaptor *mouseTouchAdaptor = 0;

93 MouseTouchAdaptor *mouseTouchAdaptor = 0;

src/main.cpp−5

@@ -32,9 +32,6 @@

32#include "CachingNetworkManagerFactory.h"

33#include "UnityCommandLineParser.h"

35−// Ubuntu Gestures

36−#include <TouchRegistry.h>

37−

38int main(int argc, const char *argv[])

35int main(int argc, const char *argv[])

39{

36{

40 bool isMirServer = false;

37 bool isMirServer = false;

@@ -89,8 +86,6 @@ int main(int argc, const char *argv[])

89 if (parser.hasFrameless()) {

86 if (parser.hasFrameless()) {

90 view->setFlags(Qt::FramelessWindowHint);

87 view->setFlags(Qt::FramelessWindowHint);

91 }

88 }

92− TouchRegistry touchRegistry;

93− view->installEventFilter(&touchRegistry);

95 // You will need this if you want to interact with touch-only components using a mouse

90 // You will need this if you want to interact with touch-only components using a mouse

96 // Needed only when manually testing on a desktop.

91 // Needed only when manually testing on a desktop.

tests/libs/UbuntuGestures/tst_TouchRegistry.cpp+75−76

@@ -53,8 +53,8 @@ private Q_SLOTS:

53 void initTestCase() {} // will be called before the first test function is executed

54 void cleanupTestCase() {} // will be called after the last test function was executed.

56− void init() {} // called right before each and every test function is executed

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

57− void cleanup() {} // called right after each and every test function is executed

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

59 void requestWithNoCandidates();

60 void lateCandidateRequestGetsNothing();

@@ -67,11 +67,23 @@ private Q_SLOTS:

67 void rejectingTouchfterItsEnd();

68 void removeOldUndecidedCandidates();

69 void interimOwnerWontGetUnownedTouchEvents();

70+

71+private:

72+ TouchRegistry *touchRegistry;

70};

73};

75+void tst_TouchRegistry::init()

76+{

77+ touchRegistry = TouchRegistry::instance();

78+}

79+

80+void tst_TouchRegistry::cleanup()

81+{

82+ delete touchRegistry;

83+}

84+

72void tst_TouchRegistry::requestWithNoCandidates()

85void tst_TouchRegistry::requestWithNoCandidates()

73{

86{

74− TouchRegistry touchRegistry;

75 DummyCandidate candidate;

87 DummyCandidate candidate;

77 {

89 {

@@ -83,17 +95,16 @@ void tst_TouchRegistry::requestWithNoCandidates()

83 Qt::NoModifier,

95 Qt::NoModifier,

84 Qt::TouchPointPressed,

96 Qt::TouchPointPressed,

85 touchPoints);

97 touchPoints);

86− touchRegistry.update(&touchEvent);

98+ touchRegistry->update(&touchEvent);

87 }

99 }

100

89− touchRegistry.requestTouchOwnership(0, &candidate);

101+ touchRegistry->requestTouchOwnership(0, &candidate);

102

91 QVERIFY(candidate.ownedTouches.contains(0));

103 QVERIFY(candidate.ownedTouches.contains(0));

92}

104}

105

94void tst_TouchRegistry::lateCandidateRequestGetsNothing()

106void tst_TouchRegistry::lateCandidateRequestGetsNothing()

95{

107{

96− TouchRegistry touchRegistry;

97 DummyCandidate earlyCandidate;

108 DummyCandidate earlyCandidate;

98 earlyCandidate.setObjectName("early");

109 earlyCandidate.setObjectName("early");

99 DummyCandidate lateCandidate;

110 DummyCandidate lateCandidate;

@@ -108,21 +119,21 @@ void tst_TouchRegistry::lateCandidateRequestGetsNothing()

108 Qt::NoModifier,

119 Qt::NoModifier,

109 Qt::TouchPointPressed,

120 Qt::TouchPointPressed,

110 touchPoints);

121 touchPoints);

111− touchRegistry.update(&touchEvent);

122+ touchRegistry->update(&touchEvent);

112 }

123 }

113

124

114− touchRegistry.addCandidateOwnerForTouch(0, &earlyCandidate);

125+ touchRegistry->addCandidateOwnerForTouch(0, &earlyCandidate);

115− touchRegistry.addCandidateOwnerForTouch(0, &lateCandidate);

126+ touchRegistry->addCandidateOwnerForTouch(0, &lateCandidate);

116

127

117 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

128 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

118 QVERIFY(lateCandidate.ownedTouches.isEmpty());

129 QVERIFY(lateCandidate.ownedTouches.isEmpty());

119

130

120− touchRegistry.requestTouchOwnership(0, &lateCandidate);

131+ touchRegistry->requestTouchOwnership(0, &lateCandidate);

121

132

122 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

133 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

123 QVERIFY(lateCandidate.ownedTouches.isEmpty());

134 QVERIFY(lateCandidate.ownedTouches.isEmpty());

124

135

125− touchRegistry.requestTouchOwnership(0, &earlyCandidate);

136+ touchRegistry->requestTouchOwnership(0, &earlyCandidate);

126

137

127 QVERIFY(earlyCandidate.ownedTouches.contains(0));

138 QVERIFY(earlyCandidate.ownedTouches.contains(0));

128 QVERIFY(lateCandidate.ownedTouches.isEmpty());

139 QVERIFY(lateCandidate.ownedTouches.isEmpty());

@@ -130,7 +141,6 @@ void tst_TouchRegistry::lateCandidateRequestGetsNothing()

130

141

131void tst_TouchRegistry::lateCandidateGestOwnershipOnceEarlyCandidateQuits()

142void tst_TouchRegistry::lateCandidateGestOwnershipOnceEarlyCandidateQuits()

132{

143{

133− TouchRegistry touchRegistry;

134 DummyCandidate earlyCandidate;

144 DummyCandidate earlyCandidate;

135 DummyCandidate lateCandidate;

145 DummyCandidate lateCandidate;

136

146

@@ -143,21 +153,21 @@ void tst_TouchRegistry::lateCandidateGestOwnershipOnceEarlyCandidateQuits()

143 Qt::NoModifier,

153 Qt::NoModifier,

144 Qt::TouchPointPressed,

154 Qt::TouchPointPressed,

145 touchPoints);

155 touchPoints);

146− touchRegistry.update(&touchEvent);

156+ touchRegistry->update(&touchEvent);

147 }

157 }

148

158

149− touchRegistry.addCandidateOwnerForTouch(0, &earlyCandidate);

159+ touchRegistry->addCandidateOwnerForTouch(0, &earlyCandidate);

150− touchRegistry.addCandidateOwnerForTouch(0, &lateCandidate);

160+ touchRegistry->addCandidateOwnerForTouch(0, &lateCandidate);

151

161

152 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

162 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

153 QVERIFY(lateCandidate.ownedTouches.isEmpty());

163 QVERIFY(lateCandidate.ownedTouches.isEmpty());

154

164

155− touchRegistry.requestTouchOwnership(0, &lateCandidate);

165+ touchRegistry->requestTouchOwnership(0, &lateCandidate);

156

166

157 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

167 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

158 QVERIFY(lateCandidate.ownedTouches.isEmpty());

168 QVERIFY(lateCandidate.ownedTouches.isEmpty());

159

169

160− touchRegistry.removeCandidateOwnerForTouch(0, &earlyCandidate);

170+ touchRegistry->removeCandidateOwnerForTouch(0, &earlyCandidate);

161

171

162 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

172 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

163 QVERIFY(lateCandidate.ownedTouches.contains(0));

173 QVERIFY(lateCandidate.ownedTouches.contains(0));

@@ -165,7 +175,6 @@ void tst_TouchRegistry::lateCandidateGestOwnershipOnceEarlyCandidateQuits()

165

175

166void tst_TouchRegistry::dispatchesTouchEventsToCandidates()

176void tst_TouchRegistry::dispatchesTouchEventsToCandidates()

167{

177{

168− TouchRegistry touchRegistry;

169 QQuickItem rootItem;

178 QQuickItem rootItem;

170

179

171 DummyCandidate candidate0;

180 DummyCandidate candidate0;

@@ -190,10 +199,10 @@ void tst_TouchRegistry::dispatchesTouchEventsToCandidates()

190 Qt::NoModifier,

199 Qt::NoModifier,

191 Qt::TouchPointPressed,

200 Qt::TouchPointPressed,

192 touchPoints);

201 touchPoints);

193− touchRegistry.update(&touchEvent);

202+ touchRegistry->update(&touchEvent);

194 }

203 }

195

204

196− touchRegistry.addCandidateOwnerForTouch(0, &candidate0);

205+ touchRegistry->addCandidateOwnerForTouch(0, &candidate0);

197

206

198 {

207 {

199 QList<QTouchEvent::TouchPoint> touchPoints;

208 QList<QTouchEvent::TouchPoint> touchPoints;

@@ -208,7 +217,7 @@ void tst_TouchRegistry::dispatchesTouchEventsToCandidates()

208 Qt::NoModifier,

217 Qt::NoModifier,

209 Qt::TouchPointPressed | Qt::TouchPointMoved,

218 Qt::TouchPointPressed | Qt::TouchPointMoved,

210 touchPoints);

219 touchPoints);

211− touchRegistry.update(&touchEvent);

220+ touchRegistry->update(&touchEvent);

212 }

221 }

213

222

214 // candidate0 should have received an update on the touch he's interested on.

223 // candidate0 should have received an update on the touch he's interested on.

@@ -220,7 +229,7 @@ void tst_TouchRegistry::dispatchesTouchEventsToCandidates()

220 QCOMPARE(candidate0.unownedTouchEvents[0].touchPoints[0].rect().x(), 11 - candidate0.x());

229 QCOMPARE(candidate0.unownedTouchEvents[0].touchPoints[0].rect().x(), 11 - candidate0.x());

221 QCOMPARE(candidate0.unownedTouchEvents[0].touchPoints[0].rect().y(), 11 - candidate0.y());

230 QCOMPARE(candidate0.unownedTouchEvents[0].touchPoints[0].rect().y(), 11 - candidate0.y());

222

231

223− touchRegistry.addCandidateOwnerForTouch(1, &candidate1);

232+ touchRegistry->addCandidateOwnerForTouch(1, &candidate1);

224

233

225 {

234 {

226 QList<QTouchEvent::TouchPoint> touchPoints;

235 QList<QTouchEvent::TouchPoint> touchPoints;

@@ -235,7 +244,7 @@ void tst_TouchRegistry::dispatchesTouchEventsToCandidates()

235 Qt::NoModifier,

244 Qt::NoModifier,

236 Qt::TouchPointPressed | Qt::TouchPointMoved,

245 Qt::TouchPointPressed | Qt::TouchPointMoved,

237 touchPoints);

246 touchPoints);

238− touchRegistry.update(&touchEvent);

247+ touchRegistry->update(&touchEvent);

239 }

248 }

240

249

241 // candidate0 gets updates only for touch 0 and

250 // candidate0 gets updates only for touch 0 and

@@ -252,7 +261,6 @@ void tst_TouchRegistry::dispatchesTouchEventsToCandidates()

252

261

253void tst_TouchRegistry::dispatchesTouchEventsToWatchers()

262void tst_TouchRegistry::dispatchesTouchEventsToWatchers()

254{

263{

255− TouchRegistry touchRegistry;

256 QQuickItem rootItem;

264 QQuickItem rootItem;

257

265

258 DummyCandidate watcher;

266 DummyCandidate watcher;

@@ -271,10 +279,10 @@ void tst_TouchRegistry::dispatchesTouchEventsToWatchers()

271 Qt::NoModifier,

279 Qt::NoModifier,

272 Qt::TouchPointPressed,

280 Qt::TouchPointPressed,

273 touchPoints);

281 touchPoints);

274− touchRegistry.update(&touchEvent);

282+ touchRegistry->update(&touchEvent);

275 }

283 }

276

284

277− touchRegistry.addTouchWatcher(0, &watcher);

285+ touchRegistry->addTouchWatcher(0, &watcher);

278

286

279 {

287 {

280 QList<QTouchEvent::TouchPoint> touchPoints;

288 QList<QTouchEvent::TouchPoint> touchPoints;

@@ -289,7 +297,7 @@ void tst_TouchRegistry::dispatchesTouchEventsToWatchers()

289 Qt::NoModifier,

297 Qt::NoModifier,

290 Qt::TouchPointPressed | Qt::TouchPointMoved,

298 Qt::TouchPointPressed | Qt::TouchPointMoved,

291 touchPoints);

299 touchPoints);

292− touchRegistry.update(&touchEvent);

300+ touchRegistry->update(&touchEvent);

293 }

301 }

294

302

295 // watcher should have received an update on the touch he's interested on.

303 // watcher should have received an update on the touch he's interested on.

@@ -314,7 +322,7 @@ void tst_TouchRegistry::dispatchesTouchEventsToWatchers()

314 Qt::NoModifier,

322 Qt::NoModifier,

315 Qt::TouchPointPressed | Qt::TouchPointMoved,

323 Qt::TouchPointPressed | Qt::TouchPointMoved,

316 touchPoints);

324 touchPoints);

317− touchRegistry.update(&touchEvent);

325+ touchRegistry->update(&touchEvent);

318 }

326 }

319

327

320 // watcher gets updates only for touch 0

328 // watcher gets updates only for touch 0

@@ -326,7 +334,6 @@ void tst_TouchRegistry::dispatchesTouchEventsToWatchers()

326

334

327void tst_TouchRegistry::keepDispatchingToWatchersAfterLastCandidateGivesUp()

335void tst_TouchRegistry::keepDispatchingToWatchersAfterLastCandidateGivesUp()

328{

336{

329− TouchRegistry touchRegistry;

330 DummyCandidate item;

337 DummyCandidate item;

331

338

332 {

339 {

@@ -338,10 +345,10 @@ void tst_TouchRegistry::keepDispatchingToWatchersAfterLastCandidateGivesUp()

338 Qt::NoModifier,

345 Qt::NoModifier,

339 Qt::TouchPointPressed,

346 Qt::TouchPointPressed,

340 touchPoints);

347 touchPoints);

341− touchRegistry.update(&touchEvent);

348+ touchRegistry->update(&touchEvent);

342 }

349 }

343

350

344− touchRegistry.addCandidateOwnerForTouch(0, &item);

351+ touchRegistry->addCandidateOwnerForTouch(0, &item);

345

352

346 {

353 {

347 QList<QTouchEvent::TouchPoint> touchPoints;

354 QList<QTouchEvent::TouchPoint> touchPoints;

@@ -354,7 +361,7 @@ void tst_TouchRegistry::keepDispatchingToWatchersAfterLastCandidateGivesUp()

354 Qt::NoModifier,

361 Qt::NoModifier,

355 Qt::TouchPointPressed | Qt::TouchPointMoved,

362 Qt::TouchPointPressed | Qt::TouchPointMoved,

356 touchPoints);

363 touchPoints);

357− touchRegistry.update(&touchEvent);

364+ touchRegistry->update(&touchEvent);

358 }

365 }

359

366

360 QCOMPARE(item.unownedTouchEvents.count(), 1);

367 QCOMPARE(item.unownedTouchEvents.count(), 1);

@@ -362,7 +369,7 @@ void tst_TouchRegistry::keepDispatchingToWatchersAfterLastCandidateGivesUp()

362 QCOMPARE(item.unownedTouchEvents[0].touchPoints[0].id(), 0);

369 QCOMPARE(item.unownedTouchEvents[0].touchPoints[0].id(), 0);

363 item.unownedTouchEvents.clear();

370 item.unownedTouchEvents.clear();

364

371

365− touchRegistry.addTouchWatcher(1, &item);

372+ touchRegistry->addTouchWatcher(1, &item);

366

373

367 {

374 {

368 QList<QTouchEvent::TouchPoint> touchPoints;

375 QList<QTouchEvent::TouchPoint> touchPoints;

@@ -375,7 +382,7 @@ void tst_TouchRegistry::keepDispatchingToWatchersAfterLastCandidateGivesUp()

375 Qt::NoModifier,

382 Qt::NoModifier,

376 Qt::TouchPointMoved,

383 Qt::TouchPointMoved,

377 touchPoints);

384 touchPoints);

378− touchRegistry.update(&touchEvent);

385+ touchRegistry->update(&touchEvent);

379 }

386 }

380

387

381 QCOMPARE(item.unownedTouchEvents.count(), 1);

388 QCOMPARE(item.unownedTouchEvents.count(), 1);

@@ -395,7 +402,7 @@ void tst_TouchRegistry::keepDispatchingToWatchersAfterLastCandidateGivesUp()

395 Qt::NoModifier,

402 Qt::NoModifier,

396 Qt::TouchPointReleased | Qt::TouchPointMoved,

403 Qt::TouchPointReleased | Qt::TouchPointMoved,

397 touchPoints);

404 touchPoints);

398− touchRegistry.update(&touchEvent);

405+ touchRegistry->update(&touchEvent);

399 }

406 }

400

407

401 QCOMPARE(item.unownedTouchEvents.count(), 1);

408 QCOMPARE(item.unownedTouchEvents.count(), 1);

@@ -404,7 +411,7 @@ void tst_TouchRegistry::keepDispatchingToWatchersAfterLastCandidateGivesUp()

404 QVERIFY(item.unownedTouchEvents[0].containsTouchWithId(1));

411 QVERIFY(item.unownedTouchEvents[0].containsTouchWithId(1));

405 item.unownedTouchEvents.clear();

412 item.unownedTouchEvents.clear();

406

413

407− touchRegistry.removeCandidateOwnerForTouch(0, &item);

414+ touchRegistry->removeCandidateOwnerForTouch(0, &item);

408

415

409 {

416 {

410 QList<QTouchEvent::TouchPoint> touchPoints;

417 QList<QTouchEvent::TouchPoint> touchPoints;

@@ -415,7 +422,7 @@ void tst_TouchRegistry::keepDispatchingToWatchersAfterLastCandidateGivesUp()

415 Qt::NoModifier,

422 Qt::NoModifier,

416 Qt::TouchPointReleased,

423 Qt::TouchPointReleased,

417 touchPoints);

424 touchPoints);

418− touchRegistry.update(&touchEvent);

425+ touchRegistry->update(&touchEvent);

419 }

426 }

420

427

421 QCOMPARE(item.unownedTouchEvents.count(), 1);

428 QCOMPARE(item.unownedTouchEvents.count(), 1);

@@ -423,7 +430,7 @@ void tst_TouchRegistry::keepDispatchingToWatchersAfterLastCandidateGivesUp()

423 QVERIFY(item.unownedTouchEvents[0].containsTouchWithId(1));

430 QVERIFY(item.unownedTouchEvents[0].containsTouchWithId(1));

424 item.unownedTouchEvents.clear();

431 item.unownedTouchEvents.clear();

425

432

426− QVERIFY(touchRegistry.m_touchInfoPool.isEmpty());

433+ QVERIFY(touchRegistry->m_touchInfoPool.isEmpty());

427}

434}

428

435

429/*

436/*

@@ -432,7 +439,6 @@ void tst_TouchRegistry::keepDispatchingToWatchersAfterLastCandidateGivesUp()

432 */

439 */

433void tst_TouchRegistry::candidatesAndWatchers_1()

440void tst_TouchRegistry::candidatesAndWatchers_1()

434{

441{

435− TouchRegistry touchRegistry;

436 DummyCandidate item;

442 DummyCandidate item;

437

443

438 {

444 {

@@ -444,10 +450,10 @@ void tst_TouchRegistry::candidatesAndWatchers_1()

444 Qt::NoModifier,

450 Qt::NoModifier,

445 Qt::TouchPointPressed,

451 Qt::TouchPointPressed,

446 touchPoints);

452 touchPoints);

447− touchRegistry.update(&touchEvent);

453+ touchRegistry->update(&touchEvent);

448 }

454 }

449

455

450− touchRegistry.addCandidateOwnerForTouch(0, &item);

456+ touchRegistry->addCandidateOwnerForTouch(0, &item);

451

457

452 {

458 {

453 QList<QTouchEvent::TouchPoint> touchPoints;

459 QList<QTouchEvent::TouchPoint> touchPoints;

@@ -460,14 +466,14 @@ void tst_TouchRegistry::candidatesAndWatchers_1()

460 Qt::NoModifier,

466 Qt::NoModifier,

461 Qt::TouchPointPressed | Qt::TouchPointMoved,

467 Qt::TouchPointPressed | Qt::TouchPointMoved,

462 touchPoints);

468 touchPoints);

463− touchRegistry.update(&touchEvent);

469+ touchRegistry->update(&touchEvent);

464 }

470 }

465

471

466− touchRegistry.addTouchWatcher(1, &item);

472+ touchRegistry->addTouchWatcher(1, &item);

467

473

468− touchRegistry.removeCandidateOwnerForTouch(0, &item);

474+ touchRegistry->removeCandidateOwnerForTouch(0, &item);

469

475

470− touchRegistry.addTouchWatcher(0, &item);

476+ touchRegistry->addTouchWatcher(0, &item);

471

477

472 {

478 {

473 QList<QTouchEvent::TouchPoint> touchPoints;

479 QList<QTouchEvent::TouchPoint> touchPoints;

@@ -480,7 +486,7 @@ void tst_TouchRegistry::candidatesAndWatchers_1()

480 Qt::NoModifier,

486 Qt::NoModifier,

481 Qt::TouchPointReleased | Qt::TouchPointMoved,

487 Qt::TouchPointReleased | Qt::TouchPointMoved,

482 touchPoints);

488 touchPoints);

483− touchRegistry.update(&touchEvent);

489+ touchRegistry->update(&touchEvent);

484 }

490 }

485

491

486 {

492 {

@@ -492,10 +498,10 @@ void tst_TouchRegistry::candidatesAndWatchers_1()

492 Qt::NoModifier,

498 Qt::NoModifier,

493 Qt::TouchPointReleased,

499 Qt::TouchPointReleased,

494 touchPoints);

500 touchPoints);

495− touchRegistry.update(&touchEvent);

501+ touchRegistry->update(&touchEvent);

496 }

502 }

497

503

498− QVERIFY(touchRegistry.m_touchInfoPool.isEmpty());

504+ QVERIFY(touchRegistry->m_touchInfoPool.isEmpty());

499

505

500 item.unownedTouchEvents.clear();

506 item.unownedTouchEvents.clear();

501

507

@@ -508,7 +514,7 @@ void tst_TouchRegistry::candidatesAndWatchers_1()

508 Qt::NoModifier,

514 Qt::NoModifier,

509 Qt::TouchPointPressed,

515 Qt::TouchPointPressed,

510 touchPoints);

516 touchPoints);

511− touchRegistry.update(&touchEvent);

517+ touchRegistry->update(&touchEvent);

512 }

518 }

513

519

514 // Haven't made any subscription for that new touch 0.

520 // Haven't made any subscription for that new touch 0.

@@ -521,8 +527,6 @@ void tst_TouchRegistry::candidatesAndWatchers_1()

521 */

527 */

522void tst_TouchRegistry::candidatesAndWatchers_2()

528void tst_TouchRegistry::candidatesAndWatchers_2()

523{

529{

524− TouchRegistry touchRegistry;

525−

526 DummyCandidate directionalDragArea;

530 DummyCandidate directionalDragArea;

527 directionalDragArea.setObjectName("DirectionalDragArea");

531 directionalDragArea.setObjectName("DirectionalDragArea");

528

532

@@ -539,14 +543,14 @@ void tst_TouchRegistry::candidatesAndWatchers_2()

539 Qt::NoModifier,

543 Qt::NoModifier,

540 Qt::TouchPointPressed,

544 Qt::TouchPointPressed,

541 touchPoints);

545 touchPoints);

542− touchRegistry.update(&touchEvent);

546+ touchRegistry->update(&touchEvent);

543 }

547 }

544

548

545 // [TouchRegistry] addCandidateOwnerForTouch id 0 candidate DirectionalDragArea

549 // [TouchRegistry] addCandidateOwnerForTouch id 0 candidate DirectionalDragArea

546− touchRegistry.addCandidateOwnerForTouch(0, &directionalDragArea);

550+ touchRegistry->addCandidateOwnerForTouch(0, &directionalDragArea);

547

551

548 // [TouchRegistry] requestTouchOwnership id 0 candidate TouchGate

552 // [TouchRegistry] requestTouchOwnership id 0 candidate TouchGate

549− touchRegistry.requestTouchOwnership(0, &touchGate);

553+ touchRegistry->requestTouchOwnership(0, &touchGate);

550

554

551 //[TouchRegistry] got TouchUpdate (id:0, state:moved, scenePos:(147,1023)) (id:1, state:pressed, scenePos:(327,792))

555 //[TouchRegistry] got TouchUpdate (id:0, state:moved, scenePos:(147,1023)) (id:1, state:pressed, scenePos:(327,792))

552 {

556 {

@@ -560,24 +564,24 @@ void tst_TouchRegistry::candidatesAndWatchers_2()

560 Qt::NoModifier,

564 Qt::NoModifier,

561 Qt::TouchPointPressed | Qt::TouchPointMoved,

565 Qt::TouchPointPressed | Qt::TouchPointMoved,

562 touchPoints);

566 touchPoints);

563− touchRegistry.update(&touchEvent);

567+ touchRegistry->update(&touchEvent);

564 }

568 }

565

569

566 // [TouchRegistry] addTouchWatcher id 1 watcher DirectionalDragArea

570 // [TouchRegistry] addTouchWatcher id 1 watcher DirectionalDragArea

567− touchRegistry.addTouchWatcher(1, &directionalDragArea);

571+ touchRegistry->addTouchWatcher(1, &directionalDragArea);

568

572

569 // [TouchRegistry] removeCandidateOwnerForTouch id 0 candidate DirectionalDragArea

573 // [TouchRegistry] removeCandidateOwnerForTouch id 0 candidate DirectionalDragArea

570− touchRegistry.removeCandidateOwnerForTouch(0, &directionalDragArea);

574+ touchRegistry->removeCandidateOwnerForTouch(0, &directionalDragArea);

571

575

572 //[TouchRegistry] sending TouchWonershipEvent(id = 0 gained) to candidate TouchGate

576 //[TouchRegistry] sending TouchWonershipEvent(id = 0 gained) to candidate TouchGate

573 QCOMPARE(touchGate.ownedTouches.count(), 1);

577 QCOMPARE(touchGate.ownedTouches.count(), 1);

574 QVERIFY(touchGate.ownedTouches.contains(0));

578 QVERIFY(touchGate.ownedTouches.contains(0));

575

579

576 // [TouchRegistry] addTouchWatcher id 0 watcher DirectionalDragArea

580 // [TouchRegistry] addTouchWatcher id 0 watcher DirectionalDragArea

577− touchRegistry.addTouchWatcher(0, &directionalDragArea);

581+ touchRegistry->addTouchWatcher(0, &directionalDragArea);

578

582

579 // [TouchRegistry] requestTouchOwnership id 1 candidate TouchGate

583 // [TouchRegistry] requestTouchOwnership id 1 candidate TouchGate

580− touchRegistry.requestTouchOwnership(1, &touchGate);

584+ touchRegistry->requestTouchOwnership(1, &touchGate);

581

585

582 //[TouchRegistry] sending TouchWonershipEvent(id = 1 gained) to candidate TouchGate

586 //[TouchRegistry] sending TouchWonershipEvent(id = 1 gained) to candidate TouchGate

583 QCOMPARE(touchGate.ownedTouches.count(), 2);

587 QCOMPARE(touchGate.ownedTouches.count(), 2);

@@ -598,7 +602,7 @@ void tst_TouchRegistry::candidatesAndWatchers_2()

598 Qt::NoModifier,

602 Qt::NoModifier,

599 Qt::TouchPointMoved,

603 Qt::TouchPointMoved,

600 touchPoints);

604 touchPoints);

601− touchRegistry.update(&touchEvent);

605+ touchRegistry->update(&touchEvent);

602 }

606 }

603

607

604 //vvvvv DDA Watchers are being ignored from now on vvvvvvv

608 //vvvvv DDA Watchers are being ignored from now on vvvvvvv

@@ -624,7 +628,7 @@ void tst_TouchRegistry::candidatesAndWatchers_2()

624 Qt::NoModifier,

628 Qt::NoModifier,

625 Qt::TouchPointMoved | Qt::TouchPointReleased,

629 Qt::TouchPointMoved | Qt::TouchPointReleased,

626 touchPoints);

630 touchPoints);

627− touchRegistry.update(&touchEvent);

631+ touchRegistry->update(&touchEvent);

628 }

632 }

629

633

630 QCOMPARE(directionalDragArea.unownedTouchEvents.count(), 1);

634 QCOMPARE(directionalDragArea.unownedTouchEvents.count(), 1);

@@ -646,7 +650,7 @@ void tst_TouchRegistry::candidatesAndWatchers_2()

646 Qt::NoModifier,

650 Qt::NoModifier,

647 Qt::TouchPointReleased,

651 Qt::TouchPointReleased,

648 touchPoints);

652 touchPoints);

649− touchRegistry.update(&touchEvent);

653+ touchRegistry->update(&touchEvent);

650 }

654 }

651

655

652 QCOMPARE(directionalDragArea.unownedTouchEvents.count(), 1);

656 QCOMPARE(directionalDragArea.unownedTouchEvents.count(), 1);

@@ -658,7 +662,6 @@ void tst_TouchRegistry::candidatesAndWatchers_2()

658

662

659void tst_TouchRegistry::rejectingTouchfterItsEnd()

663void tst_TouchRegistry::rejectingTouchfterItsEnd()

660{

664{

661− TouchRegistry touchRegistry;

662 DummyCandidate earlyCandidate;

665 DummyCandidate earlyCandidate;

663 DummyCandidate lateCandidate;

666 DummyCandidate lateCandidate;

664

667

@@ -671,16 +674,16 @@ void tst_TouchRegistry::rejectingTouchfterItsEnd()

671 Qt::NoModifier,

674 Qt::NoModifier,

672 Qt::TouchPointPressed,

675 Qt::TouchPointPressed,

673 touchPoints);

676 touchPoints);

674− touchRegistry.update(&touchEvent);

677+ touchRegistry->update(&touchEvent);

675 }

678 }

676

679

677− touchRegistry.addCandidateOwnerForTouch(0, &earlyCandidate);

680+ touchRegistry->addCandidateOwnerForTouch(0, &earlyCandidate);

678− touchRegistry.addCandidateOwnerForTouch(0, &lateCandidate);

681+ touchRegistry->addCandidateOwnerForTouch(0, &lateCandidate);

679

682

680 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

683 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

681 QVERIFY(lateCandidate.ownedTouches.isEmpty());

684 QVERIFY(lateCandidate.ownedTouches.isEmpty());

682

685

683− touchRegistry.requestTouchOwnership(0, &lateCandidate);

686+ touchRegistry->requestTouchOwnership(0, &lateCandidate);

684

687

685 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

688 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

686 QVERIFY(lateCandidate.ownedTouches.isEmpty());

689 QVERIFY(lateCandidate.ownedTouches.isEmpty());

@@ -694,25 +697,25 @@ void tst_TouchRegistry::rejectingTouchfterItsEnd()

694 Qt::NoModifier,

697 Qt::NoModifier,

695 Qt::TouchPointPressed,

698 Qt::TouchPointPressed,

696 touchPoints);

699 touchPoints);

697− touchRegistry.update(&touchEvent);

700+ touchRegistry->update(&touchEvent);

698 }

701 }

699

702

700 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

703 QVERIFY(earlyCandidate.ownedTouches.isEmpty());

701 QVERIFY(lateCandidate.ownedTouches.isEmpty());

704 QVERIFY(lateCandidate.ownedTouches.isEmpty());

702

705

703− touchRegistry.removeCandidateOwnerForTouch(0, &earlyCandidate);

706+ touchRegistry->removeCandidateOwnerForTouch(0, &earlyCandidate);

704

707

705 QCOMPARE(lateCandidate.ownedTouches.count(), 1);

708 QCOMPARE(lateCandidate.ownedTouches.count(), 1);

706 QCOMPARE(lateCandidate.ownedTouches.contains(0), 1);

709 QCOMPARE(lateCandidate.ownedTouches.contains(0), 1);

707

710

708 // Check that there's no trace left of touch 0 as we no longer need to keep tabs on it.

711 // Check that there's no trace left of touch 0 as we no longer need to keep tabs on it.

709− QVERIFY(!touchRegistry.findTouchInfo(0));

712+ QVERIFY(!touchRegistry->findTouchInfo(0));

710}

713}

711

714

712void tst_TouchRegistry::removeOldUndecidedCandidates()

715void tst_TouchRegistry::removeOldUndecidedCandidates()

713{

716{

714 FakeTimerFactory *fakeTimerFactory = new FakeTimerFactory;

717 FakeTimerFactory *fakeTimerFactory = new FakeTimerFactory;

715− TouchRegistry *touchRegistry = new TouchRegistry(nullptr, fakeTimerFactory);

718+ touchRegistry->setTimerFactory(fakeTimerFactory);

716

719

717 DummyCandidate undecidedCandidate;

720 DummyCandidate undecidedCandidate;

718 undecidedCandidate.setObjectName("undecided");

721 undecidedCandidate.setObjectName("undecided");

@@ -749,8 +752,6 @@ void tst_TouchRegistry::removeOldUndecidedCandidates()

749 QVERIFY(undecidedCandidate.lostTouches.contains(0));

752 QVERIFY(undecidedCandidate.lostTouches.contains(0));

750 QVERIFY(candidateThatWantsTouch.ownedTouches.contains(0));

753 QVERIFY(candidateThatWantsTouch.ownedTouches.contains(0));

751 QVERIFY(candidateThatWantsTouch.lostTouches.isEmpty());

754 QVERIFY(candidateThatWantsTouch.lostTouches.isEmpty());

752−

753− delete touchRegistry;

754}

755}

755

756

756/*

757/*

@@ -762,7 +763,7 @@ void tst_TouchRegistry::removeOldUndecidedCandidates()

762void tst_TouchRegistry::interimOwnerWontGetUnownedTouchEvents()

763void tst_TouchRegistry::interimOwnerWontGetUnownedTouchEvents()

763{

764{

764 FakeTimerFactory *fakeTimerFactory = new FakeTimerFactory;

765 FakeTimerFactory *fakeTimerFactory = new FakeTimerFactory;

765− TouchRegistry *touchRegistry = new TouchRegistry(nullptr, fakeTimerFactory);

766+ touchRegistry->setTimerFactory(fakeTimerFactory);

766

767

767 DummyCandidate undecidedCandidate;

768 DummyCandidate undecidedCandidate;

768 undecidedCandidate.setObjectName("undecided");

769 undecidedCandidate.setObjectName("undecided");

@@ -814,8 +815,6 @@ void tst_TouchRegistry::interimOwnerWontGetUnownedTouchEvents()

814

815

815 QCOMPARE(undecidedCandidate.unownedTouchEvents.count(), 2);

816 QCOMPARE(undecidedCandidate.unownedTouchEvents.count(), 2);

816 QCOMPARE(interimOwner.unownedTouchEvents.count(), 0);

817 QCOMPARE(interimOwner.unownedTouchEvents.count(), 0);

817−

818− delete touchRegistry;

819}

818}

820

819

821////////////// TouchMemento //////////

820////////////// TouchMemento //////////

tests/plugins/Ubuntu/Gestures/GestureTest.cpp+2−1

@@ -53,7 +53,8 @@ void GestureTest::init()

54 m_fakeTimerFactory = new FakeTimerFactory;

56− m_touchRegistry = new TouchRegistry(nullptr, m_fakeTimerFactory);

56+ m_touchRegistry = TouchRegistry::instance();

57+ m_touchRegistry->setTimerFactory(m_fakeTimerFactory);

57 m_view->installEventFilter(m_touchRegistry);

58 m_view->installEventFilter(m_touchRegistry);

59 qApp->processEvents();

60 qApp->processEvents();

tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp+20−20

@@ -202,7 +202,7 @@ void tst_DirectionalDragArea::dragWithShortDirectionChange()

202 DirectionalDragArea *edgeDragArea =

203 m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

204 QVERIFY(edgeDragArea != 0);

205− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

205+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

206 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

207

208 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);

@@ -297,7 +297,7 @@ void tst_DirectionalDragArea::sceneXAndX()

297 DirectionalDragArea *edgeDragArea =

298 m_view->rootObject()->findChild<DirectionalDragArea*>("hnDragArea");

299 QVERIFY(edgeDragArea != 0);

300− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

300+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

301 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

302 edgeDragArea->setImmediateRecognition(true);

303

@@ -326,7 +326,7 @@ void tst_DirectionalDragArea::sceneYAndY()

326 DirectionalDragArea *edgeDragArea =

327 m_view->rootObject()->findChild<DirectionalDragArea*>("vnDragArea");

328 QVERIFY(edgeDragArea != 0);

329− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

329+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

330 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

331 edgeDragArea->setImmediateRecognition(true);

332

@@ -357,7 +357,7 @@ void tst_DirectionalDragArea::twoFingerTap()

357 DirectionalDragArea *edgeDragArea =

358 m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

359 QVERIFY(edgeDragArea != 0);

360− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

360+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

361 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

362

363 // Make touches evenly spaced along the edgeDragArea

@@ -439,7 +439,7 @@ void tst_DirectionalDragArea::movingDDA()

439 DirectionalDragArea *edgeDragArea =

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

441 Q_ASSERT(edgeDragArea != 0);

442− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

442+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

443 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

444

445 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);

@@ -479,7 +479,7 @@ void tst_DirectionalDragArea::ignoreOldFinger()

479 DirectionalDragArea *edgeDragArea =

480 m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

481 Q_ASSERT(edgeDragArea != 0);

482− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

482+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

483 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

484

485 // Make touches evenly spaced along the edgeDragArea

@@ -542,7 +542,7 @@ void tst_DirectionalDragArea::rotated()

542 DirectionalDragArea *edgeDragArea =

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

544 Q_ASSERT(edgeDragArea != 0);

545− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

545+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

546 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

547

548 QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);

@@ -582,7 +582,7 @@ void tst_DirectionalDragArea::sceneDistance()

582 DirectionalDragArea *edgeDragArea =

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

584 Q_ASSERT(edgeDragArea != 0);

585− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

585+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

586 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

587

588 // to disable the position smoothing so that we can more easily check sceneDistance values

@@ -640,7 +640,7 @@ void tst_DirectionalDragArea::disabledWhileDragging()

640 DirectionalDragArea *edgeDragArea =

641 m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

642 Q_ASSERT(edgeDragArea != 0);

643− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

643+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

644 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

645

646 QPointF touchPoint = calculateInitialTouchPos(edgeDragArea);

@@ -678,7 +678,7 @@ void tst_DirectionalDragArea::oneFingerDownFollowedByLateSecondFingerDown()

678 DirectionalDragArea *edgeDragArea =

679 m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

680 Q_ASSERT(edgeDragArea != 0);

681− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

681+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

682 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

683

684 // Disable some constraints we're not interested in

@@ -753,7 +753,7 @@ void tst_DirectionalDragArea::givesUpWhenLosesTouch()

753 DirectionalDragArea *edgeDragArea =

754 m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

755 Q_ASSERT(edgeDragArea != 0);

756− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

756+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

757 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

758

759 // Disable some constraints we're not interested in

@@ -798,7 +798,7 @@ void tst_DirectionalDragArea::threeFingerDrag()

798 DirectionalDragArea *edgeDragArea =

799 m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

800 Q_ASSERT(edgeDragArea != 0);

801− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

801+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

802 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

803

804 // Disable some constraints we're not interested in

@@ -867,7 +867,7 @@ void tst_DirectionalDragArea::immediateRecognitionWhenConstraintsDisabled()

867 DirectionalDragArea *edgeDragArea =

868 m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

869 Q_ASSERT(edgeDragArea != 0);

870− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

870+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

871 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

872

873 // Disable the minimum amount of constraints to ensure immediate recognition

@@ -900,7 +900,7 @@ void tst_DirectionalDragArea::withdrawTouchOwnershipCandidacyIfDisabledDuringRec

900 DirectionalDragArea *edgeDragArea =

901 m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

902 Q_ASSERT(edgeDragArea != 0);

903− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

903+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

904 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

905

906 QPointF touchPoint = calculateInitialTouchPos(edgeDragArea);

@@ -964,7 +964,7 @@ void tst_DirectionalDragArea::gettingTouchOwnershipMakesMouseAreaBehindGetCancel

964 DirectionalDragArea *edgeDragArea =

965 m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

966 QVERIFY(edgeDragArea != nullptr);

967− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

967+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

968 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

969

970 QQuickMouseArea *mouseArea =

@@ -1014,7 +1014,7 @@ void tst_DirectionalDragArea::interleavedTouches()

1014 DirectionalDragArea *edgeDragArea =

1015 m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

1016 QVERIFY(edgeDragArea != 0);

1017− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

1017+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

1018 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

1019

1020 QPointF touch0 = edgeDragArea->mapToScene(

@@ -1109,7 +1109,7 @@ void tst_DirectionalDragArea::makoRightEdgeDrag()

1109 DirectionalDragArea *edgeDragArea =

1110 m_view->rootObject()->findChild<DirectionalDragArea*>("hnDragArea");

1111 QVERIFY(edgeDragArea != nullptr);

1112− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

1112+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

1113 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

1114

1115 StatusSpy *statusSpy = new StatusSpy(edgeDragArea);

@@ -1154,7 +1154,7 @@ void tst_DirectionalDragArea::makoRightEdgeDrag_verticalDownwards()

1154 DirectionalDragArea *edgeDragArea =

1155 m_view->rootObject()->findChild<DirectionalDragArea*>("hnDragArea");

1156 QVERIFY(edgeDragArea != nullptr);

1157− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

1157+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

1158 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

1159

1160 edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);

@@ -1198,7 +1198,7 @@ void tst_DirectionalDragArea::makoLeftEdgeDrag_slowStart()

1198 DirectionalDragArea *edgeDragArea =

1199 m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

1200 QVERIFY(edgeDragArea != nullptr);

1201− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

1201+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

1202 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

1203

1204 edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);

@@ -1262,7 +1262,7 @@ void tst_DirectionalDragArea::makoLeftEdgeDrag_movesSlightlyBackwardsOnStart()

1262 DirectionalDragArea *edgeDragArea =

1263 m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");

1264 QVERIFY(edgeDragArea != nullptr);

1265− edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());

1265+ edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer(edgeDragArea));

1266 edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());

1267

1268 edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);

tests/plugins/Ubuntu/Gestures/tst_TouchGate.cpp+1−2

@@ -95,10 +95,9 @@ void tst_TouchGate::cleanupTestCase()

96void tst_TouchGate::init()

97{

98− touchRegistry = new TouchRegistry;

98+ touchRegistry = TouchRegistry::instance();

100 view = createView();

101− view->installEventFilter(touchRegistry);

102 view->setSource(QUrl::fromLocalFile("touchGateExample.qml"));

101 view->setSource(QUrl::fromLocalFile("touchGateExample.qml"));

103 view->show();

102 view->show();

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

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

tests/qmltests/Components/tst_DragHandle.cpp−8

@@ -26,7 +26,6 @@

26#include <DirectionalDragArea.h>

27#include <DirectionalDragArea_p.h>

28#include <Timer.h>

29−#include <TouchRegistry.h>

31using namespace UbuntuGestures;

30using namespace UbuntuGestures;

@@ -61,7 +60,6 @@ private:

62 QQuickView *createView();

61 QQuickView *createView();

63 QQuickView *m_view;

62 QQuickView *m_view;

64− TouchRegistry *m_touchRegistry;

65 QTouchDevice *m_device;

63 QTouchDevice *m_device;

66 FakeTimer *m_fakeTimer;

64 FakeTimer *m_fakeTimer;

67 QSharedPointer<FakeTimeSource> m_fakeTimeSource;

65 QSharedPointer<FakeTimeSource> m_fakeTimeSource;

@@ -85,10 +83,7 @@ void tst_DragHandle::cleanupTestCase()

86void tst_DragHandle::init()

84void tst_DragHandle::init()

87{

85{

88− m_touchRegistry = new TouchRegistry;

89−

90 m_view = createView();

86 m_view = createView();

91− m_view->installEventFilter(m_touchRegistry);

92 m_view->setSource(QUrl::fromLocalFile(TEST_DIR"/tst_DragHandle.qml"));

87 m_view->setSource(QUrl::fromLocalFile(TEST_DIR"/tst_DragHandle.qml"));

93 m_view->show();

88 m_view->show();

94 QVERIFY(QTest::qWaitForWindowExposed(m_view));

89 QVERIFY(QTest::qWaitForWindowExposed(m_view));

@@ -108,9 +103,6 @@ void tst_DragHandle::cleanup()

108 delete m_view;

103 delete m_view;

109 m_view = 0;

104 m_view = 0;

110

105

111− delete m_touchRegistry;

112− m_touchRegistry = 0;

113−

114 delete m_fakeTimer;

106 delete m_fakeTimer;

115 m_fakeTimer = 0;

107 m_fakeTimer = 0;

116

108

tests/uqmlscene/main.cpp−10

@@ -63,9 +63,6 @@

63#include <QtCore/QTranslator>

64#include <QtCore/QLibraryInfo>

66−// UbuntuGestures lib

67−#include <TouchRegistry.h>

68−

69#define UQMLSCENE_DEBUG_ACTIVE_FOCUS 0

66#define UQMLSCENE_DEBUG_ACTIVE_FOCUS 0

71#if UQMLSCENE_DEBUG_ACTIVE_FOCUS

68#if UQMLSCENE_DEBUG_ACTIVE_FOCUS

@@ -434,11 +431,6 @@ int main(int argc, char ** argv)

434 app.setOrganizationName("Qt Project");

431 app.setOrganizationName("Qt Project");

435 app.setOrganizationDomain("qt-project.org");

432 app.setOrganizationDomain("qt-project.org");

436

433

437− // Create it before loading the module, so that TestUtil

438− // doesn't create one with a fake timer factory.

439− // When interacting manually with a test we want the real deal.

440− new TouchRegistry;

441−

442#ifndef QT_NO_TRANSLATION

434#ifndef QT_NO_TRANSLATION

443 QTranslator translator;

435 QTranslator translator;

444 QTranslator qtTranslator;

436 QTranslator qtTranslator;

@@ -512,8 +504,6 @@ int main(int argc, char ** argv)

512 #if UQMLSCENE_DEBUG_ACTIVE_FOCUS

504 #if UQMLSCENE_DEBUG_ACTIVE_FOCUS

513 activeFocusLogger.setWindow(qxView);

505 activeFocusLogger.setWindow(qxView);

514 #endif

506 #endif

515− TouchRegistry::instance()->setParent(qxView);

516− qxView->installEventFilter(TouchRegistry::instance());

517 window = qxView;

507 window = qxView;

518 // Set window default properties; the qml can still override them

508 // Set window default properties; the qml can still override them

519 QString oname = contentItem->objectName();

509 QString oname = contentItem->objectName();

tests/utils/modules/Unity/Test/UnityTestCase.qml−2

@@ -382,8 +382,6 @@ TestCase {

382 }

383

384 Component.onCompleted: {

385− UT.Util.ensureTouchRegistryInstalled();

386−

387 var rootItem = parent;

385 var rootItem = parent;

388 while (rootItem.parent != undefined) {

386 while (rootItem.parent != undefined) {

389 rootItem = rootItem.parent;

387 rootItem = rootItem.parent;

tests/utils/modules/Unity/Test/testutil.cpp+8−20

@@ -31,6 +31,7 @@ TestUtil::TestUtil(QObject *parent)

31 : QObject(parent)

32 , m_targetWindow(0)

33 , m_touchDevice(0)

34+ , m_putFakeTimerFactoryInTouchRegistry(false)

34{

35{

35}

36}

@@ -59,7 +60,13 @@ TouchEventSequenceWrapper *TestUtil::touchEvent(QQuickItem *item)

59{

60{

60 ensureTargetWindow();

61 ensureTargetWindow();

61 ensureTouchDevice();

62 ensureTouchDevice();

62− ensureTouchRegistryInstalled();

63+

64+ // Tests can be *very* slow to run and we don't want things timing out because

65+ // of that. So give it fake timers to use (they will never time out)

66+ if (!m_putFakeTimerFactoryInTouchRegistry) {

67+ TouchRegistry::instance()->setTimerFactory(new FakeTimerFactory);

68+ m_putFakeTimerFactoryInTouchRegistry = true;

69+ }

64 return new TouchEventSequenceWrapper(

71 return new TouchEventSequenceWrapper(

65 QTest::touchEvent(m_targetWindow, m_touchDevice, /* autoCommit */ false), item);

72 QTest::touchEvent(m_targetWindow, m_touchDevice, /* autoCommit */ false), item);

@@ -79,22 +86,3 @@ void TestUtil::ensureTouchDevice()

79 QWindowSystemInterface::registerTouchDevice(m_touchDevice);

86 QWindowSystemInterface::registerTouchDevice(m_touchDevice);

80 }

87 }

81}

88}

82−

83−void TestUtil::ensureTouchRegistryInstalled()

84−{

85− if (TouchRegistry::instance())

86− return;

87−

88− if (!m_targetWindow)

89− return;

90−

91− // Tests can be *very* slow to run and we don't want things timing out because

92− // of that. So give it fake timers to use (they will never time out)

93− TouchRegistry *touchRegistry = new TouchRegistry(this, new FakeTimerFactory);

94−

95− QQuickView *view = qobject_cast<QQuickView*>(m_targetWindow);

96− if (view) {

97− view->installEventFilter(touchRegistry);

98− touchRegistry->setParent(view);

99− }

100−}

tests/utils/modules/Unity/Test/testutil.h+1−1

@@ -34,7 +34,6 @@ public:

35 Q_INVOKABLE bool isInstanceOf(QObject*, QString);

36 Q_INVOKABLE TouchEventSequenceWrapper *touchEvent(QQuickItem *item);

37− Q_INVOKABLE void ensureTouchRegistryInstalled();

39private:

38private:

40 void ensureTargetWindow();

39 void ensureTargetWindow();

@@ -42,6 +41,7 @@ private:

43 QWindow *m_targetWindow;

42 QWindow *m_targetWindow;

44 QTouchDevice *m_touchDevice;

43 QTouchDevice *m_touchDevice;

44+ bool m_putFakeTimerFactoryInTouchRegistry;

45};

47QML_DECLARE_TYPE(TestUtil)