e715db5 · unity8 · git.iko.soy

Components/Stage.qml+1−1

compare with xenial

unifiedsplit

@@ -438,7 +438,7 @@ Showable {

438 anchors.bottom: parent.bottom

439 anchors.right: parent.right

440

441− direction: DirectionalDragArea.Leftwards

441+ direction: Direction.Leftwards

442 maxDeviation: units.gu(1)

443 wideningAngle: 20

444 distanceThreshold: units.gu(3)

Launcher/Launcher.qml+1−1

@@ -184,7 +184,7 @@ Item {

184 DirectionalDragArea {

185 id: dragArea

186

187− direction: DirectionalDragArea.Rightwards

187+ direction: Direction.Rightwards

188

189 // values to be tweaked and later removed from here and set in stone as defaults

190 // once we are confident it's all good.

plugins/Ubuntu/Gestures/CMakeLists.txt+1

@@ -7,6 +7,7 @@ find_package(Qt5Quick REQUIRED)

7set(UbuntuGestureQml_SOURCES

8 plugin.cpp

9 AxisVelocityCalculator.cpp

10+ Direction.cpp

10 DirectionalDragArea.cpp

11 DirectionalDragArea.cpp

11)

12)

12

13

plugins/Ubuntu/Gestures/Direction.cppnew file+27

@@ -0,0 +1,27 @@

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+ */

16+

17+#include "Direction.h"

18+

19+bool Direction::isHorizontal(Direction::Type type)

20+{

21+ return type == Direction::Leftwards || type == Direction::Rightwards;

22+}

23+

24+bool Direction::isVertical(Direction::Type type)

25+{

26+ return type == Direction::Upwards || type == Direction::Downwards;

27+}

plugins/Ubuntu/Gestures/Direction.hnew file+43

@@ -0,0 +1,43 @@

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+ */

16+

17+#ifndef DIRECTION_H

18+#define DIRECTION_H

19+

20+#include "UbuntuGesturesGlobal.h"

21+#include <QObject>

22+

23+/*

24+ A Direction enum wrapper so that we can do things like "direction: Direction.Righwards"

25+ from QML.

26+ */

27+class UBUNTUGESTURES_EXPORT Direction : public QObject {

28+ Q_OBJECT

29+ Q_ENUMS(Type)

30+

31+public:

32+ enum Type {

33+ Rightwards, // Along the positive direction of the X axis

34+ Leftwards, // Along the negative direction of the X axis

35+ Downwards, // Along the positive direction of the Y axis

36+ Upwards // Along the negative direction of the Y axis

37+ };

38+

39+ Q_INVOKABLE static bool isHorizontal(Direction::Type type);

40+ Q_INVOKABLE static bool isVertical(Direction::Type type);

41+};

42+

43+#endif // DIRECTION_H

plugins/Ubuntu/Gestures/DirectionalDragArea.cpp+16−26

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

41 : QQuickItem(parent)

42 , m_status(WaitingForTouch)

43 , m_touchId(-1)

44− , m_direction(DirectionalDragArea::Rightwards)

44+ , m_direction(Direction::Rightwards)

45 , m_wideningAngle(0)

46 , m_wideningFactor(0)

47 , m_distanceThreshold(0)

@@ -58,12 +58,12 @@ DirectionalDragArea::DirectionalDragArea(QQuickItem *parent)

58 m_velocityCalculator = new AxisVelocityCalculator(this);

59}

60

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

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

62{

63 return m_direction;

64}

65

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

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

67{

68 if (direction != m_direction) {

69 m_direction = direction;

@@ -151,7 +151,7 @@ void DirectionalDragArea::setAxisVelocityCalculator(AxisVelocityCalculator *newV

151

152qreal DirectionalDragArea::distance() const

153{

154− if (directionIsHorizontal()) {

154+ if (Direction::isHorizontal(m_direction)) {

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

156 } else {

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

@@ -286,13 +286,13 @@ bool DirectionalDragArea::pointInsideAllowedArea() const

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

287

288 switch (m_direction) {

289− case Upwards:

289+ case Direction::Upwards:

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

291− case Downwards:

291+ case Direction::Downwards:

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

293− case Leftwards:

293+ case Direction::Leftwards:

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

295− default: // Rightwards:

295+ default: // Direction::Rightwards:

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

297 }

298}

@@ -300,20 +300,20 @@ bool DirectionalDragArea::pointInsideAllowedArea() const

300bool DirectionalDragArea::movingInRightDirection() const

301{

302 switch (m_direction) {

303− case Upwards:

303+ case Direction::Upwards:

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

305− case Downwards:

305+ case Direction::Downwards:

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

307− case Leftwards:

307+ case Direction::Leftwards:

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

309− default: // Rightwards:

309+ default: // Direction::Rightwards:

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

311 }

312}

313

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

315{

316− if (directionIsHorizontal())

316+ if (Direction::isHorizontal(m_direction))

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

318 else

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

@@ -386,35 +386,25 @@ void DirectionalDragArea::setPreviousPos(QPointF point)

386

387 if (xChanged) {

388 Q_EMIT touchXChanged(point.x());

389− if (directionIsHorizontal())

389+ if (Direction::isHorizontal(m_direction))

390 Q_EMIT distanceChanged(distance());

391 }

392

393 if (yChanged) {

394 Q_EMIT touchYChanged(point.y());

395− if (directionIsVertical())

395+ if (Direction::isVertical(m_direction))

396 Q_EMIT distanceChanged(distance());

397 }

398}

399

400void DirectionalDragArea::updateVelocityCalculator(QPointF point)

401{

402− if (directionIsHorizontal()) {

402+ if (Direction::isHorizontal(m_direction)) {

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

404 } else {

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

406 }

407}

408

409−bool DirectionalDragArea::directionIsHorizontal() const

410−{

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

412−}

413−

414−bool 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.

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

420#include "DirectionalDragArea.moc"

410#include "DirectionalDragArea.moc"

plugins/Ubuntu/Gestures/DirectionalDragArea.h+6−13

@@ -21,6 +21,7 @@

21#include "AxisVelocityCalculator.h"

22#include "UbuntuGesturesGlobal.h"

23#include "Damper.h"

24+#include "Direction.h"

24

25

25namespace UbuntuGestures {

26namespace UbuntuGestures {

26/* Defines an interface for a Timer. */

27/* Defines an interface for a Timer. */

@@ -53,7 +54,7 @@ class UBUNTUGESTURES_EXPORT DirectionalDragArea : public QQuickItem {

53 Q_OBJECT

54 Q_OBJECT

54

55

55 // The direction in which the gesture should move in order to be recognized.

56 // The direction in which the gesture should move in order to be recognized.

56− Q_PROPERTY(Direction direction READ direction WRITE setDirection NOTIFY directionChanged)

57+ Q_PROPERTY(Direction::Type direction READ direction WRITE setDirection NOTIFY directionChanged)

57

58

58 // The distance travelled by the finger along the axis specified by

59 // The distance travelled by the finger along the axis specified by

59 // DirectionalDragArea's direction.

60 // DirectionalDragArea's direction.

@@ -116,12 +117,8 @@ class UBUNTUGESTURES_EXPORT DirectionalDragArea : public QQuickItem {

116public:

117public:

117 DirectionalDragArea(QQuickItem *parent = 0);

118 DirectionalDragArea(QQuickItem *parent = 0);

118

119

119− enum Direction { Rightwards, // Along the positive direction of the X axis

120− Leftwards, // Along the negative direction of the X axis

121− Downwards, // Along the positive direction of the Y axis

122− Upwards }; // Along the negative direction of the Y axis

123− Direction direction() const;

120+ Direction::Type direction() const;

124− void setDirection(Direction);

121+ void setDirection(Direction::Type);

125

122

126 // Describes the state of the directional drag gesture.

123 // Describes the state of the directional drag gesture.

127 enum Status {

124 enum Status {

@@ -179,7 +176,7 @@ public:

179 void setAxisVelocityCalculator(AxisVelocityCalculator *velCalc);

176 void setAxisVelocityCalculator(AxisVelocityCalculator *velCalc);

180

177

181Q_SIGNALS:

178Q_SIGNALS:

182− void directionChanged(Direction direction);

179+ void directionChanged(Direction::Type direction);

183 void statusChanged(Status value);

180 void statusChanged(Status value);

184 void draggingChanged(bool value);

181 void draggingChanged(bool value);

185 void distanceChanged(qreal value);

182 void distanceChanged(qreal value);

@@ -210,10 +207,6 @@ private:

210 void setPreviousPos(QPointF point);

207 void setPreviousPos(QPointF point);

211 void updateVelocityCalculator(QPointF point);

208 void updateVelocityCalculator(QPointF point);

212

209

213− // convenience functions

214− bool directionIsHorizontal() const;

215− bool directionIsVertical() const;

216−

217 Status m_status;

210 Status m_status;

218

211

219 QPointF m_startPos;

212 QPointF m_startPos;

@@ -225,7 +218,7 @@ private:

225 DampedPointF m_dampedPos;

218 DampedPointF m_dampedPos;

226 QPointF m_previousDampedPos;

219 QPointF m_previousDampedPos;

227

220

228− Direction m_direction;

221+ Direction::Type m_direction;

229 qreal m_wideningAngle; // in degrees

222 qreal m_wideningAngle; // in degrees

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

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

231 qreal m_distanceThreshold;

224 qreal m_distanceThreshold;

plugins/Ubuntu/Gestures/plugin.cpp+8

@@ -16,12 +16,20 @@

16

17#include "plugin.h"

18#include "AxisVelocityCalculator.h"

19+#include "Direction.h"

19#include "DirectionalDragArea.h"

20#include "DirectionalDragArea.h"

20

21

21#include <qqml.h>

22#include <qqml.h>

22

23

24+static QObject* directionSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {

25+ Q_UNUSED(engine);

26+ Q_UNUSED(scriptEngine);

27+ return new Direction;

28+}

29+

23void UbuntuGestureQmlPlugin::registerTypes(const char *uri)

30void UbuntuGestureQmlPlugin::registerTypes(const char *uri)

24{

31{

32+ qmlRegisterSingletonType<Direction>(uri, 0, 1, "Direction", directionSingleton);

25 qmlRegisterType<DirectionalDragArea>(uri, 0, 1, "DirectionalDragArea");

33 qmlRegisterType<DirectionalDragArea>(uri, 0, 1, "DirectionalDragArea");

26 qmlRegisterType<AxisVelocityCalculator>(uri, 0, 1, "AxisVelocityCalculator");

34 qmlRegisterType<AxisVelocityCalculator>(uri, 0, 1, "AxisVelocityCalculator");

27}

35}

po/nb.po+9−9

@@ -8,22 +8,22 @@ msgstr ""

8"Project-Id-Version: unity\n"

9"Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>\n"

10"POT-Creation-Date: 2013-06-08 14:40+0200\n"

11−"PO-Revision-Date: 2013-06-05 22:20+0000\n"

11+"PO-Revision-Date: 2013-06-17 09:10+0000\n"

12−"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

12+"Last-Translator: Joakim Langvand <jlangvand@gmail.com>\n"

13"Language-Team: Norwegian Bokmal <nb@li.org>\n"

14"MIME-Version: 1.0\n"

15"Content-Type: text/plain; charset=UTF-8\n"

16"Content-Transfer-Encoding: 8bit\n"

17−"X-Launchpad-Export-Date: 2013-06-11 06:34+0000\n"

17+"X-Launchpad-Export-Date: 2013-06-18 06:53+0000\n"

18−"X-Generator: Launchpad (build 16667)\n"

18+"X-Generator: Launchpad (build 16673)\n"

19

20#: Applications/applications.js:23

21msgid "Phone"

22−msgstr ""

22+msgstr "Telefon"

23

24#: Applications/applications.js:29

25msgid "Camera"

26−msgstr ""

26+msgstr "Kamera"

27

28#: Applications/applications.js:35

29msgid "Gallery"

@@ -47,15 +47,15 @@ msgstr ""

47

48#: Applications/applications.js:62

49msgid "Weather"

50−msgstr ""

50+msgstr "Vær"

51

52#: Applications/applications.js:68

53msgid "Notepad"

54−msgstr ""

54+msgstr "Notisblokk"

55

56#: Applications/applications.js:74

57msgid "Calendar"

58−msgstr ""

58+msgstr "Kalender"

59

60#: Applications/applications.js:80

61msgid "Media Player"

tests/mocks/LightDM/demo/GreeterPrivate.cpp+24−3

@@ -18,6 +18,8 @@

18

19#include "../Greeter.h"

20#include "../GreeterPrivate.h"

21+#include <QtCore/QDir>

22+#include <QtCore/QSettings>

21

23

22namespace QLightDM

24namespace QLightDM

23{

25{

@@ -33,13 +35,32 @@ void GreeterPrivate::handleAuthenticate()

33{

35{

34 Q_Q(Greeter);

36 Q_Q(Greeter);

35

37

38+ QSettings settings(QDir::homePath() + "/.unity8-greeter-demo", QSettings::NativeFormat);

39+ QVariant password = settings.value("password", "none");

40+

41+ if (password == "pin") {

42+ Q_EMIT q->showPrompt("PIN", Greeter::PromptTypeSecret);

43+ } else if (password == "keyboard") {

44+ Q_EMIT q->showPrompt("Password", Greeter::PromptTypeSecret);

45+ } else {

36− authenticated = true;

46+ authenticated = true;

37− Q_EMIT q->authenticationComplete();

47+ Q_EMIT q->authenticationComplete();

48+ }

38}

49}

39

50

40void GreeterPrivate::handleRespond(const QString &response)

51void GreeterPrivate::handleRespond(const QString &response)

41{

52{

42− Q_UNUSED(response);

53+ Q_Q(Greeter);

54+

55+ QSettings settings(QDir::homePath() + "/.unity8-greeter-demo", QSettings::NativeFormat);

56+ QVariant password = settings.value("password", "none");

57+

58+ if (password == "pin") {

59+ authenticated = (response == "1234");

60+ } else {

61+ authenticated = (response == "password");

62+ }

63+ Q_EMIT q->authenticationComplete();

43}

64}

44

65

45}

66}

tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml+1−1

@@ -51,7 +51,7 @@ Item {

51

52 height: units.gu(5)

53

54− direction: DirectionalDragArea.Downwards

54+ direction: Direction.Downwards

55 maxDeviation: units.gu(2)

56 wideningAngle: 10

57 distanceThreshold: units.gu(4)

tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml+1−1

@@ -54,7 +54,7 @@ Item {

54

55 width: units.gu(5)

56

57− direction: DirectionalDragArea.Leftwards

57+ direction: Direction.Leftwards

58 maxDeviation: units.gu(2)

59 wideningAngle: 10

60 distanceThreshold: units.gu(4)

tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml+1−1

@@ -50,7 +50,7 @@ Item {

50

51 width: units.gu(5)

52

53− direction: DirectionalDragArea.Rightwards

53+ direction: Direction.Rightwards

54 maxDeviation: units.gu(2)

55 wideningAngle: 10

56 distanceThreshold: units.gu(4)

tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml+1−1

@@ -54,7 +54,7 @@ Item {

54

55 height: units.gu(5)

56

57− direction: DirectionalDragArea.Upwards

57+ direction: Direction.Upwards

58 maxDeviation: units.gu(2)

59 wideningAngle: 10

60 distanceThreshold: units.gu(4)

tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp+9−10

@@ -132,13 +132,13 @@ namespace {

132QPointF calculateInitialTouchPos(DirectionalDragArea *edgeDragArea, QQuickView *view)

133{

134 switch (edgeDragArea->direction()) {

135− case DirectionalDragArea::Upwards:

135+ case Direction::Upwards:

136 return QPointF(view->width()/2.0f, view->height() - (edgeDragArea->height()/2.0f));

137− case DirectionalDragArea::Downwards:

137+ case Direction::Downwards:

138 return QPointF(view->width()/2.0f, edgeDragArea->height()/2.0f);

139− case DirectionalDragArea::Leftwards:

139+ case Direction::Leftwards:

140 return QPointF(view->width() - (edgeDragArea->width()/2.0f), view->height()/2.0f);

141− default: // DirectionalDragArea::Rightwards:

141+ default: // Direction::Rightwards:

142 return QPointF(edgeDragArea->width()/2.0f, view->height()/2.0f);

143 }

144}

@@ -153,13 +153,13 @@ QPointF calculateDirectionVector(DirectionalDragArea *edgeDragArea,

153 qreal angleSin = qSin(angleRadians);

154

155 switch (edgeDragArea->direction()) {

156− case DirectionalDragArea::Upwards:

156+ case Direction::Upwards:

157 return QPointF(angleSin, -angleCos);

158− case DirectionalDragArea::Downwards:

158+ case Direction::Downwards:

159 return QPointF(angleSin, angleCos);

160− case DirectionalDragArea::Leftwards:

160+ case Direction::Leftwards:

161 return QPointF(-angleCos, angleSin);

162− default: // DirectionalDragArea::Rightwards:

162+ default: // Direction::Rightwards:

163 return QPointF(angleCos, angleSin);

164 }

165}

@@ -168,8 +168,7 @@ QPointF createTouchDeviation(DirectionalDragArea *edgeDragArea)

168{

169 qreal deviation = edgeDragArea->maxDeviation() * 0.8;

170

171− if (edgeDragArea->direction() == DirectionalDragArea::Leftwards

171+ if (Direction::isHorizontal(edgeDragArea->direction())) {

172− || edgeDragArea->direction() == DirectionalDragArea::Rightwards) {

173 return QPointF(0, deviation);

172 return QPointF(0, deviation);

174 } else {

173 } else {

175 return QPointF(deviation, 0);

174 return QPointF(deviation, 0);