xenial...f20331b · unity8

CMakeLists.txt+1−1

since splitsnapshots

unifiedsplit

@@ -70,7 +70,7 @@ find_package(Qt5DBus 5.6 REQUIRED)

70find_package(Qt5Concurrent 5.6 REQUIRED)

71find_package(Qt5Sql 5.6 REQUIRED)

72

73−pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=26)

73+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=27)

74pkg_check_modules(GEONAMES REQUIRED geonames>=0.2)

75pkg_check_modules(GIO REQUIRED gio-2.0>=2.32)

76pkg_check_modules(GLIB REQUIRED glib-2.0>=2.32)

debian/control+3−3

@@ -38,7 +38,7 @@ Build-Depends: cmake,

38 libubuntugestures5-private-dev (>= 1.3.2030),

39 libudev-dev,

40 libudm-common-dev,

41− libunity-api-dev (>= 8.2),

41+ libunity-api-dev (>= 8.3),

42 libusermetricsoutput1-dev,

43# Need those X11 libs touch emulation from mouse events in manual QML tests on a X11 desktop

44 libx11-dev[!arm64 !armhf],

@@ -162,7 +162,7 @@ Depends: qml-module-qtquick-layouts,

162 qttranslations5-l10n,

163 ubuntu-thumbnailer-impl-0,

164 ubuntu-wallpapers,

165− unity-application-impl-26,

165+ unity-application-impl-27,

166 unity-notifications-impl-3,

167 unity-plugin-scopes | unity-scopes-impl,

168 unity-scopes-impl-12,

@@ -212,7 +212,7 @@ Depends: dbus-test-runner,

212 ${misc:Depends},

213 ${shlibs:Depends},

214Provides: unity-application-impl,

215− unity-application-impl-26,

215+ unity-application-impl-27,

216 unity8-fake-env,

217Replaces: unity8-autopilot (<< 8.02+15.04.20150422-0ubuntu1),

218 unity8-fake-env,

debian/unity8.install+4

@@ -16,7 +16,11 @@ usr/share/unity8/Rotation

16usr/share/unity8/DeviceConfiguration.qml

17usr/share/unity8/OrientedShell.qml

18usr/share/unity8/DisabledScreenNotice.qml

19+usr/share/unity8/qmldir

19usr/share/unity8/Shell.qml

20usr/share/unity8/Shell.qml

21+usr/share/unity8/ShellApplication.qml

22+usr/share/unity8/ShellNotifier.qml

23+usr/share/unity8/ShellScreen.qml

20usr/share/unity8/Stage

24usr/share/unity8/Stage

21usr/share/unity8/Tutorial

25usr/share/unity8/Tutorial

22usr/share/unity8/Wizard

26usr/share/unity8/Wizard

plugins/Cursor/CMakeLists.txt+1

@@ -15,6 +15,7 @@ set(QMLPLUGIN_SRC

15 CursorImageInfo.cpp

16 CursorImageProvider.cpp

17 MousePointer.cpp

18+ InputDispatcherFilter.cpp

18 # We need to run moc on this header

19 # We need to run moc on this header

19 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirMousePointerInterface.h

20 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirMousePointerInterface.h

20 )

21 )

plugins/Cursor/InputDispatcherFilter.cppnew file+175

@@ -0,0 +1,175 @@

1+/*

3+ *

4+ * This program is free software: you can redistribute it and/or modify it under

5+ * the terms of the GNU Lesser General Public License version 3, as published by

6+ * the Free Software Foundation.

7+ *

8+ * This program is distributed in the hope that it will be useful, but WITHOUT

9+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,

10+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

11+ * Lesser General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU Lesser General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+ */

16+

17+#include "InputDispatcherFilter.h"

18+#include "MousePointer.h"

19+

20+#include <QEvent>

21+#include <QGuiApplication>

22+#include <QQuickWindow>

23+#include <QScreen>

24+#include <QtMath>

25+#include <qpa/qplatformnativeinterface.h>

26+#include <qpa/qplatformscreen.h>

27+

28+InputDispatcherFilter *InputDispatcherFilter::instance()

29+{

30+ static InputDispatcherFilter filter;

31+ return &filter;

32+}

33+

34+InputDispatcherFilter::InputDispatcherFilter(QObject *parent)

35+ : QObject(parent)

36+ , m_pushing(false)

37+{

38+ QPlatformNativeInterface *ni = QGuiApplication::platformNativeInterface();

39+ m_inputDispatcher = static_cast<QObject*>(ni->nativeResourceForIntegration("InputDispatcher"));

40+ if (m_inputDispatcher) {

41+ m_inputDispatcher->installEventFilter(this);

42+ }

43+}

44+

45+void InputDispatcherFilter::registerPointer(MousePointer *pointer)

46+{

47+ // allow first registered pointer to be visible.

48+ m_pointers.insert(pointer);

49+}

50+

51+void InputDispatcherFilter::unregisterPointer(MousePointer *pointer)

52+{

53+ m_pointers.remove(pointer);

54+}

55+

56+bool InputDispatcherFilter::eventFilter(QObject *o, QEvent *e)

57+{

58+ if (o != m_inputDispatcher) return false;

59+

60+ switch (e->type()) {

61+ case QEvent::MouseMove:

62+ case QEvent::MouseButtonPress:

63+ case QEvent::MouseButtonRelease:

64+ {

65+ // if we don't have any pointers, filter all mouse events.

66+ auto pointer = currentPointer();

67+ if (!pointer) return true;

68+

69+ QMouseEvent* me = static_cast<QMouseEvent*>(e);

70+

71+ // Local position gives relative change of mouse pointer.

72+ QPointF movement = me->localPos();

73+

74+ // Adjust the position

75+ QPointF oldPos = pointer->window()->geometry().topLeft() + pointer->position();

76+ QPointF newPos = adjustedPositionForMovement(oldPos, movement);

77+

78+ QScreen* currentScreen = screenAt(newPos);

79+ if (currentScreen) {

80+ QRect screenRect = currentScreen->geometry();

81+ qreal newX = (oldPos + movement).x();

82+ qreal newY = (oldPos + movement).y();

83+

84+ if (newX <= screenRect.left() && newY < screenRect.top() + pointer->topBoundaryOffset()) { // top left corner

85+ const auto distance = qSqrt(qPow(newX, 2) + qPow(newY- screenRect.top() - pointer->topBoundaryOffset(), 2));

86+ Q_EMIT pushedTopLeftCorner(currentScreen, qAbs(distance), me->buttons());

87+ m_pushing = true;

88+ } else if (newX >= screenRect.right()-1 && newY < screenRect.top() + pointer->topBoundaryOffset()) { // top right corner

89+ const auto distance = qSqrt(qPow(newX-screenRect.right(), 2) + qPow(newY - screenRect.top() - pointer->topBoundaryOffset(), 2));

90+ Q_EMIT pushedTopRightCorner(currentScreen, qAbs(distance), me->buttons());

91+ m_pushing = true;

92+ } else if (newX < 0 && newY >= screenRect.bottom()-1) { // bottom left corner

93+ const auto distance = qSqrt(qPow(newX, 2) + qPow(newY-screenRect.bottom(), 2));

94+ Q_EMIT pushedBottomLeftCorner(currentScreen, qAbs(distance), me->buttons());

95+ m_pushing = true;

96+ } else if (newX >= screenRect.right()-1 && newY >= screenRect.bottom()-1) { // bottom right corner

97+ const auto distance = qSqrt(qPow(newX-screenRect.right(), 2) + qPow(newY-screenRect.bottom(), 2));

98+ Q_EMIT pushedBottomRightCorner(currentScreen, qAbs(distance), me->buttons());

99+ m_pushing = true;

100+ } else if (newX < screenRect.left()) { // left edge

101+ Q_EMIT pushedLeftBoundary(currentScreen, qAbs(newX), me->buttons());

102+ m_pushing = true;

103+ } else if (newX >= screenRect.right()) { // right edge

104+ Q_EMIT pushedRightBoundary(currentScreen, newX - (screenRect.right() - 1), me->buttons());

105+ m_pushing = true;

106+ } else if (newY < screenRect.top() + pointer->topBoundaryOffset()) { // top edge

107+ Q_EMIT pushedTopBoundary(currentScreen, qAbs(newY - screenRect.top() - pointer->topBoundaryOffset()), me->buttons());

108+ m_pushing = true;

109+ } else if (Q_LIKELY(newX > 0 && newX < screenRect.right()-1 && newY > 0 && newY < screenRect.bottom()-1)) { // normal pos, not pushing

110+ if (m_pushing) {

111+ Q_EMIT pushStopped(currentScreen);

112+ m_pushing = false;

113+ }

114+ }

115+ }

116+

117+ // Send the event

118+ QMouseEvent eCopy(me->type(), me->localPos(), newPos, me->button(), me->buttons(), me->modifiers());

119+ eCopy.setTimestamp(me->timestamp());

120+ o->event(&eCopy);

121+ return true;

122+ }

123+ default:

124+ break;

125+ }

126+ return false;

127+}

128+

129+QPointF InputDispatcherFilter::adjustedPositionForMovement(const QPointF &pt, const QPointF &movement) const

130+{

131+ QPointF adjusted = pt + movement;

132+

133+ auto screen = screenAt(adjusted); // first check if our move was to a screen with an enabled pointer.

134+ if (screen) {

135+ return adjusted;

136+ } else if ((screen = screenAt(pt))) { // then check if our old position was valid

137+ QRectF screenBounds = screen->geometry();

138+ // bound the new position to the old screen geometry

139+ adjusted.rx() = qMax(screenBounds.left(), qMin(adjusted.x(), screenBounds.right()-1));

140+ adjusted.ry() = qMax(screenBounds.top(), qMin(adjusted.y(), screenBounds.bottom()-1));

141+ } else {

142+ auto screens = QGuiApplication::screens();

143+

144+ // center of first screen with a pointer.

145+ Q_FOREACH(QScreen* screen, screens) {

146+ Q_FOREACH(MousePointer* pointer, m_pointers) {

147+ if (pointer->isEnabled() && pointer->screen() == screen) {

148+ return screen->geometry().center();

149+ }

150+ }

151+ }

152+ }

153+ return adjusted;

154+}

155+

156+QScreen *InputDispatcherFilter::screenAt(const QPointF &pt) const

157+{

158+ Q_FOREACH(MousePointer* pointer, m_pointers) {

159+ if (!pointer->isEnabled()) continue;

160+

161+ QScreen* screen = pointer->screen();

162+ if (screen && screen->geometry().contains(pt.toPoint()))

163+ return screen;

164+ }

165+ return nullptr;

166+}

167+

168+MousePointer *InputDispatcherFilter::currentPointer() const

169+{

170+ Q_FOREACH(MousePointer* pointer, m_pointers) {

171+ if (!pointer->isEnabled()) continue;

172+ return pointer;

173+ }

174+ return nullptr;

175+}

plugins/Cursor/InputDispatcherFilter.hnew file+62

@@ -0,0 +1,62 @@

1+/*

3+ *

4+ * This program is free software: you can redistribute it and/or modify it under

5+ * the terms of the GNU Lesser General Public License version 3, as published by

6+ * the Free Software Foundation.

7+ *

8+ * This program is distributed in the hope that it will be useful, but WITHOUT

9+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,

10+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

11+ * Lesser General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU Lesser General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+ */

16+

17+#ifndef INPUTDISPATCHERFILTER_H

18+#define INPUTDISPATCHERFILTER_H

19+

20+#include <QObject>

21+#include <QPointF>

22+#include <QSet>

23+

24+class MousePointer;

25+class QScreen;

26+

27+class InputDispatcherFilter : public QObject

28+{

29+ Q_OBJECT

30+public:

31+ static InputDispatcherFilter *instance();

32+

33+ void registerPointer(MousePointer* pointer);

34+ void unregisterPointer(MousePointer* pointer);

35+

36+Q_SIGNALS:

37+ void pushedLeftBoundary(QScreen* screen, qreal amount, Qt::MouseButtons buttons);

38+ void pushedRightBoundary(QScreen* screen, qreal amount, Qt::MouseButtons buttons);

39+ void pushedTopBoundary(QScreen* screen, qreal amount, Qt::MouseButtons buttons);

40+ void pushedTopLeftCorner(QScreen* screen, qreal amount, Qt::MouseButtons buttons);

41+ void pushedTopRightCorner(QScreen* screen, qreal amount, Qt::MouseButtons buttons);

42+ void pushedBottomLeftCorner(QScreen* screen, qreal amount, Qt::MouseButtons buttons);

43+ void pushedBottomRightCorner(QScreen* screen, qreal amount, Qt::MouseButtons buttons);

44+ void pushStopped(QScreen* screen);

45+

46+protected:

47+ InputDispatcherFilter(QObject* parent = nullptr);

48+

49+ bool eventFilter(QObject *o, QEvent *e) override;

50+

51+ QPointF adjustedPositionForMovement(const QPointF& pt, const QPointF& movement) const;

52+ QScreen* screenAt(const QPointF& pt) const;

53+

54+ MousePointer* currentPointer() const;

55+

56+private:

57+ QObject* m_inputDispatcher;

58+ QSet<MousePointer*> m_pointers;

59+ bool m_pushing;

60+};

61+

62+#endif // INPUTDISPATCHERFILTER_H

plugins/Cursor/MousePointer.cpp+63−78

@@ -16,84 +16,74 @@

16

17#include "MousePointer.h"

18#include "CursorImageProvider.h"

19−

19+#include "InputDispatcherFilter.h"

20−// Unity API

21−#include <unity/shell/application/MirPlatformCursor.h>

22

20

23#include <QQuickWindow>

21#include <QQuickWindow>

24−#include <QGuiApplication>

25−#include <QtMath>

26

22

27−#include <qpa/qwindowsysteminterface.h>

23+// Unity API

24+#include <unity/shell/application/MirPlatformCursor.h>

28

25

29MousePointer::MousePointer(QQuickItem *parent)

26MousePointer::MousePointer(QQuickItem *parent)

30 : MirMousePointerInterface(parent)

27 : MirMousePointerInterface(parent)

31 , m_cursorName(QStringLiteral("left_ptr"))

28 , m_cursorName(QStringLiteral("left_ptr"))

32 , m_themeName(QStringLiteral("default"))

29 , m_themeName(QStringLiteral("default"))

33{

30{

34−}

31+ connect(InputDispatcherFilter::instance(), &InputDispatcherFilter::pushedLeftBoundary,

35−

32+ this, [this](QScreen* screen, qreal amount, Qt::MouseButtons buttons) {

36−void MousePointer::handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons,

33+ if (window() && window()->screen() == screen) {

37− Qt::KeyboardModifiers modifiers)

34+ Q_EMIT pushedLeftBoundary(amount, buttons);

38−{

39− if (!parentItem()) {

40− return;

41− }

42−

43− if (!movement.isNull()) {

44− Q_EMIT mouseMoved();

45− }

35+ }

46−

36+ });

47− m_accumulatedMovement += movement;

37+ connect(InputDispatcherFilter::instance(), &InputDispatcherFilter::pushedRightBoundary,

48− // don't apply the fractional part

38+ this, [this](QScreen* screen, qreal amount, Qt::MouseButtons buttons) {

49− QPointF appliedMovement(int(m_accumulatedMovement.x()), int(m_accumulatedMovement.y()));

39+ if (window() && window()->screen() == screen) {

50− m_accumulatedMovement -= appliedMovement;

40+ Q_EMIT pushedRightBoundary(amount, buttons);

51−

41+ }

52− qreal newX = x() + appliedMovement.x();

42+ });

53− qreal newY = y() + appliedMovement.y();

43+ connect(InputDispatcherFilter::instance(), &InputDispatcherFilter::pushedTopBoundary,

54− const qreal sceneWidth = parentItem()->width();

44+ this, [this](QScreen* screen, qreal amount, Qt::MouseButtons buttons) {

55− const qreal sceneHeight = parentItem()->height();

45+ if (window() && window()->screen() == screen) {

56−

46+ Q_EMIT pushedTopBoundary(amount, buttons);

57− if (newX <= 0 && newY < m_topBoundaryOffset) { // top left corner

47+ }

58− const auto distance = qSqrt(qPow(newX, 2) + qPow(newY-m_topBoundaryOffset, 2));

48+ });

59− Q_EMIT pushedTopLeftCorner(qAbs(distance), buttons);

49+ connect(InputDispatcherFilter::instance(), &InputDispatcherFilter::pushedTopLeftCorner,

60− m_pushing = true;

50+ this, [this](QScreen* screen, qreal amount, Qt::MouseButtons buttons) {

61− } else if (newX >= sceneWidth-1 && newY < m_topBoundaryOffset) { // top right corner

51+ if (window() && window()->screen() == screen) {

62− const auto distance = qSqrt(qPow(newX-sceneWidth, 2) + qPow(newY-m_topBoundaryOffset, 2));

52+ Q_EMIT pushedTopLeftCorner(amount, buttons);

63− Q_EMIT pushedTopRightCorner(qAbs(distance), buttons);

53+ }

64− m_pushing = true;

54+ });

65− } else if (newX < 0 && newY >= sceneHeight-1) { // bottom left corner

55+ connect(InputDispatcherFilter::instance(), &InputDispatcherFilter::pushedTopRightCorner,

66− const auto distance = qSqrt(qPow(newX, 2) + qPow(newY-sceneHeight, 2));

56+ this, [this](QScreen* screen, qreal amount, Qt::MouseButtons buttons) {

67− Q_EMIT pushedBottomLeftCorner(qAbs(distance), buttons);

57+ if (window() && window()->screen() == screen) {

68− m_pushing = true;

58+ Q_EMIT pushedTopRightCorner(amount, buttons);

69− } else if (newX >= sceneWidth-1 && newY >= sceneHeight-1) { // bottom right corner

59+ }

70− const auto distance = qSqrt(qPow(newX-sceneWidth, 2) + qPow(newY-sceneHeight, 2));

60+ });

71− Q_EMIT pushedBottomRightCorner(qAbs(distance), buttons);

61+ connect(InputDispatcherFilter::instance(), &InputDispatcherFilter::pushedBottomLeftCorner,

72− m_pushing = true;

62+ this, [this](QScreen* screen, qreal amount, Qt::MouseButtons buttons) {

73− } else if (newX < 0) { // left edge

63+ if (window() && window()->screen() == screen) {

74− Q_EMIT pushedLeftBoundary(qAbs(newX), buttons);

64+ Q_EMIT pushedBottomLeftCorner(amount, buttons);

75− m_pushing = true;

65+ }

76− } else if (newX >= sceneWidth) { // right edge

66+ });

77− Q_EMIT pushedRightBoundary(newX - (sceneWidth - 1), buttons);

67+ connect(InputDispatcherFilter::instance(), &InputDispatcherFilter::pushedBottomRightCorner,

78− m_pushing = true;

68+ this, [this](QScreen* screen, qreal amount, Qt::MouseButtons buttons) {

79− } else if (newY < m_topBoundaryOffset) { // top edge

69+ if (window() && window()->screen() == screen) {

80− Q_EMIT pushedTopBoundary(qAbs(newY - m_topBoundaryOffset), buttons);

70+ Q_EMIT pushedBottomRightCorner(amount, buttons);

81− m_pushing = true;

71+ }

82− } else if (Q_LIKELY(newX > 0 && newX < sceneWidth-1 && newY > 0 && newY < sceneHeight-1)) { // normal pos, not pushing

72+ });

83− if (m_pushing) {

73+ connect(InputDispatcherFilter::instance(), &InputDispatcherFilter::pushStopped,

74+ this, [this](QScreen* screen) {

75+ if (window() && window()->screen() == screen) {

84 Q_EMIT pushStopped();

76 Q_EMIT pushStopped();

85− m_pushing = false;

86 }

77 }

87− }

78+ });

88

79

89− applyItemConfinement(newX, newY);

80+ InputDispatcherFilter::instance()->registerPointer(this);

90−

81+}

91− setX(qBound(0.0, newX, sceneWidth - 1));

92− setY(qBound(0.0, newY, sceneHeight - 1));

93

82

94− QPointF scenePosition = mapToItem(nullptr, QPointF(0, 0));

83+MousePointer::~MousePointer()

95− QWindowSystemInterface::handleMouseEvent(window(), timestamp, scenePosition /*local*/, scenePosition /*global*/,

84+{

96− buttons, modifiers);

85+ registerScreen(nullptr);

86+ InputDispatcherFilter::instance()->unregisterPointer(this);

97}

87}

98

88

99void MousePointer::applyItemConfinement(qreal &newX, qreal &newY)

89void MousePointer::applyItemConfinement(qreal &newX, qreal &newY)

@@ -121,17 +111,6 @@ void MousePointer::applyItemConfinement(qreal &newX, qreal &newY)

121 }

111 }

122}

112}

123

113

124−void MousePointer::handleWheelEvent(ulong timestamp, QPoint angleDelta, Qt::KeyboardModifiers modifiers)

125−{

126− if (!parentItem()) {

127− return;

128− }

129−

130− QPointF scenePosition = mapToItem(nullptr, QPointF(0, 0));

131− QWindowSystemInterface::handleWheelEvent(window(), timestamp, scenePosition /* local */, scenePosition /* global */,

132− QPoint() /* pixelDelta */, angleDelta, modifiers, Qt::ScrollUpdate);

133−}

134−

135int MousePointer::topBoundaryOffset() const

114int MousePointer::topBoundaryOffset() const

