c559464 · unity8 · git.iko.soy

git.iko.soy/unity8

on xenial help sign in

Fix the Super key not invoking the dash scope home (LP: #1607427)

c559464Lukáš Tinkl10 years ago

plugins/Utils/ElapsedTimer.h+1−1

compare with xenial

unifiedsplit

@@ -41,7 +41,7 @@ class ElapsedTimer : public AbstractElapsedTimer {

41public:

42 void start() override { m_timer.start(); }

43 qint64 msecsSinceReference() const override { return m_timer.msecsSinceReference(); }

44− qint64 elapsed() const override { return m_timer.elapsed(); }

44+ qint64 elapsed() const override { return m_timer.isValid() ? m_timer.elapsed() : 0; }

45private:

46 QElapsedTimer m_timer;

47};

plugins/Utils/Timer.cpp+5−2

@@ -37,13 +37,16 @@ void Timer::setInterval(int msecs)

37void Timer::start()

38{

39 m_timer.start();

40− AbstractTimer::start();

41}

40}

43void Timer::stop()

42void Timer::stop()

44{

43{

45 m_timer.stop();

44 m_timer.stop();

46− AbstractTimer::stop();

45+}

46+

47+bool Timer::isRunning() const

48+{

49+ return m_timer.isActive();

47}

50}

49bool Timer::isSingleShot() const

52bool Timer::isSingleShot() const

plugins/Utils/Timer.h+5−6

@@ -30,18 +30,16 @@ class AbstractTimer : public QObject

30{

31 Q_OBJECT

32public:

33− AbstractTimer(QObject *parent) : QObject(parent), m_isRunning(false) {}

33+ AbstractTimer(QObject *parent) : QObject(parent) {}

34 virtual int interval() const = 0;

35 virtual void setInterval(int msecs) = 0;

36− virtual void start() { m_isRunning = true; }

36+ virtual void start() = 0;

37− virtual void stop() { m_isRunning = false; }

37+ virtual void stop() = 0;

38− bool isRunning() const { return m_isRunning; }

38+ virtual bool isRunning() const = 0;

39 virtual bool isSingleShot() const = 0;

40 virtual void setSingleShot(bool value) = 0;

41Q_SIGNALS:

42 void timeout();

43−private:

44− bool m_isRunning;

45};

43};

47/** A QTimer wrapper */

45/** A QTimer wrapper */

@@ -55,6 +53,7 @@ public:

55 void setInterval(int msecs) override;

53 void setInterval(int msecs) override;

56 void start() override;

54 void start() override;

57 void stop() override;

55 void stop() override;

56+ bool isRunning() const override;

58 bool isSingleShot() const override;

57 bool isSingleShot() const override;

59 void setSingleShot(bool value) override;

58 void setSingleShot(bool value) override;

60private:

59private:

tests/plugins/Utils/WindowInputMonitorTest.cpp+76−9

@@ -25,14 +25,15 @@ class FakeElapsedTimer : public AbstractElapsedTimer {

25public:

26 static qint64 msecsSinceEpoch;

28− FakeElapsedTimer() { start(); }

28+ FakeElapsedTimer() {}

30− void start() override { m_msecsSinceReference = msecsSinceEpoch; }

30+ void start() override { m_msecsSinceReference = msecsSinceEpoch; m_valid = true; }

31 qint64 msecsSinceReference() const override { return m_msecsSinceReference; }

32− qint64 elapsed() const override { return msecsSinceEpoch - m_msecsSinceReference; }

32+ qint64 elapsed() const override { return m_valid ? msecsSinceEpoch - m_msecsSinceReference : qrand(); }

34private:

35 qint64 m_msecsSinceReference;

36+ bool m_valid{false};

36};

37};

37qint64 FakeElapsedTimer::msecsSinceEpoch = 0;

38qint64 FakeElapsedTimer::msecsSinceEpoch = 0;

@@ -48,11 +49,14 @@ public:

48 int interval() const override;

49 int interval() const override;

49 void setInterval(int msecs) override;

50 void setInterval(int msecs) override;