136{

115{

137 return m_topBoundaryOffset;

116 return m_topBoundaryOffset;

@@ -182,7 +161,7 @@ void MousePointer::registerScreen(QScreen *screen)

182 if (m_registeredScreen) {

161 if (m_registeredScreen) {

183 auto previousCursor = dynamic_cast<MirPlatformCursor*>(m_registeredScreen->handle()->cursor());

162 auto previousCursor = dynamic_cast<MirPlatformCursor*>(m_registeredScreen->handle()->cursor());

184 if (previousCursor) {

163 if (previousCursor) {

185− previousCursor->setMousePointer(nullptr);

164+ previousCursor->unregisterMousePointer(this);

186 } else {

165 } else {

187 qCritical("QPlatformCursor is not a MirPlatformCursor! Cursor module only works in a Mir server.");

166 qCritical("QPlatformCursor is not a MirPlatformCursor! Cursor module only works in a Mir server.");

188 }

167 }

@@ -193,7 +172,7 @@ void MousePointer::registerScreen(QScreen *screen)

193 if (m_registeredScreen) {

172 if (m_registeredScreen) {

194 auto cursor = dynamic_cast<MirPlatformCursor*>(m_registeredScreen->handle()->cursor());

173 auto cursor = dynamic_cast<MirPlatformCursor*>(m_registeredScreen->handle()->cursor());

195 if (cursor) {

174 if (cursor) {

196− cursor->setMousePointer(this);

175+ cursor->registerMousePointer(this);

197 } else {

176 } else {

198 qCritical("QPlaformCursor is not a MirPlatformCursor! Cursor module only works in Mir.");

177 qCritical("QPlaformCursor is not a MirPlatformCursor! Cursor module only works in Mir.");

199 }

178 }

@@ -216,6 +195,12 @@ void MousePointer::setThemeName(const QString &themeName)

216 }

195 }

217}

196}

218

197

198+void MousePointer::moveTo(const QPoint &position)

199+{

200+ setPosition(position);

201+ Q_EMIT mouseMoved();

202+}

203+

219void MousePointer::setCustomCursor(const QCursor &customCursor)

204void MousePointer::setCustomCursor(const QCursor &customCursor)

220{

205{

221 CursorImageProvider::instance()->setCustomCursor(customCursor);

206 CursorImageProvider::instance()->setCustomCursor(customCursor);

plugins/Cursor/MousePointer.h+5−4

@@ -31,6 +31,7 @@ class MousePointer : public MirMousePointerInterface {

31 Q_PROPERTY(int topBoundaryOffset READ topBoundaryOffset WRITE setTopBoundaryOffset NOTIFY topBoundaryOffsetChanged)

32public:

33 MousePointer(QQuickItem *parent = nullptr);

34+ ~MousePointer();

34

35

35 void setCursorName(const QString &qtCursorName) override;

36 void setCursorName(const QString &qtCursorName) override;

36 QString cursorName() const override { return m_cursorName; }

37 QString cursorName() const override { return m_cursorName; }

@@ -38,6 +39,8 @@ public:

38 void setThemeName(const QString &themeName) override;

39 void setThemeName(const QString &themeName) override;

39 QString themeName() const override { return m_themeName; }

40 QString themeName() const override { return m_themeName; }

40

41

42+ void moveTo(const QPoint& position) override;

43+

41 void setCustomCursor(const QCursor &) override;

44 void setCustomCursor(const QCursor &) override;

42

45

43 QQuickItem* confiningItem() const;

46 QQuickItem* confiningItem() const;

@@ -46,10 +49,7 @@ public:

46 int topBoundaryOffset() const;

49 int topBoundaryOffset() const;

47 void setTopBoundaryOffset(int topBoundaryOffset);

50 void setTopBoundaryOffset(int topBoundaryOffset);

48

51

49−public Q_SLOTS:

52+ QScreen* screen() const { return m_registeredScreen; }

50− void handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons,

51− Qt::KeyboardModifiers modifiers) override;

52− void handleWheelEvent(ulong timestamp, QPoint angleDelta, Qt::KeyboardModifiers modifiers) override;

53

54Q_SIGNALS:

55 void pushedLeftBoundary(qreal amount, Qt::MouseButtons buttons);

@@ -79,6 +79,7 @@ private:

79 QPointer<QScreen> m_registeredScreen;

80 QString m_cursorName;

81 QString m_themeName;

82+ bool m_active;

82

83

83 // Accumulated, unapplied, mouse movement.

84 // Accumulated, unapplied, mouse movement.

84 QPointF m_accumulatedMovement;

85 QPointF m_accumulatedMovement;

plugins/UInput/plugin.cpp+7−1

@@ -19,8 +19,14 @@

19

20#include <QtQml/qqml.h>

21

22+

23+QObject* uinputSingleton(QQmlEngine*, QJSEngine*)

24+{

25+ return new UInput;

26+}

27+

22void UInputPlugin::registerTypes(const char *uri)

28void UInputPlugin::registerTypes(const char *uri)

23{

29{

24 Q_ASSERT(uri == QLatin1String("UInput"));

30 Q_ASSERT(uri == QLatin1String("UInput"));

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

31+ qmlRegisterSingletonType<UInput>(uri, 0, 1, "UInput", uinputSingleton);

26}

32}

plugins/Unity/CMakeLists.txt+1

@@ -1,5 +1,6 @@

1add_subdirectory(ApplicationMenu)

2add_subdirectory(Connectivity)

3+add_subdirectory(Debug)

3add_subdirectory(Indicators)

4add_subdirectory(Indicators)

4add_subdirectory(Launcher)

5add_subdirectory(Launcher)

5add_subdirectory(Session)

6add_subdirectory(Session)

plugins/Unity/Debug/CMakeLists.txtnew file+30

@@ -0,0 +1,30 @@

1+include_directories(

2+ ${CMAKE_CURRENT_SOURCE_DIR}

3+ ${CMAKE_CURRENT_BINARY_DIR}

4+)

5+

6+include_directories(

7+ SYSTEM

8+ ${Qt5Gui_PRIVATE_INCLUDE_DIRS}

9+ ${Qt5Quick_PRIVATE_INCLUDE_DIRS}

10+ ${GIO_INCLUDE_DIRS}

11+)

12+

13+set(QMLPLUGIN_SRC

14+ consolelog.cpp

15+ plugin.cpp

16+ )

17+

18+add_library(Debug-qml SHARED

19+ ${QMLPLUGIN_SRC}

20+ )

21+

22+# Because this is an internal support library, we want

23+# to expose all symbols in it. Consider changing this

24+# either to a static library or just using the

25+# files directly in targets.

26+set_target_properties(Debug-qml PROPERTIES COMPILE_FLAGS -fvisibility=default)

27+

28+qt5_use_modules(Debug-qml Qml Quick Concurrent)

29+

30+add_unity8_plugin(Unity.Debug 0.1 Unity/Debug TARGETS Debug-qml)

plugins/Unity/Debug/consolelog.cppnew file+221

@@ -0,0 +1,221 @@

1+/*

3+ *

4+ * This program is free software; you can redistribute it and/or modify

5+ * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU Lesser General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+*/

16+

17+#include "consolelog.h"

18+

19+#include <unistd.h>

20+#include <stdio.h>

21+#include <thread>

22+#include <iostream>

23+#include <sys/ioctl.h>

24+

25+#include <functional>

26+

27+namespace

28+{

29+

30+int wait_fd(std::function<int(void)> fn)

31+{

32+ int ret = -1;

33+ bool fd_blocked = false;

34+ do

35+ {

36+ ret = fn();

37+ fd_blocked = (errno == EINTR || errno == EBUSY);

38+ if (fd_blocked)

39+ QThread::msleep(10);

40+ }

41+ while (ret < 0);

42+ return ret;

43+}

44+

45+#define PIPE_WAIT(val) wait_fd(std::bind(pipe, val))

46+#define DUP_WAIT(fd) wait_fd(std::bind(dup, fd))

47+#define DUP2_WAIT(fd1, fd2) wait_fd(std::bind(dup2, fd1, fd2))

48+#define CLOSE_WAIT(fd) wait_fd(std::bind(close, fd))

49+

50+}

51+

52+LogRedirector::LogRedirector()

53+ : m_ref(0)

54+ , m_stop(false)

55+{

56+ setObjectName("ConsoleLog");

57+

58+ // make stdout & stderr streams unbuffered

59+ // so that we don't need to flush the streams

60+ // before capture and after capture

61+ // (fflush can cause a deadlock if the stream is currently being used)

62+ setvbuf(stdout,NULL,_IONBF,0);

63+ setvbuf(stderr,NULL,_IONBF,0);

64+}

65+

66+void LogRedirector::run()

67+{

68+ PIPE_WAIT(m_pipe);

69+

70+ int oldStdOut = DUP_WAIT(fileno(stdout));

71+ int oldStdErr = DUP_WAIT(fileno(stderr));

72+

73+ DUP2_WAIT(m_pipe[WRITE], fileno(stdout));

74+ DUP2_WAIT(m_pipe[WRITE], fileno(stderr));

75+ CLOSE_WAIT(m_pipe[WRITE]);

76+

77+ while(true) {

78+ {

79+ QMutexLocker lock(&m_mutex);

80+ if (m_stop) break;

81+ }

82+ checkLog();

83+ QThread::msleep(50);

84+ }

85+

86+ DUP2_WAIT(oldStdOut, fileno(stdout));

87+ DUP2_WAIT(oldStdErr, fileno(stderr));

88+

89+ CLOSE_WAIT(oldStdOut);

90+ CLOSE_WAIT(oldStdErr);

91+ CLOSE_WAIT(m_pipe[READ]);

92+}

93+

94+

95+void LogRedirector::checkLog()

96+{

97+ // Do not allow read to block with no data.

98+ // If we stop the thread while waiting a read,

99+ // it will block the main thread waiting for this thread to stop.

100+ int count = 0;

101+ ioctl(m_pipe[READ], FIONREAD, &count);

102+ if (count <= 0) return;

103+

104+ std::string captured;

105+ std::string buf;

106+ const int bufSize = 1024;

107+ buf.resize(bufSize);

108+ int bytesRead = 0;

109+ bytesRead = read(m_pipe[READ], &(*buf.begin()), bufSize);

110+ while(bytesRead == bufSize)

111+ {

112+ captured += buf;

113+ bytesRead = 0;

114+ bytesRead = read(m_pipe[READ], &(*buf.begin()), bufSize);

115+ }

116+ if (bytesRead > 0)

117+ {

118+ buf.resize(bytesRead);

119+ captured += buf;

120+ }

121+

122+ if (!captured.empty()) {

123+ Q_EMIT log(QString::fromStdString(captured));

124+ }

125+}

126+

127+LogRedirector *LogRedirector::instance()

128+{

129+ static LogRedirector* log = nullptr;

130+ if (!log) {

131+ log = new LogRedirector();

132+ }

133+ return log;

134+}

135+

136+void LogRedirector::add(ConsoleLog* logger)

137+{

138+ QMutexLocker lock(&m_mutex);

139+ connect(this, &LogRedirector::log, logger, &ConsoleLog::logged, Qt::UniqueConnection);

140+

141+ m_ref++;

142+ if (!LogRedirector::instance()->isRunning()) {

143+ m_stop = false;

144+ LogRedirector::instance()->start();

145+ }

146+}

147+

148+void LogRedirector::remove(ConsoleLog* logger)

149+{

150+ QMutexLocker lock(&m_mutex);

151+ disconnect(this, &LogRedirector::log, logger, &ConsoleLog::logged);

152+

153+ m_ref = qMax(m_ref-1, 0);

154+ if (m_ref == 0 && LogRedirector::instance()->isRunning()) {

155+ m_stop = true;

156+ lock.unlock();

157+ LogRedirector::instance()->wait();

158+ }

159+}

160+

161+ConsoleLog::ConsoleLog(QObject *parent)

162+ : QObject(parent)

163+ , m_enabled(false)

164+ , m_maxLines(60)

165+{

166+ auto updateEnabled = [this]() {

167+ if (m_enabled) {

168+ LogRedirector::instance()->add(this);

169+ } else {

170+ LogRedirector::instance()->remove(this);

171+ }

172+ };

173+ connect(this, &ConsoleLog::enabledChanged, this, updateEnabled);

174+}

175+

176+ConsoleLog::~ConsoleLog()

177+{

178+ if (m_enabled) {

179+ LogRedirector::instance()->remove(this);

180+ }

181+}

182+

183+void ConsoleLog::setEnabled(bool enabled)

184+{

185+ if (m_enabled == enabled) {

186+ return;

187+ }

188+

189+ m_enabled = enabled;

190+ Q_EMIT enabledChanged();

191+}

192+

193+QString ConsoleLog::out() const

194+{

195+ return m_out.join("\n");

196+}

197+

198+void ConsoleLog::setMaxLines(int maxLines)

199+{

200+ if (m_maxLines == maxLines) {

201+ return;

202+ }

203+

204+ m_maxLines = maxLines;

205+ while (m_out.count() > m_maxLines) {

206+ m_out.removeLast();

207+ }

208+ Q_EMIT outChanged();

209+ Q_EMIT maxLinesChanged();

210+}

211+

212+void ConsoleLog::logged(QString captured)

213+{

214+ QStringList li = captured.split("\n", QString::SkipEmptyParts);

215+ li << m_out;

216+ m_out = li;

217+ while (m_out.count() > m_maxLines) {

218+ m_out.removeLast();

219+ }

220+ Q_EMIT outChanged();

221+}

plugins/Unity/Debug/consolelog.hnew file+87

@@ -0,0 +1,87 @@

1+/*

3+ *

4+ * This program is free software; you can redistribute it and/or modify

5+ * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU Lesser General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+*/

16+

17+#ifndef CONSOLELOG_H

18+#define CONSOLELOG_H

19+

20+#include <QThread>

21+#include <QMutex>

22+#include <QSet>

23+

24+class ConsoleLog;

25+

26+class LogRedirector : public QThread

27+{

28+ Q_OBJECT

29+public:

30+ static LogRedirector *instance();

31+

32+ void add(ConsoleLog* logger);

33+ void remove(ConsoleLog* logger);

34+

35+private Q_SLOTS:

36+ void checkLog();

37+

38+Q_SIGNALS:

39+ void log(QString log);

40+

41+private:

42+ LogRedirector();

43+ void run() Q_DECL_OVERRIDE;

44+

45+ QMutex m_mutex;

46+ int m_pipe[2];

47+ int m_ref;

48+ bool m_stop;

49+

50+ enum PIPES { READ, WRITE };

51+};

52+

53+class ConsoleLog : public QObject

54+{

55+ Q_OBJECT

56+ Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)

57+ Q_PROPERTY(QString out READ out NOTIFY outChanged)

58+ Q_PROPERTY(int maxLines READ maxLines WRITE setMaxLines NOTIFY maxLinesChanged)

59+public:

60+ explicit ConsoleLog(QObject *parent = 0);

61+ ~ConsoleLog();

62+

63+ bool isEnabled() const { return m_enabled; }

64+ void setEnabled(bool enabled);

65+

66+ QString out() const;

67+

68+ int maxLines() const { return m_maxLines; }

69+ void setMaxLines(int maxLines);

70+

71+public Q_SLOTS:

72+ void logged(QString captured);

73+

74+Q_SIGNALS:

75+ void enabledChanged();

76+ void outChanged();

77+ void maxLinesChanged();

78+

79+private:

80+ void updateEnabled();

81+

82+ QStringList m_out;

83+ bool m_enabled;

84+ int m_maxLines;

85+};

86+

87+#endif // CONSOLELOG_H

plugins/Unity/Debug/plugin.cppnew file+31

@@ -0,0 +1,31 @@

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

18+#include <QtQml/qqml.h>

19+

20+// self

21+#include "plugin.h"

22+

23+// local

24+#include "consolelog.h"

25+

26+void UnityDebugPlugin::registerTypes(const char *uri)

27+{

28+ Q_ASSERT(uri == QLatin1String("Unity.Debug"));

29+

30+ qmlRegisterType<ConsoleLog>(uri, 0, 1, "ConsoleLog");

31+}

src/ShellView.h → plugins/Unity/Debug/plugin.hrenamed+9−11

@@ -1,5 +1,5 @@

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

@@ -14,21 +14,19 @@

14 * along with this program. If not, see <http://www.gnu.org/licenses/>.

15 */

16

17−#ifndef UNITY_SHELL_VIEW_H

17+#ifndef UNITYDEBUG_PLUGIN_H

18−#define UNITY_SHELL_VIEW_H

18+#define UNITYDEBUG_PLUGIN_H

19

20−#include <QQuickView>

20+#include <QtQml/QQmlEngine>

21+#include <QtQml/QQmlExtensionPlugin>

21

22

22−class ShellView : public QQuickView

23+class UnityDebugPlugin : public QQmlExtensionPlugin

23{

24{

24 Q_OBJECT

25 Q_OBJECT

26+ Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")

25

27

26public:

28public:

27− ShellView(QQmlEngine *engine, QObject *qmlArgs);

29+ void registerTypes(const char *uri) override;

28−

29−private Q_SLOTS:

30− void onWidthChanged(int);

31− void onHeightChanged(int);

32};

30};

33

31

34−#endif // UNITY_SHELL_VIEW_H

32+#endif

plugins/Unity/Debug/qmldirnew file+3

@@ -0,0 +1,3 @@

1+module Unity.Debug

2+plugin Debug-qml

3+typeinfo Debug.qmltypes

qml/CMakeLists.txt+1−1

@@ -1,4 +1,4 @@

1−file(GLOB QML_JS_FILES *.qml *.js)

1+file(GLOB QML_JS_FILES *.qml *.js qmldir)

2

3install(FILES ${QML_JS_FILES}

4 DESTINATION ${SHELL_APP_DIR}

qml/Components/PanelState/PanelState.qml−1

@@ -14,7 +14,6 @@

14 * along with this program. If not, see <http://www.gnu.org/licenses/>.

15 */

16

17−pragma Singleton

18import QtQuick 2.4

17import QtQuick 2.4

19

18

20QtObject {

19QtObject {

qml/Components/PanelState/qmldir+1−1

@@ -1 +1 @@

1−singleton PanelState 1.0 PanelState.qml

1+PanelState 1.0 PanelState.qml

qml/Components/VirtualTouchPad.qml+13−19

@@ -24,16 +24,14 @@ import "../Components"

24

25Item {

26 id: root

27− property var uinput: UInput {

28− Component.onCompleted: createMouse();

29− Component.onDestruction: removeMouse();

30− }

31

27

32 Component.onCompleted: {

28 Component.onCompleted: {

29+ UInput.createMouse();

33 if (!settings.touchpadTutorialHasRun) {

30 if (!settings.touchpadTutorialHasRun) {

34 root.runTutorial()

31 root.runTutorial()

35 }

32 }

36 }

33 }

34+ Component.onDestruction: UInput.removeMouse()

37

35

38 function runTutorial() {

36 function runTutorial() {

39 // If the tutorial animation is started too early, e.g. in Component.onCompleted,

37 // If the tutorial animation is started too early, e.g. in Component.onCompleted,

@@ -85,7 +83,7 @@ Item {

85 if (((point1.pressed && !point2.pressed) || (!point1.pressed && point2.pressed))

83 if (((point1.pressed && !point2.pressed) || (!point1.pressed && point2.pressed))

86 && clickTimer.running) {

84 && clickTimer.running) {

87 clickTimer.stop();

85 clickTimer.stop();

88− uinput.pressMouse(UInput.ButtonLeft)

86+ UInput.pressMouse(UInput.ButtonLeft)

89 isDoubleClick = true;

87 isDoubleClick = true;

90 }

88 }

91 isClick = true;

89 isClick = true;

@@ -104,7 +102,7 @@ Item {

104

102

105 onReleased: {

103 onReleased: {

106 if (isDoubleClick || isDrag) {

104 if (isDoubleClick || isDrag) {

107− uinput.releaseMouse(UInput.ButtonLeft)

105+ UInput.releaseMouse(UInput.ButtonLeft)

108 isDoubleClick = false;

106 isDoubleClick = false;

109 }

107 }

110 if (isClick) {

108 if (isClick) {

@@ -120,8 +118,8 @@ Item {

120 interval: 200

118 interval: 200

121 property int button: UInput.ButtonLeft

119 property int button: UInput.ButtonLeft

122 onTriggered: {

120 onTriggered: {

123− uinput.pressMouse(button);

121+ UInput.pressMouse(button);

124− uinput.releaseMouse(button);

122+ UInput.releaseMouse(button);

125 }

123 }

126 function scheduleClick(button) {

124 function scheduleClick(button) {

127 clickTimer.button = button;

125 clickTimer.button = button;

@@ -138,7 +136,7 @@ Item {

138 isDrag = true;

136 isDrag = true;

139 }

137 }

140

138

141− uinput.moveMouse(tp.x - tp.previousX, tp.y - tp.previousY);

139+ UInput.moveMouse(tp.x - tp.previousX, tp.y - tp.previousY);

142 }

140 }

143

141

144 function scroll(touchPoints) {

142 function scroll(touchPoints) {

@@ -166,7 +164,7 @@ Item {

166 dh /= 2;

164 dh /= 2;

167 dv /= 2;

165 dv /= 2;

168

166

169− uinput.scrollMouse(dh, dv);

167+ UInput.scrollMouse(dh, dv);

170 }

168 }

171

169

172 touchPoints: [

170 touchPoints: [

@@ -189,8 +187,8 @@ Item {

189 objectName: "leftButton"

187 objectName: "leftButton"

190 Layout.fillWidth: true

188 Layout.fillWidth: true

191 Layout.fillHeight: true

189 Layout.fillHeight: true

192− onPressed: uinput.pressMouse(UInput.ButtonLeft);

190+ onPressed: UInput.pressMouse(UInput.ButtonLeft);

193− onReleased: uinput.releaseMouse(UInput.ButtonLeft);

191+ onReleased: UInput.releaseMouse(UInput.ButtonLeft);

194 property bool highlight: false

192 property bool highlight: false

195 UbuntuShape {

193 UbuntuShape {

196 anchors.fill: parent

194 anchors.fill: parent

@@ -204,8 +202,8 @@ Item {

204 objectName: "rightButton"

202 objectName: "rightButton"

205 Layout.fillWidth: true

203 Layout.fillWidth: true

206 Layout.fillHeight: true

204 Layout.fillHeight: true

207− onPressed: uinput.pressMouse(UInput.ButtonRight);

205+ onPressed: UInput.pressMouse(UInput.ButtonRight);

208− onReleased: uinput.releaseMouse(UInput.ButtonRight);

206+ onReleased: UInput.releaseMouse(UInput.ButtonRight);

209 property bool highlight: false

207 property bool highlight: false

210 UbuntuShape {

208 UbuntuShape {

211 anchors.fill: parent

209 anchors.fill: parent

@@ -239,14 +237,10 @@ Item {

239 }

237 }

240 }

238 }

241

239

242− Screens {

243− id: screens

244− }

245−

246 InputMethod {

240 InputMethod {

247 id: inputMethod

241 id: inputMethod

248 // Don't resize when there is only one screen to avoid resize clashing with the InputMethod in the Shell.

242 // Don't resize when there is only one screen to avoid resize clashing with the InputMethod in the Shell.

249− enabled: screens.count > 1 && settings.oskEnabled && !tutorial.running

243+ enabled: Screens.count > 1 && settings.oskEnabled && !tutorial.running

250 objectName: "inputMethod"

244 objectName: "inputMethod"

251 anchors.fill: parent

245 anchors.fill: parent

252 }

246 }

qml/DisabledScreenNotice.qml+2−1

@@ -28,8 +28,9 @@ Item {

28 property var screen: Screen

29 property var orientationLock: OrientationLock

30

31+ property alias deviceConfiguration: _deviceConfiguration

31 DeviceConfiguration {

32 DeviceConfiguration {

32− id: deviceConfiguration

33+ id: _deviceConfiguration

33 name: applicationArguments.deviceName

34 name: applicationArguments.deviceName

34 }

35 }

35

36

qml/Greeter/Greeter.qml+21−3

@@ -25,6 +25,7 @@ import Unity.Launcher 0.1

25import Unity.Session 0.1

26

27import "." 0.1

28+import ".." 0.1

28import "../Components"

29import "../Components"

29

30

30Showable {

31Showable {

@@ -227,7 +228,7 @@ Showable {

227 if (forcedUnlock && shown) {

228 if (forcedUnlock && shown) {

228 hideView();

229 hideView();

229 if (hideNow) {

230 if (hideNow) {

230− root.hideNow(); // skip hide animation

231+ ShellNotifier.greeter.hide(true); // skip hide animation

231 }

232 }

233 }

234 }

@@ -375,7 +376,7 @@ Showable {

375 onEmergencyCall: root.emergencyCall()

376 onEmergencyCall: root.emergencyCall()

376 onRequiredChanged: {

377 onRequiredChanged: {

377 if (!loader.item.required) {

378 if (!loader.item.required) {

378− root.hide();

379+ ShellNotifier.greeter.hide(false);

379 }

380 }

381 }

382 }

@@ -498,12 +499,29 @@ Showable {

498 onRequestAuthenticationUser: d.selectUser(d.getUserIndex(user))

499 onRequestAuthenticationUser: d.selectUser(d.getUserIndex(user))

499 }

500 }

500

501

502+ Connections {

503+ target: ShellNotifier.greeter

504+ onHide: {

505+ if (now) {

506+ root.hideNow(); // skip hide animation

507+ } else {

508+ root.hide();

509+ }

510+ }

511+ }

512+

513+ Binding {

514+ target: ShellNotifier.greeter

515+ property: "shown"

516+ value: root.shown

517+ }

518+

501 Connections {

519 Connections {

502 target: DBusUnitySessionService

520 target: DBusUnitySessionService

503 onLockRequested: root.forceShow()

521 onLockRequested: root.forceShow()

504 onUnlocked: {

522 onUnlocked: {

505 root.forcedUnlock = true;

523 root.forcedUnlock = true;

506− root.hideNow();

524+ ShellNotifier.greeter.hide(true);

507 }

525 }

508 }

526 }

509

527

qml/Greeter/SecondaryGreeter.qmlnew file+75

@@ -0,0 +1,75 @@

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+import QtQuick 2.4

18+import Ubuntu.Components 1.3

19+

20+import "../Components"

21+import ".." 0.1

22+

23+Showable {

24+ id: root

25+

26+ readonly property bool active: required || hasLockedApp

27+

28+ readonly property bool hasLockedApp: lockedApp !== ""

29+ readonly property bool locked: false

30+ readonly property bool waiting: false

31+ readonly property bool fullyShown: shown

32+

33+ property string lockedApp: ""

34+

35+ function forceShow() { show(); }

36+ property var notifyAppFocusRequested: (function(appId) { return; })

37+ property var notifyUserRequestedApp: (function(appId) { return; })

38+ property var notifyShowingDashFromDrag: (function(appId) { return false; })

39+

40+ showAnimation: StandardAnimation { property: "opacity"; to: 1 }

41+ hideAnimation: StandardAnimation { property: "opacity"; to: 0 }

42+

43+ shown: ShellNotifier.greeter.shown

44+ Component.onCompleted: opacity = shown ? 1 : 0

45+ visible: opacity != 0

46+

47+ Rectangle {

48+ anchors.fill: parent

49+ color: UbuntuColors.purple

50+ }

51+

52+ MouseArea {

53+ anchors.fill: parent

54+ acceptedButtons: Qt.AllButtons

55+ onWheel: wheel.accepted = true

56+ }

57+

58+ Connections {

59+ target: ShellNotifier.greeter

60+ onHide: {

61+ if (now) {

62+ root.hideNow(); // skip hide animation

63+ } else {

64+ root.hide();

65+ }

66+ }

67+ onShownChanged: {

68+ if (ShellNotifier.greeter.shown) {

69+ root.show();

70+ } else {

71+ root.hide();

72+ }

73+ }

74+ }

75+}

qml/OrientedShell.qml+7−9

@@ -32,15 +32,17 @@ Item {

32 implicitWidth: units.gu(40)

33 implicitHeight: units.gu(71)

34

35+ property alias deviceConfiguration: _deviceConfiguration

36+ property alias orientations: d.orientations

37+ property alias surfaceManager: shell.surfaceManager

38+

35 onWidthChanged: calculateUsageMode();

39 onWidthChanged: calculateUsageMode();

36

40

37 DeviceConfiguration {

41 DeviceConfiguration {

38− id: deviceConfiguration

42+ id: _deviceConfiguration

39 name: applicationArguments.deviceName

43 name: applicationArguments.deviceName

40 }

44 }

41

45

42− property alias orientations: d.orientations

43−

44 Item {

46 Item {

45 id: d

47 id: d

46

48

@@ -157,10 +159,6 @@ Item {

157 return false;

159 return false;

158 }

160 }

159

161

160− Screens {

161− id: screens

162− }

163−

164 property int orientation

162 property int orientation

165 onPhysicalOrientationChanged: {

163 onPhysicalOrientationChanged: {

166 if (!orientationLocked) {

164 if (!orientationLocked) {

@@ -258,7 +256,7 @@ Item {

258

256

259 Shell {

257 Shell {

260 id: shell

258 id: shell

261− objectName: "shell"

259+ objectName: "shell-"+screenWindow.objectName

262 width: root.width

260 width: root.width

263 height: root.height

261 height: root.height

264 orientation: root.angleToOrientation(orientationAngle)

262 orientation: root.angleToOrientation(orientationAngle)

@@ -272,7 +270,7 @@ Item {

272 // have multiple keyboards around. For now we only enable one keyboard at a time

270 // have multiple keyboards around. For now we only enable one keyboard at a time

273 // thus hiding it here if there is a physical one around or if we have a second

271 // thus hiding it here if there is a physical one around or if we have a second

274 // screen (the virtual touchpad & osk on the phone) attached.

272 // screen (the virtual touchpad & osk on the phone) attached.

275− oskEnabled: (keyboardsModel.count === 0 && screens.count === 1) ||

273+ oskEnabled: (keyboardsModel.count === 0 && Screens.count === 1) ||

276 forceOSKEnabled

274 forceOSKEnabled

277

275

278 usageScenario: {

276 usageScenario: {

qml/Panel/Panel.qml+14−14

@@ -47,8 +47,8 @@ Item {

47 property bool fullscreenMode: false

48 property real panelAreaShowProgress: 1.0

49 property bool greeterShown: false

50−

51 property string mode: "staged"

50 property string mode: "staged"

51+ property PanelState panelState

52

53 MouseArea {

54 id: backMouseEater

@@ -65,14 +65,14 @@ Item {

65 }

66

67 Binding {

68− target: PanelState

68+ target: panelState

69 property: "panelHeight"

70 value: minimizedPanelHeight

71 }

72

73 RegisteredApplicationMenuModel {

74 id: registeredMenuModel

75− persistentSurfaceId: PanelState.focusedPersistentSurfaceId

75+ persistentSurfaceId: panelState.focusedPersistentSurfaceId

76 }

77

78 QtObject {

@@ -83,11 +83,11 @@ Item {

83 !indicators.shown &&

84 (decorationMouseArea.containsMouse || menuBarLoader.menusRequested)

85

86− property bool showWindowDecorationControls: (revealControls && PanelState.decorationsVisible) ||

86+ property bool showWindowDecorationControls: (revealControls && panelState.decorationsVisible) ||

87− PanelState.decorationsAlwaysVisible

87+ panelState.decorationsAlwaysVisible

88

89 property bool showPointerMenu: revealControls &&

90− (PanelState.decorationsVisible || mode == "staged")

90+ (panelState.decorationsVisible || mode == "staged")

91

92 property bool enablePointerMenu: revealControls &&

93 applicationMenus.available &&

@@ -139,7 +139,7 @@ Item {

139 fill: panelAreaBackground

140 bottomMargin: -units.gu(1)

141 }

142− visible: PanelState.dropShadow

142+ visible: panelState.dropShadow

143 source: "graphics/rectangular_dropshadow.sci"

144 }

145

@@ -192,12 +192,12 @@ Item {

192 visible: opacity != 0

193 Behavior on opacity { UbuntuNumberAnimation { duration: UbuntuAnimation.SnapDuration } }

194

195− active: PanelState.decorationsVisible || PanelState.decorationsAlwaysVisible

195+ active: panelState.decorationsVisible || panelState.decorationsAlwaysVisible

196 windowIsMaximized: true

197− onCloseClicked: PanelState.closeClicked()

197+ onCloseClicked: panelState.closeClicked()

198− onMinimizeClicked: PanelState.minimizeClicked()

198+ onMinimizeClicked: panelState.minimizeClicked()

199− onMaximizeClicked: PanelState.restoreClicked()

199+ onMaximizeClicked: panelState.restoreClicked()

200− closeButtonShown: PanelState.closeButtonShown

200+ closeButtonShown: panelState.closeButtonShown

201 }

202

203 Loader {

@@ -217,7 +217,7 @@ Item {

217 anchors.left: parent.left

218 anchors.margins: units.gu(1)

219 height: menuBarLoader.height

220− enableKeyFilter: valid && PanelState.decorationsVisible

220+ enableKeyFilter: valid && panelState.decorationsVisible

221 unityMenuModel: __applicationMenus.model

222

223 Connections {

@@ -265,7 +265,7 @@ Item {

265 }

266

267 showRowTitle: !expanded

268− rowTitle: PanelState.title

268+ rowTitle: panelState.title

269 rowItemDelegate: ActionItem {

270 id: actionItem

271 property int ownIndex: index

qml/Shell.qml+48−12

@@ -1,4 +1,4 @@

1−/*

1+/*

3 *

4 * This program is free software; you can redistribute it and/or modify

@@ -38,12 +38,14 @@ import "Notifications"

38import "Stage"

39import "Tutorial"

40import "Wizard"

41+import "Components/PanelState"

41import Unity.Notifications 1.0 as NotificationBackend

42import Unity.Notifications 1.0 as NotificationBackend

42import Unity.Session 0.1

43import Unity.Session 0.1

43import Unity.DashCommunicator 0.1

44import Unity.DashCommunicator 0.1

44import Unity.Indicators 0.1 as Indicators

45import Unity.Indicators 0.1 as Indicators

45import Cursor 1.1

46import Cursor 1.1

46import WindowManager 1.0

47import WindowManager 1.0

48+import Unity.Debug 0.1 as Debug

47

49

48

50

49StyledItem {

51StyledItem {

@@ -52,6 +54,7 @@ StyledItem {

52 theme.name: "Ubuntu.Components.Themes.SuruDark"

54 theme.name: "Ubuntu.Components.Themes.SuruDark"

53

55

54 // to be set from outside

56 // to be set from outside

57+ property alias surfaceManager: topLevelSurfaceList.surfaceManager

55 property int orientationAngle: 0

58 property int orientationAngle: 0

56 property int orientation

59 property int orientation

57 property Orientations orientations

60 property Orientations orientations

@@ -259,21 +262,21 @@ StyledItem {

259 schema.id: "com.canonical.Unity8"

262 schema.id: "com.canonical.Unity8"

260 }

263 }

261

264

265+ PanelState {

266+ id: panelState

267+ objectName: "panelState"

268+ }

269+

262 Item {

270 Item {

263 id: stages

271 id: stages

264 objectName: "stages"

272 objectName: "stages"

265 width: parent.width

273 width: parent.width

266 height: parent.height

274 height: parent.height

267

275

268− SurfaceManager {

269− id: surfaceMan

270− objectName: "surfaceManager"

271− }

272 TopLevelWindowModel {

276 TopLevelWindowModel {

273 id: topLevelSurfaceList

277 id: topLevelSurfaceList

274 objectName: "topLevelSurfaceList"

278 objectName: "topLevelSurfaceList"

275 applicationManager: ApplicationManager // it's a singleton

279 applicationManager: ApplicationManager // it's a singleton

276− surfaceManager: surfaceMan

277 }

280 }

278

281

279 Stage {

282 Stage {

@@ -314,6 +317,7 @@ StyledItem {

314 altTabPressed: physicalKeysMapper.altTabPressed

317 altTabPressed: physicalKeysMapper.altTabPressed

315 oskEnabled: shell.oskEnabled

318 oskEnabled: shell.oskEnabled

316 spreadEnabled: tutorial.spreadEnabled && (!greeter || (!greeter.hasLockedApp && !greeter.shown))

319 spreadEnabled: tutorial.spreadEnabled && (!greeter || (!greeter.hasLockedApp && !greeter.shown))

320+ panelState: panelState

317

321

318 onSpreadShownChanged: {

322 onSpreadShownChanged: {

319 panel.indicators.hide();

323 panel.indicators.hide();

@@ -368,8 +372,13 @@ StyledItem {

368 objectName: "greeterLoader"

372 objectName: "greeterLoader"

369 anchors.fill: parent

373 anchors.fill: parent

370 anchors.topMargin: panel.panelHeight

374 anchors.topMargin: panel.panelHeight

371− sourceComponent: shell.mode != "shell" ? integratedGreeter :

375+ sourceComponent: {

376+ if (shell.mode != "shell") {

377+ if (screenWindow.primary) return integratedGreeter;

378+ return secondaryGreeter;

379+ }

372− Qt.createComponent(Qt.resolvedUrl("Greeter/ShimGreeter.qml"));

380+ return Qt.createComponent(Qt.resolvedUrl("Greeter/ShimGreeter.qml"));

381+ }

373 onLoaded: {

382 onLoaded: {

374 item.objectName = "greeter"

383 item.objectName = "greeter"

375 }

384 }

@@ -419,6 +428,13 @@ StyledItem {

419 }

428 }

420 }

429 }

421

430

431+ Component {

432+ id: secondaryGreeter

433+ SecondaryGreeter {

434+ hides: [launcher, panel.indicators]

435+ }

436+ }

437+

422 Timer {

438 Timer {

423 // See powerConnection for why this is useful

439 // See powerConnection for why this is useful

424 id: showGreeterDelayed

440 id: showGreeterDelayed

@@ -531,6 +547,7 @@ StyledItem {

531 fullscreenMode: (focusedSurfaceIsFullscreen && !LightDMService.greeter.active && launcher.progress == 0)

547 fullscreenMode: (focusedSurfaceIsFullscreen && !LightDMService.greeter.active && launcher.progress == 0)

532 || greeter.hasLockedApp

548 || greeter.hasLockedApp

533 greeterShown: greeter && greeter.shown

549 greeterShown: greeter && greeter.shown

550+ panelState: panelState

534 }

551 }

535

552

536 Launcher {

553 Launcher {

@@ -743,12 +760,13 @@ StyledItem {

743

760

744 Cursor {

761 Cursor {

745 id: cursor

762 id: cursor

746− objectName: "cursor"

763+ objectName: "Pointer-"+screenWindow.objectName

747− visible: shell.hasMouse

764+

748 z: itemGrabber.z + 1

765 z: itemGrabber.z + 1

766+ opacity: 0

749 topBoundaryOffset: panel.panelHeight

767 topBoundaryOffset: panel.panelHeight

750−

768+ enabled: shell.hasMouse && screenWindow.active

751− confiningItem: stage.itemConfiningMouseCursor

769+ visible: enabled

752

770

753 property bool mouseNeverMoved: true

771 property bool mouseNeverMoved: true

754 Binding {

772 Binding {

@@ -760,6 +778,8 @@ StyledItem {

760 when: cursor.mouseNeverMoved && cursor.visible

778 when: cursor.mouseNeverMoved && cursor.visible

761 }

779 }

762

780

781+ confiningItem: stage.itemConfiningMouseCursor

782+

763 height: units.gu(3)

783 height: units.gu(3)

764

784

765 readonly property var previewRectangle: stage.previewRectangle.target &&

785 readonly property var previewRectangle: stage.previewRectangle.target &&

@@ -846,4 +866,20 @@ StyledItem {

846 }

866 }

847 }

867 }

848 }

868 }

869+

870+ Loader {

871+ z: shutdownFadeOutRectangle.z + 1

872+ active: DebuggingController.logOverlay

873+

874+ sourceComponent: Text {

875+ width: shell.width

876+ height: shell.height

877+

878+ text: consoleLog.out

879+ Debug.ConsoleLog {

880+ id: consoleLog

881+ enabled: true

882+ }

883+ }

884+ }

849}

885}

qml/ShellApplication.qmlnew file+52

@@ -0,0 +1,52 @@

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+import QtQuick 2.4

18+import QtQuick.Window 2.2

19+import Unity.Screens 0.1

20+import Unity.Application 0.1

21+

22+Instantiator {

23+ id: root

24+ model: Screens

25+

26+ property QtObject surfaceMan: SurfaceManager {}

27+

28+ ShellScreen {

29+ id: window

30+ objectName: "screen"+index

31+ screen: model.screen

32+ visibility: applicationArguments.hasFullscreen ? Window.FullScreen : Window.Windowed

33+ flags: applicationArguments.hasFrameless ? Qt.FramelessWindowHint : 0

34+ surfaceManager: surfaceMan

35+

36+ Binding {

37+ when: applicationArguments.hasGeometry

38+ target: window

39+ property: "width"

40+ value: applicationArguments.windowGeometry.width

41+ }

42+ Binding {

43+ when: applicationArguments.hasGeometry

44+ target: window

45+ property: "height"

46+ value: applicationArguments.windowGeometry.height

47+ }

48+

49+ Component.onCompleted: screen.active = primary

50+ primary: index == 0

51+ }

52+}

src/SecondaryWindow.h → qml/ShellNotifier.qmlrenamed+12−12

@@ -1,5 +1,5 @@

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

@@ -14,17 +14,17 @@

14 * along with this program. If not, see <http://www.gnu.org/licenses/>.

15 */

16

17−#ifndef UNITY_SECONDARY_WINDOW_H

17+/*

18−#define UNITY_SECONDARY_WINDOW_H

18+ Shared signals & properties on multi-window desktop

19−

19+ */

20−#include <QQuickView>

21

20

22−class SecondaryWindow : public QQuickView

21+pragma Singleton

23−{

22+import QtQuick 2.4

24− Q_OBJECT

25

23

26−public:

24+QtObject {

27− SecondaryWindow(QQmlEngine *engine);

25+ property var greeter: QtObject {

28−};

26+ signal hide(bool now)

29

27

30−#endif // UNITY_SECONDARY_WINDOW_H

28+ property bool shown: true

29+ }

30+}

qml/ShellScreen.qmlnew file+65

@@ -0,0 +1,65 @@

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+import QtQuick 2.4

18+import Ubuntu.Components 1.3

19+import Unity.Screens 0.1

20+import Cursor 1.1

21+import "Components"

22+

23+ScreenWindow {

24+ id: screenWindow

25+

26+ color: "black"

27+ title: "Unity8 Shell"

28+ property bool primary: false

29+ property QtObject surfaceManager: null

30+

31+ DeviceConfiguration {

32+ id: deviceConfiguration

33+ name: applicationArguments.deviceName

34+ }

35+

36+ Loader {

37+ width: screenWindow.width

38+ height: screenWindow.height

39+

40+ sourceComponent: {

41+ if (Screens.count > 1 && primary && deviceConfiguration.category !== "desktop") {

42+ return disabledScreenComponent;

43+ }

44+ return shellComponent;

45+ }

46+ }

47+

48+ Component {

49+ id: shellComponent

50+ OrientedShell {

51+ implicitWidth: screenWindow.width

52+ implicitHeight: screenWindow.height

53+ surfaceManager: screenWindow.surfaceManager

54+

55+ deviceConfiguration {

56+ name: Screens.count > 1 ? "desktop" : applicationArguments.deviceName

57+ }

58+ }

59+ }

60+

61+ Component {

62+ id: disabledScreenComponent

63+ DisabledScreenNotice {}

64+ }

65+}

qml/Stage/DecoratedWindow.qml+3−1

@@ -72,6 +72,8 @@ FocusScope {

72

73 readonly property Item clientAreaItem: applicationWindow

74

75+ property PanelState panelState

76+

75 signal closeClicked()

77 signal closeClicked()

76 signal maximizeClicked()

78 signal maximizeClicked()

77 signal maximizeHorizontallyClicked()

79 signal maximizeHorizontallyClicked()

@@ -225,7 +227,7 @@ FocusScope {

225 enableMenus: {

227 enableMenus: {

226 return active &&

228 return active &&

227 surface &&

229 surface &&

228− (PanelState.focusedPersistentSurfaceId === surface.persistentId && !PanelState.decorationsVisible)

230+ (panelState.focusedPersistentSurfaceId === surface.persistentId && !panelState.decorationsVisible)

229 }

231 }

230 menu: sharedAppModel.model

232 menu: sharedAppModel.model

231

233

qml/Stage/FakeMaximizeDelegate.qml+12−11

@@ -35,6 +35,7 @@ Rectangle {

35 property int leftMargin

36 property real appContainerWidth

37 property real appContainerHeight

38+ property PanelState panelState

38

39

39 readonly property real hintThreshold: 0.1

40 readonly property real hintThreshold: 0.1

40

41

@@ -178,7 +179,7 @@ Rectangle {

178 ParallelAnimation {

179 ParallelAnimation {

179 id: fakeMaximizeAnimation

180 id: fakeMaximizeAnimation

180 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: leftMargin }

181 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: leftMargin }

181− UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: PanelState.panelHeight }

182+ UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: panelState.panelHeight }

182 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: appContainerWidth - leftMargin }

183 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: appContainerWidth - leftMargin }

183 UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight }

184 UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight }

184 }

185 }

@@ -186,39 +187,39 @@ Rectangle {

186 ParallelAnimation {

187 ParallelAnimation {

187 id: fakeMaximizeLeftAnimation

188 id: fakeMaximizeLeftAnimation

188 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: leftMargin }

189 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: leftMargin }

189− UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: PanelState.panelHeight }

190+ UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: panelState.panelHeight }

190 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }

191 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }

191− UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight - PanelState.panelHeight }

192+ UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight - panelState.panelHeight }

192 }

193 }

193

194

194 ParallelAnimation {

195 ParallelAnimation {

195 id: fakeMaximizeRightAnimation

196 id: fakeMaximizeRightAnimation

196 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth + leftMargin)/2 }

197 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth + leftMargin)/2 }

197− UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: PanelState.panelHeight }

198+ UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: panelState.panelHeight }

198 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }

199 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }

199− UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight - PanelState.panelHeight }

200+ UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight - panelState.panelHeight }

200 }

201 }

201

202

202 ParallelAnimation {

203 ParallelAnimation {

203 id: fakeMaximizeTopLeftAnimation

204 id: fakeMaximizeTopLeftAnimation

204 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: leftMargin }

205 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: leftMargin }

205− UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: PanelState.panelHeight }

206+ UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: panelState.panelHeight }

206 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }

207 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }

207− UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight - PanelState.panelHeight)/2 }

208+ UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight - panelState.panelHeight)/2 }

208 }

209 }

209

210

210 ParallelAnimation {

211 ParallelAnimation {

211 id: fakeMaximizeTopRightAnimation

212 id: fakeMaximizeTopRightAnimation

212 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth + leftMargin)/2 }

213 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth + leftMargin)/2 }

213− UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: PanelState.panelHeight }

214+ UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: panelState.panelHeight }

214 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }

215 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }

215− UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight - PanelState.panelHeight)/2 }

216+ UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight - panelState.panelHeight)/2 }

216 }

217 }

217

218

218 ParallelAnimation {

219 ParallelAnimation {

219 id: fakeMaximizeBottomLeftAnimation

220 id: fakeMaximizeBottomLeftAnimation

220 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: leftMargin }

221 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: leftMargin }

221− UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight + PanelState.panelHeight)/2 }