50 void start() override;

51 void start() override;

52+ void stop() override;

53+ bool isRunning() const override;

51 bool isSingleShot() const override;

54 bool isSingleShot() const override;

52 void setSingleShot(bool value) override;

55 void setSingleShot(bool value) override;

53private:

56private:

54 int m_interval;

57 int m_interval;

55 bool m_singleShot;

58 bool m_singleShot;

59+ bool m_isRunning;

56 qint64 m_nextTimeoutTime;

60 qint64 m_nextTimeoutTime;

57};

61};

@@ -85,6 +89,8 @@ private Q_SLOTS:

85 void tapWhileTouching();

89 void tapWhileTouching();

86 void multipleHomeKeys();

90 void multipleHomeKeys();

92+ void repeatedSuperPress();

93+

88private:

94private:

89 void passTime(qint64 timeSpanMs);

95 void passTime(qint64 timeSpanMs);

@@ -98,11 +104,10 @@ void WindowInputMonitorTest::init()

104

99void WindowInputMonitorTest::cleanup()

105void WindowInputMonitorTest::cleanup()

100{

106{

101− delete m_fakeTimerFactory;

107+ delete m_fakeTimerFactory;

102 m_fakeTimerFactory = nullptr;

108 m_fakeTimerFactory = nullptr;

103}

109}

104

110

105−

106void WindowInputMonitorTest::passTime(qint64 timeSpanMs)

111void WindowInputMonitorTest::passTime(qint64 timeSpanMs)

107{

112{

108 qint64 finalTime = FakeElapsedTimer::msecsSinceEpoch + timeSpanMs;

113 qint64 finalTime = FakeElapsedTimer::msecsSinceEpoch + timeSpanMs;

@@ -133,7 +138,7 @@ void WindowInputMonitorTest::touchTapTouch()

133 QFETCH(int, silenceAfterTap);

138 QFETCH(int, silenceAfterTap);

134 QFETCH(int, expectedActivatedCount);

139 QFETCH(int, expectedActivatedCount);

135 QFETCH(Qt::Key, key);

140 QFETCH(Qt::Key, key);

136− WindowInputMonitor homeKeyWatcher(m_fakeTimerFactory->create(), new FakeElapsedTimer);

141+ WindowInputMonitor homeKeyWatcher(m_fakeTimerFactory->create(this), new FakeElapsedTimer);

137 QSignalSpy activatedSpy(&homeKeyWatcher, &WindowInputMonitor::homeKeyActivated);

142 QSignalSpy activatedSpy(&homeKeyWatcher, &WindowInputMonitor::homeKeyActivated);

138 QVERIFY(activatedSpy.isValid());

143 QVERIFY(activatedSpy.isValid());

139

144

@@ -194,7 +199,7 @@ void WindowInputMonitorTest::touchTapTouch()

194

199

195void WindowInputMonitorTest::tapWhileTouching()

200void WindowInputMonitorTest::tapWhileTouching()

196{

201{

197− WindowInputMonitor homeKeyWatcher(m_fakeTimerFactory->create(), new FakeElapsedTimer);

202+ WindowInputMonitor homeKeyWatcher(m_fakeTimerFactory->create(this), new FakeElapsedTimer);

198 QSignalSpy activatedSpy(&homeKeyWatcher, &WindowInputMonitor::homeKeyActivated);

203 QSignalSpy activatedSpy(&homeKeyWatcher, &WindowInputMonitor::homeKeyActivated);

199 QVERIFY(activatedSpy.isValid());

204 QVERIFY(activatedSpy.isValid());

200

205

@@ -229,7 +234,7 @@ void WindowInputMonitorTest::tapWhileTouching()

229 */

234 */

230void WindowInputMonitorTest::multipleHomeKeys()

235void WindowInputMonitorTest::multipleHomeKeys()

231{

236{

232− WindowInputMonitor homeKeyWatcher(m_fakeTimerFactory->create(), new FakeElapsedTimer);

237+ WindowInputMonitor homeKeyWatcher(m_fakeTimerFactory->create(this), new FakeElapsedTimer);

233 QSignalSpy activatedSpy(&homeKeyWatcher, &WindowInputMonitor::homeKeyActivated);

238 QSignalSpy activatedSpy(&homeKeyWatcher, &WindowInputMonitor::homeKeyActivated);

234 QVERIFY(activatedSpy.isValid());

239 QVERIFY(activatedSpy.isValid());

235

240

@@ -258,12 +263,64 @@ void WindowInputMonitorTest::multipleHomeKeys()

258 QCOMPARE(activatedSpy.count(), 1);

263 QCOMPARE(activatedSpy.count(), 1);

259}

264}

260

265

266+// regression test for lp:1607427

267+void WindowInputMonitorTest::repeatedSuperPress()

268+{

269+ WindowInputMonitor homeKeyWatcher(m_fakeTimerFactory->create(this), new FakeElapsedTimer);

270+ QSignalSpy activatedSpy(&homeKeyWatcher, &WindowInputMonitor::homeKeyActivated);

271+ QVERIFY(activatedSpy.isValid());

272+

273+ // 1st try

274+ passTime(1000);

275+ {

276+ QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Super_L, Qt::NoModifier);

277+ homeKeyWatcher.update(&keyEvent);

278+ }

279+ passTime(50);

280+ {

281+ QKeyEvent keyEvent(QEvent::KeyRelease, Qt::Key_Super_L, Qt::NoModifier);

282+ homeKeyWatcher.update(&keyEvent);

283+ }

284+ passTime(1000);

285+ QCOMPARE(activatedSpy.count(), 1);

286+

287+ // a touch event in between

288+ {

289+ QTouchEvent touchEvent(QEvent::TouchBegin);

290+ homeKeyWatcher.update(&touchEvent);

291+ }

292+ {

293+ QTouchEvent touchEvent(QEvent::TouchUpdate);

294+ homeKeyWatcher.update(&touchEvent);

295+ }

296+ {

297+ QTouchEvent touchEvent(QEvent::TouchEnd);

298+ homeKeyWatcher.update(&touchEvent);

299+ }

300+

301+ passTime(1000);

302+ // 2nd try

303+ activatedSpy.clear();

304+ {

305+ QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Super_L, Qt::NoModifier);

306+ homeKeyWatcher.update(&keyEvent);

307+ }

308+ passTime(50);

309+ {

310+ QKeyEvent keyEvent(QEvent::KeyRelease, Qt::Key_Super_L, Qt::NoModifier);

311+ homeKeyWatcher.update(&keyEvent);

312+ }

313+ passTime(1000);

314+ QCOMPARE(activatedSpy.count(), 1);

315+}

316+

261/////////////////////////////////// FakeTimer //////////////////////////////////

317/////////////////////////////////// FakeTimer //////////////////////////////////

262

318

263FakeTimer::FakeTimer(QObject *parent)

319FakeTimer::FakeTimer(QObject *parent)

264 : UnityUtil::AbstractTimer(parent)

320 : UnityUtil::AbstractTimer(parent)

265 , m_interval(0)

321 , m_interval(0)

266 , m_singleShot(true)

322 , m_singleShot(true)

323+ , m_isRunning(false)

267{

324{

268}

325}

269

326

@@ -285,10 +342,20 @@ void FakeTimer::update()

285

342

286void FakeTimer::start()

343void FakeTimer::start()

287{

344{

288− AbstractTimer::start();

345+ m_isRunning = true;

289 m_nextTimeoutTime = FakeElapsedTimer::msecsSinceEpoch + (qint64)interval();

346 m_nextTimeoutTime = FakeElapsedTimer::msecsSinceEpoch + (qint64)interval();

290}

347}

291

348

349+void FakeTimer::stop()

350+{

351+ m_isRunning = false;

352+}

353+

354+bool FakeTimer::isRunning() const

355+{

356+ return m_isRunning;

357+}

358+

292int FakeTimer::interval() const

359int FakeTimer::interval() const

293{

360{

294 return m_interval;

361 return m_interval;