222+ UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight + panelState.panelHeight)/2 }

222 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }

223 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }

223 UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight/2 }

224 UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight/2 }

224 }

225 }

@@ -226,7 +227,7 @@ Rectangle {

226 ParallelAnimation {

227 ParallelAnimation {

227 id: fakeMaximizeBottomRightAnimation

228 id: fakeMaximizeBottomRightAnimation

228 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth + leftMargin)/2 }

229 UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth + leftMargin)/2 }

229− UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight + PanelState.panelHeight)/2 }

230+ UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight + panelState.panelHeight)/2 }

230 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }

231 UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }

231 UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight/2 }

232 UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight/2 }

232 }

233 }

qml/Stage/Spread/ScreensAndWorkspaces.qmlnew file+181

@@ -0,0 +1,181 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Ubuntu.Components.Popups 1.3

4+import Unity.Screens 0.1

5+import Unity.Application 0.1

6+import ".."

7+

8+Item {

9+ id: root

10+

11+ property string background

12+

13+ Row {

14+ id: row

15+ anchors.bottom: parent.bottom

16+ anchors.horizontalCenter: parent.horizontalCenter

17+ Behavior on anchors.horizontalCenterOffset { NumberAnimation { duration: UbuntuAnimation.SlowDuration } }

18+// anchors.left: parent.left

19+ spacing: units.gu(1)

20+

21+ Repeater {

22+ model: Screens

23+

24+ delegate: Item {

25+ height: root.height - units.gu(6)

26+ width: workspaces.width

27+ clip: true

28+

29+ UbuntuShape {

30+ id: header

31+ anchors { left: parent.left; top: parent.top; right: parent.right }

32+ height: units.gu(7)

33+ backgroundColor: "white"

34+ z: 1

35+

36+ DropArea {

37+ anchors.fill: parent

38+ keys: ["workspace"]

39+

40+ onEntered: {

41+ workspaces.workspaceModel.insert(workspaces.workspaceModel.count, {text: drag.source.text})

42+ drag.source.inDropArea = true;

43+ }

44+

45+ onExited: {

46+ workspaces.workspaceModel.remove(workspaces.workspaceModel.count - 1, 1)

47+ drag.source.inDropArea = false;

48+ }

49+

50+ onDropped: {

51+ drag.source.inDropArea = false;

52+ }

53+ }

54+

55+ Column {

56+ anchors.fill: parent

57+ anchors.margins: units.gu(1)

58+

59+ Label {

60+ text: model.screen.name

61+ color: "black"

62+ }

63+

64+ Label {

65+ text: model.screen.outputType === Screens.LVDS ? "Built-in" : "Clone"

66+ color: "black"

67+ fontSize: "x-small"

68+ }

69+

70+ Label {

71+ text: model.screen.physicalSize.width + "x" + model.screen.physicalSize.height

72+ color: "black"

73+ fontSize: "x-small"

74+ }

75+ }

76+

77+ MouseArea {

78+ anchors.fill: parent

79+// acceptedButtons: Qt.RightButton

80+

81+

82+ onClicked: {

83+ print("should open popup")

84+ PopupUtils.open(contextMenu)

85+ }

86+ }

87+

88+ Component {

89+ id: contextMenu

90+ ActionSelectionPopover {

91+ actions: ActionList {

92+ Action {

93+ text: "Add workspace"

94+ onTriggered: workspaces.workspaceModel.append({text: "" + (workspaces.workspaceModel.count + 1)})

95+ }

96+ }

97+ }

98+ }

99+ }

100+

101+

102+ Workspaces {

103+ id: workspaces

104+ height: parent.height - header.height - units.gu(2)

105+ width: Math.min(implicitWidth, index == 0 ? units.gu(80) : units.gu(40), root.width)

106+ Behavior on width { UbuntuNumberAnimation {} }

107+ anchors.bottom: parent.bottom

108+ anchors.bottomMargin: units.gu(1)

109+ anchors.horizontalCenter: parent.horizontalCenter

110+ screen: model.screen

111+ background: root.background

112+

113+ workspaceModel: ListModel {

114+ onCountChanged: print("model count changed to", count)

115+ ListElement {text: "1"}

116+ ListElement {text: "2"}

117+ ListElement {text: "3"}

118+ ListElement {text: "4"}

119+ ListElement {text: "5"}

120+ ListElement {text: "6"}

121+// ListElement {text: "7"}

122+// ListElement {text: "8"}

123+// ListElement {text: "9"}

124+ }

125+ }

126+ }

127+ }

128+ }

129+

130+ Rectangle {

131+ anchors { left: parent.left; top: parent.top; bottom: parent.bottom; topMargin: units.gu(6); bottomMargin: units.gu(1) }

132+ width: units.gu(5)

133+ color: "#33000000"

134+ visible: (row.width - root.width + units.gu(10)) / 2 - row.anchors.horizontalCenterOffset > units.gu(5)

135+ MouseArea {

136+ id: leftScrollArea

137+ anchors.fill: parent

138+ hoverEnabled: true

139+ onPressed: mouse.accepted = false;

140+ }

141+ DropArea {

142+ id: leftFakeDropArea

143+ anchors.fill: parent

144+ keys: ["application", "workspace"]

145+ }

146+ }

147+ Rectangle {

148+ anchors { right: parent.right; top: parent.top; bottom: parent.bottom; topMargin: units.gu(6); bottomMargin: units.gu(1) }

149+ width: units.gu(5)

150+ color: "#33000000"

151+ visible: (row.width - root.width + units.gu(10)) / 2 + row.anchors.horizontalCenterOffset > units.gu(5)

152+ MouseArea {

153+ id: rightScrollArea

154+ anchors.fill: parent

155+ hoverEnabled: true

156+ onPressed: mouse.accepted = false;

157+ }

158+ DropArea {

159+ id: rightFakeDropArea

160+ anchors.fill: parent

161+ keys: ["application", "workspace"]

162+ }

163+ }

164+ Timer {

165+ repeat: true

166+ running: leftScrollArea.containsMouse || rightScrollArea.containsMouse || leftFakeDropArea.containsDrag || rightFakeDropArea.containsDrag

167+ interval: UbuntuAnimation.SlowDuration

168+ triggeredOnStart: true

169+ onTriggered: {

170+ var newOffset = row.anchors.horizontalCenterOffset;

171+ var maxOffset = Math.max((row.width - root.width + units.gu(10)) / 2, 0);

172+ if (leftScrollArea.containsMouse || leftFakeDropArea.containsDrag) {

173+ newOffset += units.gu(20)

174+ } else {

175+ newOffset -= units.gu(20)

176+ }

177+ newOffset = Math.max(-maxOffset, Math.min(maxOffset, newOffset));

178+ row.anchors.horizontalCenterOffset = newOffset;

179+ }

180+ }

181+}

qml/Stage/Spread/Spread.qml+5−5

@@ -28,10 +28,10 @@ Item {

28 property var spreadFlickable

29

30 // some config options

31− property real contentMargin: 0.16 * root.height

31+ property real contentMargin: 0.1 * root.height

32− property real contentTopMargin: contentMargin

32+ property real contentTopMargin: contentMargin + root.y + windowTitle.height

33− property real contentBottomMargin: 0.35 * contentMargin

33+ property real contentBottomMargin: contentMargin

34− property real windowTitleTopMargin: 3/4 * (contentTopMargin - windowTitle.height)

34+ property real windowTitleTopMargin: contentMargin - windowTitle.height

35 property int stackItemCount: 3

36 property real leftRotationAngle: 22

37 property real rightRotationAngle: 32

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

51

52 readonly property real spreadWidth: rightStackXPos - leftStackXPos

53 readonly property real spreadHeight: root.height

54− readonly property real spreadItemHeight: spreadHeight - contentTopMargin - contentBottomMargin

54+ readonly property real spreadItemHeight: spreadHeight - contentMargin * 2

55 readonly property real spreadItemWidth: stackHeight

56

57 readonly property real dynamicLeftRotationAngle: leftRotationAngle * rotationAngleFactor

qml/Stage/Spread/SpreadDelegateInputArea.qml+24−11

@@ -85,15 +85,15 @@ Item {

85 }

86

87 // Event eater

88− MouseArea {

88+// MouseArea {

89− anchors.fill: parent

89+// anchors.fill: parent

90− onClicked: root.clicked()

90+// onClicked: root.clicked()

91− onWheel: wheel.accepted = true

91+// onWheel: wheel.accepted = true

92− }

92+// }

93

94 MultiPointTouchArea {

95 anchors.fill: parent

96− mouseEnabled: false

96+// mouseEnabled: false

97 maximumTouchPoints: 1

98 property int offset: 0

99

@@ -109,7 +109,7 @@ Item {

109 }

110

111 onTouchUpdated: {

112− if (!d.moving) {

112+ if (!d.moving || !tp.pressed) {

113 if (Math.abs(tp.startY - tp.y) > d.threshold) {

114 d.moving = true;

115 d.dragEvents = []

@@ -119,17 +119,30 @@ Item {

119 }

120 }

121

122− if (root.closeable) {

122+

123− d.distance = tp.y - tp.startY - offset

123+ var value = tp.y - tp.startY - offset;

124+ if (value < 0) {

125+ var coords = mapToItem(shell, tp.x, tp.y);

126+ fakeDragItem.x = coords.x

127+ fakeDragItem.y = coords.y

128+ fakeDragItem.Drag.active = true;

129+ fakeDragItem.surface = model.window.surface;

130+

124 } else {

131 } else {

125− var value = tp.y - tp.startY - offset;

132+ if (root.closeable) {

133+ d.distance = value

134+ } else {

126− d.distance = Math.sqrt(Math.abs(value)) * (value < 0 ? -1 : 1) * 3

135+ d.distance = Math.sqrt(Math.abs(value)) * (value < 0 ? -1 : 1) * 3

136+ }

127 }

137 }

128

138

129 d.pushDragEvent(tp);

139 d.pushDragEvent(tp);

130 }

140 }

131

141

132 onReleased: {

142 onReleased: {

143+ print("released!")

144+ fakeDragItem.surface = null;

145+

133 if (!d.moving) {

146 if (!d.moving) {

134 root.clicked()

147 root.clicked()

135 }

148 }

qml/Stage/Spread/WorkspacePreview.qmlnew file+220

@@ -0,0 +1,220 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Unity.Screens 0.1

4+import Unity.Application 0.1

5+import ".."

6+import "../../Components"

7+

8+Item {

9+ id: previewSpace

10+ clip: true

11+

12+ property string background

13+ property int screenHeight

14+

15+ property real previewScale: previewSpace.height / previewSpace.screenHeight

16+

17+ property bool containsDrag: false

18+

19+ Image {

20+ source: previewSpace.background

21+ anchors.fill: parent

22+ sourceSize.width: width

23+ sourceSize.height: height

24+

25+ Repeater {

26+ id: topLevelSurfaceRepeater

27+ model: visible ? topLevelSurfaceList : null

28+ delegate: Rectangle {

29+ width: surfaceItem.width

30+ height: surfaceItem.height + decorationHeight * previewScale

31+ x: model.window.position.x * previewScale

32+ y: (model.window.position.y - decorationHeight) * previewScale

33+ color: "blue"

34+ z: topLevelSurfaceRepeater.count - index

35+

36+ property int decorationHeight: units.gu(3)

37+

38+ WindowDecoration {

39+ width: surfaceItem.implicitWidth

40+ height: parent.decorationHeight

41+ transform: Scale {

42+ origin.x: 0

43+ origin.y: 0

44+ xScale: previewScale

45+ yScale: previewScale

46+ }

47+ title: model.window && model.window.surface ? model.window.surface.name : ""

48+ z: 3

49+ }

50+

51+ MirSurfaceItem {

52+ id: surfaceItem

53+ y: parent.decorationHeight * previewScale

54+ width: implicitWidth * previewScale

55+ height: implicitHeight * previewScale

56+ surfaceWidth: -1

57+ surfaceHeight: -1

58+ onImplicitHeightChanged: print("item", surfaceItem, "height changed", implicitHeight)

59+ surface: model.window.surface

60+ }

61+ }

62+ }

63+

64+ }

65+

66+ Rectangle {

67+ anchors.fill: parent

68+ border.color: UbuntuColors.blue

69+ border.width: units.gu(.5)

70+ color: "transparent"

71+ visible: previewSpace.containsDrag

72+ }

73+}

74+

75+ // Repeater {

76+ // id: topLevelSurfaceRepeater

77+ // model: visible ? topLevelSurfaceList : null

78+ // delegate: Rectangle {

79+ // width: surfaceItem.width

80+ // height: surfaceItem.height + decorationHeight * previewScale

81+ // x: model.window.position.x * previewScale

82+ // y: (model.window.position.y - decorationHeight) * previewScale

83+ // color: "blue"

84+ // z: topLevelSurfaceRepeater.count - index

85+

86+ // property int decorationHeight: units.gu(3)

87+

88+ // WindowDecoration {

89+ // width: surfaceItem.implicitWidth

90+ // height: parent.decorationHeight

91+ // transform: Scale {

92+ // origin.x: 0

93+ // origin.y: 0

94+ // xScale: previewScale

95+ // yScale: previewScale

96+ // }

97+ // title: model.window && model.window.surface ? model.window.surface.name : ""

98+ // z: 3

99+ // }

100+

101+ // MirSurfaceItem {

102+ // id: surfaceItem

103+ // y: parent.decorationHeight * previewScale

104+ // width: implicitWidth * previewScale

105+ // height: implicitHeight * previewScale

106+ // surfaceWidth: -1

107+ // surfaceHeight: -1

108+ // onImplicitHeightChanged: print("item", surfaceItem, "height changed", implicitHeight)

109+ // surface: model.window.surface

110+ // }

111+ // }

112+ // }

113+// }

114+// }

115+

116+

117+// MouseArea {

118+// id: mouseArea

119+// anchors.centerIn: parent

120+// anchors.verticalCenterOffset: header.height / 2

121+// width: units.gu(8)

122+// height: width

123+// hoverEnabled: true

124+// opacity: containsMouse ? 1 : 0

125+

126+// Rectangle {

127+// anchors.fill: parent

128+// color: "#80000000"

129+// radius: height / 2

130+// }

131+

132+// NumberAnimation {

133+// target: canvas

134+// property: "progress"

135+// duration: 2000

136+// running: mouseArea.containsMouse

137+// from: 0

138+// to: 1

139+// }

140+

141+// Canvas {

142+// id: canvas

143+// height: parent.height

144+// width: height

145+// anchors.centerIn: parent

146+

147+// property real progress: 0.5

148+// property int lineWidth: units.dp(4)

149+// onProgressChanged: {

150+// requestPaint();

151+// if (progress == 1) {

152+// Screens.activateScreen(index);

153+// }

154+// }

155+

156+// rotation: -90

157+

158+// onPaint: {

159+// var ctx = canvas.getContext("2d");

160+// ctx.save();

161+// ctx.reset();

162+

163+// ctx.lineWidth = lineWidth;

164+

165+// ctx.strokeStyle = "#3bffffff"

166+// ctx.beginPath();

167+// ctx.arc(canvas.width/2,canvas.height/2, (canvas.height - ctx.lineWidth) / 2, 0, (Math.PI*2),false);

168+// ctx.stroke();

169+// ctx.closePath();

170+

171+// ctx.strokeStyle = "white"

172+// ctx.beginPath();

173+// ctx.arc(canvas.width/2,canvas.height/2, (canvas.height - ctx.lineWidth) / 2, 0, (Math.PI*2*(progress)),false);

174+// ctx.stroke();

175+// ctx.closePath();

176+

177+// ctx.restore();

178+// }

179+// }

180+

181+// Icon {

182+// source: "graphics/multi-monitor_leave.png"

183+// height: units.gu(4)

184+// width: height

185+// anchors.centerIn: parent

186+// }

187+// }

188+// }

189+

190+// FloatingFlickable {

191+// id: flickable

192+// anchors.fill: parent

193+// contentWidth: workspaceRepeater.count * previewSpace.screenWidth * previewScale

194+// property real progress: contentX / contentWidth

195+// onContentXChanged: print("contentX:", contentX, "progress:", progress)

196+// }

197+

198+// MouseArea {

199+// anchors.fill: parent

200+// hoverEnabled: true

201+// property int scrollAreaWidth: width / 3

202+

203+// onMouseXChanged: {

204+// var margins = flickable.width * 0.05;

205+

206+// // do we need to scroll?

207+// if (mouseX < scrollAreaWidth + margins) {

208+// var progress = Math.min(1, (scrollAreaWidth + margins - mouseX) / (scrollAreaWidth - margins));

209+// var contentX = (1 - progress) * (flickable.contentWidth - flickable.width)

210+// flickable.contentX = Math.max(0, Math.min(flickable.contentX, contentX))

211+// }

212+// if (mouseX > flickable.width - scrollAreaWidth) {

213+// var progress = Math.min(1, (mouseX - (flickable.width - scrollAreaWidth)) / (scrollAreaWidth - margins))

214+// var contentX = progress * (flickable.contentWidth - flickable.width)

215+// flickable.contentX = Math.min(flickable.contentWidth - flickable.width, Math.max(flickable.contentX, contentX))

216+// }

217+// }

218+// }

219+// }

220+//}

qml/Stage/Spread/Workspaces.qmlnew file+316

@@ -0,0 +1,316 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import "MathUtils.js" as MathUtils

4+import "../../Components"

5+

6+Item {

7+ id: root

8+ implicitWidth: listView.count * (height * 16/9 + listView.spacing) - listView.spacing

9+// color: "blue"

10+

11+ property QtObject screen: null

12+ property alias workspaceModel: listView.model

13+ property var background // TODO: should be stored in the workspace data

14+

15+ DropArea {

16+ anchors.fill: root

17+

18+ keys: ['workspace']

19+

20+ onEntered: {

21+ var index = listView.getWorkspaceDropIndex(drag);

22+ listView.model.insert(index, {text: drag.source.text})

23+ listView.dropItemIndex = index;

24+ drag.source.inDropArea = true;

25+ }

26+

27+ onPositionChanged: {

28+ var index = listView.getWorkspaceDropIndex(drag);

29+ if (listView.dropItemIndex == index) return;

30+ listView.model.move(listView.dropItemIndex, index, 1);

31+ listView.dropItemIndex = index;

32+ }

33+

34+ onExited: {

35+ listView.model.remove(listView.dropItemIndex, 1);

36+ listView.dropItemIndex = -1;

37+ drag.source.inDropArea = false;

38+ }

39+

40+ onDropped: {

41+ listView.dropItemIndex = -1;

42+ drag.source.inDropArea = false;

43+ }

44+ }

45+ DropArea {

46+ anchors.fill: parent

47+ keys: ["application"]

48+

49+ onPositionChanged: {

50+ listView.progressiveScroll(drag.x)

51+ listView.hoveredWorkspaceIndex = listView.getApplicationDropIndex(drag)

52+ }

53+ onExited: {

54+ listView.hoveredWorkspaceIndex = -1

55+ }

56+ }

57+

58+ ListView {

59+ id: listView

60+ anchors.fill: parent

61+ anchors.leftMargin: -itemWidth

62+ anchors.rightMargin: -itemWidth

63+// interactive: false

64+

65+ orientation: ListView.Horizontal

66+ spacing: units.gu(1)

67+ leftMargin: itemWidth

68+ rightMargin: itemWidth

69+

70+ property int itemWidth: height * 16 / 9

71+ property int foldingAreaWidth: units.gu(10)

72+ property real realContentX: contentX - originX + leftMargin

73+ property int dropItemIndex: -1

74+ property int hoveredWorkspaceIndex: -1

75+

76+ function getWorkspaceDropIndex(drag) {

77+ var coords = mapToItem(listView.contentItem, drag.x, drag.y)

78+ var index = Math.floor((drag.x + listView.realContentX) / (listView.itemWidth + listView.spacing));

79+ if (index < 0) index = 0;

80+ var upperLimit = dropItemIndex == -1 ? listView.count : listView.count - 1

81+ if (index > upperLimit) index = upperLimit;

82+ return index;

83+ }

84+

85+ function getApplicationDropIndex(drag) {

86+ var coords = mapToItem(listView.contentItem, drag.x, drag.y)

87+ var index = Math.floor((drag.x + listView.realContentX) / (listView.itemWidth + listView.spacing));

88+ if (index < 0) index = 0;

89+ var upperLimit = dropItemIndex == -1 ? listView.count : listView.count - 1

90+ if (index > upperLimit) index = upperLimit;

91+ return index;

92+ }

93+

94+ function progressiveScroll(mouseX) {

95+ var progress = Math.max(0, Math.min(1, (mouseX - listView.foldingAreaWidth) / (width - listView.leftMargin * 2 - listView.foldingAreaWidth * 2)))

96+ print("p", progress, mouseX)

97+ listView.contentX = listView.originX + (listView.contentWidth - listView.width + listView.leftMargin + listView.rightMargin) * progress - listView.leftMargin

98+ }

99+

100+ displaced: Transition { UbuntuNumberAnimation { properties: "x" } }

101+

102+ delegate: Item {

103+ objectName: "delegate" + index

104+ height: parent.height

105+ width: listView.itemWidth

106+ Behavior on width { UbuntuNumberAnimation {} }

107+ visible: listView.dropItemIndex !== index

108+

109+ property int itemX: -listView.realContentX + index * (listView.itemWidth + listView.spacing)

110+ property int distanceFromLeft: itemX //- listView.leftMargin

111+ property int distanceFromRight: listView.width - listView.leftMargin - listView.rightMargin - itemX - listView.itemWidth

112+

113+ property int maxAngle: 40

114+

115+ property int itemAngle: {

116+ if (index == 0) {

117+ if (distanceFromLeft < 0) {

118+ var progress = (distanceFromLeft + listView.foldingAreaWidth) / listView.foldingAreaWidth

119+ return MathUtils.linearAnimation(1, -1, 0, maxAngle, Math.max(-1, Math.min(1, progress)));

120+ }

121+ return 0

122+ }

123+ if (index == listView.count - 1) {

124+ if (distanceFromRight < 0) {

125+ var progress = (distanceFromRight + listView.foldingAreaWidth) / listView.foldingAreaWidth

126+ return MathUtils.linearAnimation(1, -1, 0, -maxAngle, Math.max(-1, Math.min(1, progress)));

127+ }

128+ return 0

129+ }

130+

131+ if (distanceFromLeft < listView.foldingAreaWidth) {

132+ // itemX : 10gu = p : 100

133+ var progress = distanceFromLeft / listView.foldingAreaWidth

134+ return MathUtils.linearAnimation(1, -1, 0, maxAngle, Math.max(-1, Math.min(1, progress)));

135+ }

136+ if (distanceFromRight < listView.foldingAreaWidth) {

137+ var progress = distanceFromRight / listView.foldingAreaWidth

138+ return MathUtils.linearAnimation(1, -1, 0, -maxAngle, Math.max(-1, Math.min(1, progress)));

139+ }

140+ return 0

141+ }

142+

143+ property int itemOffset: {

144+ var rotationOffset = (1 - Math.cos(itemAngle * Math.PI / 360)) * listView.itemWidth

145+ if (index == 0) {

146+ if (distanceFromLeft < 0) {

147+ return -distanceFromLeft - rotationOffset

148+ }

149+ return 0

150+ }

151+ if (index == listView.count - 1) {

152+ if (distanceFromRight < 0) {

153+ return distanceFromRight + rotationOffset

154+ }

155+ return 0

156+ }

157+

158+ if (itemX < -listView.foldingAreaWidth) {

159+ return -itemX - rotationOffset

160+ }

161+ if (distanceFromLeft < listView.foldingAreaWidth) {

162+ return (listView.foldingAreaWidth - distanceFromLeft) / 2 - rotationOffset

163+ }

164+

165+ if (distanceFromRight < -listView.foldingAreaWidth) {

166+ return distanceFromRight + rotationOffset

167+ }

168+

169+ if (distanceFromRight < listView.foldingAreaWidth) {

170+ return -(listView.foldingAreaWidth - distanceFromRight) / 2 + rotationOffset

171+ }

172+

173+ return 0

174+ }

175+

176+// onItemXChanged: if (index == 1) print("x", itemX, listView.contentX)

177+

178+ z: itemOffset < 0 ? itemOffset : -itemOffset

179+ transform: [

180+ Rotation {

181+ angle: itemAngle

182+ axis { x: 0; y: 1; z: 0 }

183+ origin { x: listView.itemWidth / 2; y: height / 2 }

184+ },

185+ Translate {

186+ x: itemOffset

187+ }

188+ ]

189+

190+ WorkspacePreview {

191+ height: listView.height

192+ width: listView.itemWidth

193+ background: root.background

194+ screenHeight: root.screen.physicalSize.height

195+ containsDrag: listView.hoveredWorkspaceIndex == index

196+

197+ Label {

198+ anchors.centerIn: parent

199+ text: model.text

200+ color: "red"

201+ fontSize: "large"

202+ }

203+ }

204+ }

205+

206+ MouseArea {

207+ id: mouseArea

208+ anchors.fill: parent

209+ hoverEnabled: true

210+ propagateComposedEvents: true

211+ anchors.leftMargin: listView.leftMargin

212+ anchors.rightMargin: listView.rightMargin

213+

214+ property int draggedIndex: -1

215+

216+ property int startX: 0

217+ property int startY: 0

218+

219+ onMouseXChanged: {

220+ if (!pressed || dragging) {

221+ listView.progressiveScroll(mouseX)

222+ }

223+ }

224+ onMouseYChanged: {

225+ if (Math.abs(mouseY - startY) > units.gu(3)) {

226+ drag.axis = Drag.XAndYAxis;

227+ }

228+ }

229+

230+ onReleased: {

231+ fakeDragItem.Drag.drop();

232+ drag.target = null;

233+ }

234+

235+ property bool dragging: drag.active

236+ onDraggingChanged: {

237+ if (drag.active) {

238+ print("drai", draggedIndex)

239+ listView.model.remove(draggedIndex, 1)

240+ }

241+ }

242+

243+ onPressed: {

244+ startX = mouseX;

245+ startY = mouseY;

246+ if (listView.model.count < 2) return;

247+

248+ var coords = mapToItem(listView.contentItem, mouseX, mouseY)

249+ draggedIndex = listView.indexAt(coords.x, coords.y)

250+ var clickedItem = listView.itemAt(coords.x, coords.y)

251+

252+ var itemCoords = clickedItem.mapToItem(listView, -listView.leftMargin, 0);

253+ fakeDragItem.x = itemCoords.x

254+ fakeDragItem.y = itemCoords.y

255+ fakeDragItem.text = listView.model.get(draggedIndex).text

256+

257+ var mouseCoordsInItem = mapToItem(clickedItem, mouseX, mouseY);

258+ fakeDragItem.Drag.hotSpot.x = mouseCoordsInItem.x

259+ fakeDragItem.Drag.hotSpot.y = mouseCoordsInItem.y

260+

261+ drag.axis = Drag.YAxis;

262+ drag.target = fakeDragItem;

263+ }

264+

265+ WorkspacePreview {

266+ id: fakeDragItem

267+ height: listView.height

268+ width: listView.itemWidth

269+ background: root.background

270+ screenHeight: root.screen.physicalSize.height

271+ visible: Drag.active

272+

273+ Drag.active: mouseArea.drag.active

274+ Drag.keys: ['workspace']

275+

276+ property string text

277+ property bool inDropArea: false

278+ Label {

279+ anchors.centerIn: parent

280+ text: parent.text

281+ color: "red"

282+ fontSize: "large"

283+ }

284+

285+ Rectangle {

286+ anchors.fill: parent

287+ color: "#33000000"

288+ opacity: parent.inDropArea ? 0 : 1

289+ Behavior on opacity { UbuntuNumberAnimation { } }

290+ Rectangle {

291+ anchors.centerIn: parent

292+ width: units.gu(6)

293+ height: units.gu(6)

294+ radius: width / 2

295+ color: "#aa000000"

296+ }

297+

298+ Icon {

299+ height: units.gu(3)

300+ width: height

301+ anchors.centerIn: parent

302+ name: "edit-delete"

303+ color: "white"

304+ }

305+ }

306+

307+ states: [

308+ State {

309+ when: fakeDragItem.Drag.active

310+ ParentChange { target: fakeDragItem; parent: shell }

311+ }

312+ ]

313+ }

314+ }

315+ }

316+}

qml/Stage/Stage.qml+137−103

@@ -46,6 +46,7 @@ FocusScope {

46 property int leftMargin: 0

47 property bool oskEnabled: false

48 property rect inputMethodRect

49+ property PanelState panelState

49

50

50 // Configuration

51 // Configuration

51 property string mode: "staged"

52 property string mode: "staged"

@@ -345,23 +346,23 @@ FocusScope {

345 readonly property real virtualKeyboardHeight: root.inputMethodRect.height

346 readonly property real virtualKeyboardHeight: root.inputMethodRect.height

346 }

347 }

347

348

348− Component.onCompleted: priv.updateMainAndSideStageIndexes();

349+ Component.onCompleted: {priv.updateMainAndSideStageIndexes(); print("size", root.width, root.height)}

349

350

350 Connections {

351 Connections {

351− target: PanelState

352+ target: panelState

352 onCloseClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.close(); } }

353 onCloseClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.close(); } }

353 onMinimizeClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.requestMinimize(); } }

354 onMinimizeClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.requestMinimize(); } }

354 onRestoreClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.requestRestore(); } }

355 onRestoreClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.requestRestore(); } }

355 }

356 }

356

357

357 Binding {

358 Binding {

358− target: PanelState

359+ target: panelState

359 property: "decorationsVisible"

360 property: "decorationsVisible"

360 value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.maximized // FIXME for Locally integrated menus

361 value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.maximized // FIXME for Locally integrated menus

361 }

362 }

362

363

363 Binding {

364 Binding {

364− target: PanelState

365+ target: panelState

365 property: "title"

366 property: "title"

366 value: {

367 value: {

367 if (priv.focusedAppDelegate !== null) {

368 if (priv.focusedAppDelegate !== null) {

@@ -376,7 +377,7 @@ FocusScope {

376 }

377 }

377

378

378 Binding {

379 Binding {

379− target: PanelState

380+ target: panelState

380 property: "focusedPersistentSurfaceId"

381 property: "focusedPersistentSurfaceId"

381 value: {

382 value: {

382 if (priv.focusedAppDelegate !== null) {

383 if (priv.focusedAppDelegate !== null) {

@@ -390,21 +391,21 @@ FocusScope {

390 }

391 }

391

392

392 Binding {

393 Binding {

393− target: PanelState

394+ target: panelState

394 property: "dropShadow"

395 property: "dropShadow"

395 value: priv.focusedAppDelegate && !priv.focusedAppDelegate.maximized && priv.foregroundMaximizedAppDelegate !== null && mode == "windowed"

396 value: priv.focusedAppDelegate && !priv.focusedAppDelegate.maximized && priv.foregroundMaximizedAppDelegate !== null && mode == "windowed"

396 }

397 }

397

398

398 Binding {

399 Binding {

399− target: PanelState

400+ target: panelState

400 property: "closeButtonShown"

401 property: "closeButtonShown"

401 value: priv.focusedAppDelegate && priv.focusedAppDelegate.maximized && !priv.focusedAppDelegate.isDash

402 value: priv.focusedAppDelegate && priv.focusedAppDelegate.maximized && !priv.focusedAppDelegate.isDash

402 }

403 }

403

404

404 Component.onDestruction: {

405 Component.onDestruction: {

405− PanelState.title = "";

406+ panelState.title = "";

406− PanelState.decorationsVisible = false;

407+ panelState.decorationsVisible = false;

407− PanelState.dropShadow = false;

408+ panelState.dropShadow = false;

408 }

409 }

409

410

410 Instantiator {

411 Instantiator {

@@ -450,6 +451,7 @@ FocusScope {

450 PropertyChanges { target: cancelSpreadMouseArea; enabled: true }

451 PropertyChanges { target: cancelSpreadMouseArea; enabled: true }

451 PropertyChanges { target: blurLayer; visible: true; blurRadius: 32; brightness: .65; opacity: 1 }

452 PropertyChanges { target: blurLayer; visible: true; blurRadius: 32; brightness: .65; opacity: 1 }

452 PropertyChanges { target: wallpaper; visible: false }

453 PropertyChanges { target: wallpaper; visible: false }

454+ PropertyChanges { target: screensAndWorkspaces; opacity: 1 }

453 },

455 },

454 State {

456 State {

455 name: "stagedRightEdge"; when: (rightEdgeDragArea.dragging || edgeBarrier.progress > 0) && root.mode == "staged"

457 name: "stagedRightEdge"; when: (rightEdgeDragArea.dragging || edgeBarrier.progress > 0) && root.mode == "staged"

@@ -482,7 +484,7 @@ FocusScope {

482 },

484 },

483 State {

485 State {

484 name: "staged"; when: root.mode === "staged"

486 name: "staged"; when: root.mode === "staged"

485− PropertyChanges { target: wallpaper; visible: false }

487+ PropertyChanges { target: wallpaper; visible: priv.focusedAppDelegate && priv.focusedAppDelegate.x === 0 }

486 },

488 },

487 State {

489 State {

488 name: "stagedWithSideStage"; when: root.mode === "stagedWithSideStage"

490 name: "stagedWithSideStage"; when: root.mode === "stagedWithSideStage"

@@ -498,11 +500,13 @@ FocusScope {

498 from: "stagedRightEdge,sideStagedRightEdge,windowedRightEdge"; to: "spread"

500 from: "stagedRightEdge,sideStagedRightEdge,windowedRightEdge"; to: "spread"

499 PropertyAction { target: spreadItem; property: "highlightedIndex"; value: -1 }

501 PropertyAction { target: spreadItem; property: "highlightedIndex"; value: -1 }

500 PropertyAnimation { target: blurLayer; properties: "brightness,blurRadius"; duration: priv.animationDuration }

502 PropertyAnimation { target: blurLayer; properties: "brightness,blurRadius"; duration: priv.animationDuration }

503+ UbuntuNumberAnimation { target: screensAndWorkspaces; property: "opacity"; duration: priv.animationDuration }

501 },

504 },

502 Transition {

505 Transition {

503 to: "spread"

506 to: "spread"

504 PropertyAction { target: spreadItem; property: "highlightedIndex"; value: appRepeater.count > 1 ? 1 : 0 }

507 PropertyAction { target: spreadItem; property: "highlightedIndex"; value: appRepeater.count > 1 ? 1 : 0 }

505 PropertyAction { target: floatingFlickable; property: "contentX"; value: 0 }

508 PropertyAction { target: floatingFlickable; property: "contentX"; value: 0 }

509+ UbuntuNumberAnimation { target: screensAndWorkspaces; property: "opacity"; duration: priv.animationDuration }

506 },

510 },

507 Transition {

511 Transition {

508 from: "spread"

512 from: "spread"

@@ -559,10 +563,19 @@ FocusScope {

559 visible: false

563 visible: false

560 }

564 }

561

565

566+ ScreensAndWorkspaces {

567+ id: screensAndWorkspaces

568+ anchors { left: parent.left; top: parent.top; right: parent.right; leftMargin: root.leftMargin }

569+ height: parent.height / 3

570+ background: root.background

571+ opacity: 0

572+ visible: opacity > 0

573+ }

574+

562 Spread {

575 Spread {

563 id: spreadItem

576 id: spreadItem

564 objectName: "spreadItem"

577 objectName: "spreadItem"

565− anchors.fill: appContainer

578+ anchors { left: parent.left; bottom: parent.bottom; right: parent.right; top: screensAndWorkspaces.bottom }

566 leftMargin: root.leftMargin

579 leftMargin: root.leftMargin

567 model: root.topLevelSurfaceList

580 model: root.topLevelSurfaceList

568 spreadFlickable: floatingFlickable

581 spreadFlickable: floatingFlickable

@@ -571,6 +584,83 @@ FocusScope {

571 onLeaveSpread: {

584 onLeaveSpread: {

572 priv.goneToSpread = false;

585 priv.goneToSpread = false;

573 }

586 }

587+

588+ FloatingFlickable {

589+ id: floatingFlickable

590+ objectName: "spreadFlickable"

591+ anchors.fill: parent

592+ enabled: false

593+ contentWidth: spreadItem.spreadTotalWidth

594+

595+ function snap(toIndex) {

596+ var delegate = appRepeater.itemAt(toIndex)

597+ var targetContentX = floatingFlickable.contentWidth / spreadItem.totalItemCount * toIndex;

598+ if (targetContentX - floatingFlickable.contentX > spreadItem.rightStackXPos - (spreadItem.spreadItemWidth / 2)) {

599+ var offset = (spreadItem.rightStackXPos - (spreadItem.spreadItemWidth / 2)) - (targetContentX - floatingFlickable.contentX)

600+ snapAnimation.to = floatingFlickable.contentX - offset;

601+ snapAnimation.start();

602+ } else if (targetContentX - floatingFlickable.contentX < spreadItem.leftStackXPos + units.gu(1)) {

603+ var offset = (spreadItem.leftStackXPos + units.gu(1)) - (targetContentX - floatingFlickable.contentX);

604+ snapAnimation.to = floatingFlickable.contentX - offset;

605+ snapAnimation.start();

606+ }

607+ }

608+ UbuntuNumberAnimation {id: snapAnimation; target: floatingFlickable; property: "contentX"}

609+ }

610+

611+ MouseArea {

612+ id: hoverMouseArea

613+ objectName: "hoverMouseArea"

614+ anchors.fill: parent

615+ propagateComposedEvents: true

616+ hoverEnabled: true

617+ enabled: false

618+ visible: enabled

619+

620+ property int scrollAreaWidth: width / 3

621+ property bool progressiveScrollingEnabled: false

622+

623+ onPressed: mouse.accepted = false

624+

625+ onMouseXChanged: {

626+ mouse.accepted = false

627+

628+ if (hoverMouseArea.pressed) {

629+ return;

630+ }

631+

632+ // Find the hovered item and mark it active

633+ for (var i = appRepeater.count - 1; i >= 0; i--) {

634+ var appDelegate = appRepeater.itemAt(i);

635+ var mapped = mapToItem(appDelegate, hoverMouseArea.mouseX, hoverMouseArea.mouseY)

636+ var itemUnder = appDelegate.childAt(mapped.x, mapped.y);

637+ if (itemUnder && (itemUnder.objectName === "dragArea" || itemUnder.objectName === "windowInfoItem" || itemUnder.objectName == "closeMouseArea")) {

638+ spreadItem.highlightedIndex = i;

639+ break;

640+ }

641+ }

642+

643+ if (floatingFlickable.contentWidth > floatingFlickable.width) {

644+ var margins = floatingFlickable.width * 0.05;

645+

646+ if (!progressiveScrollingEnabled && mouseX < floatingFlickable.width - scrollAreaWidth) {

647+ progressiveScrollingEnabled = true

648+ }

649+

650+ // do we need to scroll?

651+ if (mouseX < scrollAreaWidth + margins) {

652+ var progress = Math.min(1, (scrollAreaWidth + margins - mouseX) / (scrollAreaWidth - margins));

653+ var contentX = (1 - progress) * (floatingFlickable.contentWidth - floatingFlickable.width)

654+ floatingFlickable.contentX = Math.max(0, Math.min(floatingFlickable.contentX, contentX))

655+ }

656+ if (mouseX > floatingFlickable.width - scrollAreaWidth && progressiveScrollingEnabled) {

657+ var progress = Math.min(1, (mouseX - (floatingFlickable.width - scrollAreaWidth)) / (scrollAreaWidth - margins))

658+ var contentX = progress * (floatingFlickable.contentWidth - floatingFlickable.width)

659+ floatingFlickable.contentX = Math.min(floatingFlickable.contentWidth - floatingFlickable.width, Math.max(floatingFlickable.contentX, contentX))

660+ }

661+ }

662+ }

663+ }

574 }

664 }

575

665

576 Connections {

666 Connections {

@@ -665,6 +755,23 @@ FocusScope {

665 }

755 }

666 }

756 }

667

757

758+ MirSurfaceItem {

759+ id: fakeDragItem

760+ property real previewScale: .5

761+ width: implicitWidth * previewScale

762+ height: implicitHeight * previewScale

763+ surfaceWidth: -1

764+ surfaceHeight: -1

765+ opacity: surface != null ? 1 : 0

766+ Behavior on opacity { UbuntuNumberAnimation {} }

767+ visible: opacity > 0

768+

769+ Drag.active: surface != null

770+ Drag.keys: ["application"]

771+

772+ z: 1000

773+ }

774+

668 Item {

775 Item {

669 id: boundariesForWindowPlacement

776 id: boundariesForWindowPlacement

670 anchors.fill: parent

777 anchors.fill: parent

@@ -700,6 +807,9 @@ FocusScope {

700 }

807 }

701 z: normalZ

808 z: normalZ

702

809

810+ opacity: fakeDragItem.surface == model.window.surface && fakeDragItem.Drag.active ? 0 : 1

811+ Behavior on opacity { UbuntuNumberAnimation {} }

812+

703 // Normally we want x/y where the surface thinks it is. Width/height of our delegate will

813 // Normally we want x/y where the surface thinks it is. Width/height of our delegate will

704 // match what the actual surface size is.

814 // match what the actual surface size is.

705 // Don't write to those, they will be set by states

815 // Don't write to those, they will be set by states

@@ -760,7 +870,7 @@ FocusScope {

760 target: appDelegate

870 target: appDelegate

761 property: "y"

871 property: "y"

762 value: appDelegate.requestedY -

872 value: appDelegate.requestedY -

763− Math.min(appDelegate.requestedY - PanelState.panelHeight,

873+ Math.min(appDelegate.requestedY - panelState.panelHeight,

764 Math.max(0, priv.virtualKeyboardHeight - (appContainer.height - (appDelegate.requestedY + appDelegate.height))))

874 Math.max(0, priv.virtualKeyboardHeight - (appContainer.height - (appDelegate.requestedY + appDelegate.height))))

765 when: root.oskEnabled && appDelegate.focus && (appDelegate.state == "normal" || appDelegate.state == "restored")

875 when: root.oskEnabled && appDelegate.focus && (appDelegate.state == "normal" || appDelegate.state == "restored")

766 && root.inputMethodRect.height > 0

876 && root.inputMethodRect.height > 0

@@ -1136,7 +1246,7 @@ FocusScope {

1136 progress: 0

1246 progress: 0

1137 targetHeight: spreadItem.stackHeight

1247 targetHeight: spreadItem.stackHeight

1138 targetX: spreadMaths.targetX

1248 targetX: spreadMaths.targetX

1139− startY: appDelegate.fullscreen ? 0 : PanelState.panelHeight

1249+ startY: appDelegate.fullscreen ? 0 : panelState.panelHeight

1140 targetY: spreadMaths.targetY

1250 targetY: spreadMaths.targetY

1141 targetAngle: spreadMaths.targetAngle

1251 targetAngle: spreadMaths.targetAngle

1142 targetScale: spreadMaths.targetScale

1252 targetScale: spreadMaths.targetScale

@@ -1255,9 +1365,9 @@ FocusScope {

1255 PropertyChanges {

1365 PropertyChanges {

1256 target: appDelegate

1366 target: appDelegate

1257 x: stageMaths.itemX

1367 x: stageMaths.itemX

1258− y: appDelegate.fullscreen ? 0 : PanelState.panelHeight

1368+ y: appDelegate.fullscreen ? 0 : panelState.panelHeight

1259 requestedWidth: appContainer.width

1369 requestedWidth: appContainer.width

1260− requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - PanelState.panelHeight

1370+ requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - panelState.panelHeight

1261 visuallyMaximized: true

1371 visuallyMaximized: true

1262 visible: appDelegate.x < root.width

1372 visible: appDelegate.x < root.width

1263 }

1373 }

@@ -1283,10 +1393,10 @@ FocusScope {

1283 PropertyChanges {

1393 PropertyChanges {

1284 target: appDelegate

1394 target: appDelegate

1285 x: stageMaths.itemX

1395 x: stageMaths.itemX

1286− y: appDelegate.fullscreen ? 0 : PanelState.panelHeight

1396+ y: appDelegate.fullscreen ? 0 : panelState.panelHeight

1287 z: stageMaths.itemZ

1397 z: stageMaths.itemZ

1288 requestedWidth: stageMaths.itemWidth

1398 requestedWidth: stageMaths.itemWidth

1289− requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - PanelState.panelHeight

1399+ requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - panelState.panelHeight

1290 visuallyMaximized: true

1400 visuallyMaximized: true

1291 visible: appDelegate.x < root.width

1401 visible: appDelegate.x < root.width

1292 }

1402 }

@@ -1351,9 +1461,9 @@ FocusScope {

1351 PropertyChanges {

1461 PropertyChanges {

1352 target: appDelegate

1462 target: appDelegate

1353 windowedX: root.leftMargin

1463 windowedX: root.leftMargin

1354− windowedY: PanelState.panelHeight

1464+ windowedY: panelState.panelHeight

1355 windowedWidth: (appContainer.width - root.leftMargin)/2

1465 windowedWidth: (appContainer.width - root.leftMargin)/2

1356− windowedHeight: appContainer.height - PanelState.panelHeight

1466+ windowedHeight: appContainer.height - panelState.panelHeight

1357 }

1467 }

1358 },

1468 },

1359 State {

1469 State {

@@ -1370,9 +1480,9 @@ FocusScope {

1370 PropertyChanges {

1480 PropertyChanges {

1371 target: appDelegate

1481 target: appDelegate

1372 windowedX: root.leftMargin

1482 windowedX: root.leftMargin

1373− windowedY: PanelState.panelHeight

1483+ windowedY: panelState.panelHeight

1374 windowedWidth: (appContainer.width - root.leftMargin)/2

1484 windowedWidth: (appContainer.width - root.leftMargin)/2

1375− windowedHeight: (appContainer.height - PanelState.panelHeight)/2

1485+ windowedHeight: (appContainer.height - panelState.panelHeight)/2

1376 }

1486 }

1377 },

1487 },

1378 State {

1488 State {

@@ -1389,7 +1499,7 @@ FocusScope {

1389 PropertyChanges {

1499 PropertyChanges {

1390 target: appDelegate

1500 target: appDelegate

1391 windowedX: root.leftMargin

1501 windowedX: root.leftMargin

1392− windowedY: (appContainer.height + PanelState.panelHeight)/2

1502+ windowedY: (appContainer.height + panelState.panelHeight)/2

1393 windowedWidth: (appContainer.width - root.leftMargin)/2

1503 windowedWidth: (appContainer.width - root.leftMargin)/2

1394 windowedHeight: appContainer.height/2

1504 windowedHeight: appContainer.height/2

1395 }

1505 }

@@ -1411,8 +1521,8 @@ FocusScope {

1411 State {

1521 State {

1412 name: "maximizedVertically"; when: appDelegate.maximizedVertically && !appDelegate.minimized

1522 name: "maximizedVertically"; when: appDelegate.maximizedVertically && !appDelegate.minimized

1413 extend: "normal"

1523 extend: "normal"

1414− PropertyChanges { target: appDelegate; windowedX: windowedX; windowedY: PanelState.panelHeight;

1524+ PropertyChanges { target: appDelegate; windowedX: windowedX; windowedY: panelState.panelHeight;

1415− windowedWidth: windowedWidth; windowedHeight: appContainer.height - PanelState.panelHeight }

1525+ windowedWidth: windowedWidth; windowedHeight: appContainer.height - panelState.panelHeight }

1416 },

1526 },

1417 State {

1527 State {

1418 name: "minimized"; when: appDelegate.minimized

1528 name: "minimized"; when: appDelegate.minimized

@@ -1511,7 +1621,7 @@ FocusScope {

1511 ]

1621 ]

1512

1622

1513 Binding {

1623 Binding {

1514− target: PanelState

1624+ target: panelState

1515 property: "decorationsAlwaysVisible"

1625 property: "decorationsAlwaysVisible"

1516 value: appDelegate && appDelegate.maximized && touchControls.overlayShown

1626 value: appDelegate && appDelegate.maximized && touchControls.overlayShown

1517 }

1627 }

@@ -1754,6 +1864,7 @@ FocusScope {

1754 leftMargin: root.leftMargin

1864 leftMargin: root.leftMargin

1755 appContainerWidth: appContainer.width

1865 appContainerWidth: appContainer.width

1756 appContainerHeight: appContainer.height

1866 appContainerHeight: appContainer.height

1867+ panelState: root.panelState

1757 }

1868 }

1758

1869

1759 EdgeBarrier {

1870 EdgeBarrier {

@@ -1780,83 +1891,6 @@ FocusScope {

1780 }

1891 }

1781 }

1892 }

1782

1893

1783− MouseArea {

1784− id: hoverMouseArea

1785− objectName: "hoverMouseArea"

1786− anchors.fill: appContainer

1787− propagateComposedEvents: true

1788− hoverEnabled: true

1789− enabled: false

1790− visible: enabled

1791−

1792− property int scrollAreaWidth: width / 3

1793− property bool progressiveScrollingEnabled: false

1794−

1795− onMouseXChanged: {

1796− mouse.accepted = false

1797−

1798− if (hoverMouseArea.pressed) {

1799− return;

1800− }

1801−

1802− // Find the hovered item and mark it active

1803− for (var i = appRepeater.count - 1; i >= 0; i--) {

1804− var appDelegate = appRepeater.itemAt(i);

1805− var mapped = mapToItem(appDelegate, hoverMouseArea.mouseX, hoverMouseArea.mouseY)

1806− var itemUnder = appDelegate.childAt(mapped.x, mapped.y);

1807− if (itemUnder && (itemUnder.objectName === "dragArea" || itemUnder.objectName === "windowInfoItem" || itemUnder.objectName == "closeMouseArea")) {

1808− spreadItem.highlightedIndex = i;

1809− break;

1810− }

1811− }

1812−

1813− if (floatingFlickable.contentWidth > floatingFlickable.width) {

1814− var margins = floatingFlickable.width * 0.05;

1815−

1816− if (!progressiveScrollingEnabled && mouseX < floatingFlickable.width - scrollAreaWidth) {

1817− progressiveScrollingEnabled = true

1818− }

1819−

1820− // do we need to scroll?

1821− if (mouseX < scrollAreaWidth + margins) {

1822− var progress = Math.min(1, (scrollAreaWidth + margins - mouseX) / (scrollAreaWidth - margins));

1823− var contentX = (1 - progress) * (floatingFlickable.contentWidth - floatingFlickable.width)

1824− floatingFlickable.contentX = Math.max(0, Math.min(floatingFlickable.contentX, contentX))

1825− }

1826− if (mouseX > floatingFlickable.width - scrollAreaWidth && progressiveScrollingEnabled) {

1827− var progress = Math.min(1, (mouseX - (floatingFlickable.width - scrollAreaWidth)) / (scrollAreaWidth - margins))

1828− var contentX = progress * (floatingFlickable.contentWidth - floatingFlickable.width)

1829− floatingFlickable.contentX = Math.min(floatingFlickable.contentWidth - floatingFlickable.width, Math.max(floatingFlickable.contentX, contentX))

1830− }

1831− }

1832− }

1833−

1834− onPressed: mouse.accepted = false

1835− }

1836−

1837− FloatingFlickable {

1838− id: floatingFlickable

1839− objectName: "spreadFlickable"

1840− anchors.fill: appContainer

1841− enabled: false

1842− contentWidth: spreadItem.spreadTotalWidth

1843−

1844− function snap(toIndex) {

1845− var delegate = appRepeater.itemAt(toIndex)

1846− var targetContentX = floatingFlickable.contentWidth / spreadItem.totalItemCount * toIndex;

1847− if (targetContentX - floatingFlickable.contentX > spreadItem.rightStackXPos - (spreadItem.spreadItemWidth / 2)) {

1848− var offset = (spreadItem.rightStackXPos - (spreadItem.spreadItemWidth / 2)) - (targetContentX - floatingFlickable.contentX)

1849− snapAnimation.to = floatingFlickable.contentX - offset;

1850− snapAnimation.start();

1851− } else if (targetContentX - floatingFlickable.contentX < spreadItem.leftStackXPos + units.gu(1)) {

1852− var offset = (spreadItem.leftStackXPos + units.gu(1)) - (targetContentX - floatingFlickable.contentX);

1853− snapAnimation.to = floatingFlickable.contentX - offset;

1854− snapAnimation.start();

1855− }

1856− }

1857− UbuntuNumberAnimation {id: snapAnimation; target: floatingFlickable; property: "contentX"}

1858− }

1859−

1860 PropertyAnimation {

1894 PropertyAnimation {

1861 id: shortRightEdgeSwipeAnimation

1895 id: shortRightEdgeSwipeAnimation

1862 property: "x"

1896 property: "x"

qml/Stage/SurfaceContainer.qml+2

@@ -66,6 +66,8 @@ FocusScope {

66 fillMode: MirSurfaceItem.PadOrCrop

67 consumesInput: true

68

69+ onSurfaceChanged: print("surface changed", surface, implicitWidth, implicitHeight)

70+

69 surfaceWidth: root.requestedWidth

71 surfaceWidth: root.requestedWidth

70 surfaceHeight: root.requestedHeight

72 surfaceHeight: root.requestedHeight

71

73

qml/Stage/WorkspacePreview.qmlnew file+212

@@ -0,0 +1,212 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Unity.Screens 0.1

4+import Unity.Application 0.1

5+import "../Components"

6+

7+UbuntuShape {

8+ id: previewSpace

9+

10+ // Set the height. this preview will then automatically adjust the width, keeping aspect ratio of the screen

11+ width: model.geometry.width * previewScale * 4

12+ color: "white"

13+ property string background

14+

15+ property int screenWidth: model.geometry.width

16+ property int screenHeight: model.geometry.height

17+ property real previewScale: (previewSpace.height - header.height) / previewSpace.screenHeight

18+

19+ Item {

20+ id: header

21+ anchors { left: parent.left; top: parent.top; right: parent.right }

22+ height: units.gu(7)

23+

24+ Column {

25+ anchors.fill: parent

26+ anchors.margins: units.gu(1)

27+

28+ Label {

29+ text: model.name

30+ color: "black"

31+ }

32+

33+ Label {

34+ text: model.outputType === Screens.LVDS ? "Built-in" : "Clone"

35+ color: "black"

36+ fontSize: "x-small"

37+ }

38+

39+ Label {

40+ text: model.geometry.width + "x" + model.geometry.height

41+ color: "black"

42+ fontSize: "x-small"

43+ }

44+ }

45+ }

46+

47+

48+ Rectangle {

49+ anchors.fill: parent

50+ anchors.topMargin: header.height

51+ color: "blue"

52+

53+ Repeater {

54+ id: workspaceRepeater

55+ model: 15

56+

57+ delegate: Item {

58+ x: index * previewSpace.screenWidth * previewScale

59+ height: previewSpace.screenHeight * previewScale

60+ width: previewSpace.screenWidth * previewScale

61+ clip: true

62+

63+ Wallpaper {

64+ source: previewSpace.background

65+ anchors.fill: parent

66+

67+ // Repeater {

68+ // id: topLevelSurfaceRepeater

69+ // model: visible ? topLevelSurfaceList : null

70+ // delegate: Rectangle {

71+ // width: surfaceItem.width

72+ // height: surfaceItem.height + decorationHeight * previewScale

73+ // x: model.window.position.x * previewScale

74+ // y: (model.window.position.y - decorationHeight) * previewScale

75+ // color: "blue"

76+ // z: topLevelSurfaceRepeater.count - index

77+

78+ // property int decorationHeight: units.gu(3)

79+

80+ // WindowDecoration {

81+ // width: surfaceItem.implicitWidth

82+ // height: parent.decorationHeight

83+ // transform: Scale {

84+ // origin.x: 0

85+ // origin.y: 0

86+ // xScale: previewScale

87+ // yScale: previewScale

88+ // }

89+ // title: model.window && model.window.surface ? model.window.surface.name : ""

90+ // z: 3

91+ // }

92+

93+ // MirSurfaceItem {

94+ // id: surfaceItem

95+ // y: parent.decorationHeight * previewScale

96+ // width: implicitWidth * previewScale

97+ // height: implicitHeight * previewScale

98+ // surfaceWidth: -1

99+ // surfaceHeight: -1

100+ // onImplicitHeightChanged: print("item", surfaceItem, "height changed", implicitHeight)

101+ // surface: model.window.surface

102+ // }

103+ // }

104+ // }

105+ }

106+ }

107+

108+

109+// MouseArea {

110+// id: mouseArea

111+// anchors.centerIn: parent

112+// anchors.verticalCenterOffset: header.height / 2

113+// width: units.gu(8)

114+// height: width

115+// hoverEnabled: true

116+// opacity: containsMouse ? 1 : 0

117+

118+// Rectangle {

119+// anchors.fill: parent

120+// color: "#80000000"

121+// radius: height / 2

122+// }

123+

124+// NumberAnimation {

125+// target: canvas

126+// property: "progress"

127+// duration: 2000

128+// running: mouseArea.containsMouse

129+// from: 0

130+// to: 1

131+// }

132+

133+// Canvas {

134+// id: canvas

135+// height: parent.height

136+// width: height

137+// anchors.centerIn: parent

138+

139+// property real progress: 0.5

140+// property int lineWidth: units.dp(4)

141+// onProgressChanged: {

142+// requestPaint();

143+// if (progress == 1) {

144+// Screens.activateScreen(index);

145+// }

146+// }

147+

148+// rotation: -90

149+

150+// onPaint: {

151+// var ctx = canvas.getContext("2d");

152+// ctx.save();

153+// ctx.reset();

154+

155+// ctx.lineWidth = lineWidth;

156+

157+// ctx.strokeStyle = "#3bffffff"

158+// ctx.beginPath();

159+// ctx.arc(canvas.width/2,canvas.height/2, (canvas.height - ctx.lineWidth) / 2, 0, (Math.PI*2),false);

160+// ctx.stroke();

161+// ctx.closePath();

162+

163+// ctx.strokeStyle = "white"

164+// ctx.beginPath();

165+// ctx.arc(canvas.width/2,canvas.height/2, (canvas.height - ctx.lineWidth) / 2, 0, (Math.PI*2*(progress)),false);

166+// ctx.stroke();

167+// ctx.closePath();

168+

169+// ctx.restore();

170+// }

171+// }

172+

173+// Icon {

174+// source: "graphics/multi-monitor_leave.png"

175+// height: units.gu(4)

176+// width: height

177+// anchors.centerIn: parent

178+// }

179+// }

180+ }

181+

182+ FloatingFlickable {

183+ id: flickable

184+ anchors.fill: parent

185+ contentWidth: workspaceRepeater.count * previewSpace.screenWidth * previewScale

186+ property real progress: contentX / contentWidth

187+ onContentXChanged: print("contentX:", contentX, "progress:", progress)

188+ }

189+

190+ MouseArea {

191+ anchors.fill: parent

192+ hoverEnabled: true

193+ property int scrollAreaWidth: width / 3

194+

195+ onMouseXChanged: {

196+ var margins = flickable.width * 0.05;

197+

198+ // do we need to scroll?

199+ if (mouseX < scrollAreaWidth + margins) {

200+ var progress = Math.min(1, (scrollAreaWidth + margins - mouseX) / (scrollAreaWidth - margins));

201+ var contentX = (1 - progress) * (flickable.contentWidth - flickable.width)

202+ flickable.contentX = Math.max(0, Math.min(flickable.contentX, contentX))

203+ }

204+ if (mouseX > flickable.width - scrollAreaWidth) {

205+ var progress = Math.min(1, (mouseX - (flickable.width - scrollAreaWidth)) / (scrollAreaWidth - margins))

206+ var contentX = progress * (flickable.contentWidth - flickable.width)

207+ flickable.contentX = Math.min(flickable.contentWidth - flickable.width, Math.max(flickable.contentX, contentX))

208+ }

209+ }

210+ }

211+ }

212+}

qml/Stage/graphics/multi-monitor_leave.pngnew file

Binary file not shown.

qml/qmldirnew file+1

@@ -0,0 +1 @@

1+singleton ShellNotifier 0.1 ShellNotifier.qml

src/ApplicationArguments.cpp+11−2

@@ -16,7 +16,16 @@

16

17#include "ApplicationArguments.h"

18

19−ApplicationArguments::ApplicationArguments(QObject *parent)

19+ApplicationArguments::ApplicationArguments(QCoreApplication *app)

20− : QObject(parent)

20+ : QObject(app)

21+ , UnityCommandLineParser(*app)

21{

22{

22}

23}

24+

25+void ApplicationArguments::setDeviceName(const QString &deviceName)

26+{

27+ if (deviceName != m_deviceName) {

28+ m_deviceName = deviceName;

29+ Q_EMIT deviceNameChanged(m_deviceName);

30+ }

31+}

src/ApplicationArguments.h+17−15

@@ -23,31 +23,33 @@

23#include <QSize>

24#include <QString>

25

26+#include "UnityCommandLineParser.h"

27+

26−class ApplicationArguments : public QObject

28+class ApplicationArguments : public QObject,

29+ public UnityCommandLineParser

27{

30{

28 Q_OBJECT

31 Q_OBJECT

29 Q_PROPERTY(QString deviceName READ deviceName NOTIFY deviceNameChanged)

32 Q_PROPERTY(QString deviceName READ deviceName NOTIFY deviceNameChanged)

30 Q_PROPERTY(QString mode READ mode CONSTANT)

33 Q_PROPERTY(QString mode READ mode CONSTANT)

34+

35+ Q_PROPERTY(bool hasGeometry READ hasGeometry CONSTANT)

36+ Q_PROPERTY(QSize windowGeometry READ windowGeometry CONSTANT)

37+ Q_PROPERTY(bool hasTestability READ hasTestability CONSTANT)

38+ Q_PROPERTY(bool hasFrameless READ hasFrameless CONSTANT)

39+ Q_PROPERTY(bool hasFullscreen READ hasFullscreen CONSTANT)

40+#ifdef UNITY8_ENABLE_TOUCH_EMULATION

41+ Q_PROPERTY(bool hasMouseToTouch READ hasMouseToTouch CONSTANT)

42+#endif

43+

31public:

44public:

32− ApplicationArguments(QObject *parent = nullptr);

45+ ApplicationArguments(QCoreApplication *app);

33

46

34− void setDeviceName(const QString &deviceName) {

47+ void setDeviceName(const QString &deviceName);

35− if (deviceName != m_deviceName) {

36− m_deviceName = deviceName;

37− Q_EMIT deviceNameChanged(m_deviceName);

38− }

39− }

40− QString deviceName() const { return m_deviceName; }

41

48

42− void setMode(const QString &mode) { m_mode = mode; }

49+ bool hasGeometry() const { return m_windowGeometry.isValid(); }

43− QString mode() const { return m_mode; }

44

50

45Q_SIGNALS:

51Q_SIGNALS:

46 void deviceNameChanged(const QString&);

52 void deviceNameChanged(const QString&);

47−

48−private:

49− QString m_deviceName;

50− QString m_mode;

51};

53};

52

54

53#endif // APPLICATION_ARGUMENTS_H

55#endif // APPLICATION_ARGUMENTS_H

src/CMakeLists.txt−2

@@ -27,9 +27,7 @@ set(SOURCE_FILES

27 ApplicationArguments.cpp

28 main.cpp

29 CachingNetworkManagerFactory.cpp

30− SecondaryWindow.cpp

31 ShellApplication.cpp

30 ShellApplication.cpp

32− ShellView.cpp

33 UnityCommandLineParser.cpp

31 UnityCommandLineParser.cpp

34 UnixSignalHandler.cpp

32 UnixSignalHandler.cpp

35 DebuggingController.cpp

33 DebuggingController.cpp

src/DebuggingController.cpp+12−1

@@ -49,7 +49,8 @@ public:

49};

50

51DebuggingController::DebuggingController(QObject *parent):

52− UnityDBusObject(QStringLiteral("/com/canonical/Unity8/Debugging"), QStringLiteral("com.canonical.Unity8"), true, parent)

52+ UnityDBusObject(QStringLiteral("/com/canonical/Unity8/Debugging"), QStringLiteral("com.canonical.Unity8"), true, parent),

53+ m_logOverlay(false)

53{

54{

54}

55}

55

56

@@ -90,3 +91,13 @@ void DebuggingController::SetLoggingFilterRules(const QString &filterRules)

90{

91{

91 QLoggingCategory::setFilterRules(filterRules);

92 QLoggingCategory::setFilterRules(filterRules);

92}

93}

94+

95+void DebuggingController::SetLogOverlay(bool logOverlay)

96+{

97+ if (logOverlay == m_logOverlay) {

98+ return;

99+ }

100+

101+ m_logOverlay = logOverlay;

102+ Q_EMIT logOverlayChanged(m_logOverlay);

103+}

src/DebuggingController.h+14

@@ -32,10 +32,14 @@ class DebuggingController: public UnityDBusObject

32 Q_OBJECT

33 Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity8.Debugging")

34

35+ Q_PROPERTY(bool logOverlay READ logOverlay NOTIFY logOverlayChanged)

36+

35public:

37public:

36 DebuggingController(QObject *parent = nullptr);

38 DebuggingController(QObject *parent = nullptr);

37 ~DebuggingController() = default;

39 ~DebuggingController() = default;

38

40

41+ bool logOverlay() const { return m_logOverlay; }

42+

39public Q_SLOTS:

43public Q_SLOTS:

40 /**

44 /**

41 * Set the QSG_VISUALIZE mode. This follows the vlues supported by Qt in

45 * Set the QSG_VISUALIZE mode. This follows the vlues supported by Qt in

@@ -53,5 +57,15 @@ public Q_SLOTS:

53 */

57 */

54 Q_SCRIPTABLE void SetLoggingFilterRules(const QString &filterRules);

58 Q_SCRIPTABLE void SetLoggingFilterRules(const QString &filterRules);

55

59

60+ /**

61+ * Enable/Disable the shell console log overlay

62+ */

63+ Q_SCRIPTABLE void SetLogOverlay(bool logOverlay);

64+

65+Q_SIGNALS:

66+ void logOverlayChanged(bool logOverlay);

67+

68+private:

69+ bool m_logOverlay;

56};

70};

57#endif // DEBUGGINGCONTROLLER_H

71#endif // DEBUGGINGCONTROLLER_H

src/SecondaryWindow.cppdeleted−40

@@ -1,40 +0,0 @@

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 "SecondaryWindow.h"

18−

19−// local

20−#include <paths.h>

21−

22−#include <QQmlContext>

23−

24−SecondaryWindow::SecondaryWindow(QQmlEngine *engine)

25− : QQuickView(engine, nullptr)

26−{

27− QByteArray pxpguEnv = qgetenv("GRID_UNIT_PX");

28− bool ok;

29− int pxpgu = pxpguEnv.toInt(&ok);

30− if (!ok) {

31− pxpgu = 8;

32− }

33− engine->rootContext()->setContextProperty(QStringLiteral("internalGu"), pxpgu);

34− setResizeMode(QQuickView::SizeRootObjectToView);

35− setColor("black");

36− setTitle(QStringLiteral("Unity8 Shell - Secondary Screen"));

37−

38− QUrl source(::qmlDirectory() + "/DisabledScreenNotice.qml");

39− setSource(source);

40−}

src/ShellApplication.cpp+26−104

@@ -20,6 +20,7 @@

20#include <QLibrary>

21#include <QProcess>

22#include <QScreen>

23+#include <QQmlContext>

23

24

24#include <libintl.h>

25#include <libintl.h>

25

26

@@ -34,30 +35,22 @@

34

35

35ShellApplication::ShellApplication(int & argc, char ** argv, bool isMirServer)

36ShellApplication::ShellApplication(int & argc, char ** argv, bool isMirServer)

36 : QGuiApplication(argc, argv)

37 : QGuiApplication(argc, argv)

38+ , m_qmlArgs(this)

37{

39{

38 setApplicationName(QStringLiteral("unity8"));

40 setApplicationName(QStringLiteral("unity8"));

39 setOrganizationName(QStringLiteral("Canonical"));

41 setOrganizationName(QStringLiteral("Canonical"));

40

42

41− connect(this, &QGuiApplication::screenAdded, this, &ShellApplication::onScreenAdded);

42−

43 setupQmlEngine(isMirServer);

44

45− UnityCommandLineParser parser(*this);

46−

47− if (!parser.deviceName().isEmpty()) {

45+ if (m_qmlArgs.deviceName().isEmpty()) {

48− m_deviceName = parser.deviceName();

49− } else {

50 char buffer[200];

46 char buffer[200];

51 property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);

47 property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);

52− m_deviceName = QString(buffer);

48+ m_qmlArgs.setDeviceName(QString(buffer));

53 }

49 }

54− m_qmlArgs.setDeviceName(m_deviceName);

55−

56− m_qmlArgs.setMode(parser.mode());

57

50

58 // The testability driver is only loaded by QApplication but not by QGuiApplication.

51 // The testability driver is only loaded by QApplication but not by QGuiApplication.

59 // However, QApplication depends on QWidget which would add some unneeded overhead => Let's load the testability driver on our own.

52 // However, QApplication depends on QWidget which would add some unneeded overhead => Let's load the testability driver on our own.

60− if (parser.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {

53+ if (m_qmlArgs.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {

61 QLibrary testLib(QStringLiteral("qttestability"));

54 QLibrary testLib(QStringLiteral("qttestability"));

62 if (testLib.load()) {

55 if (testLib.load()) {

63 typedef void (*TasInitialize)(void);

56 typedef void (*TasInitialize)(void);

@@ -75,57 +68,39 @@ ShellApplication::ShellApplication(int & argc, char ** argv, bool isMirServer)

75 bindtextdomain("unity8", translationDirectory().toUtf8().data());

68 bindtextdomain("unity8", translationDirectory().toUtf8().data());

76 textdomain("unity8");

69 textdomain("unity8");

77

70

78− m_shellView = new ShellView(m_qmlEngine, &m_qmlArgs);

71+ m_qmlEngine->rootContext()->setContextProperty(QStringLiteral("applicationArguments"), &m_qmlArgs);

79−

72+ m_qmlEngine->rootContext()->setContextProperty("DebuggingController", new DebuggingController(this));

80− if (parser.windowGeometry().isValid()) {

81− m_shellView->setWidth(parser.windowGeometry().width());

82− m_shellView->setHeight(parser.windowGeometry().height());

83− }

84

73

85− if (parser.hasFrameless()) {

74+ QByteArray pxpguEnv = qgetenv("GRID_UNIT_PX");

86− m_shellView->setFlags(Qt::FramelessWindowHint);

75+ bool ok;

76+ int pxpgu = pxpguEnv.toInt(&ok);

77+ if (!ok) {

78+ pxpgu = 8;

87 }

79 }

88−

80+ m_qmlEngine->rootContext()->setContextProperty("internalGu", pxpgu);

81+ m_qmlEngine->load(::qmlDirectory() + "/ShellApplication.qml");

89

82

90 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

83 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

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

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

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

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

93− if (parser.hasMouseToTouch()) {

86+ if (m_qmlArgs.hasMouseToTouch()) {

94 m_mouseTouchAdaptor = MouseTouchAdaptor::instance();

87 m_mouseTouchAdaptor = MouseTouchAdaptor::instance();

95 }

88 }

96 #endif

89 #endif

97

90

98− new DebuggingController(this);

99−

100− // Some hard-coded policy for now.

101− // NB: We don't support more than two screens at the moment

102− //

103− // TODO: Support an arbitrary number of screens and different policies

104− // (eg cloned desktop, several desktops, etc)

105− if (isMirServer && screens().count() == 2) {

106− m_shellView->setScreen(screens().at(1));

107− m_qmlArgs.setDeviceName(QStringLiteral("desktop"));

108−

109− m_secondaryWindow = new SecondaryWindow(m_qmlEngine);

110− m_secondaryWindow->setScreen(screens().at(0));

111− // QWindow::showFullScreen() also calls QWindow::requestActivate() and we don't want that!

112− m_secondaryWindow->setWindowState(Qt::WindowFullScreen);

113− m_secondaryWindow->setVisible(true);

114− }

115−

116− if (parser.mode().compare("greeter") == 0) {

91+ if (m_qmlArgs.mode().compare("greeter") == 0) {

117− QSize primaryScreenSize = this->primaryScreen()->size();

92+// QSize primaryScreenSize = this->primaryScreen()->size();

118− m_shellView->setHeight(primaryScreenSize.height());

93+// m_shellView->setHeight(primaryScreenSize.height());

119− m_shellView->setWidth(primaryScreenSize.width());

94+// m_shellView->setWidth(primaryScreenSize.width());

120− m_shellView->show();

95+// m_shellView->show();

121− m_shellView->requestActivate();

96+// m_shellView->requestActivate();

122 if (!QProcess::startDetached("initctl emit --no-wait unity8-greeter-started")) {

97 if (!QProcess::startDetached("initctl emit --no-wait unity8-greeter-started")) {

123 qDebug() << "Unable to send unity8-greeter-started event to Upstart";

98 qDebug() << "Unable to send unity8-greeter-started event to Upstart";

124 }

99 }

125− } else if (isMirServer || parser.hasFullscreen()) {

100+// } else if (isMirServer || parser.hasFullscreen()) {

126− m_shellView->showFullScreen();

101+// m_shellView->showFullScreen();

127− } else {

102+// } else {

128− m_shellView->show();

103+// m_shellView->show();

129 }

104 }

130}

105}

131

106

@@ -136,14 +111,6 @@ ShellApplication::~ShellApplication()

136

111

137void ShellApplication::destroyResources()

112void ShellApplication::destroyResources()

138{

113{

139− // Deletion order is important. Don't use QScopedPointers and the like

140− // Otherwise the process will hang on shutdown (bug somewhere I guess).

141− delete m_shellView;

142− m_shellView = nullptr;

143−

144− delete m_secondaryWindow;

145− m_secondaryWindow = nullptr;

146−

147 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

114 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

148 delete m_mouseTouchAdaptor;

115 delete m_mouseTouchAdaptor;

149 m_mouseTouchAdaptor = nullptr;

116 m_mouseTouchAdaptor = nullptr;

@@ -155,7 +122,7 @@ void ShellApplication::destroyResources()

155

122

156void ShellApplication::setupQmlEngine(bool isMirServer)

123void ShellApplication::setupQmlEngine(bool isMirServer)

157{

124{

158− m_qmlEngine = new QQmlEngine(this);

125+ m_qmlEngine = new QQmlApplicationEngine(this);

159

126

160 m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));

127 m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));

161

128

@@ -169,48 +136,3 @@ void ShellApplication::setupQmlEngine(bool isMirServer)

169

136

170 QObject::connect(m_qmlEngine, &QQmlEngine::quit, this, &QGuiApplication::quit);

137 QObject::connect(m_qmlEngine, &QQmlEngine::quit, this, &QGuiApplication::quit);

171}

138}

172−

173−void ShellApplication::onScreenAdded(QScreen * /*screen*/)

174−{

175− // TODO: Support an arbitrary number of screens and different policies

176− // (eg cloned desktop, several desktops, etc)

177− if (screens().count() == 2) {

178− m_shellView->setScreen(screens().at(1));

179− m_qmlArgs.setDeviceName(QStringLiteral("desktop"));

180− // Changing the QScreen where a QWindow is drawn makes it also lose focus (besides having

181− // its backing QPlatformWindow recreated). So lets refocus it.

182− m_shellView->requestActivate();

183− // QWindow::destroy() is called when it changes between screens. We have to manually make it visible again

184− // <dandrader> This bug is supposedly fixed in Qt 5.5.1, although I can still reproduce it there. :-/

185− m_shellView->setVisible(true);

186−

187− m_secondaryWindow = new SecondaryWindow(m_qmlEngine);

188− m_secondaryWindow->setScreen(screens().at(0));

189−

190− // QWindow::showFullScreen() also calls QWindow::requestActivate() and we don't want that!

191− m_secondaryWindow->setWindowState(Qt::WindowFullScreen);

192− m_secondaryWindow->setVisible(true);

193− }

194−}

195−

196−void ShellApplication::onScreenAboutToBeRemoved(QScreen *screen)

197−{

198− // TODO: Support an arbitrary number of screens and different policies

199− // (eg cloned desktop, several desktops, etc)

200− if (screen == m_shellView->screen()) {

201− const QList<QScreen *> allScreens = screens();

202− Q_ASSERT(allScreens.count() > 1);

203− Q_ASSERT(allScreens.at(0) != screen);

204− Q_ASSERT(m_secondaryWindow);

205− delete m_secondaryWindow;

206− m_secondaryWindow = nullptr;

207− m_shellView->setScreen(allScreens.first());

208− m_qmlArgs.setDeviceName(m_deviceName);

209− // Changing the QScreen where a QWindow is drawn makes it also lose focus (besides having

210− // its backing QPlatformWindow recreated). So lets refocus it.

211− m_shellView->requestActivate();

212− // QWindow::destroy() is called when it changes between screens. We have to manually make it visible again

213− // <dandrader> This bug is supposedly fixed in Qt 5.5.1, although I can still reproduce it there. :-/

214− m_shellView->setVisible(true);

215− }

216−}

src/ShellApplication.h+2−14

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

18#define SHELLAPPLICATION_H

19

20#include <QGuiApplication>

21−#include <QQmlEngine>

21+#include <QQmlApplicationEngine>

22#include <QQuickView>

23#include <QScopedPointer>

24

@@ -28,9 +28,6 @@

28#include "MouseTouchAdaptor.h"

29#endif

30

31−#include "SecondaryWindow.h"

32−#include "ShellView.h"

33−

34class ShellApplication : public QGuiApplication

31class ShellApplication : public QGuiApplication

35{

32{

36 Q_OBJECT

33 Q_OBJECT

@@ -39,25 +36,16 @@ public:

39 virtual ~ShellApplication();

36 virtual ~ShellApplication();

40

37

41 void destroyResources();

38 void destroyResources();

42−public Q_SLOTS:

43− // called by qtmir

44− void onScreenAboutToBeRemoved(QScreen *screen);

45−

46−private Q_SLOTS:

47− void onScreenAdded(QScreen*);

48

39

49private:

40private:

50 void setupQmlEngine(bool isMirServer);

41 void setupQmlEngine(bool isMirServer);

51− QString m_deviceName;

52 ApplicationArguments m_qmlArgs;

42 ApplicationArguments m_qmlArgs;

53− ShellView *m_shellView{nullptr};

54− SecondaryWindow *m_secondaryWindow{nullptr};

55

43

56 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

44 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

57 MouseTouchAdaptor *m_mouseTouchAdaptor{nullptr};

45 MouseTouchAdaptor *m_mouseTouchAdaptor{nullptr};

58 #endif

46 #endif

59

47

60− QQmlEngine *m_qmlEngine{nullptr};

48+ QQmlApplicationEngine *m_qmlEngine{nullptr};

61};

49};

62

50

63#endif // SHELLAPPLICATION_H

51#endif // SHELLAPPLICATION_H

src/ShellView.cppdeleted−63

@@ -1,63 +0,0 @@

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 "ShellView.h"

18−

19−// Qt

20−#include <QQmlContext>

21−#include <QQuickItem>

22−

23−// local

24−#include <paths.h>

25−

26−ShellView::ShellView(QQmlEngine *engine, QObject *qmlArgs)

27− : QQuickView(engine, nullptr)

28−{

29− setResizeMode(QQuickView::SizeRootObjectToView);

30− setColor("black");

31− setTitle(QStringLiteral("Unity8"));

32−

33− rootContext()->setContextProperty(QStringLiteral("applicationArguments"), qmlArgs);

34−

35− QUrl source(::qmlDirectory() + "/OrientedShell.qml");

36− setSource(source);

37−

38− connect(this, &QWindow::widthChanged, this, &ShellView::onWidthChanged);

39− connect(this, &QWindow::heightChanged, this, &ShellView::onHeightChanged);

40−}

41−

42−void ShellView::onWidthChanged(int w)

43−{

44− // For good measure in case SizeRootObjectToView doesn't fulfill its promise.

45− //

46− // There's at least one situation that's know to leave the root object with an outdated size.

47− // (really looks like Qt bug)

48− // Happens when starting unity8 with an external monitor already connected.

49− // The QResizeEvent we get still has the size of the first screen and since the resize move is triggered

50− // from the resize event handler, the root item doesn't get resized.

51− // TODO: Confirm the Qt bug and submit a patch upstream

52− if (rootObject()) {

53− rootObject()->setWidth(w);

54− }

55−}

56−

57−void ShellView::onHeightChanged(int h)

58−{

59− // See comment in ShellView::onWidthChanged()

60− if (rootObject()) {

61− rootObject()->setHeight(h);

62− }

63−}

src/UnityCommandLineParser.h+1−1

@@ -36,8 +36,8 @@ public:

36 bool hasFullscreen() const { return m_hasFullscreen; }

37 QString deviceName() const { return m_deviceName; }

38 QString mode() const { return m_mode; }

39−private:

40

39

40+protected:

41 int parsePixelsValue(const QString &str);

42 static float getenvFloat(const char* name, float defaultValue);

43 void resolveMode(QCommandLineParser &parser, QCommandLineOption &modeOption);

tests/mocks/Cursor/Cursor.qml+49−2

@@ -15,8 +15,11 @@

15 */

16

17import QtQuick 2.4

18+import UInput 0.1

19+

20+Canvas {

21+ id: root

18

22

19−Item {

20 property int topBoundaryOffset // effectively panel height

23 property int topBoundaryOffset // effectively panel height

21 property Item confiningItem

24 property Item confiningItem

22

25

@@ -30,5 +33,49 @@ Item {

30 signal pushStopped()

33 signal pushStopped()

31 signal mouseMoved()

34 signal mouseMoved()

32

35

36+ width: units.gu(2)

37+ height: units.gu(2)

38+ antialiasing: true

39+

40+ onPaint: {

41+ var ctx = getContext("2d");

42+ ctx.save();

43+ ctx.clearRect(0,0,width, height);

44+ ctx.strokeStyle = "#000000";

45+ ctx.lineWidth = 1

46+ ctx.fillStyle = "#ffffff";

47+ ctx.globalAlpha = 1.0;

48+ ctx.lineJoin = "round";

49+ ctx.beginPath();

50+

51+ // put rectangle in the middle

52+ // draw the rectangle

53+ ctx.moveTo(width/2,height);

54+ ctx.lineTo(width, height/2);

55+ ctx.lineTo(0,0);

56+

57+ ctx.closePath();

58+ ctx.fill();

59+ ctx.stroke();

60+ ctx.restore();

61+ }

62+

63+ Connections {

64+ target: UInput

33− onMouseMoved: opacity = 1;

65+ onMouseMoved: {

66+ var newX = root.x;

67+ newX += dx;

68+ if (newX < 0) newX = 0;

69+ else if (newX >= parent.width) newX = parent.width-1;

70+

71+ var newY = root.y;

72+ newY += dy;

73+ if (newY < 0) newY = 0;

74+ else if (newY >= parent.height) newY = parent.height-1;

75+

76+ root.x = newX;

77+ root.y = newY;

78+ root.mouseMoved();

79+ }

80+ }

34}

81}

tests/mocks/GSettings.1.0/plugin.cpp+12

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

18#include "fake_gsettings.h"

19

20#include <QtQml/qqml.h>

21+#include <QQmlEngine>

22+#include <QQmlContext>

21

23

22static QObject* controllerProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)

24static QObject* controllerProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)

23{

25{

@@ -31,3 +33,13 @@ void FakeGSettingsQmlPlugin::registerTypes(const char *uri)

31 qmlRegisterUncreatableType<GSettingsSchemaQml>(uri, 1, 0, "GSettingsSchema",

33 qmlRegisterUncreatableType<GSettingsSchemaQml>(uri, 1, 0, "GSettingsSchema",

32 "GSettingsSchema can only be used inside of a GSettings component");

34 "GSettingsSchema can only be used inside of a GSettings component");

33}

35}

36+

37+void FakeGSettingsQmlPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

38+{

39+ QQmlExtensionPlugin::initializeEngine(engine, uri);

40+

41+ QString usageType = qgetenv("UNITY_MOCK_DESKTOP");

42+ if (!usageType.isEmpty()) {

43+ GSettingsControllerQml::instance()->setUsageMode("Windowed");

44+ }

45+}

tests/mocks/GSettings.1.0/plugin.h+1

@@ -26,6 +26,7 @@ class FakeGSettingsQmlPlugin : public QQmlExtensionPlugin

26

27public:

28 void registerTypes(const char *uri) override;

29+ void initializeEngine(QQmlEngine *engine, const char *uri) override;

29};

30};

30

31

31#endif // PLUGIN_H

32#endif // PLUGIN_H

tests/mocks/UInput/plugin.cpp+6−1

@@ -19,8 +19,13 @@

19

20#include <QtQml/qqml.h>

21

22+QObject* uinputSingleton(QQmlEngine*, QJSEngine*)

23+{

24+ return new MockUInput;

25+}

26+

22void MockUInputPlugin::registerTypes(const char *uri)

27void MockUInputPlugin::registerTypes(const char *uri)

23{

28{

24 Q_ASSERT(uri == QLatin1String("UInput"));

29 Q_ASSERT(uri == QLatin1String("UInput"));

25− qmlRegisterType<MockUInput>(uri, 0, 1, "UInput");

30+ qmlRegisterSingletonType<MockUInput>(uri, 0, 1, "UInput", uinputSingleton);

26}

31}

tests/mocks/Unity/Application/MirSurfaceItem.cpp+27−4

@@ -189,9 +189,15 @@ void MirSurfaceItem::createQmlContentItem()

189 m_qmlItem = qobject_cast<QQuickItem*>(m_qmlContentComponent->create());

190 m_qmlItem->setParentItem(this);

191

192+ if (m_fillMode == FillMode::Stretch && width() != 0 && height() != 0) {

193+ m_qmlItem->setWidth(width());

194+ m_qmlItem->setHeight(height());

195+ } else {

192− m_qmlItem->setWidth(m_surfaceWidth);

196+ m_qmlItem->setWidth(m_surfaceWidth);

193− m_qmlItem->setHeight(m_surfaceHeight);

197+ m_qmlItem->setHeight(m_surfaceHeight);

198+ }

194

199

200+ qDebug() << "set size to" << m_surfaceWidth;

195 setImplicitWidth(m_qmlItem->implicitWidth());

201 setImplicitWidth(m_qmlItem->implicitWidth());

196 setImplicitHeight(m_qmlItem->implicitHeight());

202 setImplicitHeight(m_qmlItem->implicitHeight());

197

203

@@ -308,6 +314,16 @@ void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

308 connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);

314 connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);

309 connect(m_qmlSurface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);

315 connect(m_qmlSurface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);

310 connect(m_qmlSurface, &MirSurface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);

316 connect(m_qmlSurface, &MirSurface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);

317+ connect(m_qmlSurface, &MirSurface::sizeChanged, this, [this] () {

318+ if (m_fillMode == FillMode::Stretch) {

319+ m_qmlItem->setSize(QSize(this->width(), this->height()));

320+ } else {

321+ m_qmlItem->setSize(m_qmlSurface->size());

322+ }

323+ setImplicitSize(m_qmlSurface->width(), m_qmlSurface->height());

324+ });

325+ m_surfaceWidth = surface->size().width();

326+ m_surfaceHeight = surface->size().height();

311

327

312 QUrl qmlComponentFilePath;

328 QUrl qmlComponentFilePath;

313 if (!m_qmlSurface->qmlFilePath().isEmpty()) {

329 if (!m_qmlSurface->qmlFilePath().isEmpty()) {

@@ -321,6 +337,7 @@ void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

321 switch (m_qmlContentComponent->status()) {

337 switch (m_qmlContentComponent->status()) {

322 case QQmlComponent::Ready:

338 case QQmlComponent::Ready:

323 createQmlContentItem();

339 createQmlContentItem();

340+ qDebug() << "content created" << m_surfaceWidth << implicitWidth() << width();

324 break;

341 break;

325 case QQmlComponent::Loading:

342 case QQmlComponent::Loading:

326 connect(m_qmlContentComponent, &QQmlComponent::statusChanged,

343 connect(m_qmlContentComponent, &QQmlComponent::statusChanged,

@@ -399,9 +416,15 @@ void MirSurfaceItem::updateSurfaceSize()

399 if (m_qmlSurface && m_surfaceWidth > 0 && m_surfaceHeight > 0) {

416 if (m_qmlSurface && m_surfaceWidth > 0 && m_surfaceHeight > 0) {

400 m_qmlSurface->resize(m_surfaceWidth, m_surfaceHeight);

417 m_qmlSurface->resize(m_surfaceWidth, m_surfaceHeight);

401 if (m_qmlItem) {

418 if (m_qmlItem) {

419+ if (m_fillMode == FillMode::Stretch) {

420+ m_qmlItem->setWidth(width());

421+ m_qmlItem->setHeight(height());

422+ } else {

402− m_qmlItem->setWidth(m_surfaceWidth);

423+ m_qmlItem->setWidth(m_surfaceWidth);

403− m_qmlItem->setHeight(m_surfaceHeight);

424+ m_qmlItem->setHeight(m_surfaceHeight);

425+ }

404 }

426 }

427+ qDebug() << this << "setting implicitsize" << m_surfaceWidth << m_surfaceHeight;

405 setImplicitSize(m_surfaceWidth, m_surfaceHeight);

428 setImplicitSize(m_surfaceWidth, m_surfaceHeight);

406 }

429 }

407}

430}

tests/mocks/Unity/Application/SurfaceManager.cpp+1−1

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

21

22#include <paths.h>

23

24−#define SURFACEMANAGER_DEBUG 0

24+#define SURFACEMANAGER_DEBUG 1

25

26#if SURFACEMANAGER_DEBUG

27#define DEBUG_MSG(params) qDebug().nospace() << "SurfaceManager[" << (void*)this << "]::" << __func__ << params

tests/mocks/Unity/InputInfo/InputWindow.qmlnew file+68

@@ -0,0 +1,68 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Unity.InputInfo 0.1

4+

5+Rectangle {

6+ id: rect

7+ color: "white"

8+ width: parent.width

9+ height: parent.height

10+

11+ Action {

12+ id: mouseAction

13+ text: checked ? "Remove Mouse" : "Add Mouse"

14+ onTriggered: {

15+ if (checked) {

16+ console.log("ADD")

17+ MockInputDeviceBackend.addMockDevice("/mouse0", InputInfo.Mouse);

18+ } else {

19+ console.log("REMOVE")

20+ MockInputDeviceBackend.removeDevice("/mouse0");

21+ }

22+ }

23+ iconName: "input-mouse-symbolic"

24+ checkable: true

25+ checked: false

26+ }

27+

28+ Action {

29+ id: kbAction

30+ text: checked ? "Remove Keyboard" : "Add Keyboard"

31+ onTriggered: {

32+ if (checked) {

33+ MockInputDeviceBackend.addMockDevice("/kbd0", InputInfo.Keyboard);

34+ } else {

35+ MockInputDeviceBackend.removeDevice("/kbd0");

36+ }

37+ }

38+ iconName: "input-keyboard-symbolic"

39+ checkable: true

40+ checked: false

41+ }

42+

43+ Column {

44+ anchors {

45+ fill: parent

46+ margins: units.gu(1)

47+ }

48+ spacing: units.gu(1)

49+

50+ Button {

51+ anchors {

52+ left: parent.left

53+ right: parent.right

54+ }

55+ action: mouseAction

56+ color: mouseAction.checked ? UbuntuColors.red : UbuntuColors.green

57+ }

58+

59+ Button {

60+ anchors {

61+ left: parent.left

62+ right: parent.right

63+ }

64+ action: kbAction

65+ color: kbAction.checked ? UbuntuColors.red : UbuntuColors.green

66+ }

67+ }

68+}

tests/mocks/Unity/InputInfo/mockcontroller.cpp+24−2

@@ -18,10 +18,32 @@

18

19#include "qinputdeviceinfo_mock_p.h"

20

21+#include <QQuickView>

22+#include <QQmlComponent>

23+#include <QQuickItem>

24+#include <paths.h>

25+

21−MockController::MockController(QObject *parent):

26+MockController::MockController(QQmlEngine *engine)

22− QObject(parent)

23{

27{

28+ QQmlComponent component(engine);

29+ component.setData("import QtQuick 2.4; import Unity.InputInfo 0.1; InputWindow { }", ::qmlDirectory());

30+ QObject *myObject = component.create();

31+ QQuickItem *item = qobject_cast<QQuickItem*>(myObject);

32+ if (item) {

33+ auto window = new QQuickView();

34+ window->setTitle("Input");

35+ item->setParentItem(window->contentItem());

36+ window->setResizeMode(QQuickView::SizeRootObjectToView);

37+ window->setWidth(200);

38+ window->setHeight(100);

39+ window->show();

40+ }

41+}

24

42

43+MockController *MockController::instance(QQmlEngine *engine)

44+{

45+ static MockController* controller = new MockController(engine);

46+ return controller;

25}

47}

26

48

27QInputDevice *MockController::addMockDevice(const QString &devicePath, QInputDevice::InputType type)

49QInputDevice *MockController::addMockDevice(const QString &devicePath, QInputDevice::InputType type)

tests/mocks/Unity/InputInfo/mockcontroller.h+5−1

@@ -20,13 +20,17 @@

20#include <QObject>

21#include "qinputinfo.h"

22

23+class QQmlEngine;

24+

23class MockController: public QObject

25class MockController: public QObject

24{

26{

25 Q_OBJECT

27 Q_OBJECT

26public:

28public:

27− MockController(QObject *parent = 0);

29+ MockController(QQmlEngine *engine);

28 ~MockController() = default;

30 ~MockController() = default;

29

31

32+ static MockController *instance(QQmlEngine *engine);

33+

30 Q_INVOKABLE QInputDevice* addMockDevice(const QString &devicePath, QInputDevice::InputType type);

34 Q_INVOKABLE QInputDevice* addMockDevice(const QString &devicePath, QInputDevice::InputType type);

31 Q_INVOKABLE void removeDevice(const QString &devicePath);

35 Q_INVOKABLE void removeDevice(const QString &devicePath);

32};

36};

tests/mocks/Unity/InputInfo/plugin.cpp+1−2

@@ -26,9 +26,8 @@

26

27static QObject *backendProvider(QQmlEngine *engine, QJSEngine *scriptEngine)

28{

29− Q_UNUSED(engine)

30 Q_UNUSED(scriptEngine)

29 Q_UNUSED(scriptEngine)

31− return new MockController(engine);

30+ return MockController::instance(engine);

32}

31}

33

32

34void InputInfoPlugin::registerTypes(const char *uri)

33void InputInfoPlugin::registerTypes(const char *uri)

tests/mocks/Unity/InputInfo/qmldir+2

@@ -1,2 +1,4 @@

1module Unity.InputInfo

2plugin MockInputInfo

3+

4+InputWindow 0.1 InputWindow.qml

tests/mocks/Unity/Screens/CMakeLists.txt+2−1

@@ -5,10 +5,11 @@ include_directories(

5set(MockScreens_SOURCES

6 plugin.cpp

7 screens.cpp

8+ screenwindow.cpp

8)

9)

9

10

10add_library(MockScreensPlugin MODULE ${MockScreens_SOURCES})

11add_library(MockScreensPlugin MODULE ${MockScreens_SOURCES})

11

12

12−qt5_use_modules(MockScreensPlugin Gui Qml)

13+qt5_use_modules(MockScreensPlugin Gui Qml Quick)

13

14

14add_unity8_mock(Unity.Screens 0.1 Unity/Screens PREFIX mocks TARGETS MockScreensPlugin)

15add_unity8_mock(Unity.Screens 0.1 Unity/Screens PREFIX mocks TARGETS MockScreensPlugin)

tests/mocks/Unity/Screens/plugin.cpp+14−1

@@ -16,14 +16,27 @@

16

17#include "plugin.h"

18#include "screens.h"

19+#include "screenwindow.h"

19

20

20#include <QScreen>

21#include <QScreen>

21

22

23+namespace {

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

25+ Q_UNUSED(engine);

26+ Q_UNUSED(scriptEngine);

27+ return new Screens();

28+}

29+}

30+

22void UnityScreensPlugin::registerTypes(const char* uri)

31void UnityScreensPlugin::registerTypes(const char* uri)

23{

32{

24 Q_ASSERT(QLatin1String(uri) == QLatin1String("Unity.Screens"));

33 Q_ASSERT(QLatin1String(uri) == QLatin1String("Unity.Screens"));

25

34

26 qRegisterMetaType<QScreen*>("QScreen*");

35 qRegisterMetaType<QScreen*>("QScreen*");

36+ qRegisterMetaType<ScreenMode*>("ScreenMode*");

37+ qmlRegisterUncreatableType<ScreenMode>(uri, 0, 1, "ScreenMode", "ScreenMode is not creatable.");

27

38

39+ qmlRegisterSingletonType<Screens>(uri, 0, 1, "Screens", screensSingleton);

28− qmlRegisterType<Screens>(uri, 0, 1, "Screens");

40+ qmlRegisterType<ScreenWindow>(uri, 0, 1, "ScreenWindow");

41+ qmlRegisterRevision<QWindow,1>(uri, 0, 1);

29}

42}

tests/mocks/Unity/Screens/screens.cpp+52−9

@@ -18,16 +18,30 @@

18

19// Qt

20#include <QGuiApplication>

21−#include <QScreen>

22#include <QDebug>

21#include <QDebug>

23

22

24−Q_DECLARE_METATYPE(QScreen*)

25−

26Screens::Screens(QObject *parent) :

23Screens::Screens(QObject *parent) :

27 QAbstractListModel(parent)

24 QAbstractListModel(parent)

28{

25{

29− // start with one screen attached

26+ bool ok = false;

30− m_screenList.append(new Screen());

27+ int screenCount = qEnvironmentVariableIntValue("UNITY_MOCK_SCREEN_COUNT", &ok);

28+ if (!ok) screenCount = 1;

29+ QPoint lastPoint(0,0);

30+ for (int i = 0; i < screenCount; ++i) {

31+ auto screen = new Screen();

32+ screen->m_active = i == 0;

33+ screen->m_name = QString("Monitor %1").arg(i);

34+ screen->m_position = QPoint(lastPoint.x(), lastPoint.y());

35+ screen->m_sizes.append(new ScreenMode(50, QSize(640,480)));

36+ screen->m_sizes.append(new ScreenMode(60, QSize(1280,1024)));

37+ screen->m_sizes.append(new ScreenMode(60, QSize(1440,900)));

38+ screen->m_sizes.append(new ScreenMode(60, QSize(1920,1080)));

39+ screen->m_currentModeIndex = 3;

40+ screen->m_physicalSize = QSize(800,568);

41+ m_screenList.append(screen);

42+

43+ lastPoint.rx() += screen->m_sizes[screen->m_currentModeIndex]->size.width();

44+ }

31}

45}

32

46

33Screens::~Screens() noexcept

47Screens::~Screens() noexcept

@@ -40,7 +54,6 @@ QHash<int, QByteArray> Screens::roleNames() const

40{

54{

41 QHash<int, QByteArray> roles;

55 QHash<int, QByteArray> roles;

42 roles[ScreenRole] = "screen";

56 roles[ScreenRole] = "screen";

43− roles[OutputTypeRole] = "outputType";

44 return roles;

57 return roles;

45}

58}

46

59

@@ -52,9 +65,7 @@ QVariant Screens::data(const QModelIndex &index, int role) const

52

65

53 switch(role) {

66 switch(role) {

54 case ScreenRole:

67 case ScreenRole:

55− return QVariant::fromValue(m_screenList.at(index.row())->qScreen);

68+ return QVariant::fromValue(m_screenList.at(index.row()));

56− case OutputTypeRole:

57− return m_screenList.at(index.row())->outputTypes;

58 }

69 }

59

70

60 return QVariant();

71 return QVariant();

@@ -69,3 +80,35 @@ int Screens::count() const

69{

80{

70 return m_screenList.size();

81 return m_screenList.size();

71}

82}

83+

84+void Screens::activateScreen(int)

85+{

86+ qWarning("Not Implemented");

87+}

88+

89+Screen::Screen(QObject* parent)

90+ : QObject(parent)

91+{

92+}

93+

94+Screen::~Screen()

95+{

96+ qDeleteAll(m_sizes);

97+ m_sizes.clear();

98+}

99+

100+QQmlListProperty<ScreenMode> Screen::availableModes()

101+{

102+ return QQmlListProperty<ScreenMode>(this, m_sizes);

103+}

104+

105+Screen *Screen::beginConfiguration()

106+{

107+ qWarning("Not Implemented");

108+ return nullptr;

109+}

110+

111+void Screen::applyConfiguration()

112+{

113+ qWarning("Not Implemented");

114+}

tests/mocks/Unity/Screens/screens.h+84−4

@@ -19,6 +19,7 @@

19

20#include <QAbstractListModel>

21#include <QScreen>

22+#include <QQmlListProperty>

22

23

23class Screen;

24class Screen;

24

25

@@ -31,7 +32,13 @@ class Screens : public QAbstractListModel

31public:

32public:

32 enum ItemRoles {

33 enum ItemRoles {

33 ScreenRole = Qt::UserRole + 1,

34 ScreenRole = Qt::UserRole + 1,

34− OutputTypeRole

35+ OutputTypeRole,

36+ EnabledRole,

37+ NameRole,

38+ ScaleRole,

39+ FormFactorRole,

40+ GeometryRole,

41+ SizesRole

35 };

42 };

36

43

37 enum OutputTypes {

44 enum OutputTypes {

@@ -53,6 +60,15 @@ public:

53 };

60 };

54 Q_ENUM(OutputTypes)

61 Q_ENUM(OutputTypes)

55

62

63+ enum FormFactor {

64+ FormFactorUnknown,

65+ FormFactorPhone,

66+ FormFactorTablet,

67+ FormFactorMonitor,

68+ FormFactorTV,

69+ FormFactorProjector,

70+ };

71+

56 explicit Screens(QObject *parent = 0);

72 explicit Screens(QObject *parent = 0);

57 virtual ~Screens() noexcept;

73 virtual ~Screens() noexcept;

58

74

@@ -63,6 +79,9 @@ public:

63

79

64 int count() const;

80 int count() const;

65

81

82+public Q_SLOTS:

83+ void activateScreen(int index);

84+

66Q_SIGNALS:

85Q_SIGNALS:

67 void countChanged();

86 void countChanged();

68 void screenAdded(QScreen *screen);

87 void screenAdded(QScreen *screen);

@@ -72,11 +91,72 @@ private:

72 QList<Screen *> m_screenList;

91 QList<Screen *> m_screenList;

73};

92};

74

93

75−class Screen

94+class ScreenMode : public QObject

76{

95{

96+ Q_OBJECT

97+ Q_PROPERTY(qreal refreshRate MEMBER refreshRate CONSTANT)

98+ Q_PROPERTY(QSize size MEMBER size CONSTANT)

77public:

99public:

78− Screens::OutputTypes outputTypes = Screens::Unknown;

100+ ScreenMode() {}

101+ ScreenMode(qreal refreshRate, QSize size):refreshRate(refreshRate),size(size) {}

102+ ScreenMode(const ScreenMode& other)

79− QScreen *qScreen = nullptr;

103+ : QObject(nullptr),

104+ refreshRate{other.refreshRate},size{other.size}

105+ {}

106+

107+ qreal refreshRate;

108+ QSize size;

80};

109};

81

110

111+class Screen : public QObject

112+{

113+ Q_OBJECT

114+

115+ Q_PROPERTY(bool active MEMBER m_active NOTIFY activeChanged)

116+

117+ Q_PROPERTY(bool used MEMBER m_used NOTIFY usedChanged)

118+ Q_PROPERTY(QString name MEMBER m_name NOTIFY nameChanged)

119+ Q_PROPERTY(Screens::OutputTypes outputType MEMBER m_outputType NOTIFY outputTypeChanged)

120+ Q_PROPERTY(float scale MEMBER m_scale NOTIFY scaleChanged)

121+ Q_PROPERTY(Screens::FormFactor formFactor MEMBER m_formFactor NOTIFY formFactorChanged)

122+ Q_PROPERTY(QPoint position MEMBER m_position NOTIFY positionChanged)

123+ Q_PROPERTY(uint currentModeIndex MEMBER m_currentModeIndex NOTIFY currentModeIndexChanged)

124+ Q_PROPERTY(QQmlListProperty<ScreenMode> availableModes READ availableModes NOTIFY availableModesChanged)

125+ Q_PROPERTY(QSizeF physicalSize MEMBER m_physicalSize NOTIFY physicalSizeChanged)

126+public:

127+ Screen(QObject* parent = 0);

128+ ~Screen();

129+

130+ QQmlListProperty<ScreenMode> availableModes();

131+

132+ Q_INVOKABLE Screen* beginConfiguration();

133+ Q_INVOKABLE void applyConfiguration();

134+

135+Q_SIGNALS:

136+ void activeChanged();

137+ void usedChanged();

138+ void nameChanged();

139+ void outputTypeChanged();

140+ void scaleChanged();

141+ void formFactorChanged();

142+ void positionChanged();

143+ void currentModeIndexChanged();

144+ void availableModesChanged();

145+ void physicalSizeChanged();

146+

147+public:

148+ bool m_active{false};

149+ bool m_used{true};

150+ QString m_name;

151+ Screens::OutputTypes m_outputType{Screens::Unknown};

152+ float m_scale{1.0};

153+ Screens::FormFactor m_formFactor{Screens::FormFactorMonitor};

154+ QPoint m_position;

155+ uint m_currentModeIndex{0};

156+ QList<ScreenMode*> m_sizes;

157+ QSizeF m_physicalSize;

158+};

159+

160+Q_DECLARE_METATYPE(ScreenMode)

161+

82#endif // SCREENS_H

162#endif // SCREENS_H

tests/mocks/Unity/Screens/screenwindow.cppnew file+35

@@ -0,0 +1,35 @@

1+/*

3+ *

4+ * This program is free software: you can redistribute it and/or modify it under

5+ * the terms of the GNU Lesser General Public License version 3, as published by

6+ * the Free Software Foundation.

7+ *

8+ * This program is distributed in the hope that it will be useful, but WITHOUT

9+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,

10+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

11+ * Lesser General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU Lesser General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+ */

16+

17+#include "screenwindow.h"

18+

19+ScreenWindow::ScreenWindow(QWindow *parent)

20+ : QQuickWindow(parent)

21+{

22+}

23+

24+Screen *ScreenWindow::screenWrapper() const

25+{

26+ return m_screen.data();

27+}

28+

29+void ScreenWindow::setScreenWrapper(Screen *screen)

30+{

31+ if (m_screen != screen) {

32+ m_screen = screen;

33+ Q_EMIT screenWrapperChanged();

34+ }

35+}

tests/mocks/Unity/Screens/screenwindow.hnew file+42

@@ -0,0 +1,42 @@

1+/*

3+ *

4+ * This program is free software: you can redistribute it and/or modify it under

5+ * the terms of the GNU Lesser General Public License version 3, as published by

6+ * the Free Software Foundation.

7+ *

8+ * This program is distributed in the hope that it will be useful, but WITHOUT

9+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,

10+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

11+ * Lesser General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU Lesser General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+ */

16+

17+#ifndef SCREENWINDOW_H

18+#define SCREENWINDOW_H

19+

20+#include <QQuickWindow>

21+#include <QPointer>

22+

23+#include "screens.h"

24+

25+class ScreenWindow : public QQuickWindow

26+{

27+ Q_OBJECT

28+ Q_PROPERTY(Screen *screen READ screenWrapper WRITE setScreenWrapper NOTIFY screenWrapperChanged)

29+public:

30+ ScreenWindow(QWindow *parent = 0);

31+

32+ Screen *screenWrapper() const;

33+ void setScreenWrapper(Screen *screen);

34+

35+Q_SIGNALS:

36+ void screenWrapperChanged();

37+

38+private:

39+ QPointer<Screen> m_screen;

40+};

41+

42+#endif // SCREENWINDOW_H

tests/qmltests/Components/tst_VirtualTouchPad.qml+2−2

@@ -39,11 +39,11 @@ Rectangle {

39

40 SignalSpy {

41 id: mouseEventSpy1

42− target: touchScreenPad.uinput

42+ target: UInput

43 }

44 SignalSpy {

45 id: mouseEventSpy2

46− target: touchScreenPad.uinput

46+ target: UInput

47 }

48

49 UnityTestCase {

tests/qmltests/Panel/tst_Panel.qml+14−12

@@ -42,6 +42,8 @@ PanelTest {

42 value: keyboardAttached.checked

43 }

44

45+ readonly property alias panelState: panel.panelState

46+

45 SurfaceManager { id: sMgr }

47 SurfaceManager { id: sMgr }

46 ApplicationMenuDataLoader {

48 ApplicationMenuDataLoader {

47 id: appMenuData

49 id: appMenuData

@@ -148,7 +150,7 @@ PanelTest {

148 Layout.fillWidth: true

150 Layout.fillWidth: true

149 CheckBox {

151 CheckBox {

150 id: windowControlsCB

152 id: windowControlsCB

151− onClicked: PanelState.decorationsVisible = checked

153+ onClicked: panelState.decorationsVisible = checked

152 }

154 }

153 Label {

155 Label {

154 text: "Show window decorations"

156 text: "Show window decorations"

@@ -159,7 +161,7 @@ PanelTest {

159 RowLayout {

161 RowLayout {

160 Layout.fillWidth: true

162 Layout.fillWidth: true

161 CheckBox {

163 CheckBox {

162− onClicked: PanelState.title = checked ? "Fake window title" : ""

164+ onClicked: panelState.title = checked ? "Fake window title" : ""

163 }

165 }

164 Label {

166 Label {

165 text: "Show fake window title"

167 text: "Show fake window title"

@@ -245,7 +247,7 @@ PanelTest {

245

247

246 SignalSpy {

248 SignalSpy {

247 id: windowControlButtonsSpy

249 id: windowControlButtonsSpy

248− target: PanelState

250+ target: panelState

249 signalName: "closeClicked"

251 signalName: "closeClicked"

250 }

252 }

251

253

@@ -255,8 +257,8 @@ PanelTest {

255 panel.fullscreenMode = false;

257 panel.fullscreenMode = false;

256 callManager.foregroundCall = null;

258 callManager.foregroundCall = null;

257

259

258− PanelState.title = "";

260+ panelState.title = "";

259− PanelState.decorationsVisible = false;

261+ panelState.decorationsVisible = false;

260

262

261 // Wait for the indicators to get into position.

263 // Wait for the indicators to get into position.

262 // (switches between normal and fullscreen modes are animated)

264 // (switches between normal and fullscreen modes are animated)

@@ -447,7 +449,7 @@ PanelTest {

447 }

449 }

448

450

449 function test_hint(data) {

451 function test_hint(data) {

450− PanelState.title = "Fake Title"

452+ panelState.title = "Fake Title"

451 panel.fullscreenMode = data.fullscreen;

453 panel.fullscreenMode = data.fullscreen;

452 callManager.foregroundCall = data.call;

454 callManager.foregroundCall = data.call;

453

455

@@ -489,7 +491,7 @@ PanelTest {

489 // menus, first by running the hint animation, then after dragging down will

491 // menus, first by running the hint animation, then after dragging down will

490 // expose more of the panel. Releasing the touch will complete the show.

492 // expose more of the panel. Releasing the touch will complete the show.

491 function test_drag_applicationMenu_down_shows_menu(data) {

493 function test_drag_applicationMenu_down_shows_menu(data) {

492− PanelState.title = "Fake Title";

494+ panelState.title = "Fake Title";

493 panel.fullscreenMode = data.fullscreen;

495 panel.fullscreenMode = data.fullscreen;

494 callManager.foregroundCall = data.call;

496 callManager.foregroundCall = data.call;

495

497

@@ -580,7 +582,7 @@ PanelTest {

580 }

582 }

581

583

582 function test_darkenedAreaEatsAllApplicationMenuEvents() {

584 function test_darkenedAreaEatsAllApplicationMenuEvents() {

583− PanelState.title = "Fake Title"

585+ panelState.title = "Fake Title"

584

586

585 // The center of the area not covered by the indicators menu

587 // The center of the area not covered by the indicators menu

586 // Ie, the visible darkened area behind the menu

588 // Ie, the visible darkened area behind the menu

@@ -701,7 +703,7 @@ PanelTest {

701 var windowControlArea = findChild(panel, "windowControlArea");

703 var windowControlArea = findChild(panel, "windowControlArea");

702 verify(windowControlArea, "Window control area should have been created in windowed mode")

704 verify(windowControlArea, "Window control area should have been created in windowed mode")

703

705

704− PanelState.decorationsVisible = true;

706+ panelState.decorationsVisible = true;

705 // click in very topleft corner and verify the close button got clicked too

707 // click in very topleft corner and verify the close button got clicked too

706 mouseMove(panel, 0, 0);

708 mouseMove(panel, 0, 0);

707 mouseClick(panel, 0, 0, undefined /*button*/, undefined /*modifiers*/, 100 /*short delay*/);

709 mouseClick(panel, 0, 0, undefined /*button*/, undefined /*modifiers*/, 100 /*short delay*/);

@@ -762,7 +764,7 @@ PanelTest {

762 }

764 }

763

765

764 function test_stagedApplicationMenuBarShowOnMouseHover() {

766 function test_stagedApplicationMenuBarShowOnMouseHover() {

765− PanelState.title = "Fake Title";

767+ panelState.title = "Fake Title";

766 panel.mode = "staged";

768 panel.mode = "staged";

767 mouseEmulation.checked = false;

769 mouseEmulation.checked = false;

768

770

@@ -780,7 +782,7 @@ PanelTest {

780 }

782 }

781

783

782 function test_windowedApplicationMenuShowOnMouseHoverWhenDecorationsShown() {

784 function test_windowedApplicationMenuShowOnMouseHoverWhenDecorationsShown() {

783− PanelState.title = "Fake Title";

785+ panelState.title = "Fake Title";

784 panel.mode = "windowed";

786 panel.mode = "windowed";

785 mouseEmulation.checked = false;

787 mouseEmulation.checked = false;

786

788

@@ -796,7 +798,7 @@ PanelTest {

796 tryCompare(appTitle, "visible", true, undefined, "App title should still be visible on mouse hover when panel decorations are not visible");

798 tryCompare(appTitle, "visible", true, undefined, "App title should still be visible on mouse hover when panel decorations are not visible");

797 tryCompare(appMenuBar, "visible", false, undefined, "App menu bar should be visible on mouse hover when panel decorations are not visible");

799 tryCompare(appMenuBar, "visible", false, undefined, "App menu bar should be visible on mouse hover when panel decorations are not visible");

798

800

799− PanelState.decorationsVisible = true;

801+ panelState.decorationsVisible = true;

800

802

801 tryCompare(appTitle, "visible", false, undefined, "App title should still be visible on mouse hover when panel decorations are visible");

803 tryCompare(appTitle, "visible", false, undefined, "App title should still be visible on mouse hover when panel decorations are visible");

802 tryCompare(appMenuBar, "visible", true, undefined, "App menu bar should be visible on mouse hover when panel decorations not visible");

804 tryCompare(appMenuBar, "visible", true, undefined, "App menu bar should be visible on mouse hover when panel decorations not visible");

tests/qmltests/Stage/tst_DecoratedWindow.qml+5−1

@@ -52,6 +52,10 @@ Rectangle {

52 surfaceManager: sMgr

53 }

54

55+ PanelState {

56+ id: panelState

57+ }

58+

55 Item {

59 Item {

56 id: fakeShell

60 id: fakeShell

57

61

@@ -99,7 +103,7 @@ Rectangle {

99 surface: fakeApplication && fakeApplication.surfaceList.count > 0 ? fakeApplication.surfaceList.get(0) : null

103 surface: fakeApplication && fakeApplication.surfaceList.count > 0 ? fakeApplication.surfaceList.get(0) : null

100

104

101 Binding {

105 Binding {

102− target: PanelState

106+ target: panelState

103 property: "focusedPersistentSurfaceId"

107 property: "focusedPersistentSurfaceId"

104 value: decoratedWindow.surface ? decoratedWindow.surface.persistentId : "x"

108 value: decoratedWindow.surface ? decoratedWindow.surface.persistentId : "x"

105 }

109 }

tests/qmltests/Stage/tst_DesktopStage.qml+8−3

@@ -43,6 +43,10 @@ Item {

43 value: false

44 }

45

46+ PanelState {

47+ id: panelState

48+ }

49+

46 Component.onCompleted: {

50 Component.onCompleted: {

47 QuickUtils.keyboardAttached = true;

51 QuickUtils.keyboardAttached = true;

48 theme.name = "Ubuntu.Components.Themes.SuruDark";

52 theme.name = "Ubuntu.Components.Themes.SuruDark";

@@ -100,6 +104,7 @@ Item {

100 topLevelSurfaceList: topSurfaceList

104 topLevelSurfaceList: topSurfaceList

101 interactive: true

105 interactive: true

102 mode: "windowed"

106 mode: "windowed"

107+ panelState: panelState

103 }

108 }

104 }

109 }

105 }

110 }

@@ -618,19 +623,19 @@ Item {

618 maximizeDelegate(facebookAppDelegate);

623 maximizeDelegate(facebookAppDelegate);

619

624

620 // verify the drop shadow is still not visible

625 // verify the drop shadow is still not visible

621− verify(PanelState.dropShadow == false);

626+ verify(panelState.dropShadow == false);

622

627

623 // start a foreground app, not maximized

628 // start a foreground app, not maximized

624 var dialerAppDelegate = startApplication("dialer-app");

629 var dialerAppDelegate = startApplication("dialer-app");

625

630

626 // verify the drop shadow becomes visible

631 // verify the drop shadow becomes visible

627− verify(PanelState.dropShadow == true);

632+ verify(panelState.dropShadow == true);

628

633

629 // close the maximized app

634 // close the maximized app

630 ApplicationManager.stopApplication("facebook-webapp");

635 ApplicationManager.stopApplication("facebook-webapp");

631

636

632 // verify the drop shadow is gone

637 // verify the drop shadow is gone

633− tryCompare(PanelState, "dropShadow", false);

638+ tryCompare(panelState, "dropShadow", false);

634 }

639 }

635

640

636 function test_threeFingerTapShowsWindowControls_data() {

641 function test_threeFingerTapShowsWindowControls_data() {

tests/qmltests/Stage/tst_WindowResizeArea.qml+1−8

@@ -19,7 +19,6 @@ import QtQuick.Layouts 1.1

19import QtTest 1.0

20import Unity.Test 0.1

21import ".."

22−import "../../../qml/Components/PanelState"

23import "../../../qml/Stage"

22import "../../../qml/Stage"

24import Ubuntu.Components 1.3

23import Ubuntu.Components 1.3

25import Ubuntu.Components.ListItems 1.3 as ListItem

24import Ubuntu.Components.ListItems 1.3 as ListItem

@@ -31,12 +30,6 @@ Item {

31 height: units.gu(60)

30 height: units.gu(60)

32 width: units.gu(85)

31 width: units.gu(85)

33

32

34− Binding {

35− target: PanelState

36− property: "panelHeight"

37− value: units.gu(3)

38− }

39−

40 Component {

33 Component {

41 id: fakeWindowComponent

34 id: fakeWindowComponent

42

35

@@ -362,7 +355,7 @@ Item {

362

355

363 // Make sure it's again where we left it in normal state before destroying

356 // Make sure it's again where we left it in normal state before destroying

364 compare(fakeWindow.requestedX >= 0, true)

357 compare(fakeWindow.requestedX >= 0, true)

365− compare(fakeWindow.requestedY >= PanelState.panelHeight, true)

358+ compare(fakeWindow.requestedY >= 0, true)

366 compare(fakeWindow.requestedX + fakeWindow.width <= root.width, true)

359 compare(fakeWindow.requestedX + fakeWindow.width <= root.width, true)

367 compare(fakeWindow.requestedY + fakeWindow.height <= root.height, true)

360 compare(fakeWindow.requestedY + fakeWindow.height <= root.height, true)

368

361

tests/qmltests/tst_OrientedShell.qml+24−5

@@ -30,7 +30,6 @@ import Utils 0.1

30

31import "../../qml"

32import "../../qml/Components"

33−import "../../qml/Components/PanelState"

34import "Stage"

33import "Stage"

35

34

36Rectangle {

35Rectangle {

@@ -82,6 +81,12 @@ Rectangle {

82 deviceFilter: InputInfo.Keyboard

81 deviceFilter: InputInfo.Keyboard

83 }

82 }

84

83

84+ QtObject {

85+ id: _screenWindow

86+ property bool primary: true

87+ }

88+ property alias screenWindow: _screenWindow

89+

85 property int physicalOrientation0

90 property int physicalOrientation0

86 property int physicalOrientation90

91 property int physicalOrientation90

87 property int physicalOrientation180

92 property int physicalOrientation180

@@ -174,6 +179,11 @@ Rectangle {

174 Component.onDestruction: {

179 Component.onDestruction: {

175 orientedShellLoader.itemDestroyed = true;

180 orientedShellLoader.itemDestroyed = true;

176 }

181 }

182+

183+ SurfaceManager {

184+ id: surfaceMan

185+ }

186+ surfaceManager: surfaceMan

177 }

187 }

178 }

188 }

179 }

189 }

@@ -446,6 +456,15 @@ Rectangle {

446 property Item orientedShell: orientedShellLoader.status === Loader.Ready ? orientedShellLoader.item : null

456 property Item orientedShell: orientedShellLoader.status === Loader.Ready ? orientedShellLoader.item : null

447 property Item shell

457 property Item shell

448 property QtObject topLevelSurfaceList

458 property QtObject topLevelSurfaceList

459+ property var panelState: undefined

460+

461+ onOrientedShellChanged: {

462+ if (orientedShell) {

463+ panelState = findInvisibleChild(orientedShell, "panelState");

464+ } else {

465+ panelState = undefined;

466+ }

467+ }

449

468

450 SignalSpy { id: signalSpy }

469 SignalSpy { id: signalSpy }

451 SignalSpy { id: signalSpy2 }

470 SignalSpy { id: signalSpy2 }

@@ -1509,13 +1528,13 @@ Rectangle {

1509 print("exptectedAngle", expectedAngle, point.x, point.y)

1528 print("exptectedAngle", expectedAngle, point.x, point.y)

1510 switch (expectedAngle) {

1529 switch (expectedAngle) {

1511 case 0:

1530 case 0:

1512− return point.x === 0 && point.y === PanelState.panelHeight;

1531+ return point.x === 0 && point.y === panelState.panelHeight;

1513 case 90:

1532 case 90:

1514− return point.x === orientedShell.width - PanelState.panelHeight && point.y === 0;

1533+ return point.x === orientedShell.width - panelState.panelHeight && point.y === 0;

1515 case 180:

1534 case 180:

1516− return point.x === orientedShell.width && point.y === orientedShell.height - PanelState.panelHeight;

1535+ return point.x === orientedShell.width && point.y === orientedShell.height - panelState.panelHeight;

1517 default: // 270

1536 default: // 270

1518− return point.x === PanelState.panelHeight && point.y === orientedShell.height;

1537+ return point.x === panelState.panelHeight && point.y === orientedShell.height;

1519 }

1538 }

1520 }

1539 }

1521

1540

tests/qmltests/tst_Shell.qml+27−11

@@ -62,13 +62,22 @@ Rectangle {

62 if (shell) {

63 topLevelSurfaceList = testCase.findInvisibleChild(shell, "topLevelSurfaceList");

64 appMenuData.surfaceManager = testCase.findInvisibleChild(shell, "surfaceManager");

65+ panelState = testCase.findInvisibleChild(shell, "panelState");

65 } else {

66 } else {

66 topLevelSurfaceList = null;

67 topLevelSurfaceList = null;

67 appMenuData.surfaceManager = null;

68 appMenuData.surfaceManager = null;

69+ panelState = undefined;

68 }

70 }

69 }

71 }

70

72

71 property var topLevelSurfaceList: null

73 property var topLevelSurfaceList: null

74+ property var panelState: undefined

75+

76+ QtObject {

77+ id: _screenWindow

78+ property bool primary: false

79+ }

80+ property alias screenWindow: _screenWindow

72

81

73 Item {

82 Item {

74 id: shellContainer

83 id: shellContainer

@@ -143,6 +152,11 @@ Rectangle {

143 Component.onDestruction: {

152 Component.onDestruction: {

144 shellLoader.itemDestroyed = true;

153 shellLoader.itemDestroyed = true;

145 }

154 }

155+

156+ SurfaceManager {

157+ id: surfaceMan

158+ }

159+ surfaceManager: surfaceMan

146 }

160 }

147 }

161 }

148 }

162 }

@@ -261,6 +275,7 @@ Rectangle {

261 anchors { left: parent.left; right: parent.right }

275 anchors { left: parent.left; right: parent.right }

262 activeFocusOnPress: false

276 activeFocusOnPress: false

263 model: ["phone", "tablet", "desktop"]

277 model: ["phone", "tablet", "desktop"]

278+ selectedIndex: 2

264 onSelectedIndexChanged: {

279 onSelectedIndexChanged: {

265 shellLoader.state = model[selectedIndex];

280 shellLoader.state = model[selectedIndex];

266 }

281 }

@@ -274,6 +289,7 @@ Rectangle {

274 anchors { left: parent.left; right: parent.right }

289 anchors { left: parent.left; right: parent.right }

275 activeFocusOnPress: false

290 activeFocusOnPress: false

276 model: ["phone", "tablet", "desktop"]

291 model: ["phone", "tablet", "desktop"]

292+ selectedIndex: 2

277 }

293 }

278 MouseTouchEmulationCheckbox {

294 MouseTouchEmulationCheckbox {

279 id: mouseEmulation

295 id: mouseEmulation

@@ -678,7 +694,7 @@ Rectangle {

678 }

694 }

679

695

680 function ensureInputMethodSurface() {

696 function ensureInputMethodSurface() {

681− var surfaceManager = findInvisibleChild(shell, "surfaceManager");

697+ var surfaceManager = shell.surfaceManager;

682 verify(surfaceManager);

698 verify(surfaceManager);

683 surfaceManager.createInputMethodSurface();

699 surfaceManager.createInputMethodSurface();

684

700

@@ -1866,21 +1882,21 @@ Rectangle {

1866 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

1882 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

1867

1883

1868 tryCompare(appDelegate, "state", "normal");

1884 tryCompare(appDelegate, "state", "normal");

1869− tryCompare(PanelState, "decorationsVisible", false)

1885+ tryCompare(panelState, "decorationsVisible", false)

1870

1886

1871 mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);

1887 mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);

1872 tryCompare(appDelegate, "state", "maximized");

1888 tryCompare(appDelegate, "state", "maximized");

1873− tryCompare(PanelState, "decorationsVisible", true)

1889+ tryCompare(panelState, "decorationsVisible", true)

1874

1890

1875 ApplicationManager.stopApplication(application.appId);

1891 ApplicationManager.stopApplication(application.appId);

1876− tryCompare(PanelState, "decorationsVisible", false)

1892+ tryCompare(panelState, "decorationsVisible", false)

1877

1893

1878 // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

1894 // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

1879 // They won't be gone until those surface items are destroyed.

1895 // They won't be gone until those surface items are destroyed.

1880 tryCompareFunction(function() { return application.surfaceList.count }, 0);

1896 tryCompareFunction(function() { return application.surfaceList.count }, 0);

1881

1897

1882 ApplicationManager.startApplication(application.appId);

1898 ApplicationManager.startApplication(application.appId);

1883− tryCompare(PanelState, "decorationsVisible", true)

1899+ tryCompare(panelState, "decorationsVisible", true)

1884 }

1900 }

1885

1901

1886 function test_newAppHasValidGeometry() {

1902 function test_newAppHasValidGeometry() {

@@ -1937,7 +1953,7 @@ Rectangle {

1937 mousePress(appDelegate, appDelegate.width / 2, units.gu(1))

1953 mousePress(appDelegate, appDelegate.width / 2, units.gu(1))

1938 mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))

1954 mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))

1939

1955

1940− compare(appDelegate.y >= PanelState.panelHeight, true);

1956+ compare(appDelegate.y >= panelState.panelHeight, true);

1941 }

1957 }

1942

1958

1943 function test_cantResizeWindowUnderPanel() {

1959 function test_cantResizeWindowUnderPanel() {

@@ -1965,7 +1981,7 @@ Rectangle {

1965 mouseMove(decoration, decoration.width/2, -units.gu(100));

1981 mouseMove(decoration, decoration.width/2, -units.gu(100));

1966

1982

1967 // verify we don't go past the panel

1983 // verify we don't go past the panel

1968− compare(appDelegate.y >= PanelState.panelHeight, true);

1984+ compare(appDelegate.y >= panelState.panelHeight, true);

1969 }

1985 }

1970

1986

1971 function test_restoreWindowStateFixesIfUnderPanel() {

1987 function test_restoreWindowStateFixesIfUnderPanel() {

@@ -1989,7 +2005,7 @@ Rectangle {

1989 tryCompareFunction(function () { return topLevelSurfaceList.applicationAt(0).appId; }, application.appId);

2005 tryCompareFunction(function () { return topLevelSurfaceList.applicationAt(0).appId; }, application.appId);

1990

2006

1991 appDelegate = appRepeater.itemAt(0);

2007 appDelegate = appRepeater.itemAt(0);

1992− compare(appDelegate.y >= PanelState.panelHeight, true);

2008+ compare(appDelegate.y >= panelState.panelHeight, true);

1993 }

2009 }

1994

2010

1995 function test_lifecyclePolicyForNonTouchApp_data() {

2011 function test_lifecyclePolicyForNonTouchApp_data() {

@@ -2588,7 +2604,7 @@ Rectangle {

2588 function test_oskDisplacesWindow_data() {

2604 function test_oskDisplacesWindow_data() {

2589 return [

2605 return [

2590 {tag: "no need to displace", windowHeight: units.gu(10), windowY: units.gu(5), targetDisplacement: units.gu(5), oskEnabled: true},

2606 {tag: "no need to displace", windowHeight: units.gu(10), windowY: units.gu(5), targetDisplacement: units.gu(5), oskEnabled: true},

2591− {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: PanelState.panelHeight, oskEnabled: true},

2607+ {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: panelState.panelHeight, oskEnabled: true},

2592 {tag: "osk not on this screen", windowHeight: units.gu(40), windowY: units.gu(10), targetDisplacement: units.gu(10), oskEnabled: false},

2608 {tag: "osk not on this screen", windowHeight: units.gu(40), windowY: units.gu(10), targetDisplacement: units.gu(10), oskEnabled: false},

2593 ]

2609 ]

2594 }

2610 }

@@ -2611,8 +2627,8 @@ Rectangle {

2611 dashAppDelegate.windowedY = data.windowY;

2627 dashAppDelegate.windowedY = data.windowY;

2612 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2628 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2613 var initialY = dashAppDelegate.y;

2629 var initialY = dashAppDelegate.y;

2614− print("intial", initialY, "panel", PanelState.panelHeight);

2630+ print("intial", initialY, "panel", panelState.panelHeight);

2615− verify(initialY > PanelState.panelHeight);

2631+ verify(initialY > panelState.panelHeight);

2616

2632

2617 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, root.height / 2, root.width, root.height / 2));

2633 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, root.height / 2, root.width, root.height / 2));

2618 tryCompare(dashAppDelegate, "y", data.targetDisplacement);

2634 tryCompare(dashAppDelegate, "y", data.targetDisplacement);

tests/uqmlscene/main.cpp+2

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

479 // TODO: as soon as the engine construction completes, the debug service is

480 // listening for connections. But actually we aren't ready to debug anything.

481 QQmlEngine engine;

482+ engine.rootContext()->setContextProperty("DebuggingController", new DebuggingController(&app));

483+

482 QQmlComponent *component = new QQmlComponent(&engine);

484 QQmlComponent *component = new QQmlComponent(&engine);

483 for (int i = 0; i < imports.size(); ++i)

485 for (int i = 0; i < imports.size(); ++i)

484 engine.addImportPath(imports.at(i));

486 engine.addImportPath(imports.at(i));