xenial...b8150af · unity8

CMakeLists.txt+6−2

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

7070find_package(Qt5Concurrent 5.6 REQUIRED)

7171find_package(Qt5Sql 5.6 REQUIRED)

7272

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

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

74+pkg_check_modules(QTMIRSERVER REQUIRED qtmirserver>=0.6.0)

7475pkg_check_modules(GEONAMES REQUIRED geonames>=0.2)

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

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

@@ -79,6 +80,7 @@ pkg_check_modules(QMENUMODEL REQUIRED qmenumodel)

7980pkg_check_modules(GD3 REQUIRED gnome-desktop-3.0)

8081pkg_check_modules(UAL REQUIRED ubuntu-app-launch-3)

8182pkg_check_modules(UBUNTUGESTURES REQUIRED UbuntuGestures)

83+pkg_check_modules(MIRAL REQUIRED miral)

8284

8385### Check UbuntuGestures private headers. No pkg-config (.pc) file is provided for them

8486find_path(UBUNTUGESTUREPRIV

@@ -113,7 +115,9 @@ if(SHELL_PLUGINDIR STREQUAL "")

113115 message(FATAL_ERROR "Could not determine plugin import dir.")

114116endif()

115117

116−set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-permissive -pedantic -Wall -Wextra")

118+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-permissive -pedantic -Wall -Wextra")

119+

120+set (CMAKE_CXX_STANDARD 14)

117121

118122if ("${CMAKE_BUILD_TYPE}" STREQUAL "release" OR "${CMAKE_BUILD_TYPE}" STREQUAL "relwithdebinfo")

119123 option(Werror "Treat warnings as errors" ON)

debian/control+9−3

@@ -31,6 +31,7 @@ Build-Depends: cmake,

3131 libqmenumodel-dev (>= 0.2.11),

3232 libqt5svg5-dev,

3333 libqt5xmlpatterns5-dev,

34+ libqtmirserver-dev (>= 0.6.0),

3435 libsystemsettings-dev,

3536 libubuntu-app-launch3-dev,

3637 libubuntu-download-manager-common-dev,

@@ -38,13 +39,14 @@ Build-Depends: cmake,

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

3940 libudev-dev,

4041 libudm-common-dev,

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

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

4243 libusermetricsoutput1-dev,

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

4445 libx11-dev[!arm64 !armhf],

4546 libxcb1-dev[!arm64 !armhf],

4647 libxi-dev[!arm64 !armhf],

4748# End of X11 libs

49+ mirtest-dev,

4850 pkg-config,

4951 python3-all:any,

5052 python3-setuptools,

@@ -70,6 +72,9 @@ Build-Depends: cmake,

7072 qtdeclarative5-ubuntu-settings-components (>= 0.11),

7173 ttf-ubuntu-font-family,

7274 xvfb,

75+# mirtest pkgconfig requires these, but doesn't have a deb dependency. Bug lp:1633537

76+ libboost-filesystem-dev,

77+ libboost-system-dev,

7378Standards-Version: 3.9.4

7479Homepage: http://launchpad.net/unity

7580# If you aren't a member of ~unity-team but need to upload

@@ -131,6 +136,7 @@ Depends: dmz-cursor-theme,

131136 qml-module-ubuntu-web,

132137 qtdeclarative5-qtmir-plugin (>= 0.4.8),

133138 qtdeclarative5-ubuntu-telephony0.1,

139+ qtmir-desktop (>= 0.6.0) | qtmir-android (>= 0.6.0),

134140 ubuntu-system-settings (>= 0.4),

135141 unity-launcher-impl-10,

136142 unity8-common (= ${source:Version}),

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

162168 qttranslations5-l10n,

163169 ubuntu-thumbnailer-impl-0,

164170 ubuntu-wallpapers,

165− unity-application-impl-26,

171+ unity-application-impl-27,

166172 unity-notifications-impl-3,

167173 unity-plugin-scopes | unity-scopes-impl,

168174 unity-scopes-impl-12,

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

212218 ${misc:Depends},

213219 ${shlibs:Depends},

214220Provides: unity-application-impl,

215− unity-application-impl-26,

221+ unity-application-impl-27,

216222 unity8-fake-env,

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

218224 unity8-fake-env,

debian/unity8.install+5

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

1616usr/share/unity8/DeviceConfiguration.qml

1717usr/share/unity8/OrientedShell.qml

1818usr/share/unity8/DisabledScreenNotice.qml

19+usr/share/unity8/ErrorApplication.qml

20+usr/share/unity8/qmldir

1921usr/share/unity8/Shell.qml

22+usr/share/unity8/ShellApplication.qml

23+usr/share/unity8/ShellNotifier.qml

24+usr/share/unity8/ShellScreen.qml

2025usr/share/unity8/Stage

2126usr/share/unity8/Tutorial

2227usr/share/unity8/Wizard

plugins/Cursor/CMakeLists.txt+1

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

1515 CursorImageInfo.cpp

1616 CursorImageProvider.cpp

1717 MousePointer.cpp

18+ InputDispatcherFilter.cpp

1819 # We need to run moc on this header

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

2021 )

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 @@

1616

1717#include "MousePointer.h"

1818#include "CursorImageProvider.h"

19−

20−// Unity API

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

19+#include "InputDispatcherFilter.h"

2220

2321#include <QQuickWindow>

24−#include <QGuiApplication>

25−#include <QtMath>

2622

27−#include <qpa/qwindowsysteminterface.h>

23+// Unity API

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

2825

2926MousePointer::MousePointer(QQuickItem *parent)

3027 : MirMousePointerInterface(parent)

3128 , m_cursorName(QStringLiteral("left_ptr"))

3229 , m_themeName(QStringLiteral("default"))

3330{

34−}

35−

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

37− Qt::KeyboardModifiers modifiers)

38−{

39− if (!parentItem()) {

40− return;

41− }

42−

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

44− Q_EMIT mouseMoved();

45− }

46−

47− m_accumulatedMovement += movement;

48− // don't apply the fractional part

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

50− m_accumulatedMovement -= appliedMovement;

51−

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

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

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

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

56−

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

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

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

60− m_pushing = true;

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

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

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

64− m_pushing = true;

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

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

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

68− m_pushing = true;

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

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

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

72− m_pushing = true;

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

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

75− m_pushing = true;

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

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

78− m_pushing = true;

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

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

81− m_pushing = true;

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

83− if (m_pushing) {

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

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

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

34+ Q_EMIT pushedLeftBoundary(amount, buttons);

35+ }

36+ });

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

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

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

40+ Q_EMIT pushedRightBoundary(amount, buttons);

41+ }

42+ });

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

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

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

46+ Q_EMIT pushedTopBoundary(amount, buttons);

47+ }

48+ });

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

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

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

52+ Q_EMIT pushedTopLeftCorner(amount, buttons);

53+ }

54+ });

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

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

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

58+ Q_EMIT pushedTopRightCorner(amount, buttons);

59+ }

60+ });

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

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

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

64+ Q_EMIT pushedBottomLeftCorner(amount, buttons);

65+ }

66+ });

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

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

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

70+ Q_EMIT pushedBottomRightCorner(amount, buttons);

71+ }

72+ });

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

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

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

8476 Q_EMIT pushStopped();

85− m_pushing = false;

8677 }

87− }

78+ });

8879

89− applyItemConfinement(newX, newY);

90−

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

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

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

81+}

9382

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

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

96− buttons, modifiers);

83+MousePointer::~MousePointer()

84+{

85+ registerScreen(nullptr);

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

9787}

9888

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

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

121111 }

122112}

123113

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−

135114int MousePointer::topBoundaryOffset() const

136115{

137116 return m_topBoundaryOffset;

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

182161 if (m_registeredScreen) {

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

184163 if (previousCursor) {

185− previousCursor->setMousePointer(nullptr);

164+ previousCursor->unregisterMousePointer(this);

186165 } else {

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

188167 }

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

193172 if (m_registeredScreen) {

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

195174 if (cursor) {

196− cursor->setMousePointer(this);

175+ cursor->registerMousePointer(this);

197176 } else {

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

199178 }

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

216195 }

217196}

218197

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

199+{

200+ setPosition(position);

201+ Q_EMIT mouseMoved();

202+}

203+

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

220205{

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

plugins/Cursor/MousePointer.h+5−4

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

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

3232public:

3333 MousePointer(QQuickItem *parent = nullptr);

34+ ~MousePointer();

3435

3536 void setCursorName(const QString &qtCursorName) override;

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

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

3839 void setThemeName(const QString &themeName) override;

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

4041

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

43+

4144 void setCustomCursor(const QCursor &) override;

4245

4346 QQuickItem* confiningItem() const;

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

4649 int topBoundaryOffset() const;

4750 void setTopBoundaryOffset(int topBoundaryOffset);

4851

49−public Q_SLOTS:

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;

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

5353

5454Q_SIGNALS:

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

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

7979 QPointer<QScreen> m_registeredScreen;

8080 QString m_cursorName;

8181 QString m_themeName;

82+ bool m_active;

8283

8384 // Accumulated, unapplied, mouse movement.

8485 QPointF m_accumulatedMovement;

plugins/UInput/plugin.cpp+7−1

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

1919

2020#include <QtQml/qqml.h>

2121

22+

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

24+{

25+ return new UInput;

26+}

27+

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

2329{

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

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

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

2632}

plugins/Unity/CMakeLists.txt+1

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

11add_subdirectory(ApplicationMenu)

22add_subdirectory(Connectivity)

3+add_subdirectory(Debug)

34add_subdirectory(Indicators)

45add_subdirectory(Launcher)

56add_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 @@

11/*

33 *

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

55 * it under the terms of the GNU General Public License as published by

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

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

1515 */

1616

17−#ifndef UNITY_SHELL_VIEW_H

18−#define UNITY_SHELL_VIEW_H

17+#ifndef UNITYDEBUG_PLUGIN_H

18+#define UNITYDEBUG_PLUGIN_H

1919

20−#include <QQuickView>

20+#include <QtQml/QQmlEngine>

21+#include <QtQml/QQmlExtensionPlugin>

2122

22−class ShellView : public QQuickView

23+class UnityDebugPlugin : public QQmlExtensionPlugin

2324{

2425 Q_OBJECT

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

2527

2628public:

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

28−

29−private Q_SLOTS:

30− void onWidthChanged(int);

31− void onHeightChanged(int);

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

3230};

3331

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

plugins/WindowManager/CMakeLists.txt+26−2

@@ -1,16 +1,40 @@

1+include_directories(

2+ SYSTEM

3+ ${QTMIRSERVER_INCLUDE_DIRS}

4+)

5+

6+include_directories(

7+ ${CMAKE_CURRENT_SOURCE_DIR}

8+ ${libunity8-private_SOURCE_DIR}

9+)

10+

111set(WINDOWMANAGER_SRC

212 TopLevelWindowModel.cpp

313 Window.cpp

414 WindowManagerPlugin.cpp

15+ Screen.cpp

16+ ScreenAttached.cpp

17+ Screens.cpp

18+ ScreenWindow.cpp

19+ WindowManagerObjects.cpp

20+ Workspace.cpp

21+ WorkspaceManager.cpp

22+ WorkspaceModel.cpp

523 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h

24+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationManagerInterface.h

625 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h

726 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h

827 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceListInterface.h

928 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/SurfaceManagerInterface.h

10− )

29+)

1130

1231add_library(windowmanager-qml SHARED ${WINDOWMANAGER_SRC})

1332

33+target_link_libraries(windowmanager-qml

34+ ${QTMIRSERVER_LDFLAGS}

35+ unity8-private

36+)

37+

1438qt5_use_modules(windowmanager-qml Qml Quick Gui)

1539

16−add_unity8_plugin(WindowManager 0.1 WindowManager TARGETS windowmanager-qml)

40+add_unity8_plugin(WindowManager 1.0 WindowManager TARGETS windowmanager-qml)

plugins/WindowManager/Screen.cppnew file+300

@@ -0,0 +1,300 @@

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 "Screen.h"

18+#include "Screens.h"

19+#include "WorkspaceManager.h"

20+#include "Workspace.h"

21+

22+ScreenInterface::ScreenInterface(QObject *parent)

23+ : QObject(parent)

24+{

25+}

26+

27+void ScreenInterface::connectToScreen(qtmir::Screen *screen)

28+{

29+ m_wrapped = screen;

30+ connect(screen, &qtmir::Screen::usedChanged, this, &ScreenInterface::usedChanged);

31+ connect(screen, &qtmir::Screen::nameChanged, this, &ScreenInterface::nameChanged);

32+ connect(screen, &qtmir::Screen::outputTypeChanged, this, &ScreenInterface::outputTypeChanged);

33+ connect(screen, &qtmir::Screen::scaleChanged, this, &ScreenInterface::scaleChanged);

34+ connect(screen, &qtmir::Screen::formFactorChanged, this, &ScreenInterface::formFactorChanged);

35+ connect(screen, &qtmir::Screen::physicalSizeChanged, this, &ScreenInterface::physicalSizeChanged);

36+ connect(screen, &qtmir::Screen::positionChanged, this, &ScreenInterface::positionChanged);

37+ connect(screen, &qtmir::Screen::activeChanged, this, &ScreenInterface::activeChanged);

38+ connect(screen, &qtmir::Screen::currentModeIndexChanged, this, &ScreenInterface::currentModeIndexChanged);

39+ connect(screen, &qtmir::Screen::availableModesChanged, this, &ScreenInterface::availableModesChanged);

40+}

41+

42+void ScreenInterface::connectToScreen(ScreenInterface *screen)

43+{

44+ connectToScreen(screen->wrapped());

45+ connect(screen, &ScreenInterface::currentWorkspaceChanged, this, &ScreenInterface::currentWorkspaceChanged);

46+}

47+

48+qtmir::OutputId ScreenInterface::outputId() const

49+{

50+ if (!m_wrapped) return qtmir::OutputId(-1);

51+ return m_wrapped->outputId();

52+}

53+

54+bool ScreenInterface::used() const

55+{

56+ if (!m_wrapped) return false;

57+ return m_wrapped->used();

58+}

59+

60+QString ScreenInterface::name() const

61+{

62+ if (!m_wrapped) return QString();

63+ return m_wrapped->name();

64+}

65+

66+float ScreenInterface::scale() const

67+{

68+ if (!m_wrapped) return 1.0;

69+ return m_wrapped->scale();

70+}

71+

72+QSizeF ScreenInterface::physicalSize() const

73+{

74+ if (!m_wrapped) return QSizeF();

75+ return m_wrapped->physicalSize();

76+}

77+

78+qtmir::FormFactor ScreenInterface::formFactor() const

79+{

80+ if (!m_wrapped) return qtmir::FormFactorUnknown;

81+ return m_wrapped->formFactor();

82+}

83+

84+qtmir::OutputTypes ScreenInterface::outputType() const

85+{

86+ if (!m_wrapped) return qtmir::Unknown;

87+ return m_wrapped->outputType();

88+}

89+

90+MirPowerMode ScreenInterface::powerMode() const

91+{

92+ if (!m_wrapped) return mir_power_mode_on;

93+ return m_wrapped->powerMode();

94+}

95+

96+Qt::ScreenOrientation ScreenInterface::orientation() const

97+{

98+ if (!m_wrapped) return Qt::PrimaryOrientation;

99+ return m_wrapped->orientation();

100+}

101+

102+QPoint ScreenInterface::position() const

103+{

104+ if (!m_wrapped) return QPoint();

105+ return m_wrapped->position();

106+}

107+

108+QQmlListProperty<qtmir::ScreenMode> ScreenInterface::availableModes()

109+{

110+ if (!m_wrapped) return QQmlListProperty<qtmir::ScreenMode>();

111+ return m_wrapped->availableModes();

112+}

113+

114+uint ScreenInterface::currentModeIndex() const

115+{

116+ if (!m_wrapped) return -1;

117+ return m_wrapped->currentModeIndex();

118+}

119+

120+bool ScreenInterface::isActive() const

121+{

122+ if (!m_wrapped) return false;

123+ return m_wrapped->isActive();

124+}

125+

126+void ScreenInterface::activate()

127+{

128+ setActive(true);

129+}

130+

131+void ScreenInterface::setActive(bool active)

132+{

133+ if (!m_wrapped) return;

134+ m_wrapped->setActive(active);

135+}

136+

137+QScreen *ScreenInterface::qscreen() const

138+{

139+ if (!m_wrapped) return nullptr;

140+ return m_wrapped->qscreen();

141+}

142+

143+qtmir::ScreenConfiguration *ScreenInterface::beginConfiguration() const

144+{

145+ if (!m_wrapped) return nullptr;

146+ return m_wrapped->beginConfiguration();

147+}

148+

149+bool ScreenInterface::applyConfiguration(qtmir::ScreenConfiguration *configuration)

150+{

151+ if (!m_wrapped) return false;

152+ return m_wrapped->applyConfiguration(configuration);

153+}

154+

155+QString ScreenInterface::outputTypeName() const

156+{

157+ switch (m_wrapped->outputType()) {

158+ case qtmir::Unknown:

159+ return tr("Unknown");

160+ case qtmir::VGA:

161+ return tr("VGA");

162+ case qtmir::DVII:

163+ case qtmir::DVID:

164+ case qtmir::DVIA:

165+ return tr("DVI");

166+ case qtmir::Composite:

167+ return tr("Composite");

168+ case qtmir::SVideo:

169+ return tr("S-Video");

170+ case qtmir::LVDS:

171+ case qtmir::NinePinDIN:

172+ case qtmir::EDP:

173+ return tr("Internal");

174+ case qtmir::Component:

175+ return tr("Component");

176+ case qtmir::DisplayPort:

177+ return tr("DisplayPort");

178+ case qtmir::HDMIA:

179+ case qtmir::HDMIB:

180+ return tr("HDMI");

181+ case qtmir::TV:

182+ return tr("TV");

183+ }

184+ return QString();

185+}

186+

187+void ScreenInterface::sync(ScreenInterface *proxy)

188+{

189+ if (!proxy) return;

190+ workspaces()->sync(proxy->workspaces());

191+}

192+

193+Screen::Screen(qtmir::Screen* wrapped)

194+ : m_workspaces(new WorkspaceModel)

195+{

196+ connectToScreen(wrapped);

197+

198+ // Connect the active workspace to activate the screen.

199+ connect(m_workspaces.data(), &WorkspaceModel::workspaceInserted, this, [this](int, Workspace* workspace) {

200+ connect(workspace, &Workspace::activeChanged, this, [this, workspace](bool active) {

201+ if (active) {

202+ setCurrentWorkspace(workspace);

203+ activate();

204+ }

205+ });

206+ if (workspace->isActive()) {

207+ activate();

208+ setCurrentWorkspace(workspace);

209+ }

210+ if (!m_currentWorspace) {

211+ setCurrentWorkspace(workspace);

212+ }

213+ });

214+ connect(m_workspaces.data(), &WorkspaceModel::workspaceRemoved, this, [this](Workspace* workspace) {

215+ disconnect(workspace, &Workspace::activeChanged, this, 0);

216+ if (workspace == m_currentWorspace) {

217+ resetCurrentWorkspace();

218+ }

219+ });

220+ connect(this, &Screen::activeChanged, this, [this](bool active) {

221+ if (active && m_currentWorspace) {

222+ m_currentWorspace->activate();

223+ }

224+ });

225+

226+ WorkspaceManager::instance()->createWorkspace()->assign(m_workspaces.data());

227+ WorkspaceManager::instance()->createWorkspace()->assign(m_workspaces.data());

228+}

229+

230+void Screen::resetCurrentWorkspace()

231+{

232+ auto newCurrent = m_workspaces->rowCount() > 0 ? m_workspaces->get(0) : nullptr;

233+ if (m_currentWorspace != newCurrent) {

234+ m_currentWorspace = newCurrent;

235+ Q_EMIT currentWorkspaceChanged(newCurrent);

236+ }

237+}

238+

239+

240+WorkspaceModel *Screen::workspaces() const

241+{

242+ return m_workspaces.data();

243+}

244+

245+Workspace *Screen::currentWorkspace() const

246+{

247+ return m_currentWorspace.data();

248+}

249+

250+void Screen::setCurrentWorkspace(Workspace *workspace)

251+{

252+ if (m_currentWorspace != workspace) {

253+ m_currentWorspace = workspace;

254+ Q_EMIT currentWorkspaceChanged(workspace);

255+ }

256+}

257+

258+ScreenProxy::ScreenProxy(ScreenInterface *const screen)

259+ : m_workspaces(new WorkspaceModelProxy(screen->workspaces()))

260+ , m_original(screen)

261+{

262+ connectToScreen(screen);

263+

264+ auto updateCurrentWorkspaceFn = [this](Workspace* realWorkspace) {

265+ Q_FOREACH(Workspace* workspace, m_workspaces->list()) {

266+ auto p = qobject_cast<WorkspaceProxy*>(workspace);

267+ if (p && p->proxyObject() == realWorkspace) {

268+ if (m_currentWorspace != p) {

269+ m_currentWorspace = p;

270+ Q_EMIT currentWorkspaceChanged(p);

271+ }

272+ }

273+ }

274+ };

275+ connect(screen, &ScreenInterface::currentWorkspaceChanged, this, updateCurrentWorkspaceFn);

276+ updateCurrentWorkspaceFn(screen->currentWorkspace());

277+}

278+

279+WorkspaceModel *ScreenProxy::workspaces() const

280+{

281+ return m_workspaces.data();

282+}

283+

284+Workspace *ScreenProxy::currentWorkspace() const

285+{

286+ return m_currentWorspace.data();

287+}

288+

289+void ScreenProxy::setCurrentWorkspace(Workspace *workspace)

290+{

291+ auto p = qobject_cast<WorkspaceProxy*>(workspace);

292+ if (p) {

293+ m_original->setCurrentWorkspace(p->proxyObject());

294+ }

295+}

296+

297+void ScreenProxy::addWorkspace()

298+{

299+ (new WorkspaceProxy(WorkspaceManager::instance()->createWorkspace()))->assign(workspaces());

300+}

plugins/WindowManager/Screen.hnew file+132

@@ -0,0 +1,132 @@

1+#ifndef SCREEN_H

2+#define SCREEN_H

3+

4+#include <qtmir/screen.h>

5+#include <QScopedPointer>

6+#include <QPointer>

7+

8+#include "WorkspaceModel.h"

9+

10+class ScreenProxy;

11+class ScreenAttached;

12+

13+class ScreenInterface: public QObject

14+{

15+ Q_OBJECT

16+

17+ Q_PROPERTY(bool active READ isActive WRITE setActive NOTIFY activeChanged)

18+ Q_PROPERTY(bool used READ used NOTIFY usedChanged)

19+ Q_PROPERTY(QString name READ name NOTIFY nameChanged)

20+ Q_PROPERTY(qtmir::OutputTypes outputType READ outputType NOTIFY outputTypeChanged)

21+ Q_PROPERTY(float scale READ scale NOTIFY scaleChanged)

22+ Q_PROPERTY(qtmir::FormFactor formFactor READ formFactor NOTIFY formFactorChanged)

23+ Q_PROPERTY(MirPowerMode powerMode READ powerMode NOTIFY powerModeChanged)

24+ Q_PROPERTY(Qt::ScreenOrientation orientation READ orientation NOTIFY orientationChanged)

25+ Q_PROPERTY(QPoint position READ position NOTIFY positionChanged)

26+ Q_PROPERTY(uint currentModeIndex READ currentModeIndex NOTIFY currentModeIndexChanged)

27+ Q_PROPERTY(QQmlListProperty<qtmir::ScreenMode> availableModes READ availableModes NOTIFY availableModesChanged)

28+ Q_PROPERTY(QSizeF physicalSize READ physicalSize NOTIFY physicalSizeChanged)

29+ Q_PROPERTY(QString outputTypeName READ outputTypeName NOTIFY outputTypeChanged)

30+ Q_PROPERTY(WorkspaceModel* workspaces READ workspaces CONSTANT)

31+ Q_PROPERTY(Workspace* currentWorkspace READ currentWorkspace WRITE setCurrentWorkspace NOTIFY currentWorkspaceChanged)

32+public:

33+ // From qtmir::Screen

34+ qtmir::OutputId outputId() const;

35+ bool used() const;

36+ QString name() const;

37+ float scale() const;

38+ QSizeF physicalSize() const;

39+ qtmir::FormFactor formFactor() const;

40+ qtmir::OutputTypes outputType() const;

41+ MirPowerMode powerMode() const;

42+ Qt::ScreenOrientation orientation() const;

43+ QPoint position() const;

44+ QQmlListProperty<qtmir::ScreenMode> availableModes();

45+ uint currentModeIndex() const;

46+ bool isActive() const;

47+ void setActive(bool active);

48+ QScreen* qscreen() const;

49+ qtmir::ScreenConfiguration *beginConfiguration() const;

50+ bool applyConfiguration(qtmir::ScreenConfiguration *configuration);

51+ QString outputTypeName() const;

52+

53+ virtual WorkspaceModel* workspaces() const = 0;

54+ virtual Workspace *currentWorkspace() const = 0;

55+ virtual void setCurrentWorkspace(Workspace* workspace) = 0;

56+

57+ void sync(ScreenInterface* proxy);

58+

59+ qtmir::Screen* wrapped() const { return m_wrapped; }

60+

61+public Q_SLOTS:

62+ void activate();

63+

64+Q_SIGNALS:

65+ void usedChanged();

66+ void nameChanged();

67+ void outputTypeChanged();

68+ void scaleChanged();

69+ void formFactorChanged();

70+ void powerModeChanged();

71+ void orientationChanged();

72+ void positionChanged();

73+ void currentModeIndexChanged();

74+ void physicalSizeChanged();

75+ void availableModesChanged();

76+ void activeChanged(bool active);

77+ void currentWorkspaceChanged(Workspace*);

78+

79+protected:

80+ ScreenInterface(QObject* parent = 0);

81+

82+ void connectToScreen(qtmir::Screen* screen);

83+ void connectToScreen(ScreenInterface* screen);

84+

85+protected:

86+ QPointer<qtmir::Screen> m_wrapped;

87+};

88+

89+

90+class Screen : public ScreenInterface

91+{

92+ Q_OBJECT

93+public:

94+ explicit Screen(qtmir::Screen*const wrapped);

95+

96+ // From qtmir::Screen

97+ WorkspaceModel* workspaces() const override;

98+ Workspace *currentWorkspace() const override;

99+ void setCurrentWorkspace(Workspace* workspace) override;

100+

101+ static ScreenAttached *qmlAttachedProperties(QObject *owner);

102+

103+protected:

104+ void resetCurrentWorkspace();

105+

106+ const QScopedPointer<WorkspaceModel> m_workspaces;

107+ QPointer<Workspace> m_currentWorspace;

108+};

109+

110+class ScreenProxy : public ScreenInterface

111+{

112+ Q_OBJECT

113+public:

114+ explicit ScreenProxy(ScreenInterface*const screen);

115+

116+ // From qtmir::Screen

117+ WorkspaceModel* workspaces() const override;

118+ Workspace *currentWorkspace() const override;

119+ void setCurrentWorkspace(Workspace* workspace) override;

120+

121+ ScreenInterface* proxyObject() const { return m_original.data(); }

122+

123+public Q_SLOTS:

124+ void addWorkspace();

125+

126+private:

127+ const QScopedPointer<WorkspaceModel> m_workspaces;

128+ const QPointer<ScreenInterface> m_original;

129+ QPointer<Workspace> m_currentWorspace;

130+};

131+

132+#endif // SCREEN_H

plugins/WindowManager/ScreenAttached.cppnew file+149

@@ -0,0 +1,149 @@

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 "ScreenAttached.h"

18+#include "ScreenWindow.h"

19+#include "Screens.h"

20+

21+#include <QQuickItem>

22+#include <QScreen>

23+

24+ScreenAttached::ScreenAttached(QObject *owner)

25+ : ScreenInterface(owner)

26+ , m_window(nullptr)

27+{

28+ if (auto item = qobject_cast<QQuickItem*>(owner)) {

29+ connect(item, &QQuickItem::windowChanged, this, &ScreenAttached::windowChanged);

30+ windowChanged(item->window());

31+ } else if (auto window = qobject_cast<QQuickWindow*>(owner)) {

32+ windowChanged(window);

33+ }

34+}

35+

36+WorkspaceModel *ScreenAttached::workspaces() const

37+{

38+ if (!m_screen) return nullptr;

39+ return m_screen->workspaces();

40+}

41+

42+Workspace *ScreenAttached::currentWorkspace() const

43+{

44+ if (!m_screen) return nullptr;

45+ return m_screen->currentWorkspace();

46+}

47+

48+void ScreenAttached::setCurrentWorkspace(Workspace *workspace)

49+{

50+ if (!m_screen) return;

51+ return m_screen->setCurrentWorkspace(workspace);

52+}

53+

54+void ScreenAttached::windowChanged(QQuickWindow *window)

55+{

56+ if (m_window) {

57+ disconnect(m_window, &QWindow::screenChanged, this, &ScreenAttached::screenChanged);

58+ }

59+

60+ m_window = window;

61+ auto screenWindow = qobject_cast<ScreenWindow*>(window);

62+

63+ if (screenWindow) {

64+ screenChanged2(screenWindow->screenWrapper());

65+ connect(screenWindow, &ScreenWindow::screenWrapperChanged, this, &ScreenAttached::screenChanged2);

66+ } else {

67+ screenChanged(window ? window->screen() : NULL);

68+ if (window) {

69+ connect(window, &QWindow::screenChanged, this, &ScreenAttached::screenChanged);

70+ }

71+ }

72+}

73+

74+void ScreenAttached::screenChanged(QScreen *qscreen)

75+{

76+ // Find a screen that matches.

77+ // Should only get here in mocks if we don't have a ScreenWindow

78+ ScreenInterface* screen{nullptr};

79+ Q_FOREACH(auto s, Screens::self()->list()) {

80+ if (s->qscreen() == qscreen) {

81+ screen = s;

82+ }

83+ }

84+ screenChanged2(screen);

85+}

86+

87+void ScreenAttached::screenChanged2(ScreenInterface* screen)

88+{

89+ if (screen == m_screen) return;

90+

91+ ScreenInterface* oldScreen = m_screen;

92+ m_screen = screen;

93+

94+ if (oldScreen)

95+ oldScreen->disconnect(this);

96+

97+ if (!screen)

98+ return; //Don't bother emitting signals, because the new values are garbage anyways

99+

100+ if (!oldScreen || screen->isActive() != oldScreen->isActive())

101+ Q_EMIT activeChanged(screen->isActive());

102+ if (!oldScreen || screen->used() != oldScreen->used())

103+ Q_EMIT usedChanged();

104+ if (!oldScreen || screen->name() != oldScreen->name())

105+ Q_EMIT nameChanged();

106+ if (!oldScreen || screen->outputType() != oldScreen->outputType())

107+ Q_EMIT outputTypeChanged();

108+ if (!oldScreen || screen->scale() != oldScreen->scale())

109+ Q_EMIT scaleChanged();

110+ if (!oldScreen || screen->formFactor() != oldScreen->formFactor())

111+ Q_EMIT formFactorChanged();

112+ if (!oldScreen || screen->powerMode() != oldScreen->powerMode())

113+ Q_EMIT powerModeChanged();

114+ if (!oldScreen || screen->orientation() != oldScreen->orientation())

115+ Q_EMIT orientationChanged();

116+ if (!oldScreen || screen->position() != oldScreen->position())

117+ Q_EMIT positionChanged();

118+ if (!oldScreen || screen->currentModeIndex() != oldScreen->currentModeIndex())

119+ Q_EMIT currentModeIndexChanged();

120+ if (!oldScreen || screen->physicalSize() != oldScreen->physicalSize())

121+ Q_EMIT physicalSizeChanged();

122+

123+ if (oldScreen) {

124+ QVector<qtmir::ScreenMode*> oldModes;

125+ auto oldModesQmlList = oldScreen->availableModes();

126+ for (int i = 0; i < oldModesQmlList.count(&oldModesQmlList); i++) {

127+ oldModes << oldModesQmlList.at(&oldModesQmlList, i);

128+ }

129+

130+ QVector<qtmir::ScreenMode*> newModes;

131+ auto newModesQmlList = screen->availableModes();

132+ for (int i = 0; i < newModesQmlList.count(&newModesQmlList); i++) {

133+ newModes << newModesQmlList.at(&newModesQmlList, i);

134+ }

135+

136+ if (newModes != newModes) {

137+ Q_EMIT availableModesChanged();

138+ }

139+ } else {

140+ Q_EMIT availableModesChanged();

141+ }

142+

143+ connectToScreen(screen);

144+}

145+

146+ScreenAttached *WMScreen::qmlAttachedProperties(QObject *owner)

147+{

148+ return new ScreenAttached(owner);

149+}

plugins/WindowManager/ScreenAttached.hnew file+56

@@ -0,0 +1,56 @@

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 SCREENATTACHED_H

18+#define SCREENATTACHED_H

19+

20+#include "Screen.h"

21+

22+#include <QQmlEngine>

23+#include <QtQml>

24+

25+class QQuickWindow;

26+

27+class ScreenAttached : public ScreenInterface

28+{

29+ Q_OBJECT

30+public:

31+ ScreenAttached(QObject* owner);

32+

33+ WorkspaceModel* workspaces() const override;

34+ Workspace *currentWorkspace() const override;

35+ void setCurrentWorkspace(Workspace* workspace) override;

36+

37+private Q_SLOTS:

38+ void windowChanged(QQuickWindow*);

39+ void screenChanged(QScreen*);

40+ void screenChanged2(ScreenInterface* screen);

41+

42+private:

43+ QPointer<ScreenInterface> m_screen;

44+ QQuickWindow* m_window;

45+};

46+

47+class WMScreen : public QObject

48+{

49+ Q_OBJECT

50+public:

51+ static ScreenAttached *qmlAttachedProperties(QObject *owner);

52+};

53+

54+QML_DECLARE_TYPEINFO(WMScreen, QML_HAS_ATTACHED_PROPERTIES)

55+

56+#endif // SCREENATTACHED_H

plugins/WindowManager/ScreenWindow.cppnew file+45

@@ -0,0 +1,45 @@

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+#include "Screen.h"

19+

20+// Qt

21+#include <QGuiApplication>

22+#include <QDebug>

23+

24+ScreenWindow::ScreenWindow(QQuickWindow *parent)

25+ : QQuickWindow(parent)

26+{

27+}

28+

29+ScreenWindow::~ScreenWindow()

30+{

31+}

32+

33+Screen *ScreenWindow::screenWrapper() const

34+{

35+ return m_screen.data();

36+}

37+

38+void ScreenWindow::setScreenWrapper(Screen *screen)

39+{

40+ if (m_screen != screen) {

41+ m_screen = screen;

42+ Q_EMIT screenWrapperChanged(screen);

43+ }

44+ QQuickWindow::setScreen(screen->qscreen());

45+}

plugins/WindowManager/ScreenWindow.hnew file+49

@@ -0,0 +1,49 @@

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 UNITY_SCREENWINDOW_H

18+#define UNITY_SCREENWINDOW_H

19+

20+#include <QQuickWindow>

21+#include <QPointer>

22+

23+#include "Screen.h"

24+

25+class ScreenAdapter;

26+

27+/*

28+ * ScreenWindow - wrapper of QQuickWindow to enable QML to specify destination screen.

29+**/

30+class ScreenWindow : public QQuickWindow

31+{

32+ Q_OBJECT

33+ Q_PROPERTY(Screen *screen READ screenWrapper WRITE setScreenWrapper NOTIFY screenWrapperChanged)

34+ Q_PROPERTY(int winId READ winId CONSTANT)

35+public:

36+ explicit ScreenWindow(QQuickWindow *parent = 0);

37+ ~ScreenWindow();

38+

39+ Screen *screenWrapper() const;

40+ void setScreenWrapper(Screen *screen);

41+

42+Q_SIGNALS:

43+ void screenWrapperChanged(Screen* screen);

44+

45+private:

46+ QPointer<Screen> m_screen;

47+};

48+

49+#endif // UNITY_SCREENWINDOW_H

plugins/WindowManager/Screens.cppnew file+213

@@ -0,0 +1,213 @@

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 "Screens.h"

18+#include "Screen.h"

19+#include "WorkspaceManager.h"

20+

21+// qtmirserver

22+#include <qtmir/screens.h>

23+#include <QGuiApplication>

24+#include <QQmlEngine>

25+

26+// Qt

27+#include <QScreen>

28+#include <QWindow>

29+

30+Screens* Screens::m_self{nullptr};

31+

32+Screens::Screens(const QSharedPointer<qtmir::Screens>& model)

33+ : m_wrapped(model)

34+{

35+ m_self = this;

36+ connect(m_wrapped.data(), &qtmir::Screens::screenAdded, this, &Screens::onScreenAdded);

37+ connect(m_wrapped.data(), &qtmir::Screens::screenRemoved, this, &Screens::onScreenRemoved);

38+ connect(m_wrapped.data(), &qtmir::Screens::activeScreenChanged, this, &Screens::activeScreenChanged);

39+

40+ Q_FOREACH(qtmir::Screen* screen, m_wrapped->screens()) {

41+ auto screenWrapper(new Screen(screen));

42+ QQmlEngine::setObjectOwnership(screenWrapper, QQmlEngine::CppOwnership);

43+ m_screens.push_back(screenWrapper);

44+ }

45+}

46+

47+Screens::~Screens()

48+{

49+ qDeleteAll(m_screens);

50+ m_screens.clear();

51+}

52+

53+Screens::Screens(const Screens &other)

54+ : QAbstractListModel(nullptr)

55+ , m_wrapped(other.m_wrapped)

56+{

57+}

58+

59+QHash<int, QByteArray> Screens::roleNames() const

60+{

61+ QHash<int, QByteArray> roles;

62+ roles[ScreenRole] = "screen";

63+ return roles;

64+}

65+

66+QVariant Screens::data(const QModelIndex &index, int role) const

67+{

68+ if (!index.isValid() || index.row() >= m_screens.size()) {

69+ return QVariant();

70+ }

71+

72+ switch(role) {

73+ case ScreenRole:

74+ return QVariant::fromValue(m_screens.at(index.row()));

75+ } // switch

76+

77+ return QVariant();

78+}

79+

80+int Screens::rowCount(const QModelIndex &) const

81+{

82+ return count();

83+}

84+

85+int Screens::count() const

86+{

87+ return m_screens.size();

88+}

89+

90+QVariant Screens::activeScreen() const

91+{

92+ for (int i = 0; i < m_screens.count(); i++) {

93+ if (m_screens[i]->isActive()) return i;

94+ }

95+ return QVariant();

96+}

97+

98+Screens *Screens::self()

99+{

100+ return Screens::m_self;

101+}

102+

103+ScreensProxy *Screens::createProxy()

104+{

105+ return new ScreensProxy(this);

106+}

107+

108+void Screens::sync(Screens *proxy)

109+{

110+ if (!proxy) return;

111+

112+ const auto& proxyList = proxy->list();

113+ for (int i = 0; i < m_screens.count() && i < proxyList.count(); ++i) {

114+ m_screens[i]->sync(proxyList[i]);

115+ }

116+

117+ // need to clean up all the workspaces we unassigned.

118+ WorkspaceManager::instance()->destroyFloatingWorkspaces();

119+}

120+

121+void Screens::activateScreen(const QVariant& vindex)

122+{

123+ bool ok = false;

124+ int index = vindex.toInt(&ok);

125+ if (!ok || index < 0 || m_screens.count() <= index) return;

126+

127+ auto screen = m_screens.at(index);

128+ screen->setActive(true);

129+}

130+

131+void Screens::onScreenAdded(qtmir::Screen *added)

132+{

133+ Q_FOREACH(auto screenWrapper, m_screens) {

134+ if (screenWrapper->wrapped() == added) return;

135+ }

136+

137+ beginInsertRows(QModelIndex(), count(), count());

138+ auto screenWrapper(new Screen(added));

139+ QQmlEngine::setObjectOwnership(screenWrapper, QQmlEngine::CppOwnership);

140+ m_screens.push_back(screenWrapper);

141+ endInsertRows();

142+ Q_EMIT screenAdded(screenWrapper);

143+ Q_EMIT countChanged();

144+}

145+

146+void Screens::onScreenRemoved(qtmir::Screen *removed)

147+{

148+ int index = 0;

149+ QMutableVectorIterator<ScreenInterface*> iter(m_screens);

150+ while(iter.hasNext()) {

151+ auto screenWrapper = iter.next();

152+ if (screenWrapper->wrapped() == removed) {

153+

154+ beginRemoveRows(QModelIndex(), index, index);

155+ iter.remove();

156+ endRemoveRows();

157+

158+ Q_EMIT screenRemoved(screenWrapper);

159+ Q_EMIT countChanged();

160+

161+ screenWrapper->deleteLater();

162+ break;

163+ }

164+ index++;

165+ }

166+}

167+

168+ScreensProxy::ScreensProxy(Screens * const screens)

169+ : Screens(*screens)

170+ , m_original(screens)

171+{

172+ connect(screens, &Screens::screenAdded, this, [this](ScreenInterface *added) {

173+ Q_FOREACH(auto screen, m_screens) {

174+ auto proxy = static_cast<ScreenProxy*>(screen);

175+ if (proxy->proxyObject() == added) return;

176+ }

177+

178+ beginInsertRows(QModelIndex(), count(), count());

179+ auto screenWrapper(new ScreenProxy(added));

180+ QQmlEngine::setObjectOwnership(screenWrapper, QQmlEngine::CppOwnership);

181+ m_screens.push_back(screenWrapper);

182+ endInsertRows();

183+ Q_EMIT screenAdded(screenWrapper);

184+ Q_EMIT countChanged();

185+ });

186+

187+ connect(screens, &Screens::screenRemoved, this, [this](ScreenInterface *removed) {

188+ int index = 0;

189+ QMutableVectorIterator<ScreenInterface*> iter(m_screens);

190+ while(iter.hasNext()) {

191+ auto proxy = static_cast<ScreenProxy*>(iter.next());

192+ if (proxy->proxyObject() == removed) {

193+

194+ beginRemoveRows(QModelIndex(), index, index);

195+ iter.remove();

196+ endRemoveRows();

197+

198+ Q_EMIT screenRemoved(proxy);

199+ Q_EMIT countChanged();

200+

201+ delete proxy;

202+ break;

203+ }

204+ index++;

205+ }

206+ });

207+

208+ Q_FOREACH(ScreenInterface* screen, screens->list()) {

209+ auto screenWrapper(new ScreenProxy(screen));

210+ QQmlEngine::setObjectOwnership(screenWrapper, QQmlEngine::CppOwnership);

211+ m_screens.push_back(new ScreenProxy(screen));

212+ }

213+}

plugins/WindowManager/Screens.hnew file+93

@@ -0,0 +1,93 @@

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 UNITY_SCREENS_H

18+#define UNITY_SCREENS_H

19+

20+#include <QAbstractListModel>

21+#include <QSharedPointer>

22+#include <QPointer>

23+

24+namespace qtmir

25+{

26+class Screen;

27+class Screens;

28+}

29+

30+class ScreenInterface;

31+class ScreensProxy;

32+

33+class Screens : public QAbstractListModel

34+{

35+ Q_OBJECT

36+ Q_PROPERTY(int count READ count NOTIFY countChanged)

37+ Q_PROPERTY(QVariant activeScreen READ activeScreen WRITE activateScreen NOTIFY activeScreenChanged)

38+

39+public:

40+ enum ItemRoles {

41+ ScreenRole = Qt::UserRole + 1

42+ };

43+

44+ explicit Screens(const QSharedPointer<qtmir::Screens>& model);

45+ ~Screens();

46+

47+ Q_INVOKABLE ScreensProxy *createProxy();

48+ Q_INVOKABLE void sync(Screens *proxy);

49+

50+ /* QAbstractItemModel */

51+ QHash<int, QByteArray> roleNames() const override;

52+ QVariant data(const QModelIndex &index, int role = ScreenRole) const override;

53+ int rowCount(const QModelIndex &parent = QModelIndex()) const override;

54+

55+ int count() const;

56+ QVariant activeScreen() const;

57+

58+ const QVector<ScreenInterface*>& list() const { return m_screens; }

59+

60+ static Screens *self();

61+

62+public Q_SLOTS:

63+ void activateScreen(const QVariant& index);

64+

65+Q_SIGNALS:

66+ void countChanged();

67+ void activeScreenChanged();

68+

69+ void screenAdded(ScreenInterface* screen);

70+ void screenRemoved(ScreenInterface* screen);

71+

72+private Q_SLOTS:

73+ void onScreenAdded(qtmir::Screen *screen);

74+ void onScreenRemoved(qtmir::Screen *screen);

75+

76+protected:

77+ Screens(const Screens& other);

78+

79+ QVector<ScreenInterface*> m_screens;

80+ QSharedPointer<qtmir::Screens> m_wrapped;

81+ static Screens* m_self;

82+};

83+

84+class ScreensProxy : public Screens

85+{

86+public:

87+ ScreensProxy(Screens*const screens);

88+

89+private:

90+ const QPointer<Screens> m_original;

91+};

92+

93+#endif // SCREENS_H

plugins/WindowManager/TopLevelWindowModel.cpp+194−54

@@ -15,6 +15,7 @@

1515 */

1616

1717#include "TopLevelWindowModel.h"

18+#include "WindowManagerObjects.h"

1819

1920// unity-api

2021#include <unity/shell/application/ApplicationInfoInterface.h>

@@ -24,11 +25,11 @@

2425#include <unity/shell/application/SurfaceManagerInterface.h>

2526

2627// Qt

27−#include <QGuiApplication>

2828#include <QDebug>

2929

3030// local

3131#include "Window.h"

32+#include "Workspace.h"

3233

3334Q_LOGGING_CATEGORY(TOPLEVELWINDOWMODEL, "toplevelwindowmodel", QtInfoMsg)

3435

@@ -37,8 +38,16 @@ Q_LOGGING_CATEGORY(TOPLEVELWINDOWMODEL, "toplevelwindowmodel", QtInfoMsg)

3738

3839namespace unityapi = unity::shell::application;

3940

40−TopLevelWindowModel::TopLevelWindowModel()

41+TopLevelWindowModel::TopLevelWindowModel(Workspace* workspace)

42+ : m_workspace(workspace)

4143{

44+ connect(WindowManagerObjects::instance(), &WindowManagerObjects::applicationManagerChanged,

45+ this, &TopLevelWindowModel::setApplicationManager);

46+ connect(WindowManagerObjects::instance(), &WindowManagerObjects::surfaceManagerChanged,

47+ this, &TopLevelWindowModel::setSurfaceManager);

48+

49+ setApplicationManager(WindowManagerObjects::instance()->applicationManager());

50+ setSurfaceManager(WindowManagerObjects::instance()->surfaceManager());

4251}

4352

4453void TopLevelWindowModel::setApplicationManager(unityapi::ApplicationManagerInterface* value)

@@ -55,7 +64,6 @@ void TopLevelWindowModel::setApplicationManager(unityapi::ApplicationManagerInte

5564 beginResetModel();

5665

5766 if (m_applicationManager) {

58− m_windowModel.clear();

5967 disconnect(m_applicationManager, 0, this, 0);

6068 }

6169

@@ -64,26 +72,26 @@ void TopLevelWindowModel::setApplicationManager(unityapi::ApplicationManagerInte

6472 if (m_applicationManager) {

6573 connect(m_applicationManager, &QAbstractItemModel::rowsInserted,

6674 this, [this](const QModelIndex &/*parent*/, int first, int last) {

67− for (int i = first; i <= last; ++i) {

68− auto application = m_applicationManager->get(i);

69− addApplication(application);

70− }

71− });

75+ if (!m_workspace || !m_workspace->isActive())

76+ return;

77+

78+ for (int i = first; i <= last; ++i) {

79+ auto application = m_applicationManager->get(i);

80+ addApplication(application);

81+ }

82+ });

7283

7384 connect(m_applicationManager, &QAbstractItemModel::rowsAboutToBeRemoved,

7485 this, [this](const QModelIndex &/*parent*/, int first, int last) {

75− for (int i = first; i <= last; ++i) {

76− auto application = m_applicationManager->get(i);

77− removeApplication(application);

78− }

79− });

80−

81− for (int i = 0; i < m_applicationManager->rowCount(); ++i) {

82− auto application = m_applicationManager->get(i);

83− addApplication(application);

84− }

86+ for (int i = first; i <= last; ++i) {

87+ auto application = m_applicationManager->get(i);

88+ removeApplication(application);

89+ }

90+ });

8591 }

8692

93+ refreshWindows();

94+

8795 endResetModel();

8896 m_modelState = IdleState;

8997}

@@ -96,6 +104,11 @@ void TopLevelWindowModel::setSurfaceManager(unityapi::SurfaceManagerInterface *s

96104

97105 DEBUG_MSG << "(" << surfaceManager << ")";

98106

107+ Q_ASSERT(m_modelState == IdleState);

108+ m_modelState = ResettingState;

109+

110+ beginResetModel();

111+

99112 if (m_surfaceManager) {

100113 disconnect(m_surfaceManager, 0, this, 0);

101114 }

@@ -107,9 +120,17 @@ void TopLevelWindowModel::setSurfaceManager(unityapi::SurfaceManagerInterface *s

107120 connect(m_surfaceManager, &unityapi::SurfaceManagerInterface::surfacesRaised, this, &TopLevelWindowModel::onSurfacesRaised);

108121 connect(m_surfaceManager, &unityapi::SurfaceManagerInterface::modificationsStarted, this, &TopLevelWindowModel::onModificationsStarted);

109122 connect(m_surfaceManager, &unityapi::SurfaceManagerInterface::modificationsEnded, this, &TopLevelWindowModel::onModificationsEnded);

123+

124+ connect(m_surfaceManager, &unityapi::SurfaceManagerInterface::surfacesAddedToWorkspace,

125+ this, &TopLevelWindowModel::onSurfacesAddedToWorkspace);

126+ connect(m_surfaceManager, &unityapi::SurfaceManagerInterface::surfacesAboutToBeRemovedFromWorkspace,

127+ this, &TopLevelWindowModel::onSurfacesAboutToBeRemovedFromWorkspace);

110128 }

111129

112− Q_EMIT surfaceManagerChanged(m_surfaceManager);

130+ refreshWindows();

131+

132+ endResetModel();

133+ m_modelState = IdleState;

113134}

114135

115136void TopLevelWindowModel::addApplication(unityapi::ApplicationInfoInterface *application)

@@ -153,6 +174,7 @@ void TopLevelWindowModel::prependSurface(unityapi::MirSurfaceInterface *surface,

153174 ModelEntry &entry = m_windowModel[i];

154175 if (entry.application == application && entry.window->surface() == nullptr) {

155176 entry.window->setSurface(surface);

177+ m_allSurfaces.insert(surface);

156178 connectSurface(surface);

157179 INFO_MSG << " appId=" << application->appId() << " surface=" << surface

158180 << ", filling out placeholder. after: " << toString();

@@ -180,6 +202,7 @@ void TopLevelWindowModel::prependSurfaceHelper(unityapi::MirSurfaceInterface *su

180202

181203 m_windowModel.prepend(ModelEntry(window, application));

182204 if (surface) {

205+ m_allSurfaces.insert(surface);

183206 connectSurface(surface);

184207 }

185208

@@ -207,15 +230,14 @@ void TopLevelWindowModel::connectWindow(Window *window)

207230

208231 connect(window, &Window::focusedChanged, this, [this, window](bool focused) {

209232 if (window->surface()) {

210− // Condense changes to the focused window

211− // eg: Do focusedWindow=A to focusedWindow=B instead of

212− // focusedWindow=A to focusedWindow=null to focusedWindow=B

213233 if (focused) {

214− Q_ASSERT(m_newlyFocusedWindow == nullptr);

215− m_focusedWindowChanged = true;

216− m_newlyFocusedWindow = window;

234+ setFocusedWindow(window);

235+ m_focusedWindowCleared = false;

217236 } else if (m_focusedWindow == window) {

218− m_focusedWindowChanged = true;

237+ // Condense changes to the focused window

238+ // eg: Do focusedWindow=A to focusedWindow=B instead of

239+ // focusedWindow=A to focusedWindow=null to focusedWindow=B

240+ m_focusedWindowCleared = true;

219241 } else {

220242 // don't clear the focused window if you were not there in the first place

221243 // happens when a filled window gets replaced with an empty one (no surface) as the focused window.

@@ -313,6 +335,7 @@ void TopLevelWindowModel::onSurfaceDestroyed(unityapi::MirSurfaceInterface *surf

313335 auto window = m_windowModel[i].window;

314336 window->setSurface(nullptr);

315337 window->setFocused(false);

338+ m_allSurfaces.remove(surface);

316339 INFO_MSG << " Removed surface from entry. After: " << toString();

317340 }

318341}

@@ -328,35 +351,99 @@ Window *TopLevelWindowModel::createWindow(unityapi::MirSurfaceInterface *surface

328351 return qmlWindow;

329352}

330353

331−void TopLevelWindowModel::onSurfaceCreated(unityapi::MirSurfaceInterface *surface)

354+

355+void TopLevelWindowModel::onSurfaceCreated(unityapi::MirSurfaceInterface */*surface*/)

332356{

333− DEBUG_MSG << "(" << surface << ")";

357+}

334358

335− if (surface->parentSurface()) {

336− // Wrap it in a Window so that we keep focusedWindow() up to date.

337− Window *window = createWindow(surface);

338− connect(surface, &QObject::destroyed, window, [=](){

339− window->setSurface(nullptr);

340− window->deleteLater();

341− });

342− } else {

343− if (surface->type() == Mir::InputMethodType) {

344− connectSurface(surface);

345− setInputMethodWindow(createWindow(surface));

359+void TopLevelWindowModel::onSurfacesAddedToWorkspace(const std::shared_ptr<miral::Workspace>& workspace,

360+ const QVector<unity::shell::application::MirSurfaceInterface*> surfaces)

361+{

362+ if (!m_workspace || !m_applicationManager) return;

363+ if (workspace != m_workspace->workspace()) return;

364+

365+ Q_FOREACH(auto surface, surfaces) {

366+ if (m_allSurfaces.contains(surface)) continue;

367+

368+ if (surface->parentSurface()) {

369+ // Wrap it in a Window so that we keep focusedWindow() up to date.

370+ Window *window = createWindow(surface);

371+ connect(surface, &QObject::destroyed, window, [=](){

372+ window->setSurface(nullptr);

373+ window->deleteLater();

374+ });

346375 } else {

347− auto *application = m_applicationManager->findApplicationWithSurface(surface);

348− if (application) {

349− prependSurface(surface, application);

376+ if (surface->type() == Mir::InputMethodType) {

377+ connectSurface(surface);

378+ setInputMethodWindow(createWindow(surface));

350379 } else {

351− // Must be a prompt session. No need to do add it as a prompt surface is not top-level.

352− // It will show up in the ApplicationInfoInterface::promptSurfaceList of some application.

353− // Still wrap it in a Window though, so that we keep focusedWindow() up to date.

354− Window *promptWindow = createWindow(surface);

355− connect(surface, &QObject::destroyed, promptWindow, [=](){

356− promptWindow->setSurface(nullptr);

357− promptWindow->deleteLater();

358− });

380+ auto *application = m_applicationManager->findApplicationWithSurface(surface);

381+ if (application) {

382+ prependSurface(surface, application);

383+ } else {

384+ // Must be a prompt session. No need to do add it as a prompt surface is not top-level.

385+ // It will show up in the ApplicationInfoInterface::promptSurfaceList of some application.

386+ // Still wrap it in a Window though, so that we keep focusedWindow() up to date.

387+ Window *promptWindow = createWindow(surface);

388+ connect(surface, &QObject::destroyed, promptWindow, [=](){

389+ promptWindow->setSurface(nullptr);

390+ promptWindow->deleteLater();

391+ });

392+ }

393+ }

394+ }

395+ }

396+}

397+

398+void TopLevelWindowModel::onSurfacesAboutToBeRemovedFromWorkspace(const std::shared_ptr<miral::Workspace> &workspace,

399+ const QVector<unity::shell::application::MirSurfaceInterface *> surfaces)

400+{

401+ if (!m_workspace || workspace != m_workspace->workspace()) return;

402+

403+ int start = -1;

404+ int end = -1;

405+ for (auto iter = surfaces.constBegin(); iter != surfaces.constEnd();) {

406+ auto surface = *iter;

407+ iter++;

408+

409+ // Do removals in adjacent blocks.

410+ start = end = indexOf(surface);

411+ if (start == -1) {

412+ // probably a child surface

413+ m_allSurfaces.remove(surface);

414+ continue;

415+ }

416+ while(iter != surfaces.constEnd()) {

417+ int index = indexOf(*iter);

418+ if (index != end+1) {

419+ break;

359420 }

421+ end++;

422+ iter++;

423+ }

424+

425+ if (m_modelState == IdleState) {

426+ beginRemoveRows(QModelIndex(), start, end);

427+ m_modelState = RemovingState;

428+ } else {

429+ Q_ASSERT(m_modelState == ResettingState);

430+ // No point in signaling anything if we're resetting the whole model

431+ }

432+

433+ for (int index = start; index <= end; index++) {

434+ auto window = m_windowModel[start].window;

435+ window->setSurface(nullptr);

436+ window->setFocused(false);

437+

438+ m_windowModel.removeAt(start);

439+ m_allSurfaces.remove(surface);

440+ }

441+

442+ if (m_modelState == RemovingState) {

443+ endRemoveRows();

444+ Q_EMIT countChanged();

445+ Q_EMIT listChanged();

446+ m_modelState = IdleState;

360447 }

361448 }

362449}

@@ -372,11 +459,13 @@ void TopLevelWindowModel::removeAt(int index)

372459 }

373460

374461 auto window = m_windowModel[index].window;

462+ auto surface = window->surface();

375463

376464 window->setSurface(nullptr);

377465 window->setFocused(false);

378466

379467 m_windowModel.removeAt(index);

468+ m_allSurfaces.remove(surface);

380469

381470 if (m_modelState == RemovingState) {

382471 endRemoveRows();

@@ -388,6 +477,7 @@ void TopLevelWindowModel::removeAt(int index)

388477 disconnect(window, 0, this, 0);

389478 if (m_focusedWindow == window) {

390479 setFocusedWindow(nullptr);

480+ m_focusedWindowCleared = false;

391481 }

392482 delete window;

393483

@@ -656,12 +746,11 @@ void TopLevelWindowModel::onModificationsStarted()

656746

657747void TopLevelWindowModel::onModificationsEnded()

658748{

659− if (m_focusedWindowChanged) {

660− setFocusedWindow(m_newlyFocusedWindow);

749+ if (m_focusedWindowCleared) {

750+ setFocusedWindow(nullptr);

661751 }

662752 // reset

663− m_focusedWindowChanged = false;

664− m_newlyFocusedWindow = nullptr;

753+ m_focusedWindowCleared = false;

665754}

666755

667756void TopLevelWindowModel::activateTopMostWindowWithoutId(int forbiddenId)

@@ -675,3 +764,54 @@ void TopLevelWindowModel::activateTopMostWindowWithoutId(int forbiddenId)

675764 }

676765 }

677766}

767+

768+void TopLevelWindowModel::refreshWindows()

769+{

770+ DEBUG_MSG << "()";

771+ clear();

772+

773+ if (!m_workspace || !m_applicationManager || !m_surfaceManager) return;

774+

775+ m_surfaceManager->forEachSurfaceInWorkspace(m_workspace->workspace(), [this](unity::shell::application::MirSurfaceInterface* surface) {

776+ if (surface->parentSurface()) {

777+ // Wrap it in a Window so that we keep focusedWindow() up to date.

778+ Window *window = createWindow(surface);

779+ connect(surface, &QObject::destroyed, window, [=](){

780+ window->setSurface(nullptr);

781+ window->deleteLater();

782+ });

783+ } else {

784+ if (surface->type() == Mir::InputMethodType) {

785+ setInputMethodWindow(createWindow(surface));

786+ } else {

787+ auto *application = m_applicationManager->findApplicationWithSurface(surface);

788+ if (application) {

789+ prependSurface(surface, application);

790+ } else {

791+ // Must be a prompt session. No need to do add it as a prompt surface is not top-level.

792+ // It will show up in the ApplicationInfoInterface::promptSurfaceList of some application.

793+ // Still wrap it in a Window though, so that we keep focusedWindow() up to date.

794+ Window *promptWindow = createWindow(surface);

795+ connect(surface, &QObject::destroyed, promptWindow, [=](){

796+ promptWindow->setSurface(nullptr);

797+ promptWindow->deleteLater();

798+ });

799+ }

800+ }

801+ }

802+ });

803+}

804+

805+void TopLevelWindowModel::clear()

806+{

807+ DEBUG_MSG << "()";

808+

809+ while(m_windowModel.count() > 0) {

810+ ModelEntry entry = m_windowModel.takeAt(0);

811+ disconnect(entry.window, 0, this, 0);

812+ delete entry.window;

813+ }

814+ m_allSurfaces.clear();

815+ setFocusedWindow(nullptr);

816+ m_focusedWindowCleared = false;

817+}

plugins/WindowManager/TopLevelWindowModel.h+20−22

@@ -20,9 +20,14 @@

2020#include <QAbstractListModel>

2121#include <QLoggingCategory>

2222

23+#include <memory>

24+

2325Q_DECLARE_LOGGING_CATEGORY(TOPLEVELWINDOWMODEL)

2426

2527class Window;

28+class Workspace;

29+

30+namespace miral { class Workspace; }

2631

2732namespace unity {

2833 namespace shell {

@@ -70,16 +75,6 @@ class TopLevelWindowModel : public QAbstractListModel

7075 */

7176 Q_PROPERTY(Window* focusedWindow READ focusedWindow NOTIFY focusedWindowChanged)

7277

73− Q_PROPERTY(unity::shell::application::SurfaceManagerInterface* surfaceManager

74− READ surfaceManager

75− WRITE setSurfaceManager

76− NOTIFY surfaceManagerChanged)

77−

78− Q_PROPERTY(unity::shell::application::ApplicationManagerInterface* applicationManager

79− READ applicationManager

80− WRITE setApplicationManager

81− NOTIFY applicationManagerChanged)

82−

8378 /**

8479 The id to be used on the next entry created

8580 Useful for tests

@@ -98,7 +93,7 @@ public:

9893 ApplicationRole = Qt::UserRole + 1,

9994 };

10095

101− TopLevelWindowModel();

96+ TopLevelWindowModel(Workspace* workspace);

10297

10398 // From QAbstractItemModel

10499 int rowCount(const QModelIndex &parent = QModelIndex()) const override;

@@ -109,17 +104,11 @@ public:

109104 return roleNames;

110105 }

111106

112− // Own API

107+ // Own API;

113108

114109 unity::shell::application::MirSurfaceInterface* inputMethodSurface() const;

115110 Window* focusedWindow() const;

116111

117− unity::shell::application::ApplicationManagerInterface *applicationManager() const { return m_applicationManager; }

118− void setApplicationManager(unity::shell::application::ApplicationManagerInterface*);

119−

120− unity::shell::application::SurfaceManagerInterface *surfaceManager() const { return m_surfaceManager; }

121− void setSurfaceManager(unity::shell::application::SurfaceManagerInterface*);

122−

123112 int nextId() const { return m_nextId; }

124113

125114public:

@@ -166,8 +155,6 @@ Q_SIGNALS:

166155 void countChanged();

167156 void inputMethodSurfaceChanged(unity::shell::application::MirSurfaceInterface* inputMethodSurface);

168157 void focusedWindowChanged(Window *focusedWindow);

169− void applicationManagerChanged(unity::shell::application::ApplicationManagerInterface*);

170− void surfaceManagerChanged(unity::shell::application::SurfaceManagerInterface*);

171158

172159 /**

173160 * @brief Emitted when the list changes

@@ -179,7 +166,14 @@ Q_SIGNALS:

179166 void nextIdChanged();

180167

181168private Q_SLOTS:

169+ void setApplicationManager(unity::shell::application::ApplicationManagerInterface*);

170+ void setSurfaceManager(unity::shell::application::SurfaceManagerInterface*);

171+

182172 void onSurfaceCreated(unity::shell::application::MirSurfaceInterface *surface);

173+ void onSurfacesAddedToWorkspace(const std::shared_ptr<miral::Workspace>& workspace,

174+ const QVector<unity::shell::application::MirSurfaceInterface*> surfaces);

175+ void onSurfacesAboutToBeRemovedFromWorkspace(const std::shared_ptr<miral::Workspace>& workspace,

176+ const QVector<unity::shell::application::MirSurfaceInterface*> surfaces);

183177 void onSurfacesRaised(const QVector<unity::shell::application::MirSurfaceInterface*> &surfaces);

184178

185179 void onModificationsStarted();

@@ -219,6 +213,8 @@ private:

219213 void activateEmptyWindow(Window *window);

220214

221215 void activateTopMostWindowWithoutId(int forbiddenId);

216+ void refreshWindows();

217+ void clear();

222218

223219 Window *createWindow(unity::shell::application::MirSurfaceInterface *surface);

224220

@@ -235,6 +231,9 @@ private:

235231 QVector<ModelEntry> m_windowModel;

236232 Window* m_inputMethodWindow{nullptr};

237233 Window* m_focusedWindow{nullptr};

234+ Workspace* m_workspace{nullptr};

235+ // track all the surfaces we've been told about.

236+ QSet<unity::shell::application::MirSurfaceInterface*> m_allSurfaces;

238237

239238 int m_nextId{1};

240239 // Just something big enough that we don't risk running out of unused id numbers.

@@ -255,8 +254,7 @@ private:

255254 ModelState m_modelState{IdleState};

256255

257256 // Valid between modificationsStarted and modificationsEnded

258− bool m_focusedWindowChanged{false};

259− Window *m_newlyFocusedWindow{nullptr};

257+ bool m_focusedWindowCleared{false};

260258};

261259

262260#endif // TOPLEVELWINDOWMODEL_H

plugins/WindowManager/WindowManagerObjects.cppnew file+47

@@ -0,0 +1,47 @@

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 "WindowManagerObjects.h"

18+

19+WindowManagerObjects::WindowManagerObjects(QObject *parent)

20+ : QObject(parent)

21+ , m_surfaceManager(nullptr)

22+ , m_applicationManager(nullptr)

23+{

24+}

25+

26+WindowManagerObjects *WindowManagerObjects::instance()

27+{

28+ static WindowManagerObjects* objects(new WindowManagerObjects());

29+ return objects;

30+}

31+

32+

33+void WindowManagerObjects::setSurfaceManager(unity::shell::application::SurfaceManagerInterface *surfaceManager)

34+{

35+ if (m_surfaceManager == surfaceManager) return;

36+

37+ m_surfaceManager = surfaceManager;

38+ Q_EMIT surfaceManagerChanged(surfaceManager);

39+}

40+

41+void WindowManagerObjects::setApplicationManager(unity::shell::application::ApplicationManagerInterface *applicationManager)

42+{

43+ if (m_applicationManager == applicationManager) return;

44+

45+ m_applicationManager = applicationManager;

46+ Q_EMIT applicationManagerChanged(applicationManager);

47+}

plugins/WindowManager/WindowManagerObjects.hnew file+64

@@ -0,0 +1,64 @@

1+/*

3+ *

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

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

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

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef WINDOWMANAGEROBJECTS_H

18+#define WINDOWMANAGEROBJECTS_H

19+

20+#include <QObject>

21+

22+namespace unity {

23+ namespace shell {

24+ namespace application {

25+ class SurfaceManagerInterface;

26+ class ApplicationManagerInterface;

27+ }

28+ }

29+}

30+

31+class WindowManagerObjects : public QObject

32+{

33+ Q_OBJECT

34+

35+ Q_PROPERTY(unity::shell::application::SurfaceManagerInterface* surfaceManager

36+ READ surfaceManager

37+ WRITE setSurfaceManager

38+ NOTIFY surfaceManagerChanged)

39+

40+ Q_PROPERTY(unity::shell::application::ApplicationManagerInterface* applicationManager

41+ READ applicationManager

42+ WRITE setApplicationManager

43+ NOTIFY applicationManagerChanged)

44+public:

45+ explicit WindowManagerObjects(QObject *parent = 0);

46+

47+ static WindowManagerObjects *instance();

48+

49+ unity::shell::application::SurfaceManagerInterface *surfaceManager() const { return m_surfaceManager; }

50+ void setSurfaceManager(unity::shell::application::SurfaceManagerInterface*);

51+

52+ unity::shell::application::ApplicationManagerInterface *applicationManager() const { return m_applicationManager; }

53+ void setApplicationManager(unity::shell::application::ApplicationManagerInterface*);

54+

55+Q_SIGNALS:

56+ void surfaceManagerChanged(unity::shell::application::SurfaceManagerInterface*);

57+ void applicationManagerChanged(unity::shell::application::ApplicationManagerInterface*);

58+

59+private:

60+ unity::shell::application::SurfaceManagerInterface* m_surfaceManager;

61+ unity::shell::application::ApplicationManagerInterface* m_applicationManager;

62+};

63+

64+#endif // WINDOWMANAGEROBJECTS_H

plugins/WindowManager/WindowManagerPlugin.cpp+44−2

@@ -16,16 +16,58 @@

1616

1717#include "WindowManagerPlugin.h"

1818

19+#include "Screen.h"

20+#include "ScreenAttached.h"

21+#include "Screens.h"

22+#include "ScreenWindow.h"

1923#include "TopLevelWindowModel.h"

2024#include "Window.h"

25+#include "WindowManagerObjects.h"

26+#include "WorkspaceManager.h"

27+#include "Workspace.h"

28+#include "WorkspaceModel.h"

2129

2230#include <QtQml>

31+#include <qtmir/qtmir.h>

32+

33+static const QString notInstantiatable = QStringLiteral("Not instantiatable");

34+

35+static QObject *workspace_manager(QQmlEngine *engine, QJSEngine *scriptEngine)

36+{

37+ Q_UNUSED(engine)

38+ Q_UNUSED(scriptEngine)

39+ return WorkspaceManager::instance();

40+}

41+QObject* screensSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {

42+ Q_UNUSED(engine);

43+ Q_UNUSED(scriptEngine);

44+ return new Screens(qtmir::get_screen_model());

45+}

46+QObject* objectsSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {

47+ Q_UNUSED(engine);

48+ Q_UNUSED(scriptEngine);

49+ return WindowManagerObjects::instance();

50+}

2351

2452void WindowManagerPlugin::registerTypes(const char *uri)

2553{

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

54+ qmlRegisterSingletonType<WorkspaceManager>(uri, 1, 0, "WorkspaceManager", workspace_manager);

55+ qmlRegisterUncreatableType<WorkspaceModel>(uri, 1, 0, "WorkspaceModel", notInstantiatable);

56+ qmlRegisterSingletonType<Screens>(uri, 1, 0, "Screens", screensSingleton);

57+ qmlRegisterUncreatableType<qtmir::ScreenMode>(uri, 1, 0, "ScreenMode", notInstantiatable);

58+ qmlRegisterUncreatableType<Workspace>(uri, 1, 0, "Workspace", notInstantiatable);

59+ qmlRegisterSingletonType<WindowManagerObjects>(uri, 1, 0, "WindowManagerObjects", objectsSingleton);

2760

28− qRegisterMetaType<Window*>("Window*");

61+ qRegisterMetaType<Screen*>("Screen*");

62+ qRegisterMetaType<ScreensProxy*>("ScreensProxy*");

63+ qRegisterMetaType<Workspace*>("Workspace*");

64+ qRegisterMetaType<TopLevelWindowModel*>("TopLevelWindowModel*");

2965

66+ qRegisterMetaType<Window*>("Window*");

3067 qRegisterMetaType<QAbstractListModel*>("QAbstractListModel*");

68+

69+ qmlRegisterType<ScreenWindow>(uri, 1, 0, "ScreenWindow");

70+ qmlRegisterRevision<QWindow,1>(uri, 1, 0);

71+

72+ qmlRegisterUncreatableType<WMScreen>(uri, 1, 0, "WMScreen", notInstantiatable);

3173}

plugins/WindowManager/Workspace.cppnew file+143

@@ -0,0 +1,143 @@

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 "Workspace.h"

18+#include "WorkspaceModel.h"

19+#include "WorkspaceManager.h"

20+#include "TopLevelWindowModel.h"

21+

22+#include "wmpolicyinterface.h"

23+

24+int nextWorkspace = 0;

25+

26+Workspace::Workspace(QObject *parent)

27+ : QObject(parent)

28+ , m_workspace(WMPolicyInterface::instance()->createWorkspace())

29+ , m_model(nullptr)

30+ , m_windowModel(new TopLevelWindowModel(this))

31+ , m_active(false)

32+{

33+ setObjectName((QString("Wks%1").arg(nextWorkspace++)));

34+

35+ connect(WorkspaceManager::instance(), &WorkspaceManager::activeWorkspaceChanged, this, [this]() {

36+ bool newActive = WorkspaceManager::instance()->activeWorkspace() == this;

37+ if (newActive != m_active) {

38+ m_active = newActive;

39+ Q_EMIT activeChanged(m_active);

40+

41+ if (m_active) {

42+ WMPolicyInterface::instance()->setActiveWorkspace(m_workspace);

43+ }

44+ }

45+ });

46+}

47+

48+Workspace::Workspace(const Workspace &other)

49+ : QObject(nullptr)

50+ , m_workspace(other.m_workspace)

51+ , m_model(nullptr)

52+ , m_windowModel(other.m_windowModel)

53+ , m_active(other.m_active)

54+{

55+ setObjectName(other.objectName());

56+

57+ connect(&other, &Workspace::activeChanged, this, [this](bool active) {

58+ m_active = active;

59+ Q_EMIT activeChanged(m_active);

60+ });

61+}

62+

63+Workspace::~Workspace()

64+{

65+ if (m_model) {

66+ m_model->remove(this);

67+ }

68+}

69+

70+void Workspace::activate()

71+{

72+ WorkspaceManager::instance()->setActiveWorkspace(this);

73+}

74+

75+void Workspace::assign(WorkspaceModel *model, const QVariant& vIndex)

76+{

77+ if (m_model == model) return;

78+

79+ if (m_model) {

80+ disconnect(m_model, 0, this, 0);

81+ m_model->remove(this);

82+ }

83+

84+ m_model = model;

85+

86+ if (model) {

87+ int index = m_model->rowCount();

88+ if (vIndex.isValid() && vIndex.canConvert(QVariant::Int)) {

89+ index = vIndex.toInt();

90+ }

91+ m_model->insert(index, this);

92+

93+ connect(m_model, &QObject::destroyed, this, [this]() {

94+ m_model = nullptr;

95+ Q_EMIT unassigned();

96+ });

97+ Q_EMIT assigned();

98+ } else {

99+ Q_EMIT unassigned();

100+ }

101+}

102+

103+void Workspace::unassign()

104+{

105+ assign(nullptr);

106+}

107+

108+void Workspace::release()

109+{

110+ WMPolicyInterface::instance()->releaseWorkspace(m_workspace);

111+ deleteLater();

112+}

113+

114+bool Workspace::isAssigned() const

115+{

116+ return m_model != nullptr;

117+}

118+

119+WorkspaceProxy::WorkspaceProxy(Workspace * const workspace)

120+ : Workspace(*workspace)

121+ , m_original(workspace)

122+{

123+}

124+

125+void WorkspaceProxy::assign(WorkspaceModel *model, const QVariant &index)

126+{

127+ Workspace::assign(model, index);

128+}

129+

130+void WorkspaceProxy::unassign()

131+{

132+ Workspace::unassign();

133+}

134+

135+bool WorkspaceProxy::isActive() const

136+{

137+ return m_original ? m_original->isActive() : false;

138+}

139+

140+void WorkspaceProxy::activate()

141+{

142+ if (m_original) m_original->activate();

143+}

plugins/WindowManager/Workspace.hnew file+100

@@ -0,0 +1,100 @@

1+/*

3+ *

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

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

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

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef WINDOWMANAGER_WORKSPACE_H

18+#define WINDOWMANAGER_WORKSPACE_H

19+

20+#include <QObject>

21+#include <QVariant>

22+#include <QPointer>

23+

24+#include <memory>

25+#include <functional>

26+

27+class WorkspaceModel;

28+class TopLevelWindowModel;

29+

30+namespace miral { class Workspace; }

31+

32+namespace unity {

33+ namespace shell {

34+ namespace application {

35+ class MirSurfaceInterface;

36+ }

37+ }

38+}

39+

40+class Workspace : public QObject

41+{

42+ Q_OBJECT

43+ Q_PROPERTY(bool active READ isActive NOTIFY activeChanged)

44+ Q_PROPERTY(TopLevelWindowModel* windowModel READ windowModel NOTIFY windowModelChanged)

45+public:

46+ ~Workspace();

47+

48+ virtual void assign(WorkspaceModel* model, const QVariant& index = QVariant());

49+ virtual void unassign();

50+ void release();

51+

52+ virtual bool isActive() const { return m_active; }

53+

54+ TopLevelWindowModel *windowModel() const { return m_windowModel; }

55+ std::shared_ptr<miral::Workspace> workspace() const { return m_workspace; }

56+ bool isAssigned() const;

57+

58+public Q_SLOTS:

59+ virtual void activate();

60+

61+Q_SIGNALS:

62+ void assigned();

63+ void unassigned();

64+

65+ void activeChanged(bool);

66+ void windowModelChanged();

67+

68+protected:

69+ Workspace(QObject *parent = 0);

70+ Workspace(Workspace const& other);

71+

72+ std::shared_ptr<miral::Workspace> m_workspace;

73+ WorkspaceModel* m_model;

74+ TopLevelWindowModel* m_windowModel;

75+ bool m_active;

76+

77+ friend class WorkspaceManager;

78+};

79+

80+class WorkspaceProxy : public Workspace

81+{

82+ Q_OBJECT

83+public:

84+ WorkspaceProxy(Workspace*const workspace);

85+

86+ Q_INVOKABLE void assign(WorkspaceModel* model, const QVariant& index = QVariant()) override;

87+

88+ bool isActive() const override;

89+ void activate() override;

90+

91+ Workspace* proxyObject() const { return m_original.data(); }

92+

93+public Q_SLOTS:

94+ void unassign() override;

95+

96+private:

97+ const QPointer<Workspace> m_original;

98+};

99+

100+#endif // WINDOWMANAGER_WORKSPACE_H

plugins/WindowManager/WorkspaceManager.cppnew file+135

@@ -0,0 +1,135 @@

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 "WorkspaceManager.h"

18+#include "Workspace.h"

19+#include "TopLevelWindowModel.h"

20+#include "WindowManagerObjects.h"

21+#include <unity/shell/application/SurfaceManagerInterface.h>

22+

23+// Qt

24+#include <QGuiApplication>

25+#include <QScreen>

26+#include <QQmlEngine>

27+

28+WorkspaceManager *WorkspaceManager::instance()

29+{

30+ static WorkspaceManager* workspaceManager(new WorkspaceManager());

31+ return workspaceManager;

32+}

33+

34+WorkspaceManager::WorkspaceManager()

35+ : m_activeWorkspace(nullptr)

36+{

37+}

38+

39+Workspace *WorkspaceManager::createWorkspace()

40+{

41+ auto workspace = new Workspace(this);

42+ QQmlEngine::setObjectOwnership(workspace, QQmlEngine::CppOwnership);

43+ m_allWorkspaces.insert(workspace);

44+ m_floatingWorkspaces.append(workspace);

45+

46+ connect(workspace, &Workspace::assigned, this, [this, workspace]() {

47+ m_floatingWorkspaces.removeOne(workspace);

48+ Q_EMIT floatingWorkspacesChanged();

49+ });

50+ connect(workspace, &Workspace::unassigned, this, [this, workspace]() {

51+ m_floatingWorkspaces.append(workspace);

52+ Q_EMIT floatingWorkspacesChanged();

53+ });

54+

55+ if (m_allWorkspaces.count() == 0 && m_activeWorkspace) {

56+ setActiveWorkspace(nullptr);

57+ Q_EMIT activeWorkspaceChanged();

58+ } else if (m_allWorkspaces.count() == 1) {

59+ setActiveWorkspace(workspace);

60+ }

61+

62+ return workspace;

63+}

64+

65+void WorkspaceManager::destroyWorkspace(Workspace *workspace)

66+{

67+ if (!workspace) return;

68+

69+ if (workspace->isAssigned()) {

70+ workspace->unassign();

71+ }

72+ m_floatingWorkspaces.removeOne(workspace);

73+ m_allWorkspaces.remove(workspace);

74+ Q_EMIT floatingWorkspacesChanged();

75+

76+ if (m_activeWorkspace == workspace) {

77+ Q_ASSERT(false); // Shouldn't happen, should have chosen something by now.

78+ // just choose anything.

79+ setActiveWorkspace(m_allWorkspaces.count() ? *m_allWorkspaces.begin() : nullptr);

80+ }

81+ if (m_activeWorkspace) {

82+ moveWorkspaceContentToWorkspace(m_activeWorkspace, workspace);

83+ }

84+

85+ disconnect(workspace, 0, this, 0);

86+ workspace->release();

87+}

88+

89+QQmlListProperty<Workspace> WorkspaceManager::floatingWorkspaces()

90+{

91+ return QQmlListProperty<Workspace>(this, m_floatingWorkspaces);

92+}

93+

94+void WorkspaceManager::destroyFloatingWorkspaces()

95+{

96+ QList<Workspace*> dpCpy(m_floatingWorkspaces);

97+ Q_FOREACH(auto workspace, dpCpy) {

98+ destroyWorkspace(workspace);

99+ }

100+}

101+

102+void WorkspaceManager::moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface *surface, Workspace *workspace)

103+{

104+ auto surfaceManager = WindowManagerObjects::instance()->surfaceManager();

105+ if (surfaceManager) {

106+ surfaceManager->moveSurfaceToWorkspace(surface, workspace->workspace());

107+ }

108+}

109+

110+void WorkspaceManager::moveWorkspaceContentToWorkspace(Workspace *to, Workspace *from)

111+{

112+ auto surfaceManager = WindowManagerObjects::instance()->surfaceManager();

113+ if (surfaceManager) {

114+ surfaceManager->moveWorkspaceContentToWorkspace(to->workspace(), from->workspace());

115+ }

116+}

117+

118+Workspace *WorkspaceManager::activeWorkspace() const

119+{

120+ return m_activeWorkspace;

121+}

122+

123+void WorkspaceManager::setActiveWorkspace(Workspace *workspace)

124+{

125+ if (workspace != m_activeWorkspace) {

126+ m_activeWorkspace = workspace;

127+ Q_EMIT activeWorkspaceChanged();

128+ }

129+}

130+

131+void WorkspaceManager::setActiveWorkspace2(Workspace *workspace)

132+{

133+ if (!workspace) return;

134+ workspace->activate();

135+}

plugins/WindowManager/WorkspaceManager.hnew file+72

@@ -0,0 +1,72 @@

1+/*

3+ *

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

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

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

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef WORKSPACEMANAGER_H

18+#define WORKSPACEMANAGER_H

19+

20+#include "WorkspaceModel.h"

21+#include <QQmlListProperty>

22+

23+class Workspace;

24+class ScreensProxy;

25+

26+namespace unity {

27+ namespace shell {

28+ namespace application {

29+ class MirSurfaceInterface;

30+ class SurfaceManagerInterface;

31+ }

32+ }

33+}

34+

35+class WorkspaceManager : public QObject

36+{

37+ Q_OBJECT

38+ Q_PROPERTY(Workspace* activeWorkspace READ activeWorkspace WRITE setActiveWorkspace2 NOTIFY activeWorkspaceChanged)

39+

40+public:

41+ static WorkspaceManager* instance();

42+

43+ Workspace* activeWorkspace() const;

44+ void setActiveWorkspace(Workspace* workspace);

45+

46+ Workspace* createWorkspace();

47+ void destroyWorkspace(Workspace* workspace);

48+

49+ QQmlListProperty<Workspace> floatingWorkspaces();

50+ void destroyFloatingWorkspaces();

51+

52+ Q_INVOKABLE void moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface* surface,

53+ Workspace* workspace);

54+

55+ Q_INVOKABLE void moveWorkspaceContentToWorkspace(Workspace* to, Workspace* from);

56+

57+Q_SIGNALS:

58+ void activeWorkspaceChanged();

59+ void floatingWorkspacesChanged();

60+

61+private:

62+ WorkspaceManager();

63+

64+ void setActiveWorkspace2(Workspace* workspace);

65+

66+ QSet<Workspace*> m_allWorkspaces;

67+ QList<Workspace*> m_floatingWorkspaces;

68+ Workspace* m_activeWorkspace;

69+ unity::shell::application::SurfaceManagerInterface* m_surfaceManager;

70+};

71+

72+#endif // WORKSPACEMANAGER_H

plugins/WindowManager/WorkspaceModel.cppnew file+220

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

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 "WorkspaceModel.h"

18+#include "WorkspaceManager.h"

19+#include "Workspace.h"

20+

21+#include <QQmlEngine>

22+

23+Q_LOGGING_CATEGORY(WORKSPACES, "Workspaces", QtInfoMsg)

24+

25+#define DEBUG_MSG qCDebug(WORKSPACES).nospace().noquote() << __func__

26+#define INFO_MSG qCInfo(WORKSPACES).nospace().noquote() << __func__

27+

28+WorkspaceModel::WorkspaceModel(QObject *parent)

29+ : QAbstractListModel(parent)

30+{

31+}

32+

33+void WorkspaceModel::append(Workspace *workspace)

34+{

35+ insert(m_workspaces.count(), workspace);

36+}

37+

38+void WorkspaceModel::insert(int index, Workspace *workspace)

39+{

40+ beginInsertRows(QModelIndex(), index, index);

41+

42+ m_workspaces.insert(index, workspace);

43+

44+ endInsertRows();

45+

46+ Q_EMIT workspaceInserted(index, workspace);

47+ Q_EMIT countChanged();

48+}

49+

50+void WorkspaceModel::remove(Workspace *workspace)

51+{

52+ int index = m_workspaces.indexOf(workspace);

53+ if (index < 0) return;

54+

55+ beginRemoveRows(QModelIndex(), index, index);

56+

57+ m_workspaces.removeAt(index);

58+

59+ endRemoveRows();

60+

61+ Q_EMIT workspaceRemoved(workspace);

62+ Q_EMIT countChanged();

63+}

64+

65+void WorkspaceModel::move(int from, int to)

66+{

67+ if (from == to) return;

68+ DEBUG_MSG << " from=" << from << " to=" << to;

69+

70+ if (from >= 0 && from < m_workspaces.size() && to >= 0 && to < m_workspaces.size()) {

71+ QModelIndex parent;

72+

73+ beginMoveRows(parent, from, from, parent, to + (to > from ? 1 : 0));

74+#if QT_VERSION < QT_VERSION_CHECK(5, 6, 0)

75+ const auto &window = m_windowModel.takeAt(from);

76+ m_workspaces.insert(to, window);

77+#else

78+ m_workspaces.move(from, to);

79+#endif

80+ endMoveRows();

81+

82+ Q_EMIT workspaceMoved(from, to);

83+ }

84+}

85+

86+int WorkspaceModel::indexOf(Workspace *workspace) const

87+{

88+ return m_workspaces.indexOf(workspace);

89+}

90+

91+Workspace *WorkspaceModel::get(int index) const

92+{

93+ if (index < 0 || index >= rowCount()) return nullptr;

94+ return m_workspaces.at(index);

95+}

96+

97+int WorkspaceModel::rowCount(const QModelIndex &) const

98+{

99+ return m_workspaces.count();

100+}

101+

102+QVariant WorkspaceModel::data(const QModelIndex &index, int role) const

103+{

104+ if (index.row() < 0 || index.row() >= m_workspaces.size())

105+ return QVariant();

106+

107+ if (role == WorkspaceRole) {

108+ Workspace *workspace = m_workspaces.at(index.row());

109+ return QVariant::fromValue(workspace);

110+ } else {

111+ return QVariant();

112+ }

113+}

114+

115+void WorkspaceModel::sync(WorkspaceModel *proxy)

116+{

117+ if (!proxy) return;

118+ m_syncing = proxy;

119+ const auto& proxyList = proxy->list();

120+

121+ // check for removals

122+ int removedIndexWhichWasActive = -1;

123+ QVector<Workspace*> dpCpy(this->list());

124+ Q_FOREACH(auto workspace, dpCpy) {

125+

126+ bool found = false;

127+ Q_FOREACH(auto p, proxyList) {

128+ auto workspaceProxy = qobject_cast<WorkspaceProxy*>(p);

129+ if (workspaceProxy->proxyObject() == workspace) {

130+ found = true;

131+ break;

132+ }

133+ }

134+ if (!found) {

135+ if (workspace->isActive()) {

136+ removedIndexWhichWasActive = indexOf(workspace);

137+ }

138+ workspace->unassign();

139+ }

140+ }

141+

142+ // existing

143+ QSet<Workspace*> newWorkspaces;

144+ for (int i = 0; i < proxyList.count(); i++) {

145+ auto workspaceProxy = qobject_cast<WorkspaceProxy*>(proxyList[i]);

146+ auto workspace = workspaceProxy->proxyObject();

147+

148+ int oldIndex = this->indexOf(workspace);

149+

150+ if (oldIndex < 0) {

151+ workspace->assign(this, QVariant(i));

152+ } else if (oldIndex != i) {

153+ this->move(oldIndex, i);

154+ }

155+ newWorkspaces.insert(workspace);

156+ }

157+

158+ // Make sure we have at least one workspace in the model.

159+ if (rowCount() == 0) {

160+ Workspace* workspace = WorkspaceManager::instance()->createWorkspace();

161+ workspace->assign(this);

162+ (new WorkspaceProxy(workspace))->assign(proxy);

163+ }

164+

165+ if (removedIndexWhichWasActive != -1) {

166+ int newActiveIndex = qMin(removedIndexWhichWasActive, this->rowCount()-1);

167+ Workspace* newActiveWorkspace = newActiveIndex >= 0 ? this->get(newActiveIndex) : nullptr;

168+

169+ WorkspaceManager::instance()->setActiveWorkspace(newActiveWorkspace);

170+ }

171+ m_syncing = nullptr;

172+}

173+

174+bool WorkspaceModel::isSyncingWith(WorkspaceModel *m)

175+{

176+ return m_syncing == m;

177+}

178+

179+WorkspaceModelProxy::WorkspaceModelProxy(WorkspaceModel * const model)

180+ : m_original(model)

181+{

182+ Q_FOREACH(auto workspace, model->list()) {

183+ auto proxy = new WorkspaceProxy(workspace);

184+ QQmlEngine::setObjectOwnership(proxy, QQmlEngine::CppOwnership);

185+ proxy->assign(this);

186+ }

187+ connect(m_original, &WorkspaceModel::workspaceInserted, this, [this](int index, Workspace* inserted) {

188+ if (m_original->isSyncingWith(this)) return;

189+

190+ (new WorkspaceProxy(inserted))->assign(this, index);

191+ });

192+ connect(m_original, &WorkspaceModel::workspaceRemoved, this, [this](Workspace* removed) {

193+ if (m_original->isSyncingWith(this)) return;

194+

195+ for (int i = 0; i < rowCount(); i++) {

196+ auto workspaceProxy = qobject_cast<WorkspaceProxy*>(get(i));

197+ auto w = workspaceProxy->proxyObject();

198+ if (w == removed) {

199+ remove(workspaceProxy);

200+ break;

201+ }

202+ }

203+ });

204+ connect(m_original, &WorkspaceModel::workspaceMoved, this, [this](int from, int to) {

205+ if (m_original->isSyncingWith(this)) return;

206+

207+ move(from, to);

208+ });

209+}

210+

211+WorkspaceModelProxy::~WorkspaceModelProxy()

212+{

213+ qDeleteAll(m_workspaces.toList()); // make a copy so the list doesnt edit itself during delete.

214+ m_workspaces.clear();

215+}

216+

217+void WorkspaceModelProxy::move(int from, int to)

218+{

219+ WorkspaceModel::move(from, to);

220+}

plugins/WindowManager/WorkspaceModel.hnew file+91

@@ -0,0 +1,91 @@

1+/*

3+ *

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

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

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

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef WORKSPACEMODEL_H

18+#define WORKSPACEMODEL_H

19+

20+#include <QAbstractListModel>

21+#include <QLoggingCategory>

22+#include <QPointer>

23+

24+Q_DECLARE_LOGGING_CATEGORY(WORKSPACES)

25+

26+class Workspace;

27+class WorkspaceModelProxy;

28+

29+class WorkspaceModel : public QAbstractListModel

30+{

31+ Q_OBJECT

32+ Q_PROPERTY(int count READ rowCount NOTIFY countChanged)

33+public:

34+ /**

35+ * @brief The Roles supported by the model

36+ *

37+ * WorkspaceRole - A workspace.

38+ */

39+ enum Roles {

40+ WorkspaceRole = Qt::UserRole

41+ };

42+

43+ explicit WorkspaceModel(QObject *parent = 0);

44+

45+ void append(Workspace *workspace);

46+ void insert(int index, Workspace *workspace);

47+ void remove(Workspace* workspace);

48+ virtual void move(int from, int to);

49+

50+ int indexOf(Workspace *workspace) const;

51+ Q_INVOKABLE Workspace* get(int index) const;

52+

53+ // From QAbstractItemModel

54+ int rowCount(const QModelIndex &parent = QModelIndex()) const override;

55+ QVariant data(const QModelIndex& index, int role) const override;

56+ QHash<int, QByteArray> roleNames() const override {

57+ QHash<int, QByteArray> roleNames { {WorkspaceRole, "workspace"} };

58+ return roleNames;

59+ }

60+

61+ const QVector<Workspace*>& list() const { return m_workspaces; }

62+

63+ void sync(WorkspaceModel* proxy);

64+ bool isSyncingWith(WorkspaceModel*);

65+

66+Q_SIGNALS:

67+ void countChanged();

68+

69+ void workspaceInserted(int index, Workspace *workspace);

70+ void workspaceRemoved(Workspace *workspace);

71+ void workspaceMoved(int from, int to);

72+

73+protected:

74+ QVector<Workspace*> m_workspaces;

75+ WorkspaceModel* m_syncing;

76+};

77+

78+class WorkspaceModelProxy : public WorkspaceModel

79+{

80+ Q_OBJECT

81+public:

82+ WorkspaceModelProxy(WorkspaceModel*const model);

83+ ~WorkspaceModelProxy();

84+

85+ Q_INVOKABLE void move(int from, int to) override;

86+

87+protected:

88+ const QPointer<WorkspaceModel> m_original;

89+};

90+

91+#endif // WORKSPACEMODEL_H

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)

22

33install(FILES ${QML_JS_FILES}

44 DESTINATION ${SHELL_APP_DIR}

qml/Components/PanelState/PanelState.qml−1

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

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

1515 */

1616

17−pragma Singleton

1817import QtQuick 2.4

1918

2019QtObject {

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+14−20

@@ -18,22 +18,20 @@ import QtQuick 2.4

1818import QtQuick.Layouts 1.1

1919import Ubuntu.Components 1.3

2020import Qt.labs.settings 1.0

21−import Unity.Screens 0.1

21+import WindowManager 1.0

2222import UInput 0.1

2323import "../Components"

2424

2525Item {

2626 id: root

27− property var uinput: UInput {

28− Component.onCompleted: createMouse();

29− Component.onDestruction: removeMouse();

30− }

3127

3228 Component.onCompleted: {

29+ UInput.createMouse();

3330 if (!settings.touchpadTutorialHasRun) {

3431 root.runTutorial()

3532 }

3633 }

34+ Component.onDestruction: UInput.removeMouse()

3735

3836 function runTutorial() {

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

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

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

8684 && clickTimer.running) {

8785 clickTimer.stop();

88− uinput.pressMouse(UInput.ButtonLeft)

86+ UInput.pressMouse(UInput.ButtonLeft)

8987 isDoubleClick = true;

9088 }

9189 isClick = true;

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

104102

105103 onReleased: {

106104 if (isDoubleClick || isDrag) {

107− uinput.releaseMouse(UInput.ButtonLeft)

105+ UInput.releaseMouse(UInput.ButtonLeft)

108106 isDoubleClick = false;

109107 }

110108 if (isClick) {

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

120118 interval: 200

121119 property int button: UInput.ButtonLeft

122120 onTriggered: {

123− uinput.pressMouse(button);

124− uinput.releaseMouse(button);

121+ UInput.pressMouse(button);

122+ UInput.releaseMouse(button);

125123 }

126124 function scheduleClick(button) {

127125 clickTimer.button = button;

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

138136 isDrag = true;

139137 }

140138

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

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

142140 }

143141

144142 function scroll(touchPoints) {

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

166164 dh /= 2;

167165 dv /= 2;

168166

169− uinput.scrollMouse(dh, dv);

167+ UInput.scrollMouse(dh, dv);

170168 }

171169

172170 touchPoints: [

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

189187 objectName: "leftButton"

190188 Layout.fillWidth: true

191189 Layout.fillHeight: true

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

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

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

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

194192 property bool highlight: false

195193 UbuntuShape {

196194 anchors.fill: parent

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

204202 objectName: "rightButton"

205203 Layout.fillWidth: true

206204 Layout.fillHeight: true

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

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

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

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

209207 property bool highlight: false

210208 UbuntuShape {

211209 anchors.fill: parent

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

239237 }

240238 }

241239

242− Screens {

243− id: screens

244− }

245−

246240 InputMethod {

247241 id: inputMethod

248242 // 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

250244 objectName: "inputMethod"

251245 anchors.fill: parent

252246 }

qml/DisabledScreenNotice.qml+2−1

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

2828 property var screen: Screen

2929 property var orientationLock: OrientationLock

3030

31+ property alias deviceConfiguration: _deviceConfiguration

3132 DeviceConfiguration {

32− id: deviceConfiguration

33+ id: _deviceConfiguration

3334 name: applicationArguments.deviceName

3435 }

3536

qml/ErrorApplication.qmlnew file+67

@@ -0,0 +1,67 @@

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 Ubuntu.Components 1.3

20+import WindowManager 1.0

21+

22+Instantiator {

23+ id: root

24+ model: Screens

25+

26+ ScreenWindow {

27+ id: window

28+ objectName: "screen"+index

29+ screen: model.screen

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

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

32+

33+ Binding {

34+ when: applicationArguments.hasGeometry

35+ target: window

36+ property: "width"

37+ value: applicationArguments.windowGeometry.width

38+ }

39+ Binding {

40+ when: applicationArguments.hasGeometry

41+ target: window

42+ property: "height"

43+ value: applicationArguments.windowGeometry.height

44+ }

45+

46+ Loader {

47+ width: window.width

48+ height: window.height

49+

50+ Rectangle {

51+ color: "white"

52+ Column {

53+ spacing: units.gu(1)

54+

55+ Label {

56+ text: "Unity encountered an unrecoverable error while loading:"

57+ fontSize: "large"

58+ }

59+

60+ Label {

61+ text: errorString

62+ }

63+ }

64+ }

65+ }

66+ }

67+}

qml/Greeter/Greeter.qml+21−3

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

2525import Unity.Session 0.1

2626

2727import "." 0.1

28+import ".." 0.1

2829import "../Components"

2930

3031Showable {

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

227228 if (forcedUnlock && shown) {

228229 hideView();

229230 if (hideNow) {

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

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

231232 }

232233 }

233234 }

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

375376 onEmergencyCall: root.emergencyCall()

376377 onRequiredChanged: {

377378 if (!loader.item.required) {

378− root.hide();

379+ ShellNotifier.greeter.hide(false);

379380 }

380381 }

381382 }

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

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

499500 }

500501

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+

501519 Connections {

502520 target: DBusUnitySessionService

503521 onLockRequested: root.forceShow()

504522 onUnlocked: {

505523 root.forcedUnlock = true;

506− root.hideNow();

524+ ShellNotifier.greeter.hide(true);

507525 }

508526 }

509527

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+6−9

@@ -18,7 +18,7 @@ import QtQuick 2.4

1818import QtQuick.Window 2.2

1919import Unity.InputInfo 0.1

2020import Unity.Session 0.1

21−import Unity.Screens 0.1

21+import WindowManager 1.0

2222import Utils 0.1

2323import GSettings 1.0

2424import "Components"

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

3232 implicitWidth: units.gu(40)

3333 implicitHeight: units.gu(71)

3434

35+ property alias deviceConfiguration: _deviceConfiguration

36+ property alias orientations: d.orientations

37+

3538 onWidthChanged: calculateUsageMode();

3639

3740 DeviceConfiguration {

38− id: deviceConfiguration

41+ id: _deviceConfiguration

3942 name: applicationArguments.deviceName

4043 }

4144

42− property alias orientations: d.orientations

43−

4445 Item {

4546 id: d

4647

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

157158 return false;

158159 }

159160

160− Screens {

161− id: screens

162− }

163−

164161 property int orientation

165162 onPhysicalOrientationChanged: {

166163 if (!orientationLocked) {

@@ -264,7 +261,7 @@ Item {

264261

265262 Shell {

266263 id: shell

267− objectName: "shell"

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

268265 width: root.width

269266 height: root.height

270267 orientation: root.angleToOrientation(orientationAngle)

qml/Panel/Panel.qml+15−14

@@ -47,6 +47,7 @@ Item {

4747 property bool hasKeyboard: false

4848

4949 property string mode: "staged"

50+ property PanelState panelState

5051

5152 MouseArea {

5253 id: backMouseEater

@@ -63,14 +64,14 @@ Item {

6364 }

6465

6566 Binding {

66− target: PanelState

67+ target: panelState

6768 property: "panelHeight"

6869 value: minimizedPanelHeight

6970 }

7071

7172 RegisteredApplicationMenuModel {

7273 id: registeredMenuModel

73− persistentSurfaceId: PanelState.focusedPersistentSurfaceId

74+ persistentSurfaceId: panelState.focusedPersistentSurfaceId

7475 }

7576

7677 QtObject {

@@ -81,11 +82,11 @@ Item {

8182 !indicators.shown &&

8283 (decorationMouseArea.containsMouse || menuBarLoader.menusRequested)

8384

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

85− PanelState.decorationsAlwaysVisible

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

86+ panelState.decorationsAlwaysVisible

8687

8788 property bool showPointerMenu: revealControls &&

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

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

8990

9091 property bool enablePointerMenu: revealControls &&

9192 applicationMenus.available &&

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

137138 fill: panelAreaBackground

138139 bottomMargin: -units.gu(1)

139140 }

140− visible: PanelState.dropShadow

141+ visible: panelState.dropShadow

141142 source: "graphics/rectangular_dropshadow.sci"

142143 }

143144

@@ -190,12 +191,12 @@ Item {

190191 visible: opacity != 0

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

192193

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

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

194195 windowIsMaximized: true

195− onCloseClicked: PanelState.closeClicked()

196− onMinimizeClicked: PanelState.minimizeClicked()

197− onMaximizeClicked: PanelState.restoreClicked()

198− closeButtonShown: PanelState.closeButtonShown

196+ onCloseClicked: panelState.closeClicked()

197+ onMinimizeClicked: panelState.minimizeClicked()

198+ onMaximizeClicked: panelState.restoreClicked()

199+ closeButtonShown: panelState.closeButtonShown

199200 }

200201

201202 Loader {

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

217218 anchors.left: parent.left

218219 anchors.margins: units.gu(1)

219220 height: menuBarLoader.height

220− enableKeyFilter: valid && PanelState.decorationsVisible

221+ enableKeyFilter: valid && panelState.decorationsVisible

221222 unityMenuModel: __applicationMenus.model

222223

223224 Connections {

@@ -230,7 +231,7 @@ Item {

230231 onShownChanged: bar.dismiss();

231232 }

232233

233− onDoubleClicked: PanelState.restoreClicked()

234+ onDoubleClicked: panelState.restoreClicked()

234235 }

235236 }

236237 }

@@ -267,7 +268,7 @@ Item {

267268 }

268269

269270 showRowTitle: !expanded

270− rowTitle: PanelState.title

271+ rowTitle: panelState.title

271272 rowItemDelegate: ActionItem {

272273 id: actionItem

273274 property int ownIndex: index

qml/Shell.qml+58−23

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

1−/*

1+/*

33 *

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

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

3838import "Stage"

3939import "Tutorial"

4040import "Wizard"

41+import "Components/PanelState"

4142import Unity.Notifications 1.0 as NotificationBackend

4243import Unity.Session 0.1

4344import Unity.DashCommunicator 0.1

4445import Unity.Indicators 0.1 as Indicators

4546import Cursor 1.1

4647import WindowManager 1.0

48+import Unity.Debug 0.1 as Debug

4749

4850

4951StyledItem {

@@ -96,6 +98,11 @@ StyledItem {

9698

9799 readonly property var mainApp: stage.mainApp

98100

101+ readonly property var topLevelSurfaceList: {

102+ if (!WMScreen.currentWorkspace) return null;

103+ return WMScreen.currentWorkspace.windowModel

104+ }

105+

99106 onMainAppChanged: {

100107 if (mainApp) {

101108 _onMainAppChanged(mainApp.appId);

@@ -186,6 +193,7 @@ StyledItem {

186193 if (ApplicationManager.findApplication(appId)) {

187194 ApplicationManager.requestFocusApplication(appId);

188195 } else {

196+ print("calling startApplication. active workspace is", WorkspaceManager.activeWorkspace)

189197 ApplicationManager.startApplication(appId);

190198 }

191199 }

@@ -260,23 +268,17 @@ StyledItem {

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

261269 }

262270

271+ PanelState {

272+ id: panelState

273+ objectName: "panelState"

274+ }

275+

263276 Item {

264277 id: stages

265278 objectName: "stages"

266279 width: parent.width

267280 height: parent.height

268281

269− SurfaceManager {

270− id: surfaceMan

271− objectName: "surfaceManager"

272− }

273− TopLevelWindowModel {

274− id: topLevelSurfaceList

275− objectName: "topLevelSurfaceList"

276− applicationManager: ApplicationManager // it's a singleton

277− surfaceManager: surfaceMan

278− }

279−

280282 Stage {

281283 id: stage

282284 objectName: "stage"

@@ -287,7 +289,7 @@ StyledItem {

287289 background: wallpaperResolver.background

288290

289291 applicationManager: ApplicationManager

290− topLevelSurfaceList: topLevelSurfaceList

292+ topLevelSurfaceList: shell.topLevelSurfaceList

291293 inputMethodRect: inputMethod.visibleRect

292294 rightEdgePushProgress: rightEdgeBarrier.progress

293295

@@ -316,6 +318,7 @@ StyledItem {

316318 altTabPressed: physicalKeysMapper.altTabPressed

317319 oskEnabled: shell.oskEnabled

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

321+ panelState: panelState

319322

320323 onSpreadShownChanged: {

321324 panel.indicators.hide();

@@ -356,7 +359,7 @@ StyledItem {

356359 InputMethod {

357360 id: inputMethod

358361 objectName: "inputMethod"

359− surface: topLevelSurfaceList.inputMethodSurface

362+ surface: shell.topLevelSurfaceList.inputMethodSurface

360363 anchors {

361364 fill: parent

362365 topMargin: panel.panelHeight

@@ -370,8 +373,13 @@ StyledItem {

370373 objectName: "greeterLoader"

371374 anchors.fill: parent

372375 anchors.topMargin: panel.panelHeight

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

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

376+ sourceComponent: {

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

378+ if (screenWindow.primary) return integratedGreeter;

379+ return secondaryGreeter;

380+ }

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

382+ }

375383 onLoaded: {

376384 item.objectName = "greeter"

377385 }

@@ -421,6 +429,13 @@ StyledItem {

421429 }

422430 }

423431

432+ Component {

433+ id: secondaryGreeter

434+ SecondaryGreeter {

435+ hides: [launcher, panel.indicators]

436+ }

437+ }

438+

424439 Timer {

425440 // See powerConnection for why this is useful

426441 id: showGreeterDelayed

@@ -528,13 +543,14 @@ StyledItem {

528543 && !stage.spreadShown

529544 }

530545

531− readonly property bool focusedSurfaceIsFullscreen: topLevelSurfaceList.focusedWindow

532− ? topLevelSurfaceList.focusedWindow.state === Mir.FullscreenState

546+ readonly property bool focusedSurfaceIsFullscreen: shell.topLevelSurfaceList.focusedWindow

547+ ? shell.topLevelSurfaceList.focusedWindow.state === Mir.FullscreenState

533548 : false

534549 fullscreenMode: (focusedSurfaceIsFullscreen && !LightDMService.greeter.active && launcher.progress == 0 && !stage.spreadShown)

535550 || greeter.hasLockedApp

536551 greeterShown: greeter && greeter.shown

537552 hasKeyboard: shell.hasKeyboard

553+ panelState: panelState

538554 }

539555

540556 Launcher {

@@ -774,12 +790,13 @@ StyledItem {

774790

775791 Cursor {

776792 id: cursor

777− objectName: "cursor"

778− visible: shell.hasMouse

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

794+

779795 z: itemGrabber.z + 1

796+ opacity: 0

780797 topBoundaryOffset: panel.panelHeight

781−

782− confiningItem: stage.itemConfiningMouseCursor

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

799+ visible: enabled

783800

784801 property bool mouseNeverMoved: true

785802 Binding {

@@ -791,6 +808,8 @@ StyledItem {

791808 when: cursor.mouseNeverMoved && cursor.visible

792809 }

793810

811+ confiningItem: stage.itemConfiningMouseCursor

812+

794813 height: units.gu(3)

795814

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

@@ -854,7 +873,7 @@ StyledItem {

854873

855874 // non-visual objects

856875 KeymapSwitcher {

857− focusedSurface: topLevelSurfaceList.focusedWindow ? topLevelSurfaceList.focusedWindow.surface : null

876+ focusedSurface: shell.topLevelSurfaceList.focusedWindow ? shell.topLevelSurfaceList.focusedWindow.surface : null

858877 }

859878 BrightnessControl {}

860879

@@ -877,4 +896,20 @@ StyledItem {

877896 }

878897 }

879898 }

899+

900+ Loader {

901+ z: shutdownFadeOutRectangle.z + 1

902+ active: DebuggingController.logOverlay

903+

904+ sourceComponent: Text {

905+ width: shell.width

906+ height: shell.height

907+

908+ text: consoleLog.out

909+ Debug.ConsoleLog {

910+ id: consoleLog

911+ enabled: true

912+ }

913+ }

914+ }

880915}

qml/ShellApplication.qmlnew file+60

@@ -0,0 +1,60 @@

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 WindowManager 1.0

20+import Unity.Application 0.1

21+

22+Instantiator {

23+ id: root

24+ model: Screens

25+

26+ ShellScreen {

27+ id: window

28+ objectName: "screen"+index

29+ screen: model.screen

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

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

32+

33+ Binding {

34+ when: applicationArguments.hasGeometry

35+ target: window

36+ property: "width"

37+ value: applicationArguments.windowGeometry.width

38+ }

39+ Binding {

40+ when: applicationArguments.hasGeometry

41+ target: window

42+ property: "height"

43+ value: applicationArguments.windowGeometry.height

44+ }

45+

46+ Component.onCompleted: screen.active = primary

47+ primary: index == 0

48+ }

49+

50+ property var windowManagerSurfaceManagerBinding: Binding {

51+ target: WindowManagerObjects

52+ property: "surfaceManager"

53+ value: SurfaceManager

54+ }

55+ property var windowManagerApplicationManagerBinding: Binding {

56+ target: WindowManagerObjects

57+ property: "applicationManager"

58+ value: ApplicationManager

59+ }

60+}

qml/ShellNotifier.qmlnew file+30

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

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

18+ Shared signals & properties on multi-window desktop

19+ */

20+

21+pragma Singleton

22+import QtQuick 2.4

23+

24+QtObject {

25+ property var greeter: QtObject {

26+ signal hide(bool now)

27+

28+ property bool shown: true

29+ }

30+}

qml/ShellScreen.qmlnew file+64

@@ -0,0 +1,64 @@

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 WindowManager 1.0

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+

30+ DeviceConfiguration {

31+ id: deviceConfiguration

32+ name: applicationArguments.deviceName

33+ }

34+

35+ Loader {

36+ id: 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+

54+ deviceConfiguration {

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

56+ }

57+ }

58+ }

59+

60+ Component {

61+ id: disabledScreenComponent

62+ DisabledScreenNotice {}

63+ }

64+}

qml/Stage/ApplicationWindow.qml+9−207

@@ -50,37 +50,23 @@ FocusScope {

5050 // transitions in stateGroup take place.

5151 // More specifically, the moment surfaceContainer.surface gets updated relative to the

5252 // other instructions.

53+ print("AAA surface changed,", surface)

5354 if (surface) {

5455 surfaceContainer.surface = surface;

55− d.liveSurface = surface.live;

56− d.hadSurface = false;

56+ d.hadSurface = true;

5757 surfaceInitTimer.start();

5858 } else {

59− if (d.surfaceInitialized) {

60− d.hadSurface = true;

61− }

6259 d.surfaceInitialized = false;

6360 surfaceContainer.surface = null;

6461 }

6562 }

6663

64+ Component.onCompleted: print("AAA completed")

6765 QtObject {

6866 id: d

6967

70− property bool liveSurface: false;

71− property var con: Connections {

72− target: root.surface

73− onLiveChanged: d.liveSurface = root.surface.live

74− }

75− // using liveSurface instead of root.surface.live because with the latter

76− // this expression is not reevaluated when root.surface changes

77− readonly property bool needToTakeScreenshot: root.surface && d.surfaceInitialized && !d.liveSurface

78− && applicationState !== ApplicationInfoInterface.Running

79− onNeedToTakeScreenshotChanged: {

80− if (needToTakeScreenshot && screenshotImage.status === Image.Null) {

81− screenshotImage.take();

82− }

83− }

68+ onHadSurfaceChanged: print("AAA had surface changed,", hadSurface)

69+ onSurfaceInitializedChanged: print("AAA surface initialized changed", surfaceInitialized)

8470

8571 // helpers so that we don't have to check for the existence of an application everywhere

8672 // (in order to avoid breaking qml binding due to a javascript exception)

@@ -135,39 +121,12 @@ FocusScope {

135121 }

136122 }

137123

138− Timer {

139− id: surfaceIsOldTimer

140− interval: 1000

141− onTriggered: { if (stateGroup.state === "surface") { d.surfaceOldEnoughToBeResized = true; } }

142− }

143−

144− Image {

145− id: screenshotImage

146− objectName: "screenshotImage"

147− anchors.fill: parent

148− fillMode: Image.PreserveAspectCrop

149− horizontalAlignment: Image.AlignLeft

150− verticalAlignment: Image.AlignTop

151− antialiasing: !root.interactive

152− z: 1

153−

154− function take() {

155− // Save memory by using a half-resolution (thus quarter size) screenshot.

156− // Do not make this a binding, we can only take the screenshot once!

157− surfaceContainer.grabToImage(

158− function(result) {

159− screenshotImage.source = result.url;

160− },

161− Qt.size(root.width / 2, root.height / 2));

162− }

163− }

164−

165124 Loader {

166125 id: splashLoader

167126 visible: active

168127 active: false

169128 anchors.fill: parent

170− z: screenshotImage.z + 1

129+ z: 1

171130 sourceComponent: Component {

172131 Splash {

173132 id: splash

@@ -239,166 +198,9 @@ FocusScope {

239198 objectName: "applicationWindowStateGroup"

240199 states: [

241200 State {

242− name: "void"

243− when:

244− d.hadSurface && (!root.surface || !d.surfaceInitialized)

245− &&

246− screenshotImage.status !== Image.Ready

247− },

248− State {

249− name: "splashScreen"

250− when:

251− !d.hadSurface && (!root.surface || !d.surfaceInitialized)

252− &&

253− screenshotImage.status !== Image.Ready

254− },

255− State {

256− name: "surface"

257− when:

258− (root.surface && d.surfaceInitialized)

259− &&

260− (d.liveSurface ||

261− (d.applicationState !== ApplicationInfoInterface.Running

262− && screenshotImage.status !== Image.Ready))

263− PropertyChanges {

264− target: root

265− implicitWidth: surfaceContainer.implicitWidth

266− implicitHeight: surfaceContainer.implicitHeight

267− }

268− },

269− State {

270− name: "screenshot"

271− when:

272− screenshotImage.status === Image.Ready

273− &&

274− (d.applicationState !== ApplicationInfoInterface.Running

275− || !root.surface || !d.surfaceInitialized)

276− },

277− State {

278− // This is a dead end. From here we expect the surface to be removed from the model

279− // shortly after we stop referencing to it in our SurfaceContainer.

280− name: "closed"

281− when:

282− // The surface died while the application is running. It must have been closed

283− // by the shell or the application decided to destroy it by itself

284− root.surface && d.surfaceInitialized && !d.liveSurface

285− && d.applicationState === ApplicationInfoInterface.Running

286− }

287− ]

288−

289− transitions: [

290− Transition {

291− from: ""; to: "splashScreen"

292− PropertyAction { target: splashLoader; property: "active"; value: true }

293− PropertyAction { target: surfaceContainer

294− property: "visible"; value: false }

295− },

296− Transition {

297− from: "splashScreen"; to: "surface"

298− SequentialAnimation {

299− PropertyAction { target: surfaceContainer

300− property: "opacity"; value: 0.0 }

301− PropertyAction { target: surfaceContainer

302− property: "visible"; value: true }

303− UbuntuNumberAnimation { target: surfaceContainer; property: "opacity";

304− from: 0.0; to: 1.0

305− duration: UbuntuAnimation.BriskDuration }

306− ScriptAction { script: {

307− splashLoader.active = false;

308− surfaceIsOldTimer.start();

309− } }

310− }

311− },

312− Transition {

313− from: "surface"; to: "splashScreen"

314− SequentialAnimation {

315− ScriptAction { script: {

316− surfaceIsOldTimer.stop();

317− d.surfaceOldEnoughToBeResized = false;

318− splashLoader.active = true;

319− surfaceContainer.visible = true;

320− } }

321− UbuntuNumberAnimation { target: splashLoader; property: "opacity";

322− from: 0.0; to: 1.0

323− duration: UbuntuAnimation.BriskDuration }

324− PropertyAction { target: surfaceContainer

325− property: "visible"; value: false }

326− }

327− },

328− Transition {

329− from: "surface"; to: "screenshot"

330− SequentialAnimation {

331− ScriptAction { script: {

332− surfaceIsOldTimer.stop();

333− d.surfaceOldEnoughToBeResized = false;

334− screenshotImage.visible = true;

335− } }

336− UbuntuNumberAnimation { target: screenshotImage; property: "opacity";

337− from: 0.0; to: 1.0

338− duration: UbuntuAnimation.BriskDuration }

339− ScriptAction { script: {

340− surfaceContainer.visible = false;

341− surfaceContainer.surface = null;

342− d.hadSurface = true;

343− } }

344− }

345− },

346− Transition {

347− from: "screenshot"; to: "surface"

348− SequentialAnimation {

349− PropertyAction { target: surfaceContainer

350− property: "visible"; value: true }

351− UbuntuNumberAnimation { target: screenshotImage; property: "opacity";

352− from: 1.0; to: 0.0

353− duration: UbuntuAnimation.BriskDuration }

354− ScriptAction { script: {

355− screenshotImage.visible = false;

356− screenshotImage.source = "";

357− surfaceIsOldTimer.start();

358− } }

359− }

360− },

361− Transition {

362− from: "splashScreen"; to: "screenshot"

363− SequentialAnimation {

364− PropertyAction { target: screenshotImage

365− property: "visible"; value: true }

366− UbuntuNumberAnimation { target: screenshotImage; property: "opacity";

367− from: 0.0; to: 1.0

368− duration: UbuntuAnimation.BriskDuration }

369− PropertyAction { target: splashLoader; property: "active"; value: false }

370− }

371− },

372− Transition {

373− from: "surface"; to: "void"

374− ScriptAction { script: {

375− surfaceIsOldTimer.stop();

376− d.surfaceOldEnoughToBeResized = false;

377− surfaceContainer.visible = false;

378− } }

379− },

380− Transition {

381− from: "void"; to: "surface"

382− SequentialAnimation {

383− PropertyAction { target: surfaceContainer; property: "opacity"; value: 0.0 }

384− PropertyAction { target: surfaceContainer; property: "visible"; value: true }

385− UbuntuNumberAnimation { target: surfaceContainer; property: "opacity";

386− from: 0.0; to: 1.0

387− duration: UbuntuAnimation.BriskDuration }

388− ScriptAction { script: {

389− surfaceIsOldTimer.start();

390− } }

391− }

392− },

393− Transition {

394− to: "closed"

395− SequentialAnimation {

396− ScriptAction { script: {

397− surfaceContainer.visible = false;

398− surfaceContainer.surface = null;

399− d.hadSurface = true;

400− } }

401− }

201+ name: "splash"

202+ when: !root.surface && !d.surfaceInitialized && !d.hadSurface

203+ PropertyChanges { target: splashLoader; active: true }

402204 }

403205 ]

404206 }

qml/Stage/DecoratedWindow.qml+13−11

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

7272

7373 readonly property Item clientAreaItem: applicationWindow

7474

75+ property PanelState panelState

76+

7577 signal closeClicked()

7678 signal maximizeClicked()

7779 signal maximizeHorizontallyClicked()

@@ -116,15 +118,15 @@ FocusScope {

116118 name: "preview"; when: root.scaleToPreviewProgress > 0

117119 PropertyChanges {

118120 target: root

119− implicitWidth: MathUtils.linearAnimation(0, 1, applicationWindow.oldRequestedWidth, root.scaleToPreviewSize, root.scaleToPreviewProgress)

120− implicitHeight: MathUtils.linearAnimation(0, 1, applicationWindow.oldRequestedHeight, root.scaleToPreviewSize, root.scaleToPreviewProgress)

121+ implicitWidth: MathUtils.linearAnimation(0, 1, applicationWindow.requestedWidth, root.scaleToPreviewSize, root.scaleToPreviewProgress)

122+ implicitHeight: MathUtils.linearAnimation(0, 1, applicationWindow.requestedHeight, root.scaleToPreviewSize, root.scaleToPreviewProgress)

121123 }

122124 PropertyChanges {

123125 target: applicationWindow;

124− requestedWidth: applicationWindow.oldRequestedWidth

125− requestedHeight: applicationWindow.oldRequestedHeight

126− width: MathUtils.linearAnimation(0, 1, applicationWindow.oldRequestedWidth, applicationWindow.minSize, root.scaleToPreviewProgress)

127− height: MathUtils.linearAnimation(0, 1, applicationWindow.oldRequestedHeight, applicationWindow.minSize, root.scaleToPreviewProgress)

126+// requestedWidth: applicationWindow.oldRequestedWidth

127+// requestedHeight: applicationWindow.oldRequestedHeight

128+ width: MathUtils.linearAnimation(0, 1, applicationWindow.requestedWidth, applicationWindow.minSize, root.scaleToPreviewProgress)

129+ height: MathUtils.linearAnimation(0, 1, applicationWindow.requestedHeight, applicationWindow.minSize, root.scaleToPreviewProgress)

128130 itemScale: root.implicitWidth / width

129131 }

130132 }

@@ -163,10 +165,10 @@ FocusScope {

163165 height: implicitHeight

164166 requestedHeight: !counterRotate ? root.requestedHeight - d.requestedDecorationHeight : root.requestedWidth

165167 requestedWidth: !counterRotate ? root.requestedWidth : root.requestedHeight - d.requestedDecorationHeight

166− property int oldRequestedWidth: requestedWidth

167− property int oldRequestedHeight: requestedHeight

168− onRequestedWidthChanged: oldRequestedWidth = requestedWidth

169− onRequestedHeightChanged: oldRequestedHeight = requestedHeight

168+// property int oldRequestedWidth: requestedWidth

169+// property int oldRequestedHeight: requestedHeight

170+// onRequestedWidthChanged: oldRequestedWidth = requestedWidth

171+// onRequestedHeightChanged: oldRequestedHeight = requestedHeight

170172 focus: true

171173

172174 property real itemScale: 1

@@ -231,7 +233,7 @@ FocusScope {

231233 enableMenus: {

232234 return active &&

233235 surface &&

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

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

235237 }

236238 menu: sharedAppModel.model

237239

qml/Stage/FakeMaximizeDelegate.qml+12−11

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

3535 property int leftMargin

3636 property real appContainerWidth

3737 property real appContainerHeight

38+ property PanelState panelState

3839

3940 readonly property real hintThreshold: 0.1

4041

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

178179 ParallelAnimation {

179180 id: fakeMaximizeAnimation

180181 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 }

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

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

184185 }

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

186187 ParallelAnimation {

187188 id: fakeMaximizeLeftAnimation

188189 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 }

190191 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 }

192193 }

193194

194195 ParallelAnimation {

195196 id: fakeMaximizeRightAnimation

196197 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 }

198199 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 }

200201 }

201202

202203 ParallelAnimation {

203204 id: fakeMaximizeTopLeftAnimation

204205 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 }

206207 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 }

208209 }

209210

210211 ParallelAnimation {

211212 id: fakeMaximizeTopRightAnimation

212213 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 }

214215 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 }

216217 }

217218

218219 ParallelAnimation {

219220 id: fakeMaximizeBottomLeftAnimation

220221 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 }

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

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

224225 }

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

226227 ParallelAnimation {

227228 id: fakeMaximizeBottomRightAnimation

228229 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 }

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

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

232233 }

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

@@ -0,0 +1,211 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Ubuntu.Components.Popups 1.3

4+import WindowManager 1.0

5+import Unity.Application 0.1

6+import ".."

7+

8+Item {

9+ id: root

10+

11+ property string background

12+

13+ property var screensProxy: Screens.createProxy();

14+

15+ signal closeSpread();

16+

17+ Row {

18+ id: row

19+ anchors.bottom: parent.bottom

20+ anchors.horizontalCenter: parent.horizontalCenter

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

22+// anchors.left: parent.left

23+ spacing: units.gu(1)

24+

25+ Repeater {

26+ model: screensProxy

27+

28+ delegate: Item {

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

30+ width: workspaces.width

31+

32+ UbuntuShape {

33+ id: header

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

35+ height: units.gu(7)

36+ backgroundColor: "white"

37+ z: 1

38+

39+ DropArea {

40+ anchors.fill: parent

41+ keys: ["workspace"]

42+

43+ onEntered: {

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

45+ drag.source.inDropArea = true;

46+ }

47+

48+ onExited: {

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

50+ drag.source.inDropArea = false;

51+ }

52+

53+ onDropped: {

54+ drag.source.inDropArea = false;

55+ }

56+ }

57+

58+ Column {

59+ anchors.fill: parent

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

61+

62+ Label {

63+ text: model.screen.name

64+ color: "black"

65+ }

66+

67+ Label {

68+ text: model.screen.outputTypeName

69+ color: "black"

70+ fontSize: "x-small"

71+ }

72+

73+ Label {

74+ text: screen.availableModes[screen.currentModeIndex].size.width + "x" + screen.availableModes[screen.currentModeIndex].size.height

75+ color: "black"

76+ fontSize: "x-small"

77+ }

78+ }

79+

80+ MouseArea {

81+ anchors.fill: parent

82+

83+ onClicked: {

84+ var obj = screensMenuComponent.createObject(header)

85+ obj.open(mouseX, mouseY)

86+ }

87+ }

88+

89+ Component {

90+ id: screensMenuComponent

91+ UbuntuShape {

92+ id: screensMenu

93+ width: units.gu(20)

94+ height: contentColumn.childrenRect.height

95+ backgroundColor: "white"

96+

97+ function open(mouseX, mouseY) {

98+ x = Math.max(0, Math.min(mouseX - width / 2, parent.width - width))

99+ y = mouseY + units.gu(1)

100+ }

101+

102+ InverseMouseArea {

103+ anchors.fill: parent

104+ onClicked: {

105+ screensMenu.destroy()

106+ }

107+ }

108+

109+ Column {

110+ id: contentColumn

111+ width: parent.width

112+ ListItem {

113+ height: layout.height

114+ highlightColor: "transparent"

115+ ListItemLayout {

116+ id: layout

117+ title.text: qsTr("Add workspace")

118+ title.color: "black"

119+ }

120+ onClicked: {

121+ screen.addWorkspace();

122+ Screens.sync(root.screensProxy);

123+ screensMenu.destroy();

124+ }

125+ }

126+ }

127+ }

128+ }

129+ }

130+

131+ Workspaces {

132+ id: workspaces

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

134+ width: {

135+ var width = 0;

136+ if (screensProxy.count == 1) {

137+ width = Math.min(implicitWidth, root.width - units.gu(8));

138+ } else {

139+ width = Math.min(implicitWidth, model.screen.active ? root.width - units.gu(48) : units.gu(40))

140+ }

141+ return Math.max(workspaces.minimumWidth, width);

142+ }

143+

144+ Behavior on width { UbuntuNumberAnimation {} }

145+ anchors.bottom: parent.bottom

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

147+ anchors.horizontalCenter: parent.horizontalCenter

148+ screen: model.screen

149+ background: root.background

150+

151+ workspaceModel: model.screen.workspaces

152+

153+ onCommitScreenSetup: Screens.sync(root.screensProxy)

154+ onCloseSpread: root.closeSpread();

155+ }

156+ }

157+ }

158+ }

159+

160+ Rectangle {

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

162+ width: units.gu(5)

163+ color: "#33000000"

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

165+ MouseArea {

166+ id: leftScrollArea

167+ anchors.fill: parent

168+ hoverEnabled: true

169+ onPressed: mouse.accepted = false;

170+ }

171+ DropArea {

172+ id: leftFakeDropArea

173+ anchors.fill: parent

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

175+ }

176+ }

177+ Rectangle {

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

179+ width: units.gu(5)

180+ color: "#33000000"

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

182+ MouseArea {

183+ id: rightScrollArea

184+ anchors.fill: parent

185+ hoverEnabled: true

186+ onPressed: mouse.accepted = false;

187+ }

188+ DropArea {

189+ id: rightFakeDropArea

190+ anchors.fill: parent

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

192+ }

193+ }

194+ Timer {

195+ repeat: true

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

197+ interval: UbuntuAnimation.SlowDuration

198+ triggeredOnStart: true

199+ onTriggered: {

200+ var newOffset = row.anchors.horizontalCenterOffset;

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

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

203+ newOffset += units.gu(20)

204+ } else {

205+ newOffset -= units.gu(20)

206+ }

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

208+ row.anchors.horizontalCenterOffset = newOffset;

209+ }

210+ }

211+}

qml/Stage/Spread/Spread.qml+7−8

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

2828 property var spreadFlickable

2929

3030 // some config options

31− property real contentMargin: 0.16 * root.height

32− property real contentTopMargin: contentMargin

33− property real contentBottomMargin: 0.35 * contentMargin

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

31+ property real contentMargin: 0.1 * root.height

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

33+ property real contentBottomMargin: contentMargin

34+ property real windowTitleTopMargin: contentMargin - windowTitle.height

3535 property int stackItemCount: 3

3636 property real leftRotationAngle: 22

3737 property real rightRotationAngle: 32

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

5151

5252 readonly property real spreadWidth: rightStackXPos - leftStackXPos

5353 readonly property real spreadHeight: root.height

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

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

5555 readonly property real spreadItemWidth: stackHeight

5656

5757 readonly property real dynamicLeftRotationAngle: leftRotationAngle * rotationAngleFactor

@@ -91,10 +91,9 @@ Item {

9191

9292 readonly property real visibleItemCount: (spreadWidth / spreadItemWidth) / (1 - itemOverlap)

9393

94− readonly property real spreadTotalWidth: Math.max(2,totalItemCount) * spreadWidth / visibleItemCount

95−

96− readonly property real centeringOffset: Math.max(spreadWidth - spreadTotalWidth ,0) / (2 * spreadWidth)

94+ readonly property real spreadTotalWidth: totalItemCount * spreadWidth / visibleItemCount

9795

96+ readonly property real centeringOffset: Math.max(spreadWidth - spreadTotalWidth + (leftStackXPos - leftMargin) * 2, 0) / (2 * spreadWidth)

9897

9998 readonly property var curve: BezierCurve {

10099 controlPoint2: {'x': 0.19, 'y': 0.00}

qml/Stage/Spread/SpreadDelegateInputArea.qml+33−17

@@ -84,33 +84,27 @@ Item {

8484 }

8585 }

8686

87− // Event eater

88− MouseArea {

89− anchors.fill: parent

90− onClicked: root.clicked()

91− onWheel: wheel.accepted = true

92− }

93−

9487 MultiPointTouchArea {

9588 anchors.fill: parent

96− mouseEnabled: false

9789 maximumTouchPoints: 1

9890 property int offset: 0

9991

92+ // tp.startY seems to be broken for mouse interaction... lets track it ourselves

93+ property int startY: 0

94+

10095 touchPoints: [

10196 TouchPoint {

10297 id: tp

10398 }

10499 ]

105100

106− onCanceled: {

107− d.moving = false

108− animation.animate("center");

101+ onPressed: {

102+ startY = tp.y

109103 }

110104

111105 onTouchUpdated: {

112− if (!d.moving) {

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

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

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

114108 d.moving = true;

115109 d.dragEvents = []

116110 offset = tp.y - tp.startY;

@@ -119,17 +113,32 @@ Item {

119113 }

120114 }

121115

122− if (root.closeable) {

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

116+

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

118+ if (value < 0) {

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

120+ fakeDragItem.Drag.hotSpot.x = fakeDragItem.width / 2

121+ fakeDragItem.Drag.hotSpot.y = units.gu(2)

122+ fakeDragItem.x = coords.x - fakeDragItem.Drag.hotSpot.x

123+ fakeDragItem.y = coords.y - fakeDragItem.Drag.hotSpot.y

124+ fakeDragItem.Drag.active = true;

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

126+

124127 } else {

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

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

128+ if (root.closeable) {

129+ d.distance = value

130+ } else {

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

132+ }

127133 }

128134

129135 d.pushDragEvent(tp);

130136 }

131137

132138 onReleased: {

139+ var result = fakeDragItem.Drag.drop();

140+ fakeDragItem.surface = null;

141+

133142 if (!d.moving) {

134143 root.clicked()

135144 }

@@ -149,6 +158,13 @@ Item {

149158 animation.animate("center")

150159 }

151160 }

161+

162+ onCanceled: {

163+ fakeDragItem.Drag.active = false;

164+ fakeDragItem.surface = null;

165+ d.moving = false

166+ animation.animate("center");

167+ }

152168 }

153169

154170 UbuntuNumberAnimation {

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

@@ -0,0 +1,266 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Unity.Application 0.1

4+import WindowManager 1.0

5+import ".."

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

7+

8+Item {

9+ id: previewSpace

10+ clip: true

11+

12+ property var workspace

13+

14+ property string background

15+ property int screenHeight

16+

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

18+

19+ property bool containsDragLeft: false

20+ property bool containsDragRight: false

21+ property bool isActive: false

22+

23+ Image {

24+ source: previewSpace.background

25+ anchors.fill: parent

26+ sourceSize.width: width

27+ sourceSize.height: height

28+

29+ Repeater {

30+ id: topLevelSurfaceRepeater

31+ model: visible ? workspace.windowModel : null

32+ delegate: Rectangle {

33+ width: surfaceItem.width

34+ height: surfaceItem.height + decorationHeight * previewScale

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

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

37+ color: "blue"

38+ z: topLevelSurfaceRepeater.count - index

39+

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

41+

42+ WindowDecoration {

43+ width: surfaceItem.implicitWidth

44+ height: parent.decorationHeight

45+ transform: Scale {

46+ origin.x: 0

47+ origin.y: 0

48+ xScale: previewScale

49+ yScale: previewScale

50+ }

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

52+ z: 3

53+ }

54+

55+ MirSurfaceItem {

56+ id: surfaceItem

57+ y: parent.decorationHeight * previewScale

58+ width: implicitWidth * previewScale

59+ height: implicitHeight * previewScale

60+ surfaceWidth: -1

61+ surfaceHeight: -1

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

63+ surface: model.window.surface

64+ }

65+ }

66+ }

67+

68+ }

69+

70+ Rectangle {

71+ anchors.fill: parent

72+ border.color: UbuntuColors.ash

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

74+ color: "transparent"

75+ visible: previewSpace.isActive

76+ }

77+

78+ Rectangle {

79+ anchors.fill: parent

80+ anchors.rightMargin: parent.width / 2

81+ color: "#55000000"

82+ visible: previewSpace.containsDragLeft

83+

84+ Column {

85+ anchors.centerIn: parent

86+ spacing: units.gu(1)

87+ Icon {

88+ source: "../graphics/multi-monitor_drop-here.png"

89+ height: units.gu(4)

90+ width: height

91+ anchors.horizontalCenter: parent.horizontalCenter

92+ }

93+ Label {

94+ text: qsTr("Drop here")

95+ }

96+ }

97+ }

98+

99+ Rectangle {

100+ anchors.fill: parent

101+ anchors.leftMargin: parent.width / 2

102+ color: "#55000000"

103+ visible: previewSpace.containsDragRight

104+

105+ Column {

106+ anchors.centerIn: parent

107+ spacing: units.gu(1)

108+ Icon {

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

110+ height: units.gu(4)

111+ width: height

112+ anchors.horizontalCenter: parent.horizontalCenter

113+ }

114+ Label {

115+ text: qsTr("Drop and go")

116+ }

117+ }

118+ }

119+}

120+

121+ // Repeater {

122+ // id: topLevelSurfaceRepeater

123+ // model: visible ? topLevelSurfaceList : null

124+ // delegate: Rectangle {

125+ // width: surfaceItem.width

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

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

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

129+ // color: "blue"

130+ // z: topLevelSurfaceRepeater.count - index

131+

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

133+

134+ // WindowDecoration {

135+ // width: surfaceItem.implicitWidth

136+ // height: parent.decorationHeight

137+ // transform: Scale {

138+ // origin.x: 0

139+ // origin.y: 0

140+ // xScale: previewScale

141+ // yScale: previewScale

142+ // }

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

144+ // z: 3

145+ // }

146+

147+ // MirSurfaceItem {

148+ // id: surfaceItem

149+ // y: parent.decorationHeight * previewScale

150+ // width: implicitWidth * previewScale

151+ // height: implicitHeight * previewScale

152+ // surfaceWidth: -1

153+ // surfaceHeight: -1

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

155+ // surface: model.window.surface

156+ // }

157+ // }

158+ // }

159+// }

160+// }

161+

162+

163+// MouseArea {

164+// id: mouseArea

165+// anchors.centerIn: parent

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

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

168+// height: width

169+// hoverEnabled: true

170+// opacity: containsMouse ? 1 : 0

171+

172+// Rectangle {

173+// anchors.fill: parent

174+// color: "#80000000"

175+// radius: height / 2

176+// }

177+

178+// NumberAnimation {

179+// target: canvas

180+// property: "progress"

181+// duration: 2000

182+// running: mouseArea.containsMouse

183+// from: 0

184+// to: 1

185+// }

186+

187+// Canvas {

188+// id: canvas

189+// height: parent.height

190+// width: height

191+// anchors.centerIn: parent

192+

193+// property real progress: 0.5

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

195+// onProgressChanged: {

196+// requestPaint();

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

198+// Screens.activateScreen(index);

199+// }

200+// }

201+

202+// rotation: -90

203+

204+// onPaint: {

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

206+// ctx.save();

207+// ctx.reset();

208+

209+// ctx.lineWidth = lineWidth;

210+

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

212+// ctx.beginPath();

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

214+// ctx.stroke();

215+// ctx.closePath();

216+

217+// ctx.strokeStyle = "white"

218+// ctx.beginPath();

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

220+// ctx.stroke();

221+// ctx.closePath();

222+

223+// ctx.restore();

224+// }

225+// }

226+

227+// Icon {

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

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

230+// width: height

231+// anchors.centerIn: parent

232+// }

233+// }

234+// }

235+

236+// FloatingFlickable {

237+// id: flickable

238+// anchors.fill: parent

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

240+// property real progress: contentX / contentWidth

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

242+// }

243+

244+// MouseArea {

245+// anchors.fill: parent

246+// hoverEnabled: true

247+// property int scrollAreaWidth: width / 3

248+

249+// onMouseXChanged: {

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

251+

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

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

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

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

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

257+// }

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

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

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

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

262+// }

263+// }

264+// }

265+// }

266+//}

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

@@ -0,0 +1,412 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import WindowManager 1.0

4+import "MathUtils.js" as MathUtils

5+import "../../Components"

6+

7+Item {

8+ id: root

9+ implicitWidth: listView.contentWidth

10+ readonly property int minimumWidth: {

11+ var count = Math.min(3, listView.count);

12+ return listView.itemWidth * count + listView.spacing * (count - 1)

13+ }

14+

15+ property QtObject screen: null

16+ property alias workspaceModel: listView.model

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

18+

19+ signal commitScreenSetup();

20+ signal closeSpread();

21+

22+ DropArea {

23+ anchors.fill: root

24+

25+ keys: ['workspace']

26+

27+ onEntered: {

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

29+ drag.source.workspace.assign(workspaceModel, index)

30+ drag.source.inDropArea = true;

31+ }

32+

33+ onPositionChanged: {

34+ var index = listView.getDropIndex(drag);

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

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

37+ listView.dropItemIndex = index;

38+ }

39+

40+ onExited: {

41+ drag.source.workspace.unassign()

42+ listView.dropItemIndex = -1;

43+ listView.hoveredWorkspaceIndex = -1;

44+ drag.source.inDropArea = false;

45+ }

46+

47+ onDropped: {

48+ drop.accept(Qt.MoveAction);

49+ listView.dropItemIndex = -1;

50+ drag.source.inDropArea = false;

51+ }

52+ }

53+ DropArea {

54+ anchors.fill: parent

55+ keys: ["application"]

56+

57+ onPositionChanged: {

58+ listView.progressiveScroll(drag.x)

59+ listView.updateDropProperties(drag)

60+ }

61+ onExited: {

62+ listView.hoveredWorkspaceIndex = -1

63+ }

64+ onDropped: {

65+ var surface = drag.source.surface;

66+ drag.source.surface = null;

67+ var workspace = listView.model.get(listView.hoveredWorkspaceIndex);

68+ WorkspaceManager.moveSurfaceToWorkspace(surface, workspace);

69+ drop.accept(Qt.MoveAction)

70+ if (listView.hoveredHalf == "right") {

71+ workspace.activate();

72+ root.closeSpread();

73+ }

74+ listView.hoveredWorkspaceIndex = -1

75+ }

76+ }

77+

78+ Item {

79+ // We need to clip the listview as it has left/right margins and it would

80+ // overlap with items next to it and eat mouse input. However, we can't

81+ // just clip at the actual bounds as the delegates have the close button

82+ // on hover which reaches a bit outside, so lets some margins for the clipping

83+ anchors.fill: parent

84+ anchors.margins: -units.gu(2)

85+ clip: true

86+

87+ ListView {

88+ id: listView

89+ anchors {

90+ fill: parent

91+ topMargin: -parent.anchors.margins

92+ bottomMargin: -parent.anchors.margins

93+ leftMargin: -itemWidth - parent.anchors.margins

94+ rightMargin: -itemWidth - parent.anchors.margins

95+ }

96+ boundsBehavior: Flickable.StopAtBounds

97+

98+ Behavior on contentX {

99+ SmoothedAnimation { duration: 200 }

100+ }

101+

102+ orientation: ListView.Horizontal

103+ spacing: units.gu(1)

104+ leftMargin: itemWidth

105+ rightMargin: itemWidth

106+

107+ Connections {

108+ target: screen

109+ onAvailableModesChanged: {

110+ print("blabla", screen.availableModes[screen.currentModeIndex].size.width, screen.availableModes[screen.currentModeIndex].size.height)

111+ }

112+ }

113+

114+ property int screenWidth: screen.availableModes[screen.currentModeIndex].size.width

115+ property int screenHeight: screen.availableModes[screen.currentModeIndex].size.height

116+ property int itemWidth: height * screenWidth / screenHeight

117+ property int foldingAreaWidth: itemWidth / 2

118+ property int maxAngle: 40

119+

120+ property real realContentX: contentX - originX + leftMargin

121+ property int dropItemIndex: -1

122+ property int hoveredWorkspaceIndex: -1

123+ property string hoveredHalf: "" // left or right

124+

125+ function getDropIndex(drag) {

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

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

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

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

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

131+ return index;

132+ }

133+

134+ function updateDropProperties(drag) {

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

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

137+ if (index < 0) {

138+ listView.hoveredWorkspaceIndex = -1;

139+ listView.hoveredHalf = "";

140+ return;

141+ }

142+

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

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

145+ listView.hoveredWorkspaceIndex = index;

146+ print("updating drag:", (drag.x + listView.realContentX) % (listView.itemWidth + listView.spacing))

147+ var pixelsInTile = (drag.x + listView.realContentX) % (listView.itemWidth + listView.spacing);

148+ listView.hoveredHalf = (pixelsInTile / listView.itemWidth) < .5 ? "left" : "right";

149+ }

150+

151+ function progressiveScroll(mouseX) {

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

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

154+ }

155+

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

157+

158+ delegate: Item {

159+ id: workspaceDelegate

160+ objectName: "delegate" + index

161+ height: parent.height

162+ width: listView.itemWidth

163+ Behavior on width { UbuntuNumberAnimation {} }

164+ visible: listView.dropItemIndex !== index

165+

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

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

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

169+

170+ property int itemAngle: {

171+ if (index == 0) {

172+ if (distanceFromLeft < 0) {

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

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

175+ }

176+ return 0

177+ }

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

179+ if (distanceFromRight < 0) {

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

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

182+ }

183+ return 0

184+ }

185+

186+ if (distanceFromLeft < listView.foldingAreaWidth) {

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

188+ var progress = distanceFromLeft / listView.foldingAreaWidth

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

190+ }

191+ if (distanceFromRight < listView.foldingAreaWidth) {

192+ var progress = distanceFromRight / listView.foldingAreaWidth

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

194+ }

195+ return 0

196+ }

197+

198+ property int itemOffset: {

199+ if (index == 0) {

200+ if (distanceFromLeft < 0) {

201+ return -distanceFromLeft

202+ }

203+ return 0

204+ }

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

206+ if (distanceFromRight < 0) {

207+ return distanceFromRight

208+ }

209+ return 0

210+ }

211+

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

213+ return -itemX

214+ }

215+ if (distanceFromLeft < listView.foldingAreaWidth) {

216+ return (listView.foldingAreaWidth - distanceFromLeft) / 2

217+ }

218+

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

220+ return distanceFromRight

221+ }

222+

223+ if (distanceFromRight < listView.foldingAreaWidth) {

224+ return -(listView.foldingAreaWidth - distanceFromRight) / 2

225+ }

226+

227+ return 0

228+ }

229+

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

231+

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

233+ transform: [

234+ Rotation {

235+ angle: itemAngle

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

237+ origin { x: itemAngle < 0 ? listView.itemWidth : 0; y: height / 2 }

238+ },

239+ Translate {

240+ x: itemOffset

241+ }

242+ ]

243+

244+ WorkspacePreview {

245+ id: workspacePreview

246+ height: listView.height

247+ width: listView.itemWidth

248+ background: root.background

249+ screenHeight: listView.screenHeight

250+ containsDragLeft: listView.hoveredWorkspaceIndex == index && listView.hoveredHalf == "left"

251+ containsDragRight: listView.hoveredWorkspaceIndex == index && listView.hoveredHalf == "right"

252+ isActive: model.workspace.active

253+ workspace: model.workspace

254+ }

255+ MouseArea {

256+ anchors.fill: parent

257+ onClicked: {

258+ print("clickkkked!")

259+ model.workspace.activate();

260+ }

261+ onDoubleClicked: {

262+ model.workspace.activate();

263+ root.closeSpread();

264+ }

265+ }

266+

267+ MouseArea {

268+ id: closeMouseArea

269+ objectName: "closeMouseArea"

270+ anchors { left: parent.left; top: parent.top; leftMargin: -height / 2; topMargin: -height / 2 }

271+ hoverEnabled: true

272+ height: units.gu(4)

273+ width: height

274+ visible: listView.count > 1

275+

276+ onClicked: {

277+ model.workspace.unassign();

278+ root.commitScreenSetup();

279+ }

280+ Image {

281+ id: closeImage

282+ source: "../graphics/window-close.svg"

283+ anchors.fill: closeMouseArea

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

285+ sourceSize.width: width

286+ sourceSize.height: height

287+ readonly property var mousePos: hoverMouseArea.mapToItem(workspaceDelegate, hoverMouseArea.mouseX, hoverMouseArea.mouseY)

288+ readonly property bool shown: (hoverMouseArea.containsMouse || parent.containsMouse)

289+ && mousePos.y < workspaceDelegate.width / 4

290+ && mousePos.y > -units.gu(2)

291+ && mousePos.x > -units.gu(2)

292+ && mousePos.x < workspaceDelegate.height / 4

293+ opacity: shown ? 1 : 0

294+ visible: opacity > 0

295+ Behavior on opacity { UbuntuNumberAnimation { duration: UbuntuAnimation.SnapDuration } }

296+

297+ }

298+ }

299+ }

300+

301+ MouseArea {

302+ id: hoverMouseArea

303+ anchors.fill: parent

304+ hoverEnabled: true

305+ propagateComposedEvents: true

306+ anchors.leftMargin: listView.leftMargin

307+ anchors.rightMargin: listView.rightMargin

308+

309+ property int draggedIndex: -1

310+

311+ property int startX: 0

312+ property int startY: 0

313+

314+ onMouseXChanged: {

315+ if (!pressed || dragging) {

316+ listView.progressiveScroll(mouseX)

317+ }

318+ }

319+ onMouseYChanged: {

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

321+ drag.axis = Drag.XAndYAxis;

322+ }

323+ }

324+

325+ onReleased: {

326+ var result = fakeDragItem.Drag.drop();

327+ // if (result == Qt.IgnoreAction) {

328+ // WorkspaceManager.destroyWorkspace(fakeDragItem.workspace);

329+ // }

330+ root.commitScreenSetup();

331+ drag.target = null;

332+ }

333+

334+ property bool dragging: drag.active

335+ onDraggingChanged: {

336+ if (drag.active) {

337+ print("drai", draggedIndex)

338+ var ws = listView.model.get(draggedIndex);

339+ print("ws:", ws)

340+ ws.unassign();

341+ // listView.model.remove(draggedIndex, 1)

342+ }

343+ }

344+

345+ onPressed: {

346+ startX = mouseX;

347+ startY = mouseY;

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

349+

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

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

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

353+

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

355+ fakeDragItem.x = itemCoords.x

356+ fakeDragItem.y = itemCoords.y

357+ fakeDragItem.workspace = listView.model.get(draggedIndex)

358+

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

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

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

362+

363+ drag.axis = Drag.YAxis;

364+ drag.target = fakeDragItem;

365+ }

366+

367+ WorkspacePreview {

368+ id: fakeDragItem

369+ height: listView.height

370+ width: listView.itemWidth

371+ background: root.background

372+ screenHeight: screen.availableModes[screen.currentModeIndex].size.height

373+ visible: Drag.active

374+

375+ Drag.active: hoverMouseArea.drag.active

376+ Drag.keys: ['workspace']

377+

378+ property bool inDropArea: false

379+

380+ Rectangle {

381+ anchors.fill: parent

382+ color: "#33000000"

383+ opacity: parent.inDropArea ? 0 : 1

384+ Behavior on opacity { UbuntuNumberAnimation { } }

385+ Rectangle {

386+ anchors.centerIn: parent

387+ width: units.gu(6)

388+ height: units.gu(6)

389+ radius: width / 2

390+ color: "#aa000000"

391+ }

392+

393+ Icon {

394+ height: units.gu(3)

395+ width: height

396+ anchors.centerIn: parent

397+ name: "edit-delete"

398+ color: "white"

399+ }

400+ }

401+

402+ states: [

403+ State {

404+ when: fakeDragItem.Drag.active

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

406+ }

407+ ]

408+ }

409+ }

410+ }

411+ }

412+}

qml/Stage/Stage.qml+179−123

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

4747 property bool oskEnabled: false

4848 property rect inputMethodRect

4949 property real rightEdgePushProgress: 0

50+ property PanelState panelState

5051

5152 // Configuration

5253 property string mode: "staged"

@@ -349,23 +350,23 @@ FocusScope {

349350 readonly property real virtualKeyboardHeight: root.inputMethodRect.height

350351 }

351352

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

353+ Component.onCompleted: priv.updateMainAndSideStageIndexes()

353354

354355 Connections {

355− target: PanelState

356+ target: panelState

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

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

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

359360 }

360361

361362 Binding {

362− target: PanelState

363+ target: panelState

363364 property: "decorationsVisible"

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

365366 }

366367

367368 Binding {

368− target: PanelState

369+ target: panelState

369370 property: "title"

370371 value: {

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

@@ -380,7 +381,7 @@ FocusScope {

380381 }

381382

382383 Binding {

383− target: PanelState

384+ target: panelState

384385 property: "focusedPersistentSurfaceId"

385386 value: {

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

@@ -394,21 +395,21 @@ FocusScope {

394395 }

395396

396397 Binding {

397− target: PanelState

398+ target: panelState

398399 property: "dropShadow"

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

400401 }

401402

402403 Binding {

403− target: PanelState

404+ target: panelState

404405 property: "closeButtonShown"

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

406407 }

407408

408409 Component.onDestruction: {

409− PanelState.title = "";

410− PanelState.decorationsVisible = false;

411− PanelState.dropShadow = false;

410+ panelState.title = "";

411+ panelState.decorationsVisible = false;

412+ panelState.dropShadow = false;

412413 }

413414

414415 Instantiator {

@@ -454,6 +455,7 @@ FocusScope {

454455 PropertyChanges { target: cancelSpreadMouseArea; enabled: true }

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

456457 PropertyChanges { target: wallpaper; visible: false }

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

457459 },

458460 State {

459461 name: "stagedRightEdge"; when: root.spreadEnabled && (rightEdgeDragArea.dragging || rightEdgePushProgress > 0) && root.mode == "staged"

@@ -502,10 +504,13 @@ FocusScope {

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

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

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

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

505508 },

506509 Transition {

507510 to: "spread"

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

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

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

509514 },

510515 Transition {

511516 from: "spread"

@@ -563,10 +568,21 @@ FocusScope {

563568 visible: false

564569 }

565570

571+ ScreensAndWorkspaces {

572+ id: screensAndWorkspaces

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

574+ height: Math.max(units.gu(30), parent.height * .3)

575+ background: root.background

576+ opacity: 0

577+ visible: opacity > 0

578+

579+ onCloseSpread: priv.goneToSpread = false;

580+ }

581+

566582 Spread {

567583 id: spreadItem

568584 objectName: "spreadItem"

569− anchors.fill: appContainer

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

570586 leftMargin: root.leftMargin

571587 model: root.topLevelSurfaceList

572588 spreadFlickable: floatingFlickable

@@ -575,6 +591,83 @@ FocusScope {

575591 onLeaveSpread: {

576592 priv.goneToSpread = false;

577593 }

594+

595+ FloatingFlickable {

596+ id: floatingFlickable

597+ objectName: "spreadFlickable"

598+ anchors.fill: parent

599+ enabled: false

600+ contentWidth: spreadItem.spreadTotalWidth

601+

602+ function snap(toIndex) {

603+ var delegate = appRepeater.itemAt(toIndex)

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

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

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

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

608+ snapAnimation.start();

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

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

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

612+ snapAnimation.start();

613+ }

614+ }

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

616+ }

617+

618+ MouseArea {

619+ id: hoverMouseArea

620+ objectName: "hoverMouseArea"

621+ anchors.fill: parent

622+ propagateComposedEvents: true

623+ hoverEnabled: true

624+ enabled: false

625+ visible: enabled

626+

627+ property int scrollAreaWidth: width / 3

628+ property bool progressiveScrollingEnabled: false

629+

630+ onPressed: mouse.accepted = false

631+

632+ onMouseXChanged: {

633+ mouse.accepted = false

634+

635+ if (hoverMouseArea.pressed) {

636+ return;

637+ }

638+

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

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

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

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

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

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

645+ spreadItem.highlightedIndex = i;

646+ break;

647+ }

648+ }

649+

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

651+ var margins = floatingFlickable.width * 0.05;

652+

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

654+ progressiveScrollingEnabled = true

655+ }

656+

657+ // do we need to scroll?

658+ if (mouseX < scrollAreaWidth + margins) {

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

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

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

662+ }

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

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

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

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

667+ }

668+ }

669+ }

670+ }

578671 }

579672

580673 Connections {

@@ -669,10 +762,28 @@ FocusScope {

669762 }

670763 }

671764

765+ MirSurfaceItem {

766+ id: fakeDragItem

767+ property real previewScale: .5

768+ height: (screensAndWorkspaces.height - units.gu(8)) / 2

769+ // w : h = iw : ih

770+ width: implicitWidth * height / implicitHeight

771+ surfaceWidth: -1

772+ surfaceHeight: -1

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

774+ Behavior on opacity { UbuntuNumberAnimation {} }

775+ visible: opacity > 0

776+

777+ Drag.active: surface != null

778+ Drag.keys: ["application"]

779+

780+ z: 1000

781+ }

782+

672783 Item {

673784 id: boundariesForWindowPlacement

674785 anchors.fill: parent

675− anchors.topMargin: PanelState.panelHeight

786+ anchors.topMargin: panelState.panelHeight

676787 visible: false

677788 }

678789

@@ -704,6 +815,9 @@ FocusScope {

704815 }

705816 z: normalZ

706817

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

819+ Behavior on opacity { UbuntuNumberAnimation {} }

820+

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

708822 // match what the actual surface size is.

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

@@ -765,7 +879,7 @@ FocusScope {

765879 target: appDelegate

766880 property: "y"

767881 value: appDelegate.requestedY -

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

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

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

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

771885 && root.inputMethodRect.height > 0

@@ -876,7 +990,6 @@ FocusScope {

876990 function claimFocus() {

877991 if (root.state == "spread") {

878992 spreadItem.highlightedIndex = index

879− priv.goneToSpread = false;

880993 }

881994 if (root.mode == "stagedWithSideStage") {

882995 if (appDelegate.stage == ApplicationInfoInterface.SideStage && !sideStage.shown) {

@@ -1163,7 +1276,7 @@ FocusScope {

11631276 progress: 0

11641277 targetHeight: spreadItem.stackHeight

11651278 targetX: spreadMaths.targetX

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

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

11671280 targetY: spreadMaths.targetY

11681281 targetAngle: spreadMaths.targetAngle

11691282 targetScale: spreadMaths.targetScale

@@ -1209,8 +1322,6 @@ FocusScope {

12091322 y: spreadMaths.targetY

12101323 z: index

12111324 height: spreadItem.spreadItemHeight

1212− requestedWidth: decoratedWindow.oldRequestedWidth

1213− requestedHeight: decoratedWindow.oldRequestedHeight

12141325 visible: spreadMaths.itemVisible

12151326 }

12161327 PropertyChanges { target: dragArea; enabled: true }

@@ -1230,8 +1341,6 @@ FocusScope {

12301341 y: stagedRightEdgeMaths.animatedY

12311342 z: stagedRightEdgeMaths.animatedZ

12321343 height: stagedRightEdgeMaths.animatedHeight

1233− requestedWidth: decoratedWindow.oldRequestedWidth

1234− requestedHeight: decoratedWindow.oldRequestedHeight

12351344 visible: appDelegate.x < root.width

12361345 }

12371346 PropertyChanges {

@@ -1261,8 +1370,6 @@ FocusScope {

12611370 y: windowedRightEdgeMaths.animatedY

12621371 z: windowedRightEdgeMaths.animatedZ

12631372 height: stagedRightEdgeMaths.animatedHeight

1264− requestedWidth: decoratedWindow.oldRequestedWidth

1265− requestedHeight: decoratedWindow.oldRequestedHeight

12661373 }

12671374 PropertyChanges {

12681375 target: decoratedWindow

@@ -1284,12 +1391,16 @@ FocusScope {

12841391 PropertyChanges {

12851392 target: appDelegate

12861393 x: stageMaths.itemX

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

1288− requestedWidth: appContainer.width

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

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

12901395 visuallyMaximized: true

12911396 visible: appDelegate.x < root.width

12921397 }

1398+ PropertyChanges {

1399+ target: appDelegate

1400+ requestedWidth: appContainer.width

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

1402+ restoreEntryValues: false

1403+ }

12931404 PropertyChanges {

12941405 target: decoratedWindow

12951406 hasDecoration: false

@@ -1312,13 +1423,17 @@ FocusScope {

13121423 PropertyChanges {

13131424 target: appDelegate

13141425 x: stageMaths.itemX

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

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

13161427 z: stageMaths.itemZ

1317− requestedWidth: stageMaths.itemWidth

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

13191428 visuallyMaximized: true

13201429 visible: appDelegate.x < root.width

13211430 }

1431+ PropertyChanges {

1432+ target: appDelegate

1433+ requestedWidth: stageMaths.itemWidth

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

1435+ restoreEntryValues: false

1436+ }

13221437 PropertyChanges {

13231438 target: decoratedWindow

13241439 hasDecoration: false

@@ -1336,8 +1451,12 @@ FocusScope {

13361451 requestedY: 0;

13371452 visuallyMinimized: false;

13381453 visuallyMaximized: true

1339− requestedWidth: appContainer.width - root.leftMargin;

1340− requestedHeight: appContainer.height;

1454+ }

1455+ PropertyChanges {

1456+ target: appDelegate

1457+ requestedWidth: appContainer.width - root.leftMargin

1458+ requestedHeight: appContainer.height

1459+ restoreEntryValues: false

13411460 }

13421461 PropertyChanges { target: touchControls; enabled: true }

13431462 },

@@ -1347,8 +1466,12 @@ FocusScope {

13471466 target: appDelegate;

13481467 requestedX: 0

13491468 requestedY: 0

1350− requestedWidth: appContainer.width;

1351− requestedHeight: appContainer.height;

1469+ }

1470+ PropertyChanges {

1471+ target: appDelegate

1472+ requestedWidth: appContainer.width

1473+ requestedHeight: appContainer.height

1474+ restoreEntryValues: false

13521475 }

13531476 PropertyChanges { target: decoratedWindow; hasDecoration: false }

13541477 },

@@ -1363,6 +1486,12 @@ FocusScope {

13631486 PropertyChanges { target: touchControls; enabled: true }

13641487 PropertyChanges { target: resizeArea; enabled: true }

13651488 PropertyChanges { target: decoratedWindow; shadowOpacity: .3}

1489+ PropertyChanges {

1490+ target: appDelegate

1491+ requestedWidth: windowedWidth

1492+ requestedHeight: windowedHeight

1493+ restoreEntryValues: false

1494+ }

13661495 },

13671496 State {

13681497 name: "restored";

@@ -1380,9 +1509,9 @@ FocusScope {

13801509 PropertyChanges {

13811510 target: appDelegate

13821511 windowedX: root.leftMargin

1383− windowedY: PanelState.panelHeight

1512+ windowedY: panelState.panelHeight

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

1385− windowedHeight: appContainer.height - PanelState.panelHeight

1514+ windowedHeight: appContainer.height - panelState.panelHeight

13861515 }

13871516 },

13881517 State {

@@ -1399,9 +1528,9 @@ FocusScope {

13991528 PropertyChanges {

14001529 target: appDelegate

14011530 windowedX: root.leftMargin

1402− windowedY: PanelState.panelHeight

1531+ windowedY: panelState.panelHeight

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

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

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

14051534 }

14061535 },

14071536 State {

@@ -1418,7 +1547,7 @@ FocusScope {

14181547 PropertyChanges {

14191548 target: appDelegate

14201549 windowedX: root.leftMargin

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

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

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

14231552 windowedHeight: appContainer.height/2

14241553 }

@@ -1440,8 +1569,8 @@ FocusScope {

14401569 State {

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

14421571 extend: "normal"

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

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

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

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

14451574 },

14461575 State {

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

@@ -1456,6 +1585,10 @@ FocusScope {

14561585 }

14571586 }

14581587 ]

1588+ onStateChanged: {

1589+ print("item", index, "state changed", state)

1590+ }

1591+

14591592 transitions: [

14601593 Transition {

14611594 from: "staged,stagedWithSideStage"

@@ -1469,6 +1602,7 @@ FocusScope {

14691602 UbuntuNumberAnimation { target: appDelegate; properties: "x,y,requestedX,requestedY,requestedWidth,requestedHeight"; duration: priv.animationDuration}

14701603 },

14711604 Transition {

1605+ from: "normal,restored,maximized,maximizedHorizontally,maximizedVertically,maximizedLeft,maximizedRight,maximizedTopLeft,maximizedBottomLeft,maximizedTopRight,maximizedBottomRight,staged,stagedWithSideStage,windowedRightEdge,stagedRightEdge";

14721606 to: "spread"

14731607 // DecoratedWindow wants the scaleToPreviewSize set before enabling scaleToPreview

14741608 PropertyAction { target: appDelegate; properties: "z,visible" }

@@ -1554,7 +1688,7 @@ FocusScope {

15541688 ]

15551689

15561690 Binding {

1557− target: PanelState

1691+ target: panelState

15581692 property: "decorationsAlwaysVisible"

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

15601694 }

@@ -1575,6 +1709,7 @@ FocusScope {

15751709 borderThickness: units.gu(2)

15761710 enabled: false

15771711 visible: enabled

1712+ readyToAssesBounds: !appDelegate._constructing

15781713

15791714 onPressed: {

15801715 appDelegate.activate();

@@ -1602,12 +1737,6 @@ FocusScope {

16021737 requestedWidth: appDelegate.requestedWidth

16031738 requestedHeight: appDelegate.requestedHeight

16041739

1605− property int oldRequestedWidth: -1

1606− property int oldRequestedHeight: -1

1607−

1608− onRequestedWidthChanged: oldRequestedWidth = requestedWidth

1609− onRequestedHeightChanged: oldRequestedHeight = requestedHeight

1610−

16111740 onCloseClicked: { appDelegate.close(); }

16121741 onMaximizeClicked: {

16131742 if (appDelegate.canBeMaximized) {

@@ -1730,12 +1859,15 @@ FocusScope {

17301859 objectName: "closeMouseArea"

17311860 anchors { left: parent.left; top: parent.top; leftMargin: -height / 2; topMargin: -height / 2 + spreadMaths.closeIconOffset }

17321861 readonly property var mousePos: hoverMouseArea.mapToItem(appDelegate, hoverMouseArea.mouseX, hoverMouseArea.mouseY)

1733− visible: !appDelegate.isDash && dragArea.distance == 0

1862+ readonly property bool shown: !appDelegate.isDash && dragArea.distance == 0

17341863 && index == spreadItem.highlightedIndex

17351864 && mousePos.y < (decoratedWindow.height / 3)

17361865 && mousePos.y > -units.gu(4)

17371866 && mousePos.x > -units.gu(4)

17381867 && mousePos.x < (decoratedWindow.width * 2 / 3)

1868+ opacity: shown ? 1 : 0

1869+ visible: opacity > 0

1870+ Behavior on opacity { UbuntuNumberAnimation { duration: UbuntuAnimation.SnapDuration } }

17391871 height: units.gu(6)

17401872 width: height

17411873

@@ -1797,83 +1929,7 @@ FocusScope {

17971929 leftMargin: root.leftMargin

17981930 appContainerWidth: appContainer.width

17991931 appContainerHeight: appContainer.height

1800− }

1801−

1802− MouseArea {

1803− id: hoverMouseArea

1804− objectName: "hoverMouseArea"

1805− anchors.fill: appContainer

1806− propagateComposedEvents: true

1807− hoverEnabled: true

1808− enabled: false

1809− visible: enabled

1810−

1811− property int scrollAreaWidth: width / 3

1812− property bool progressiveScrollingEnabled: false

1813−

1814− onMouseXChanged: {

1815− mouse.accepted = false

1816−

1817− if (hoverMouseArea.pressed) {

1818− return;

1819− }

1820−

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

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

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

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

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

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

1827− spreadItem.highlightedIndex = i;

1828− break;

1829− }

1830− }

1831−

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

1833− var margins = floatingFlickable.width * 0.05;

1834−

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

1836− progressiveScrollingEnabled = true

1837− }

1838−

1839− // do we need to scroll?

1840− if (mouseX < scrollAreaWidth + margins) {

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

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

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

1844− }

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

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

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

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

1849− }

1850− }

1851− }

1852−

1853− onPressed: mouse.accepted = false

1854− }

1855−

1856− FloatingFlickable {

1857− id: floatingFlickable

1858− objectName: "spreadFlickable"

1859− anchors.fill: appContainer

1860− enabled: false

1861− contentWidth: spreadItem.spreadTotalWidth

1862−

1863− function snap(toIndex) {

1864− var delegate = appRepeater.itemAt(toIndex)

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

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

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

1868− snapAnimation.to = Math.max(0, floatingFlickable.contentX - offset);

1869− snapAnimation.start();

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

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

1872− snapAnimation.to = Math.max(0, floatingFlickable.contentX - offset);

1873− snapAnimation.start();

1874− }

1875− }

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

1932+ panelState: root.panelState

18771933 }

18781934

18791935 PropertyAnimation {

qml/Stage/SurfaceContainer.qml+2

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

6666 fillMode: MirSurfaceItem.PadOrCrop

6767 consumesInput: true

6868

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

70+

6971 surfaceWidth: root.requestedWidth

7072 surfaceHeight: root.requestedHeight

7173

qml/Stage/WindowResizeArea.qml+27−4

@@ -36,35 +36,58 @@ MouseArea {

3636 property int minWidth: 0

3737 property int minHeight: 0

3838

39+ property bool readyToAssesBounds: false

40+ onReadyToAssesBoundsChanged: d.reassesBounds()

41+

3942 QtObject {

4043 id: d

4144

4245 readonly property int maxSafeInt: 2147483647

4346 readonly property int maxSizeIncrement: units.gu(40)

4447

48+ function reassesBounds() {

49+ if (!readyToAssesBounds) return;

50+

51+ if (target.windowedWidth < minimumWidth) {

52+ target.windowedWidth = minimumWidth;

53+ }

54+ if (target.windowedHeight < minimumHeight) {

55+ target.windowedHeight = minimumHeight;

56+ }

57+ if (target.windowedHeight < minimumHeight) {

58+ target.windowedHeight = minimumHeight;

59+ }

60+ if (target.windowedWidth > maximumWidth) {

61+ target.windowedWidth = maximumWidth;

62+ }

63+ if (target.windowedHeight > maximumHeight) {

64+ target.windowedHeight = maximumHeight;

65+ }

66+ }

67+

4568 readonly property int minimumWidth: root.target ? Math.max(root.minWidth, root.target.minimumWidth) : root.minWidth

4669 onMinimumWidthChanged: {

47− if (target.windowedWidth < minimumWidth) {

70+ if (readyToAssesBounds && target.windowedWidth < minimumWidth) {

4871 target.windowedWidth = minimumWidth;

4972 }

5073 }

5174 readonly property int minimumHeight: root.target ? Math.max(root.minHeight, root.target.minimumHeight) : root.minHeight

5275 onMinimumHeightChanged: {

53− if (target.windowedHeight < minimumHeight) {

76+ if (readyToAssesBounds && target.windowedHeight < minimumHeight) {

5477 target.windowedHeight = minimumHeight;

5578 }

5679 }

5780 readonly property int maximumWidth: root.target && root.target.maximumWidth >= minimumWidth && root.target.maximumWidth > 0

5881 ? root.target.maximumWidth : maxSafeInt

5982 onMaximumWidthChanged: {

60− if (target.windowedWidth > maximumWidth) {

83+ if (readyToAssesBounds && target.windowedWidth > maximumWidth) {

6184 target.windowedWidth = maximumWidth;

6285 }

6386 }

6487 readonly property int maximumHeight: root.target && root.target.maximumHeight >= minimumHeight && root.target.maximumHeight > 0

6588 ? root.target.maximumHeight : maxSafeInt

6689 onMaximumHeightChanged: {

67− if (target.windowedHeight > maximumHeight) {

90+ if (readyToAssesBounds && target.windowedHeight > maximumHeight) {

6891 target.windowedHeight = maximumHeight;

6992 }

7093 }

qml/Stage/WindowStateSaver.qml+4−1

@@ -43,7 +43,10 @@ QtObject {

4343 (target.fullscreen ? 0 : root.leftMargin)); });

4444 target.windowedY = Qt.binding(function() { return Math.max(Math.min(windowGeometry.y, screenHeight - target.windowedHeight), minimumY); });

4545

46− target.updateNormalGeometry();

46+ target.normalWidth = target.windowedWidth;

47+ target.normalHeight = target.windowedHeight;

48+ target.normalX = target.windowedX;

49+ target.normalY = target.windowedY;

4750

4851 // initialize the x/y to restore to

4952 target.restoredX = target.normalX;

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_drop-here.pngnew file

Binary file not shown.

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 @@

1616

1717#include "ApplicationArguments.h"

1818

19−ApplicationArguments::ApplicationArguments(QObject *parent)

20− : QObject(parent)

19+ApplicationArguments::ApplicationArguments(QCoreApplication *app)

20+ : QObject(app)

21+ , UnityCommandLineParser(*app)

2122{

2223}

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 @@

2323#include <QSize>

2424#include <QString>

2525

26−class ApplicationArguments : public QObject

26+#include "UnityCommandLineParser.h"

27+

28+class ApplicationArguments : public QObject,

29+ public UnityCommandLineParser

2730{

2831 Q_OBJECT

2932 Q_PROPERTY(QString deviceName READ deviceName NOTIFY deviceNameChanged)

3033 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+

3144public:

32− ApplicationArguments(QObject *parent = nullptr);

45+ ApplicationArguments(QCoreApplication *app);

3346

34− 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; }

47+ void setDeviceName(const QString &deviceName);

4148

42− void setMode(const QString &mode) { m_mode = mode; }

43− QString mode() const { return m_mode; }

49+ bool hasGeometry() const { return m_windowGeometry.isValid(); }

4450

4551Q_SIGNALS:

4652 void deviceNameChanged(const QString&);

47−

48−private:

49− QString m_deviceName;

50− QString m_mode;

5153};

5254

5355#endif // APPLICATION_ARGUMENTS_H

src/CMakeLists.txt+10−4

@@ -7,6 +7,7 @@ include_directories(

77 ${Qt5Gui_PRIVATE_INCLUDE_DIRS}

88 ${Qt5Quick_PRIVATE_INCLUDE_DIRS}

99 ${CONNECTIVITY_INCLUDE_DIRS}

10+ ${QTMIRSERVER_INCLUDE_DIRS}

1011)

1112

1213include_directories(

@@ -27,12 +28,11 @@ set(SOURCE_FILES

2728 ApplicationArguments.cpp

2829 main.cpp

2930 CachingNetworkManagerFactory.cpp

30− SecondaryWindow.cpp

31− ShellApplication.cpp

32− ShellView.cpp

31+ UnityApplication.cpp

3332 UnityCommandLineParser.cpp

3433 UnixSignalHandler.cpp

3534 DebuggingController.cpp

35+ WindowManagementPolicy.cpp

3636 ${QML_FILES} # This is to make qml and image files appear in the IDE's project tree

3737)

3838

@@ -47,7 +47,13 @@ qt5_use_modules(${SHELL_APP} DBus Gui Qml Quick Test)

4747if (NOT "${ANDROID_PROPERTIES_INCLUDE_DIRS}" STREQUAL "")

4848 set_target_properties(${SHELL_APP} PROPERTIES INCLUDE_DIRECTORIES ${ANDROID_PROPERTIES_INCLUDE_DIRS})

4949endif()

50−target_link_libraries(${SHELL_APP} ${ANDROID_PROPERTIES_LDFLAGS} UbuntuGestures connectivity-qt1 unity8-private)

50+target_link_libraries(${SHELL_APP}

51+ ${ANDROID_PROPERTIES_LDFLAGS}

52+ ${QTMIRSERVER_LDFLAGS}

53+ UbuntuGestures

54+ connectivity-qt1

55+ unity8-private

56+)

5157

5258if (ENABLE_TOUCH_EMULATION)

5359 target_link_libraries(${SHELL_APP} ${MOUSETOUCHADAPTOR_LIBS_LDFLAGS})

src/DebuggingController.cpp+12−1

@@ -49,7 +49,8 @@ public:

4949};

5050

5151DebuggingController::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)

5354{

5455}

5556

@@ -90,3 +91,13 @@ void DebuggingController::SetLoggingFilterRules(const QString &filterRules)

9091{

9192 QLoggingCategory::setFilterRules(filterRules);

9293}

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

3232 Q_OBJECT

3333 Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity8.Debugging")

3434

35+ Q_PROPERTY(bool logOverlay READ logOverlay NOTIFY logOverlayChanged)

36+

3537public:

3638 DebuggingController(QObject *parent = nullptr);

3739 ~DebuggingController() = default;

3840

41+ bool logOverlay() const { return m_logOverlay; }

42+

3943public Q_SLOTS:

4044 /**

4145 * Set the QSG_VISUALIZE mode. This follows the vlues supported by Qt in

@@ -53,5 +57,15 @@ public Q_SLOTS:

5357 */

5458 Q_SCRIPTABLE void SetLoggingFilterRules(const QString &filterRules);

5559

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;

5670};

5771#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.cppdeleted−216

@@ -1,216 +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 "ShellApplication.h"

18−

19−// Qt

20−#include <QLibrary>

21−#include <QProcess>

22−#include <QScreen>

23−

24−#include <libintl.h>

25−

26−// libandroid-properties

27−#include <hybris/properties/properties.h>

28−

29−// local

30−#include <paths.h>

31−#include "CachingNetworkManagerFactory.h"

32−#include "UnityCommandLineParser.h"

33−#include "DebuggingController.h"

34−

35−ShellApplication::ShellApplication(int & argc, char ** argv, bool isMirServer)

36− : QGuiApplication(argc, argv)

37−{

38− setApplicationName(QStringLiteral("unity8"));

39− setOrganizationName(QStringLiteral("Canonical"));

40−

41− connect(this, &QGuiApplication::screenAdded, this, &ShellApplication::onScreenAdded);

42−

43− setupQmlEngine(isMirServer);

44−

45− UnityCommandLineParser parser(*this);

46−

47− if (!parser.deviceName().isEmpty()) {

48− m_deviceName = parser.deviceName();

49− } else {

50− char buffer[200];

51− property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);

52− m_deviceName = QString(buffer);

53− }

54− m_qmlArgs.setDeviceName(m_deviceName);

55−

56− m_qmlArgs.setMode(parser.mode());

57−

58− // 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.

60− if (parser.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {

61− QLibrary testLib(QStringLiteral("qttestability"));

62− if (testLib.load()) {

63− typedef void (*TasInitialize)(void);

64− TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");

65− if (initFunction) {

66− initFunction();

67− } else {

68− qCritical("Library qttestability resolve failed!");

69− }

70− } else {

71− qCritical("Library qttestability load failed!");

72− }

73− }

74−

75− bindtextdomain("unity8", translationDirectory().toUtf8().data());

76− textdomain("unity8");

77−

78− m_shellView = new ShellView(m_qmlEngine, &m_qmlArgs);

79−

80− if (parser.windowGeometry().isValid()) {

81− m_shellView->setWidth(parser.windowGeometry().width());

82− m_shellView->setHeight(parser.windowGeometry().height());

83− }

84−

85− if (parser.hasFrameless()) {

86− m_shellView->setFlags(Qt::FramelessWindowHint);

87− }

88−

89−

90− #ifdef UNITY8_ENABLE_TOUCH_EMULATION

91− // 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.

93− if (parser.hasMouseToTouch()) {

94− m_mouseTouchAdaptor = MouseTouchAdaptor::instance();

95− }

96− #endif

97−

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) {

117− QSize primaryScreenSize = this->primaryScreen()->size();

118− m_shellView->setHeight(primaryScreenSize.height());

119− m_shellView->setWidth(primaryScreenSize.width());

120− m_shellView->show();

121− m_shellView->requestActivate();

122− if (!QProcess::startDetached("initctl emit --no-wait unity8-greeter-started")) {

123− qDebug() << "Unable to send unity8-greeter-started event to Upstart";

124− }

125− } else if (isMirServer || parser.hasFullscreen()) {

126− m_shellView->showFullScreen();

127− } else {

128− m_shellView->show();

129− }

130−}

131−

132−ShellApplication::~ShellApplication()

133−{

134− destroyResources();

135−}

136−

137−void ShellApplication::destroyResources()

138−{

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

148− delete m_mouseTouchAdaptor;

149− m_mouseTouchAdaptor = nullptr;

150− #endif

151−

152− delete m_qmlEngine;

153− m_qmlEngine = nullptr;

154−}

155−

156−void ShellApplication::setupQmlEngine(bool isMirServer)

157−{

158− m_qmlEngine = new QQmlEngine(this);

159−

160− m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));

161−

162− prependImportPaths(m_qmlEngine, ::overrideImportPaths());

163− if (!isMirServer) {

164− prependImportPaths(m_qmlEngine, ::nonMirImportPaths());

165− }

166− appendImportPaths(m_qmlEngine, ::fallbackImportPaths());

167−

168− m_qmlEngine->setNetworkAccessManagerFactory(new CachingNetworkManagerFactory);

169−

170− QObject::connect(m_qmlEngine, &QQmlEngine::quit, this, &QGuiApplication::quit);

171−}

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/ShellView.cppdeleted−85

@@ -1,85 +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−#include <QtQuick/private/qquickitem_p.h>

23−#include <QtQuick/private/qquickrectangle_p.h>

24−#include <QtQuick/private/qquicktext_p.h>

25−

26−// local

27−#include <paths.h>

28−

29−ShellView::ShellView(QQmlEngine *engine, QObject *qmlArgs)

30− : QQuickView(engine, nullptr)

31−{

32− setResizeMode(QQuickView::SizeRootObjectToView);

33− setColor("black");

34− setTitle(QStringLiteral("Unity8"));

35−

36− rootContext()->setContextProperty(QStringLiteral("applicationArguments"), qmlArgs);

37−

38− connect(this, &QQuickView::statusChanged, this, [this] {

39− if (status() == QQuickView::Error) {

40− QQuickRectangle *rect = new QQuickRectangle(contentItem());

41− rect->setColor(Qt::white);

42− QQuickItemPrivate::get(rect)->anchors()->setFill(contentItem());

43−

44− QString errorsString;

45− for(const QQmlError &e: errors()) {

46− errorsString += e.toString() + "\n";

47− }

48− QQuickText *text = new QQuickText(rect);

49− text->setColor(Qt::black);

50− text->setWrapMode(QQuickText::Wrap);

51− text->setText(QString("There was an error loading Unity8:\n%1").arg(errorsString));

52− QQuickItemPrivate::get(text)->anchors()->setFill(rect);

53− }

54− }

55− );

56−

57− QUrl source(::qmlDirectory() + "/OrientedShell.qml");

58− setSource(source);

59−

60− connect(this, &QWindow::widthChanged, this, &ShellView::onWidthChanged);

61− connect(this, &QWindow::heightChanged, this, &ShellView::onHeightChanged);

62−}

63−

64−void ShellView::onWidthChanged(int w)

65−{

66− // For good measure in case SizeRootObjectToView doesn't fulfill its promise.

67− //

68− // There's at least one situation that's know to leave the root object with an outdated size.

69− // (really looks like Qt bug)

70− // Happens when starting unity8 with an external monitor already connected.

71− // The QResizeEvent we get still has the size of the first screen and since the resize move is triggered

72− // from the resize event handler, the root item doesn't get resized.

73− // TODO: Confirm the Qt bug and submit a patch upstream

74− if (rootObject()) {

75− rootObject()->setWidth(w);

76− }

77−}

78−

79−void ShellView::onHeightChanged(int h)

80−{

81− // See comment in ShellView::onWidthChanged()

82− if (rootObject()) {

83− rootObject()->setHeight(h);

84− }

85−}

src/UnityApplication.cppnew file+142

@@ -0,0 +1,142 @@

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 "UnityApplication.h"

18+

19+// Qt

20+#include <QLibrary>

21+#include <QProcess>

22+#include <QScreen>

23+#include <QQmlContext>

24+#include <QQmlComponent>

25+

26+#include <libintl.h>

27+

28+// libandroid-properties

29+#include <hybris/properties/properties.h>

30+

31+// local

32+#include <paths.h>

33+#include "CachingNetworkManagerFactory.h"

34+#include "UnityCommandLineParser.h"

35+#include "DebuggingController.h"

36+#include "WindowManagementPolicy.h"

37+

38+#include <QDebug>

39+

40+

41+

42+UnityApplication::UnityApplication(int & argc, char ** argv)

43+ : qtmir::MirServerApplication(argc, argv, { qtmir::SetWindowManagementPolicy<WindowManagementPolicy>() })

44+ , m_qmlArgs(this)

45+{

46+ setApplicationName(QStringLiteral("unity8"));

47+ setOrganizationName(QStringLiteral("Canonical"));

48+

49+ setupQmlEngine();

50+

51+ if (m_qmlArgs.deviceName().isEmpty()) {

52+ char buffer[200];

53+ property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);

54+ m_qmlArgs.setDeviceName(QString(buffer));

55+ }

56+

57+ // The testability driver is only loaded by QApplication but not by QGuiApplication.

58+ // However, QApplication depends on QWidget which would add some unneeded overhead => Let's load the testability driver on our own.

59+ if (m_qmlArgs.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {

60+ QLibrary testLib(QStringLiteral("qttestability"));

61+ if (testLib.load()) {

62+ typedef void (*TasInitialize)(void);

63+ TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");

64+ if (initFunction) {

65+ initFunction();

66+ } else {

67+ qCritical("Library qttestability resolve failed!");

68+ }

69+ } else {

70+ qCritical("Library qttestability load failed!");

71+ }

72+ }

73+

74+ bindtextdomain("unity8", translationDirectory().toUtf8().data());

75+ textdomain("unity8");

76+

77+ m_qmlEngine->rootContext()->setContextProperty(QStringLiteral("applicationArguments"), &m_qmlArgs);

78+ m_qmlEngine->rootContext()->setContextProperty("DebuggingController", new DebuggingController(this));

79+

80+ QByteArray pxpguEnv = qgetenv("GRID_UNIT_PX");

81+ bool ok;

82+ int pxpgu = pxpguEnv.toInt(&ok);

83+ if (!ok) {

84+ pxpgu = 8;

85+ }

86+ m_qmlEngine->rootContext()->setContextProperty("internalGu", pxpgu);

87+

88+ auto component(new QQmlComponent(m_qmlEngine, m_qmlArgs.qmlfie()));

89+ component->create();

90+ if (component->status() == QQmlComponent::Error) {

91+ m_qmlEngine->rootContext()->setContextProperty(QStringLiteral("errorString"), component->errorString());

92+ auto errorComponent(new QQmlComponent(m_qmlEngine,

93+ QUrl::fromLocalFile(::qmlDirectory() + "/ErrorApplication.qml")));

94+ errorComponent->create();

95+ qDebug() << errorComponent->errorString();

96+ return;

97+ }

98+

99+ #ifdef UNITY8_ENABLE_TOUCH_EMULATION

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

101+ // Needed only when manually testing on a desktop.

102+ if (m_qmlArgs.hasMouseToTouch()) {

103+ m_mouseTouchAdaptor = MouseTouchAdaptor::instance();

104+ }

105+ #endif

106+

107+ if (m_qmlArgs.mode().compare("greeter") == 0) {

108+ if (!QProcess::startDetached("initctl emit --no-wait unity8-greeter-started")) {

109+ qDebug() << "Unable to send unity8-greeter-started event to Upstart";

110+ }

111+ }

112+}

113+

114+UnityApplication::~UnityApplication()

115+{

116+ destroyResources();

117+}

118+

119+void UnityApplication::destroyResources()

120+{

121+ #ifdef UNITY8_ENABLE_TOUCH_EMULATION

122+ delete m_mouseTouchAdaptor;

123+ m_mouseTouchAdaptor = nullptr;

124+ #endif

125+

126+ delete m_qmlEngine;

127+ m_qmlEngine = nullptr;

128+}

129+

130+void UnityApplication::setupQmlEngine()

131+{

132+ m_qmlEngine = new QQmlEngine(this);

133+

134+ m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));

135+

136+ prependImportPaths(m_qmlEngine, ::overrideImportPaths());

137+ appendImportPaths(m_qmlEngine, ::fallbackImportPaths());

138+

139+ m_qmlEngine->setNetworkAccessManagerFactory(new CachingNetworkManagerFactory);

140+

141+ QObject::connect(m_qmlEngine, &QQmlEngine::quit, this, &QGuiApplication::quit);

142+}

src/ShellApplication.h → src/UnityApplication.hrenamed+9−19

@@ -14,11 +14,11 @@

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

1515 */

1616

17−#ifndef SHELLAPPLICATION_H

18−#define SHELLAPPLICATION_H

17+#ifndef UNITYAPPLICATION_H

18+#define UNITYAPPLICATION_H

1919

2020#include <QGuiApplication>

21−#include <QQmlEngine>

21+#include <QQmlApplicationEngine>

2222#include <QQuickView>

2323#include <QScopedPointer>

2424

@@ -28,30 +28,20 @@

2828#include "MouseTouchAdaptor.h"

2929#endif

3030

31−#include "SecondaryWindow.h"

32−#include "ShellView.h"

31+#include <qtmir/mirserverapplication.h>

3332

34−class ShellApplication : public QGuiApplication

33+class UnityApplication : public qtmir::MirServerApplication

3534{

3635 Q_OBJECT

3736public:

38− ShellApplication(int & argc, char ** argv, bool isMirServer);

39− virtual ~ShellApplication();

37+ UnityApplication(int & argc, char ** argv);

38+ virtual ~UnityApplication();

4039

4140 void destroyResources();

42−public Q_SLOTS:

43− // called by qtmir

44− void onScreenAboutToBeRemoved(QScreen *screen);

45−

46−private Q_SLOTS:

47− void onScreenAdded(QScreen*);

4841

4942private:

50− void setupQmlEngine(bool isMirServer);

51− QString m_deviceName;

43+ void setupQmlEngine();

5244 ApplicationArguments m_qmlArgs;

53− ShellView *m_shellView{nullptr};

54− SecondaryWindow *m_secondaryWindow{nullptr};

5545

5646 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

5747 MouseTouchAdaptor *m_mouseTouchAdaptor{nullptr};

@@ -60,4 +50,4 @@ private:

6050 QQmlEngine *m_qmlEngine{nullptr};

6151};

6252

63−#endif // SHELLAPPLICATION_H

53+#endif // UNITYAPPLICATION_H

src/UnityCommandLineParser.cpp+8

@@ -15,6 +15,7 @@

1515 */

1616

1717#include "UnityCommandLineParser.h"

18+#include <paths.h>

1819

1920#include <QDebug>

2021

@@ -60,6 +61,11 @@ UnityCommandLineParser::UnityCommandLineParser(const QCoreApplication &app)

6061 QStringLiteral("mode"), QStringLiteral("full-greeter"));

6162 parser.addOption(modeOption);

6263

64+ QCommandLineOption qmlfileOption(QStringLiteral("qmlfile"),

65+ QStringLiteral("The base qml file to load"),

66+ QStringLiteral("qmlfile"), ::qmlDirectory() + "/ShellApplication.qml");

67+ parser.addOption(qmlfileOption);

68+

6369 // Treat args with single dashes the same as arguments with two dashes

6470 // Ex: -fullscreen == --fullscreen

6571 parser.setSingleDashWordOptionMode(QCommandLineParser::ParseAsLongOptions);

@@ -85,6 +91,8 @@ UnityCommandLineParser::UnityCommandLineParser(const QCoreApplication &app)

8591 m_hasFullscreen = parser.isSet(fullscreenOption);

8692 m_deviceName = parser.value(devicenameOption);

8793 resolveMode(parser, modeOption);

94+

95+ m_qmlfile = parser.value(qmlfileOption);

8896}

8997

9098int UnityCommandLineParser::parsePixelsValue(const QString &str)

src/UnityCommandLineParser.h+4−1

@@ -36,8 +36,10 @@ public:

3636 bool hasFullscreen() const { return m_hasFullscreen; }

3737 QString deviceName() const { return m_deviceName; }

3838 QString mode() const { return m_mode; }

39−private:

4039

40+ QString qmlfie() const { return m_qmlfile; }

41+

42+protected:

4143 int parsePixelsValue(const QString &str);

4244 static float getenvFloat(const char* name, float defaultValue);

4345 void resolveMode(QCommandLineParser &parser, QCommandLineOption &modeOption);

@@ -55,6 +57,7 @@ private:

5557 bool m_hasFullscreen;

5658 QString m_deviceName;

5759 QString m_mode;

60+ QString m_qmlfile;

5861};

5962

6063#endif // UNITY_COMMAND_LINE_PARSER_H

src/WindowManagementPolicy.cppnew file+69

@@ -0,0 +1,69 @@

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 "WindowManagementPolicy.h"

18+

19+WindowManagementPolicy::WindowManagementPolicy(const miral::WindowManagerTools &tools, qtmir::WindowManagementPolicyPrivate &dd)

20+ : qtmir::WindowManagementPolicy(tools, dd)

21+ , m_dummyWorkspace(this->tools.create_workspace())

22+{

23+ wmPolicyInterface = this;

24+

25+ // we must always have a active workspace.

26+ m_activeWorkspace = m_dummyWorkspace;

27+}

28+

29+void WindowManagementPolicy::advise_new_window(miral::WindowInfo const& window_info)

30+{

31+ qtmir::WindowManagementPolicy::advise_new_window(window_info);

32+

33+ auto const parent = window_info.parent();

34+

35+ auto activeWorkspace = m_activeWorkspace.lock();

36+ if (!parent && activeWorkspace) {

37+ tools.add_tree_to_workspace(window_info.window(), activeWorkspace);

38+ }

39+}

40+

41+std::shared_ptr<miral::Workspace> WindowManagementPolicy::createWorkspace()

42+{

43+ auto workspace = tools.create_workspace();

44+ m_workspaces.insert(workspace);

45+

46+ if (m_activeWorkspace.lock() == m_dummyWorkspace) {

47+ tools.move_workspace_content_to_workspace(workspace, m_dummyWorkspace);

48+ m_activeWorkspace = workspace;

49+ }

50+ return workspace;

51+}

52+

53+void WindowManagementPolicy::releaseWorkspace(const std::shared_ptr<miral::Workspace> &workspace)

54+{

55+ auto iter = m_workspaces.find(workspace);

56+ if (iter != m_workspaces.end()) m_workspaces.erase(iter);

57+

58+ if (m_workspaces.size() == 0) {

59+ m_activeWorkspace = m_dummyWorkspace;

60+ tools.move_workspace_content_to_workspace(m_dummyWorkspace, workspace);

61+ }

62+}

63+

64+void WindowManagementPolicy::setActiveWorkspace(const std::shared_ptr<miral::Workspace> &workspace)

65+{

66+ if (m_activeWorkspace.lock() == workspace)

67+ return;

68+ m_activeWorkspace = workspace ? workspace : m_dummyWorkspace;

69+}

src/WindowManagementPolicy.hnew file+47

@@ -0,0 +1,47 @@

1+/*

3+ *

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

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

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

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef UNITY_WINDOWMANAGEMENTPOLICY_H

18+#define UNITY_WINDOWMANAGEMENTPOLICY_H

19+

20+#include <qtmir/windowmanagementpolicy.h>

21+#include "wmpolicyinterface.h"

22+

23+#include <unordered_set>

24+

25+class Q_DECL_EXPORT WindowManagementPolicy : public qtmir::WindowManagementPolicy,

26+ public WMPolicyInterface

27+{

28+public:

29+ WindowManagementPolicy(const miral::WindowManagerTools &tools, qtmir::WindowManagementPolicyPrivate& dd);

30+

31+ void advise_new_window(miral::WindowInfo const& window_info) override;

32+

33+ // From WMPolicyInterface

34+ std::shared_ptr<miral::Workspace> createWorkspace() override;

35+

36+ void releaseWorkspace(const std::shared_ptr<miral::Workspace> &workspace) override;

37+

38+ void setActiveWorkspace(const std::shared_ptr<miral::Workspace>& workspace) override;

39+

40+private:

41+ std::weak_ptr<miral::Workspace> m_activeWorkspace;

42+

43+ std::unordered_set<std::shared_ptr<miral::Workspace>> m_workspaces;

44+ const std::shared_ptr<miral::Workspace> m_dummyWorkspace;

45+};

46+

47+#endif // UNITY_WINDOWMANAGEMENTPOLICY_H

src/libunity8-private/CMakeLists.txt+1

@@ -8,6 +8,7 @@ set(lib${LIB_NAME}_SRCS

88 abstractdbusservicemonitor.cpp

99 unitydbusobject.cpp

1010 unitydbusvirtualobject.cpp

11+ wmpolicyinterface.cpp

1112 )

1213

1314add_library(${LIB_NAME} SHARED

src/SecondaryWindow.h → src/libunity8-private/wmpolicyinterface.cpprenamed+6−12

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

11/*

33 *

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

55 * it under the terms of the GNU General Public License as published by

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

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

1515 */

1616

17−#ifndef UNITY_SECONDARY_WINDOW_H

18−#define UNITY_SECONDARY_WINDOW_H

17+#include "wmpolicyinterface.h"

1918

20−#include <QQuickView>

19+WMPolicyInterface* wmPolicyInterface = nullptr;

2120

22−class SecondaryWindow : public QQuickView

21+WMPolicyInterface *WMPolicyInterface::instance()

2322{

24− Q_OBJECT

25−

26−public:

27− SecondaryWindow(QQmlEngine *engine);

28−};

29−

30−#endif // UNITY_SECONDARY_WINDOW_H

23+ return wmPolicyInterface;

24+}

src/libunity8-private/wmpolicyinterface.hnew file+44

@@ -0,0 +1,44 @@

1+/*

3+ *

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

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

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

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef WMPOLICYINTERFACE_H

18+#define WMPOLICYINTERFACE_H

19+

20+#include <memory>

21+#include <functional>

22+

23+#include <qglobal.h>

24+

25+namespace miral {

26+class Workspace;

27+class Window;

28+}

29+

30+class Q_DECL_EXPORT WMPolicyInterface

31+{

32+public:

33+ static WMPolicyInterface *instance();

34+

35+ virtual std::shared_ptr<miral::Workspace> createWorkspace() = 0;

36+

37+ virtual void releaseWorkspace(const std::shared_ptr<miral::Workspace> &workspace) = 0;

38+

39+ virtual void setActiveWorkspace(const std::shared_ptr<miral::Workspace>& workspace) = 0;

40+};

41+

42+extern Q_DECL_EXPORT WMPolicyInterface* wmPolicyInterface;

43+

44+#endif // WMPOLICYINTERFACE_H

src/main.cpp+4−8

@@ -15,9 +15,10 @@

1515 */

1616

1717// local

18−#include "ShellApplication.h"

18+#include "UnityApplication.h"

1919#include "qmldebuggerutils.h"

2020#include "UnixSignalHandler.h"

21+#include <paths.h>

2122

2223#include <QTranslator>

2324#include <QLibraryInfo>

@@ -27,17 +28,12 @@ int main(int argc, const char *argv[])

2728{

2829 qSetMessagePattern("[%{time yyyy-MM-dd:hh:mm:ss.zzz}] %{if-category}%{category}: %{endif}%{message}");

2930

30− bool isMirServer = qgetenv("QT_QPA_PLATFORM") == "mirserver";

31− if (!isMirServer && qgetenv("QT_QPA_PLATFORM") == "ubuntumirclient") {

32− setenv("QT_QPA_PLATFORM", "mirserver", 1 /* overwrite */);

33− isMirServer = true;

34− }

35−

3631 if (enableQmlDebugger(argc, argv)) {

3732 QQmlDebuggingEnabler qQmlEnableDebuggingHelper(true);

3833 }

3934

40− ShellApplication *application = new ShellApplication(argc, (char**)argv, isMirServer);

35+ auto *application = new UnityApplication(argc,

36+ (char**)argv);

4137

4238 UnixSignalHandler signalHandler([]{

4339 QGuiApplication::exit(0);

tests/mocks/CMakeLists.txt+1

@@ -43,6 +43,7 @@ add_subdirectory(SessionBroadcast)

4343add_subdirectory(Ubuntu)

4444add_subdirectory(Unity)

4545add_subdirectory(QtMultimedia)

46+add_subdirectory(WindowManager)

4647add_subdirectory(Wizard)

4748add_subdirectory(Utils)

4849add_subdirectory(UInput)

tests/mocks/Cursor/Cursor.qml+49−2

@@ -15,8 +15,11 @@

1515 */

1616

1717import QtQuick 2.4

18+import UInput 0.1

19+

20+Canvas {

21+ id: root

1822

19−Item {

2023 property int topBoundaryOffset // effectively panel height

2124 property Item confiningItem

2225

@@ -30,5 +33,49 @@ Item {

3033 signal pushStopped()

3134 signal mouseMoved()

3235

33− onMouseMoved: opacity = 1;

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

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+ }

3481}

tests/mocks/GSettings.1.0/plugin.cpp+12

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

1818#include "fake_gsettings.h"

1919

2020#include <QtQml/qqml.h>

21+#include <QQmlEngine>

22+#include <QQmlContext>

2123

2224static QObject* controllerProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)

2325{

@@ -31,3 +33,13 @@ void FakeGSettingsQmlPlugin::registerTypes(const char *uri)

3133 qmlRegisterUncreatableType<GSettingsSchemaQml>(uri, 1, 0, "GSettingsSchema",

3234 "GSettingsSchema can only be used inside of a GSettings component");

3335}

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

2626

2727public:

2828 void registerTypes(const char *uri) override;

29+ void initializeEngine(QQmlEngine *engine, const char *uri) override;

2930};

3031

3132#endif // PLUGIN_H

tests/mocks/UInput/plugin.cpp+6−1

@@ -19,8 +19,13 @@

1919

2020#include <QtQml/qqml.h>

2121

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

23+{

24+ return new MockUInput;

25+}

26+

2227void MockUInputPlugin::registerTypes(const char *uri)

2328{

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

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

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

2631}

tests/mocks/Unity/Application/CMakeLists.txt+26−1

@@ -1,3 +1,12 @@

1+pkg_check_modules(MIRTEST mirtest>=0.26 REQUIRED)

2+

3+include_directories(

4+ SYSTEM

5+ ${MIRTEST_INCLUDE_DIRS}

6+ ${MIRAL_INCLUDE_DIRS}

7+ ${libunity8-private_SOURCE_DIR}

8+)

9+

110set(FakeUnityApplicationQml_SOURCES

211 plugin.cpp

312 ApplicationInfo.cpp

@@ -19,11 +28,27 @@ set(FakeUnityApplicationQml_SOURCES

1928 resources/surfaces.qrc

2029)

2130

22−add_library(FakeUnityApplicationQml MODULE ${FakeUnityApplicationQml_SOURCES})

31+add_library(FakeUnityApplicationQml MODULE

32+ ${FakeUnityApplicationQml_SOURCES}

33+)

34+

35+#add_dependencies(FakeUnityApplicationQml windowmanagementpolicy)

36+

37+target_link_libraries(FakeUnityApplicationQml

38+ ${MIRTEST_LDFLAGS}

39+ ${MIRAL_LDFLAGS}

40+ mockwindowmanagmentpolicy

41+)

2342

2443add_library(NonMirUnityApplicationQml MODULE ${FakeUnityApplicationQml_SOURCES})

2544set_target_properties(NonMirUnityApplicationQml PROPERTIES OUTPUT_NAME FakeUnityApplicationQml)

2645

46+target_link_libraries(NonMirUnityApplicationQml

47+ ${MIRTEST_LDFLAGS}

48+ ${MIRAL_LDFLAGS}

49+ mockwindowmanagmentpolicy

50+)

51+

2752qt5_use_modules(FakeUnityApplicationQml Core Quick DBus)

2853qt5_use_modules(NonMirUnityApplicationQml Core Quick DBus)

2954

tests/mocks/Unity/Application/MirSurfaceItem.cpp+27−4

@@ -189,9 +189,15 @@ void MirSurfaceItem::createQmlContentItem()

189189 m_qmlItem = qobject_cast<QQuickItem*>(m_qmlContentComponent->create());

190190 m_qmlItem->setParentItem(this);

191191

192− m_qmlItem->setWidth(m_surfaceWidth);

193− m_qmlItem->setHeight(m_surfaceHeight);

192+ if (m_fillMode == FillMode::Stretch && width() != 0 && height() != 0) {

193+ m_qmlItem->setWidth(width());

194+ m_qmlItem->setHeight(height());

195+ } else {

196+ m_qmlItem->setWidth(m_surfaceWidth);

197+ m_qmlItem->setHeight(m_surfaceHeight);

198+ }

194199

200+ qDebug() << "set size to" << m_surfaceWidth;

195201 setImplicitWidth(m_qmlItem->implicitWidth());

196202 setImplicitHeight(m_qmlItem->implicitHeight());

197203

@@ -308,6 +314,16 @@ void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

308314 connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);

309315 connect(m_qmlSurface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);

310316 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();

311327

312328 QUrl qmlComponentFilePath;

313329 if (!m_qmlSurface->qmlFilePath().isEmpty()) {

@@ -321,6 +337,7 @@ void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

321337 switch (m_qmlContentComponent->status()) {

322338 case QQmlComponent::Ready:

323339 createQmlContentItem();

340+ qDebug() << "content created" << m_surfaceWidth << implicitWidth() << width();

324341 break;

325342 case QQmlComponent::Loading:

326343 connect(m_qmlContentComponent, &QQmlComponent::statusChanged,

@@ -399,9 +416,15 @@ void MirSurfaceItem::updateSurfaceSize()

399416 if (m_qmlSurface && m_surfaceWidth > 0 && m_surfaceHeight > 0) {

400417 m_qmlSurface->resize(m_surfaceWidth, m_surfaceHeight);

401418 if (m_qmlItem) {

402− m_qmlItem->setWidth(m_surfaceWidth);

403− m_qmlItem->setHeight(m_surfaceHeight);

419+ if (m_fillMode == FillMode::Stretch) {

420+ m_qmlItem->setWidth(width());

421+ m_qmlItem->setHeight(height());

422+ } else {

423+ m_qmlItem->setWidth(m_surfaceWidth);

424+ m_qmlItem->setHeight(m_surfaceHeight);

425+ }

404426 }

427+ qDebug() << this << "setting implicitsize" << m_surfaceWidth << m_surfaceHeight;

405428 setImplicitSize(m_surfaceWidth, m_surfaceHeight);

406429 }

407430}

tests/mocks/Unity/Application/SurfaceManager.cpp+93−2

@@ -18,10 +18,12 @@

1818

1919#include "ApplicationInfo.h"

2020#include "VirtualKeyboard.h"

21+#include "../../WindowManager/WindowManagementPolicy.h"

2122

2223#include <paths.h>

24+#include <mirtest/mir/test/doubles/stub_surface.h>

2325

24−#define SURFACEMANAGER_DEBUG 0

26+#define SURFACEMANAGER_DEBUG 1

2527

2628#if SURFACEMANAGER_DEBUG

2729#define DEBUG_MSG(params) qDebug().nospace() << "SurfaceManager[" << (void*)this << "]::" << __func__ << params

@@ -31,6 +33,12 @@

3133

3234namespace unityapi = unity::shell::application;

3335

36+uint qHash(const WindowWrapper &key, uint)

37+{

38+ std::shared_ptr<mir::scene::Surface> surface = key.window;

39+ return (quintptr)surface.get();

40+}

41+

3442SurfaceManager *SurfaceManager::m_instance = nullptr;

3543

3644SurfaceManager *SurfaceManager::instance()

@@ -44,6 +52,21 @@ SurfaceManager::SurfaceManager(QObject *)

4452

4553 Q_ASSERT(m_instance == nullptr);

4654 m_instance = this;

55+

56+ connect(WindowManagementPolicy::instance(), &WindowManagementPolicy::windowAdded,

57+ this, [this](const miral::Window& window) {

58+ Q_EMIT surfaceCreated(surfaceFor(window));

59+ });

60+

61+ connect(WindowManagementPolicy::instance(), &WindowManagementPolicy::windowsAddedToWorkspace,

62+ this, [this](const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows) {

63+ Q_EMIT surfacesAddedToWorkspace(workspace, surfacesFor(windows));

64+ });

65+

66+ connect(WindowManagementPolicy::instance(), &WindowManagementPolicy::windowsAboutToBeRemovedFromWorkspace,

67+ this, [this](const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows) {

68+ Q_EMIT surfacesAboutToBeRemovedFromWorkspace(workspace, surfacesFor(windows));

69+ });

4770}

4871

4972SurfaceManager::~SurfaceManager()

@@ -58,6 +81,36 @@ SurfaceManager::~SurfaceManager()

5881 m_instance = nullptr;

5982}

6083

84+MirSurfaceInterface *SurfaceManager::surfaceFor(const miral::Window& window) const

85+{

86+ auto iter = m_windowToSurface.find({window});

87+ if (iter != m_windowToSurface.end()) {

88+ return *iter;

89+ }

90+ return nullptr;

91+}

92+

93+QVector<MirSurfaceInterface*> SurfaceManager::surfacesFor(const std::vector<miral::Window> &windows) const

94+{

95+ QVector<unityapi::MirSurfaceInterface*> surfaces;

96+ for (size_t i = 0; i < windows.size(); i++) {

97+ auto mirSurface = surfaceFor(windows[i]);

98+ if (mirSurface) {

99+ surfaces.push_back(mirSurface);

100+ }

101+ }

102+ return surfaces;

103+}

104+

105+miral::Window SurfaceManager::windowFor(MirSurfaceInterface *surface) const

106+{

107+ auto iter = m_surfaceToWindow.find(surface);

108+ if (iter != m_surfaceToWindow.end()) {

109+ return iter->window;

110+ }

111+ return miral::Window();

112+}

113+

61114MirSurface *SurfaceManager::createSurface(const QString& name,

62115 Mir::Type type,

63116 Mir::State state,

@@ -75,7 +128,12 @@ MirSurface *SurfaceManager::createSurface(const QString& name,

75128

76129void SurfaceManager::registerSurface(MirSurface *surface)

77130{

131+ auto fakeSurface = std::make_shared<mir::test::doubles::StubSurface>();

132+ WindowWrapper window{miral::Window(nullptr, fakeSurface), fakeSurface};

133+

78134 m_surfaces.prepend(surface);

135+ m_windowToSurface.insert(window, surface);

136+ m_surfaceToWindow.insert(surface, window);

79137

80138 if (!surface->parentSurface()) {

81139 surface->setMinimumWidth(m_newSurfaceMinimumWidth);

@@ -92,6 +150,8 @@ void SurfaceManager::registerSurface(MirSurface *surface)

92150

93151 const QString persistentId = surface->persistentId();

94152 connect(surface, &QObject::destroyed, this, [=]() {

153+ WindowWrapper key = m_surfaceToWindow.take(surface);

154+ m_windowToSurface.remove(key);

95155 this->onSurfaceDestroyed(surface, persistentId);

96156 });

97157

@@ -99,7 +159,12 @@ void SurfaceManager::registerSurface(MirSurface *surface)

99159

100160void SurfaceManager::notifySurfaceCreated(unityapi::MirSurfaceInterface *surface)

101161{

102− Q_EMIT surfaceCreated(surface);

162+ if (Q_UNLIKELY(!m_surfaceToWindow.contains(surface))) {

163+ Q_EMIT surfaceCreated(surface);

164+ return;

165+ }

166+

167+ WindowManagementPolicy::instance()->addWindow(m_surfaceToWindow[surface].window);

103168}

104169

105170void SurfaceManager::setNewSurfaceMinimumWidth(int value)

@@ -209,6 +274,32 @@ void SurfaceManager::activate(unityapi::MirSurfaceInterface *apiSurface)

209274 DEBUG_MSG("("<<surface<<") ended");

210275}

211276

277+void SurfaceManager::forEachSurfaceInWorkspace(const std::shared_ptr<miral::Workspace> &workspace,

278+ const std::function<void(unity::shell::application::MirSurfaceInterface*)> &callback)

279+{

280+ WindowManagementPolicy::instance()->forEachWindowInWorkspace(workspace, [&](const miral::Window &window) {

281+ auto surface = surfaceFor(window);

282+ if (surface) {

283+ callback(surface);

284+ }

285+ });

286+}

287+

288+void SurfaceManager::moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface* surface,

289+ const std::shared_ptr<miral::Workspace> &workspace)

290+{

291+ auto window = windowFor(surface);

292+ if (window) {

293+ WindowManagementPolicy::instance()->moveWindowToWorkspace(window, workspace);

294+ }

295+}

296+

297+void SurfaceManager::moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to,

298+ const std::shared_ptr<miral::Workspace> &from)

299+{

300+ WindowManagementPolicy::instance()->moveWorkspaceContentToWorkspace(to, from);

301+}

302+

212303void SurfaceManager::onStateRequested(MirSurface *surface, Mir::State state)

213304{

214305 DEBUG_MSG("("<<surface<<","<<state<<") started");

tests/mocks/Unity/Application/SurfaceManager.h+21

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

2020#include <QObject>

2121

2222#include <unity/shell/application/SurfaceManagerInterface.h>

23+#include <miral/window.h>

2324

2425#include "MirSurface.h"

2526#include "VirtualKeyboard.h"

2627

2728class ApplicationInfo;

2829

30+struct WindowWrapper {

31+ miral::Window window;

32+ std::shared_ptr<mir::scene::Surface> session{nullptr}; // Keeps the window surface alive.

33+ bool operator==(const WindowWrapper& other) const { return window==other.window; }

34+};

35+uint qHash(const WindowWrapper &key, uint seed = 0);

36+

2937class SurfaceManager : public unity::shell::application::SurfaceManagerInterface

3038{

3139 Q_OBJECT

@@ -46,6 +54,13 @@ public:

4654 void raise(unity::shell::application::MirSurfaceInterface *surface) override;

4755 void activate(unity::shell::application::MirSurfaceInterface *surface) override;

4856

57+ void forEachSurfaceInWorkspace(const std::shared_ptr<miral::Workspace> &workspace,

58+ const std::function<void(unity::shell::application::MirSurfaceInterface*)> &callback) override;

59+ void moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface* surface,

60+ const std::shared_ptr<miral::Workspace> &workspace) override;

61+ void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to,

62+ const std::shared_ptr<miral::Workspace> &from) override;

63+

4964 Q_INVOKABLE MirSurface* createSurface(const QString& name,

5065 Mir::Type type,

5166 Mir::State state,

@@ -95,6 +110,9 @@ private:

95110 void doRaise(unity::shell::application::MirSurfaceInterface *surface);

96111 void focusFirstAvailableSurface();

97112 void registerSurface(MirSurface *surface);

113+ unity::shell::application::MirSurfaceInterface* surfaceFor(const miral::Window &window) const;

114+ QVector<unity::shell::application::MirSurfaceInterface*> surfacesFor(const std::vector<miral::Window> &windows) const;

115+ miral::Window windowFor(unity::shell::application::MirSurfaceInterface* surface) const;

98116

99117 static SurfaceManager *m_instance;

100118

@@ -110,6 +128,9 @@ private:

110128

111129 QList<MirSurface*> m_surfaces;

112130

131+ QHash<WindowWrapper, unity::shell::application::MirSurfaceInterface*> m_windowToSurface;

132+ QHash<unity::shell::application::MirSurfaceInterface*, WindowWrapper> m_surfaceToWindow;

133+

113134 VirtualKeyboard *m_virtualKeyboard{nullptr};

114135};

115136

tests/mocks/Unity/Application/plugin.cpp+7−1

@@ -38,6 +38,12 @@ QObject* mirSingleton(QQmlEngine*, QJSEngine*)

3838{

3939 return new MirMock;

4040}

41+

42+QObject* surfaceManagerSingleton(QQmlEngine*, QJSEngine*)

43+{

44+ return new SurfaceManager;

45+}

46+

4147} // anonymous namespace

4248

4349void FakeUnityApplicationQmlPlugin::registerTypes(const char *uri)

@@ -59,7 +65,7 @@ void FakeUnityApplicationQmlPlugin::registerTypes(const char *uri)

5965

6066 qmlRegisterSingletonType<ApplicationManager>(uri, 0, 1, "ApplicationManager", applicationManagerSingleton);

6167 qmlRegisterSingletonType<MirMock>(uri, 0, 1, "Mir", mirSingleton);

62− qmlRegisterType<SurfaceManager>(uri, 0, 1, "SurfaceManager");

68+ qmlRegisterSingletonType<SurfaceManager>(uri, 0, 1, "SurfaceManager", surfaceManagerSingleton);

6369}

6470

6571void FakeUnityApplicationQmlPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

tests/mocks/Unity/CMakeLists.txt−1

@@ -6,7 +6,6 @@ add_subdirectory(InputInfo)

66add_subdirectory(Launcher)

77add_subdirectory(Notifications)

88add_subdirectory(DashCommunicator)

9−add_subdirectory(Screens)

109add_subdirectory(Platform)

1110

1211pkg_search_module(GOBJECT gobject-2.0 REQUIRED)

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 @@

1818

1919#include "qinputdeviceinfo_mock_p.h"

2020

21−MockController::MockController(QObject *parent):

22− QObject(parent)

21+#include <QQuickView>

22+#include <QQmlComponent>

23+#include <QQuickItem>

24+#include <paths.h>

25+

26+MockController::MockController(QQmlEngine *engine)

2327{

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+}

2442

43+MockController *MockController::instance(QQmlEngine *engine)

44+{

45+ static MockController* controller = new MockController(engine);

46+ return controller;

2547}

2648

2749QInputDevice *MockController::addMockDevice(const QString &devicePath, QInputDevice::InputType type)

tests/mocks/Unity/InputInfo/mockcontroller.h+5−1

@@ -20,13 +20,17 @@

2020#include <QObject>

2121#include "qinputinfo.h"

2222

23+class QQmlEngine;

24+

2325class MockController: public QObject

2426{

2527 Q_OBJECT

2628public:

27− MockController(QObject *parent = 0);

29+ MockController(QQmlEngine *engine);

2830 ~MockController() = default;

2931

32+ static MockController *instance(QQmlEngine *engine);

33+

3034 Q_INVOKABLE QInputDevice* addMockDevice(const QString &devicePath, QInputDevice::InputType type);

3135 Q_INVOKABLE void removeDevice(const QString &devicePath);

3236};

tests/mocks/Unity/InputInfo/plugin.cpp+1−2

@@ -26,9 +26,8 @@

2626

2727static QObject *backendProvider(QQmlEngine *engine, QJSEngine *scriptEngine)

2828{

29− Q_UNUSED(engine)

3029 Q_UNUSED(scriptEngine)

31− return new MockController(engine);

30+ return MockController::instance(engine);

3231}

3332

3433void InputInfoPlugin::registerTypes(const char *uri)

tests/mocks/Unity/InputInfo/qmldir+2

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

11module Unity.InputInfo

22plugin MockInputInfo

3+

4+InputWindow 0.1 InputWindow.qml

tests/mocks/Unity/Screens/CMakeLists.txtdeleted−14

@@ -1,14 +0,0 @@

1−include_directories(

2− ${CMAKE_CURRENT_SOURCE_DIR}

3−)

4−

5−set(MockScreens_SOURCES

6− plugin.cpp

7− screens.cpp

8−)

9−

10−add_library(MockScreensPlugin MODULE ${MockScreens_SOURCES})

11−

12−qt5_use_modules(MockScreensPlugin Gui Qml)

13−

14−add_unity8_mock(Unity.Screens 0.1 Unity/Screens PREFIX mocks TARGETS MockScreensPlugin)

tests/mocks/Unity/Screens/qmldirdeleted−2

@@ -1,2 +0,0 @@

1−module Unity.Screens

2−plugin MockScreensPlugin

tests/mocks/Unity/Screens/screens.cppdeleted−71

@@ -1,71 +0,0 @@

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 "screens.h"

18−

19−// Qt

20−#include <QGuiApplication>

21−#include <QScreen>

22−#include <QDebug>

23−

24−Q_DECLARE_METATYPE(QScreen*)

25−

26−Screens::Screens(QObject *parent) :

27− QAbstractListModel(parent)

28−{

29− // start with one screen attached

30− m_screenList.append(new Screen());

31−}

32−

33−Screens::~Screens() noexcept

34−{

35− qDeleteAll(m_screenList);

36− m_screenList.clear();

37−}

38−

39−QHash<int, QByteArray> Screens::roleNames() const

40−{

41− QHash<int, QByteArray> roles;

42− roles[ScreenRole] = "screen";

43− roles[OutputTypeRole] = "outputType";

44− return roles;

45−}

46−

47−QVariant Screens::data(const QModelIndex &index, int role) const

48−{

49− if (!index.isValid() || index.row() >= m_screenList.size()) {

50− return QVariant();

51− }

52−

53− switch(role) {

54− case ScreenRole:

55− return QVariant::fromValue(m_screenList.at(index.row())->qScreen);

56− case OutputTypeRole:

57− return m_screenList.at(index.row())->outputTypes;

58− }

59−

60− return QVariant();

61−}

62−

63−int Screens::rowCount(const QModelIndex &) const

64−{

65− return count();

66−}

67−

68−int Screens::count() const

69−{

70− return m_screenList.size();

71−}

tests/mocks/Unity/Screens/screens.hdeleted−82

@@ -1,82 +0,0 @@

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 SCREENS_H

18−#define SCREENS_H

19−

20−#include <QAbstractListModel>

21−#include <QScreen>

22−

23−class Screen;

24−

25−class Screens : public QAbstractListModel

26−{

27− Q_OBJECT

28−

29− Q_PROPERTY(int count READ count NOTIFY countChanged)

30−

31−public:

32− enum ItemRoles {

33− ScreenRole = Qt::UserRole + 1,

34− OutputTypeRole

35− };

36−

37− enum OutputTypes {

38− Unknown,

39− VGA,

40− DVII,

41− DVID,

42− DVIA,

43− Composite,

44− SVideo,

45− LVDS,

46− Component,

47− NinePinDIN,

48− DisplayPort,

49− HDMIA,

50− HDMIB,

51− TV,

52− EDP

53− };

54− Q_ENUM(OutputTypes)

55−

56− explicit Screens(QObject *parent = 0);

57− virtual ~Screens() noexcept;

58−

59− /* QAbstractItemModel */

60− QHash<int, QByteArray> roleNames() const override;

61− QVariant data(const QModelIndex &index, int role = ScreenRole) const override;

62− int rowCount(const QModelIndex &parent = QModelIndex()) const override;

63−

64− int count() const;

65−

66−Q_SIGNALS:

67− void countChanged();

68− void screenAdded(QScreen *screen);

69− void screenRemoved(QScreen *screen);

70−

71−private:

72− QList<Screen *> m_screenList;

73−};

74−

75−class Screen

76−{

77−public:

78− Screens::OutputTypes outputTypes = Screens::Unknown;

79− QScreen *qScreen = nullptr;

80−};

81−

82−#endif // SCREENS_H

tests/mocks/WindowManager/CMakeLists.txtnew file+53

@@ -0,0 +1,53 @@

1+include_directories(

2+ SYSTEM

3+ ${QTMIRSERVER_INCLUDE_DIRS}

4+)

5+

6+include_directories(

7+ ${CMAKE_CURRENT_SOURCE_DIR}

8+ ${CMAKE_CURRENT_BINARY_DIR}

9+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager

10+ ${libunity8-private_SOURCE_DIR}

11+)

12+

13+add_library(mockwindowmanagmentpolicy SHARED

14+ WindowManagementPolicy.cpp

15+)

16+target_link_libraries(mockwindowmanagmentpolicy

17+ ${MIRAL_LDFLAGS}

18+ unity8-private

19+)

20+qt5_use_modules(mockwindowmanagmentpolicy Core)

21+

22+set(WINDOWMANAGER_SRC

23+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Screen.cpp

24+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/ScreenAttached.cpp

25+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Screens.cpp

26+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/ScreenWindow.cpp

27+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/TopLevelWindowModel.cpp

28+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Window.cpp

29+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/WindowManagerObjects.cpp

30+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/WorkspaceManager.cpp

31+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/WorkspaceModel.cpp

32+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Workspace.cpp

33+ MockScreens.cpp

34+ MockScreenWindow.cpp

35+ WindowManagerPlugin.cpp

36+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h

37+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationManagerInterface.h

38+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h

39+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h

40+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceListInterface.h

41+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/SurfaceManagerInterface.h

42+)

43+

44+add_library(MockWindowManager-qml SHARED ${WINDOWMANAGER_SRC})

45+

46+target_link_libraries(MockWindowManager-qml

47+ ${QTMIRSERVER_LDFLAGS}

48+ mockwindowmanagmentpolicy

49+)

50+

51+qt5_use_modules(MockWindowManager-qml Qml Quick Gui)

52+

53+add_unity8_mock(WindowManager 1.0 WindowManager TARGETS MockWindowManager-qml)

tests/mocks/Unity/Screens/plugin.cpp → tests/mocks/WindowManager/MockScreenWindow.cpprenamed+14−9

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

11/*

33 *

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

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

@@ -14,16 +14,21 @@

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

1515 */

1616

17−#include "plugin.h"

18−#include "screens.h"

17+#include "MockScreenWindow.h"

18+#include "MockScreens.h"

1919

20−#include <QScreen>

20+// Qt

21+#include <QGuiApplication>

22+#include <QDebug>

2123

22−void UnityScreensPlugin::registerTypes(const char* uri)

24+MockScreenWindow::MockScreenWindow(QQuickWindow *parent)

25+ : ScreenWindow(parent)

2326{

24− Q_ASSERT(QLatin1String(uri) == QLatin1String("Unity.Screens"));

25−

26− qRegisterMetaType<QScreen*>("QScreen*");

27+ connect(this, &ScreenWindow::screenWrapperChanged, this, [this]() {

28+ MockScreens::instance()->connectWindow(this);

29+ });

30+}

2731

28− qmlRegisterType<Screens>(uri, 0, 1, "Screens");

32+MockScreenWindow::~MockScreenWindow()

33+{

2934}

tests/mocks/Unity/Screens/plugin.h → tests/mocks/WindowManager/MockScreenWindow.hrenamed+11−6

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

11/*

33 *

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

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

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

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

1515 */

1616

17−#include <QQmlExtensionPlugin>

18−#include <QtQml/qqml.h>

17+#ifndef MOCK_SCREENWINDOW_H

18+#define MOCK_SCREENWINDOW_H

1919

20−class UnityScreensPlugin : public QQmlExtensionPlugin {

20+#include "ScreenWindow.h"

21+

22+class MockScreenWindow : public ScreenWindow

23+{

2124 Q_OBJECT

22− Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface/1.0")

2325public:

24− void registerTypes(const char* uri) override;

26+ explicit MockScreenWindow(QQuickWindow *parent = 0);

27+ ~MockScreenWindow();

2528};

29+

30+#endif // MOCK_SCREENWINDOW_H

tests/mocks/WindowManager/MockScreens.cppnew file+217

@@ -0,0 +1,217 @@

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 "MockScreens.h"

18+#include "ScreenWindow.h"

19+

20+// qtmirserver

21+#include <qtmir/screen.h>

22+

23+#include <QGuiApplication>

24+#include <QWindow>

25+#include <QWeakPointer>

26+

27+namespace {

28+

29+QWeakPointer<MockScreens> m_screens;

30+

31+class MockScreen : public qtmir::Screen

32+{

33+ Q_OBJECT

34+ Q_PROPERTY(QString outputTypeName READ outputTypeName NOTIFY outputTypeNameChanged)

35+public:

36+ MockScreen()

37+ {

38+ m_sizes.append(new qtmir::ScreenMode(50, QSize(800,568)));

39+ m_sizes.append(new qtmir::ScreenMode(60, QSize(1280,1024)));

40+ m_sizes.append(new qtmir::ScreenMode(60, QSize(1440,900)));

41+ m_sizes.append(new qtmir::ScreenMode(60, QSize(1920,1080)));

42+ m_physicalSize = QSize(800,568);

43+ }

44+ ~MockScreen() {

45+ qDeleteAll(m_sizes);

46+ m_sizes.clear();

47+ }

48+

49+ void connectToWindow(QWindow* w)

50+ {

51+ if (m_connectedWindow == w) return;

52+

53+ if (m_connectedWindow) {

54+ disconnect(m_connectedWindow.data());

55+ }

56+

57+ m_connectedWindow = w;

58+

59+ if (w) {

60+ connect(w, &ScreenWindow::heightChanged, this, [this](int height) {

61+ if (height == 0 || height == m_sizes.first()->size.rheight()) {

62+ return;

63+ }

64+ m_sizes.first()->size.rheight() = height;

65+ Q_EMIT availableModesChanged();

66+

67+ });

68+ connect(w, &ScreenWindow::widthChanged, this, [this](int width) {

69+ if (width == 0 || width == m_sizes.first()->size.rwidth()) {

70+ return;

71+ }

72+ m_sizes.first()->size.rwidth() = width;

73+ Q_EMIT availableModesChanged();

74+ });

75+

76+ Q_EMIT availableModesChanged();

77+ }

78+ }

79+

80+ qtmir::OutputId outputId() const override { return m_id; }

81+ bool used() const override { return m_used; }

82+ QString name() const override { return m_name; }

83+ float scale() const override { return m_scale; }

84+ QSizeF physicalSize() const override { return m_physicalSize; }

85+ qtmir::FormFactor formFactor() const override { return m_formFactor; }

86+ qtmir::OutputTypes outputType() const override { return m_outputType; }

87+ QString outputTypeName() const { return QStringLiteral("Internal"); }

88+ MirPowerMode powerMode() const override { return m_powerMode; }

89+ Qt::ScreenOrientation orientation() const override { return m_orientation; }

90+ QPoint position() const override { return m_position; }

91+ uint currentModeIndex() const override { return m_currentModeIndex; }

92+ bool isActive() const override { return m_active; }

93+

94+ QQmlListProperty<qtmir::ScreenMode> availableModes() override {

95+ return QQmlListProperty<qtmir::ScreenMode>(this, m_sizes);

96+ }

97+

98+ void setActive(bool active) override {

99+ if (m_active != active) {

100+ m_active = active;

101+ Q_EMIT activeChanged(m_active);

102+ }

103+ }

104+

105+ QScreen* qscreen() const override {

106+ if (qGuiApp->topLevelWindows().count() > 0) {

107+ return qGuiApp->topLevelWindows()[0]->screen();

108+ }

109+ return qGuiApp->primaryScreen();

110+ }

111+

112+ qtmir::ScreenConfiguration *beginConfiguration() const override {

113+ auto config = new qtmir::ScreenConfiguration;

114+ config->valid = true;

115+ config->id = m_id;

116+ config->used = m_used;

117+ config->topLeft = m_position;

118+ config->currentModeIndex = m_currentModeIndex;

119+ config->powerMode = m_powerMode;

120+ config->scale = m_scale;

121+ config->formFactor = m_formFactor;

122+ return config;

123+ }

124+

125+ bool applyConfiguration(qtmir::ScreenConfiguration *configuration) override {

126+ m_used = configuration->used;

127+ m_position = configuration->topLeft;

128+ m_currentModeIndex = configuration->currentModeIndex;

129+ m_powerMode = configuration->powerMode;

130+ m_scale = configuration->scale;

131+ m_formFactor = configuration->formFactor;

132+ return true;

133+ }

134+

135+Q_SIGNALS:

136+ void outputTypeNameChanged();

137+

138+public:

139+ qtmir::OutputId m_id{0};

140+ bool m_active{false};

141+ bool m_used{true};

142+ QString m_name;

143+ qtmir::OutputTypes m_outputType{qtmir::Unknown};

144+ MirPowerMode m_powerMode{mir_power_mode_on};

145+ Qt::ScreenOrientation m_orientation{Qt::PrimaryOrientation};

146+ float m_scale{1.0};

147+ qtmir::FormFactor m_formFactor{qtmir::FormFactorMonitor};

148+ QPoint m_position;

149+ uint m_currentModeIndex{0};

150+ QList<qtmir::ScreenMode*> m_sizes;

151+ QSizeF m_physicalSize;

152+

153+ QPointer<QWindow> m_connectedWindow;

154+};

155+}

156+

157+MockScreens::MockScreens()

158+{

159+ bool ok = false;

160+ int screenCount = qEnvironmentVariableIntValue("UNITY_MOCK_SCREEN_COUNT", &ok);

161+ if (!ok) screenCount = 1;

162+ QPoint lastPoint(0,0);

163+ for (int i = 0; i < screenCount; ++i) {

164+ auto screen = new MockScreen();

165+ screen->m_id = qtmir::OutputId{i};

166+ screen->m_active = i == 0;

167+ screen->m_name = QString("Monitor %1").arg(i);

168+ screen->m_position = QPoint(lastPoint.x(), lastPoint.y());

169+ screen->m_currentModeIndex = 0;

170+ m_mocks.append(screen);

171+

172+ lastPoint.rx() += screen->m_sizes[screen->m_currentModeIndex]->size.width();

173+ }

174+}

175+

176+MockScreens::~MockScreens()

177+{

178+ qDeleteAll(m_mocks);

179+ m_mocks.clear();

180+}

181+

182+QVector<qtmir::Screen *> MockScreens::screens() const

183+{

184+ return m_mocks;

185+}

186+

187+qtmir::Screen *MockScreens::activeScreen() const

188+{

189+ Q_FOREACH(auto screen, m_mocks) {

190+ if (screen->isActive()) return screen;

191+ }

192+ return nullptr;

193+}

194+

195+QSharedPointer<MockScreens> MockScreens::instance()

196+{

197+ if (!m_screens) {

198+ QSharedPointer<MockScreens> screens(new MockScreens());

199+ m_screens = screens.toWeakRef();

200+ return screens;

201+ } else {

202+ return m_screens.lock();

203+ }

204+}

205+

206+void MockScreens::connectWindow(ScreenWindow *w)

207+{

208+ Screen* screen = w->screenWrapper();

209+ if (!screen) return;

210+

211+ auto mockScreen = qobject_cast<MockScreen*>(screen->wrapped());

212+ if (mockScreen) {

213+ mockScreen->connectToWindow(w);

214+ }

215+}

216+

217+#include "MockScreens.moc"

tests/mocks/WindowManager/MockScreens.hnew file+54

@@ -0,0 +1,54 @@

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 MOCK_SCREENS_H

18+#define MOCK_SCREENS_H

19+

20+#include <QAbstractListModel>

21+#include <QSharedPointer>

22+

23+#include <qtmir/screens.h>

24+

25+namespace qtmir

26+{

27+class Screens;

28+}

29+

30+class Screen;

31+class ScreenWindow;

32+

33+class MockScreens : public qtmir::Screens

34+{

35+ Q_OBJECT

36+public:

37+ MockScreens();

38+ ~MockScreens();

39+

40+ QVector<qtmir::Screen*> screens() const override;

41+

42+ qtmir::Screen *activeScreen() const override;

43+

44+ static QSharedPointer<MockScreens> instance();

45+

46+public Q_SLOTS:

47+ void connectWindow(ScreenWindow *w);

48+

49+private:

50+ QVector<qtmir::Screen*> m_mocks;

51+};

52+

53+

54+#endif // MOCK_SCREENS_H

tests/mocks/WindowManager/WindowManagementPolicy.cppnew file+114

@@ -0,0 +1,114 @@

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 "WindowManagementPolicy.h"

18+

19+#include <QDebug>

20+

21+WindowManagementPolicy::WindowManagementPolicy()

22+ : m_dummyWorkspace(std::shared_ptr<miral::Workspace>())

23+{

24+ wmPolicyInterface = this;

25+ m_activeWorkspace = m_dummyWorkspace;

26+}

27+

28+WindowManagementPolicy *WindowManagementPolicy::instance()

29+{

30+ static WindowManagementPolicy* wmPolicy(new WindowManagementPolicy);

31+ return wmPolicy;

32+}

33+

34+std::shared_ptr<miral::Workspace> WindowManagementPolicy::createWorkspace()

35+{

36+ auto workspace = std::make_shared<miral::Workspace>();

37+ m_workspaces.insert(workspace);

38+

39+ if (m_activeWorkspace.lock() == m_dummyWorkspace) {

40+ moveWorkspaceContentToWorkspace(workspace, m_dummyWorkspace);

41+ m_activeWorkspace = workspace;

42+ }

43+ return workspace;

44+}

45+

46+void WindowManagementPolicy::releaseWorkspace(const std::shared_ptr<miral::Workspace> &workspace)

47+{

48+ auto iter = m_workspaces.find(workspace);

49+ if (iter != m_workspaces.end()) m_workspaces.erase(iter);

50+

51+ if (m_workspaces.size() == 0) {

52+ m_activeWorkspace = m_dummyWorkspace;

53+ moveWorkspaceContentToWorkspace(m_dummyWorkspace, workspace);

54+ }

55+}

56+

57+void WindowManagementPolicy::setActiveWorkspace(const std::shared_ptr<miral::Workspace> &workspace)

58+{

59+ if (m_activeWorkspace.lock() == workspace)

60+ return;

61+ m_activeWorkspace = workspace ? workspace : m_dummyWorkspace;

62+}

63+

64+void WindowManagementPolicy::addWindow(const miral::Window &window)

65+{

66+ Q_EMIT windowAdded(window);

67+

68+ auto activeWorkspace = m_activeWorkspace.lock();

69+ if (activeWorkspace) {

70+ m_windows.insert(activeWorkspace, window);

71+

72+ Q_EMIT windowsAddedToWorkspace(activeWorkspace, {window});

73+ }

74+}

75+

76+void WindowManagementPolicy::forEachWindowInWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::function<void(const miral::Window &)> &callback)

77+{

78+ WorkspaceWindows::iterator i = m_windows.find(workspace);

79+ while (i != m_windows.end() && i.key() == workspace) {

80+ callback(i.value());

81+ ++i;

82+ }

83+}

84+

85+void WindowManagementPolicy::moveWindowToWorkspace(const miral::Window &window, const std::shared_ptr<miral::Workspace> &workspace)

86+{

87+ auto from = m_windows.key(window);

88+ if (from) {

89+ auto iter = m_windows.find(from, window);

90+ Q_EMIT windowsAboutToBeRemovedFromWorkspace(from, { window });

91+ m_windows.erase(iter);

92+ }

93+

94+ m_windows.insert(workspace, window);

95+ Q_EMIT windowsAddedToWorkspace(workspace, { window });

96+}

97+

98+void WindowManagementPolicy::moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to, const std::shared_ptr<miral::Workspace> &from)

99+{

100+ std::vector<miral::Window> windows;

101+

102+ WorkspaceWindows::iterator i = m_windows.find(from);

103+ while (i != m_windows.end() && i.key() == from) {

104+ windows.push_back(i.value());

105+ ++i;

106+ }

107+ Q_EMIT windowsAboutToBeRemovedFromWorkspace(from, windows);

108+ m_windows.remove(from);

109+

110+ Q_FOREACH(miral::Window window, windows) {

111+ m_windows.insert(to, window);

112+ }

113+ Q_EMIT windowsAddedToWorkspace(to, windows);

114+}

tests/mocks/WindowManager/WindowManagementPolicy.hnew file+73

@@ -0,0 +1,73 @@

1+/*

3+ *

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

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

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

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef MOCKWINDOMANAGEMENTPOLICY_H

18+#define MOCKWINDOMANAGEMENTPOLICY_H

19+

20+#include "wmpolicyinterface.h"

21+

22+#include <QObject>

23+#include <QMultiMap>

24+#include <QVector>

25+

26+#include <miral/window.h>

27+#include <memory>

28+#include <unordered_set>

29+

30+namespace miral {

31+class Workspace {};

32+}

33+

34+// A Fake window management policy for the mock.

35+class Q_DECL_EXPORT WindowManagementPolicy : public QObject,

36+ public WMPolicyInterface

37+{

38+ Q_OBJECT

39+public:

40+ WindowManagementPolicy();

41+

42+ // for use in mocks

43+ static WindowManagementPolicy *instance();

44+

45+ // From WMPolicyInterface

46+ std::shared_ptr<miral::Workspace> createWorkspace() override;

47+ void releaseWorkspace(const std::shared_ptr<miral::Workspace>& workspace) override;

48+ void setActiveWorkspace(const std::shared_ptr<miral::Workspace>& workspace) override;

49+

50+ void addWindow(const miral::Window& window);

51+

52+ void forEachWindowInWorkspace(std::shared_ptr<miral::Workspace> const& workspace,

53+ std::function<void(miral::Window const&)> const& callback);

54+

55+ void moveWindowToWorkspace(const miral::Window &window, const std::shared_ptr<miral::Workspace> &workspace);

56+

57+ void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace>& to,

58+ const std::shared_ptr<miral::Workspace>& from);

59+

60+Q_SIGNALS:

61+ void windowAdded(const miral::Window& window);

62+ void windowsAddedToWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows);

63+ void windowsAboutToBeRemovedFromWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows);

64+

65+private:

66+ std::weak_ptr<miral::Workspace> m_activeWorkspace;

67+ std::shared_ptr<miral::Workspace> m_dummyWorkspace;

68+ std::unordered_set<std::shared_ptr<miral::Workspace>> m_workspaces;

69+

70+ typedef QMultiMap<std::shared_ptr<miral::Workspace>, miral::Window> WorkspaceWindows;

71+ WorkspaceWindows m_windows;

72+};

73+#endif // UNITY_WINDOWMANAGEMENTPOLICY_H

tests/mocks/WindowManager/WindowManagerPlugin.cppnew file+82

@@ -0,0 +1,82 @@

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 "WindowManagerPlugin.h"

18+

19+#include "MockScreens.h"

20+#include "MockScreenWindow.h"

21+#include "Screen.h"

22+#include "ScreenAttached.h"

23+#include "Screens.h"

24+#include "TopLevelWindowModel.h"

25+#include "Window.h"

26+#include "WorkspaceManager.h"

27+#include "Workspace.h"

28+#include "WorkspaceModel.h"

29+#include "WindowManagementPolicy.h"

30+#include "WindowManagerObjects.h"

31+

32+#include <QtQml>

33+

34+static const QString notInstantiatable = QStringLiteral("Not instantiatable");

35+

36+static QObject *workspace_manager(QQmlEngine *engine, QJSEngine *scriptEngine)

37+{

38+ Q_UNUSED(engine)

39+ Q_UNUSED(scriptEngine)

40+ return WorkspaceManager::instance();

41+}

42+QObject* screensSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {

43+ Q_UNUSED(engine);

44+ Q_UNUSED(scriptEngine);

45+ return new Screens(MockScreens::instance());

46+}

47+QObject* objectsSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {

48+ Q_UNUSED(engine);

49+ Q_UNUSED(scriptEngine);

50+ return WindowManagerObjects::instance();

51+}

52+

53+void WindowManagerPlugin::registerTypes(const char *uri)

54+{

55+ qmlRegisterSingletonType<WorkspaceManager>(uri, 1, 0, "WorkspaceManager", workspace_manager);

56+ qmlRegisterUncreatableType<WorkspaceModel>(uri, 1, 0, "WorkspaceModel", notInstantiatable);

57+ qmlRegisterSingletonType<Screens>(uri, 1, 0, "Screens", screensSingleton);

58+ qmlRegisterUncreatableType<qtmir::ScreenMode>(uri, 1, 0, "ScreenMode", notInstantiatable);

59+ qmlRegisterUncreatableType<Workspace>(uri, 1, 0, "Workspace", notInstantiatable);

60+ qmlRegisterSingletonType<WindowManagerObjects>(uri, 1, 0, "WindowManagerObjects", objectsSingleton);

61+

62+ qRegisterMetaType<Screen*>("Screen*");

63+ qRegisterMetaType<ScreensProxy*>("ScreensProxy*");

64+ qRegisterMetaType<Workspace*>("Workspace*");

65+ qRegisterMetaType<TopLevelWindowModel*>("TopLevelWindowModel*");

66+

67+ qRegisterMetaType<Window*>("Window*");

68+ qRegisterMetaType<QAbstractListModel*>("QAbstractListModel*");

69+

70+ qmlRegisterType<MockScreenWindow>(uri, 1, 0, "ScreenWindow");

71+ qmlRegisterRevision<QWindow,1>(uri, 1, 0);

72+

73+ qmlRegisterUncreatableType<WMScreen>(uri, 1, 0, "WMScreen", notInstantiatable);

74+}

75+

76+void WindowManagerPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

77+{

78+ QQmlExtensionPlugin::initializeEngine(engine, uri);

79+

80+ // Make sure we've initialized the wm policy.

81+ WindowManagementPolicy::instance();

82+}

tests/mocks/WindowManager/WindowManagerPlugin.hnew file+33

@@ -0,0 +1,33 @@

1+/*

3+ *

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

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

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

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef WINDOWMANAGER_PLUGIN_H

18+#define WINDOWMANAGER_PLUGIN_H

19+

20+#include <QtQml/QQmlEngine>

21+#include <QtQml/QQmlExtensionPlugin>

22+

23+class WindowManagerPlugin : public QQmlExtensionPlugin

24+{

25+ Q_OBJECT

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

27+

28+public:

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

30+ void initializeEngine(QQmlEngine *engine, const char *uri) override;

31+};

32+

33+#endif // WINDOWMANAGER_PLUGIN_H

tests/mocks/WindowManager/qmldirnew file+2

@@ -0,0 +1,2 @@

1+module WindowManager

2+plugin MockWindowManager-qml

tests/qmltests/ApplicationMenuDataLoader.qml+1−4

@@ -22,11 +22,8 @@ import Unity.Indicators 0.1 as Indicators

2222

2323Object {

2424

25− property alias surfaceManager: sMgrHandler.target

26−

2725 Connections {

28− id: sMgrHandler

29− target: null

26+ target: SurfaceManager

3027 onSurfaceCreated: {

3128 var fakeMenuPath = "/" + surface.persistentId.replace(/\W+/g, "");

3229

tests/qmltests/ApplicationMenus/tst_MenuBar.qml−2

@@ -42,10 +42,8 @@ Item {

4242 value: false

4343 }

4444

45− SurfaceManager { id: sMgr }

4645 ApplicationMenuDataLoader {

4746 id: appMenuData

48− surfaceManager: sMgr

4947 }

5048

5149 Rectangle {

tests/qmltests/CMakeLists.txt+1

@@ -5,6 +5,7 @@ add_unity8_qmltest(. OrientedShell)

55add_unity8_qmltest(. DisabledScreenNotice)

66add_unity8_qmltest(. Shell)

77add_unity8_qmltest(. ShellWithPin)

8+add_unity8_qmltest(. ShellApplication)

89add_unity8_qmltest(. DeviceConfiguration)

910add_unity8_qmltest_data(. EdgeBarrierControls)

1011add_unity8_qmltest_data(. ApplicationMenuDataLoader)

tests/qmltests/Components/tst_VirtualTouchPad.qml+2−2

@@ -39,11 +39,11 @@ Rectangle {

3939

4040 SignalSpy {

4141 id: mouseEventSpy1

42− target: touchScreenPad.uinput

42+ target: UInput

4343 }

4444 SignalSpy {

4545 id: mouseEventSpy2

46− target: touchScreenPad.uinput

46+ target: UInput

4747 }

4848

4949 UnityTestCase {

tests/qmltests/Panel/tst_ActiveCallHint.qml−2

@@ -41,8 +41,6 @@ Item {

4141 elapsedTimerRunning: true

4242 }

4343

44− SurfaceManager {}

45−

4644 ActiveCallHint {

4745 id: callHint

4846 anchors {

tests/qmltests/Panel/tst_Panel.qml+14−14

@@ -42,10 +42,10 @@ PanelTest {

4242 value: keyboardAttached.checked

4343 }

4444

45− SurfaceManager { id: sMgr }

45+ readonly property alias panelState: panel.panelState

46+

4647 ApplicationMenuDataLoader {

4748 id: appMenuData

48− surfaceManager: sMgr

4949 }

5050

5151 Component.onCompleted: {

@@ -148,7 +148,7 @@ PanelTest {

148148 Layout.fillWidth: true

149149 CheckBox {

150150 id: windowControlsCB

151− onClicked: PanelState.decorationsVisible = checked

151+ onClicked: panelState.decorationsVisible = checked

152152 }

153153 Label {

154154 text: "Show window decorations"

@@ -159,7 +159,7 @@ PanelTest {

159159 RowLayout {

160160 Layout.fillWidth: true

161161 CheckBox {

162− onClicked: PanelState.title = checked ? "Fake window title" : ""

162+ onClicked: panelState.title = checked ? "Fake window title" : ""

163163 }

164164 Label {

165165 text: "Show fake window title"

@@ -245,7 +245,7 @@ PanelTest {

245245

246246 SignalSpy {

247247 id: windowControlButtonsSpy

248− target: PanelState

248+ target: panelState

249249 signalName: "closeClicked"

250250 }

251251

@@ -255,8 +255,8 @@ PanelTest {

255255 panel.fullscreenMode = false;

256256 callManager.foregroundCall = null;

257257

258− PanelState.title = "";

259− PanelState.decorationsVisible = false;

258+ panelState.title = "";

259+ panelState.decorationsVisible = false;

260260

261261 // Wait for the indicators to get into position.

262262 // (switches between normal and fullscreen modes are animated)

@@ -448,7 +448,7 @@ PanelTest {

448448 }

449449

450450 function test_hint(data) {

451− PanelState.title = "Fake Title"

451+ panelState.title = "Fake Title"

452452 panel.fullscreenMode = data.fullscreen;

453453 callManager.foregroundCall = data.call;

454454

@@ -490,7 +490,7 @@ PanelTest {

490490 // menus, first by running the hint animation, then after dragging down will

491491 // expose more of the panel. Releasing the touch will complete the show.

492492 function test_drag_applicationMenu_down_shows_menu(data) {

493− PanelState.title = "Fake Title";

493+ panelState.title = "Fake Title";

494494 panel.fullscreenMode = data.fullscreen;

495495 callManager.foregroundCall = data.call;

496496

@@ -581,7 +581,7 @@ PanelTest {

581581 }

582582

583583 function test_darkenedAreaEatsAllApplicationMenuEvents() {

584− PanelState.title = "Fake Title"

584+ panelState.title = "Fake Title"

585585

586586 // The center of the area not covered by the indicators menu

587587 // Ie, the visible darkened area behind the menu

@@ -702,7 +702,7 @@ PanelTest {

702702 var windowControlArea = findChild(panel, "windowControlArea");

703703 verify(windowControlArea, "Window control area should have been created in windowed mode")

704704

705− PanelState.decorationsVisible = true;

705+ panelState.decorationsVisible = true;

706706 // click in very topleft corner and verify the close button got clicked too

707707 mouseMove(panel, 0, 0);

708708 mouseClick(panel, 0, 0, undefined /*button*/, undefined /*modifiers*/, 100 /*short delay*/);

@@ -765,7 +765,7 @@ PanelTest {

765765 }

766766

767767 function test_stagedApplicationMenuBarShowOnMouseHover() {

768− PanelState.title = "Fake Title";

768+ panelState.title = "Fake Title";

769769 panel.mode = "staged";

770770 mouseEmulation.checked = false;

771771

@@ -783,7 +783,7 @@ PanelTest {

783783 }

784784

785785 function test_windowedApplicationMenuShowOnMouseHoverWhenDecorationsShown() {

786− PanelState.title = "Fake Title";

786+ panelState.title = "Fake Title";

787787 panel.mode = "windowed";

788788 mouseEmulation.checked = false;

789789

@@ -799,7 +799,7 @@ PanelTest {

799799 tryCompare(appTitle, "visible", true, undefined, "App title should still be visible on mouse hover when panel decorations are not visible");

800800 tryCompare(appMenuBar, "visible", false, undefined, "App menu bar should be visible on mouse hover when panel decorations are not visible");

801801

802− PanelState.decorationsVisible = true;

802+ panelState.decorationsVisible = true;

803803

804804 tryCompare(appTitle, "visible", false, undefined, "App title should still be visible on mouse hover when panel decorations are visible");

805805 tryCompare(appMenuBar, "visible", true, undefined, "App menu bar should be visible on mouse hover when panel decorations not visible");

tests/qmltests/Stage/tst_ApplicationWindow.qml−2

@@ -37,8 +37,6 @@ Rectangle {

3737 }

3838 property QtObject fakeApplication: null

3939

40− SurfaceManager{}

41−

4240 Loader {

4341 id: applicationWindowLoader

4442 focus: true

tests/qmltests/Stage/tst_DecoratedWindow.qml+5−3

@@ -46,10 +46,12 @@ Rectangle {

4646 value: false

4747 }

4848

49− SurfaceManager { id: sMgr }

5049 ApplicationMenuDataLoader {

5150 id: appMenuData

52− surfaceManager: sMgr

51+ }

52+

53+ PanelState {

54+ id: panelState

5355 }

5456

5557 Item {

@@ -99,7 +101,7 @@ Rectangle {

99101 surface: fakeApplication && fakeApplication.surfaceList.count > 0 ? fakeApplication.surfaceList.get(0) : null

100102

101103 Binding {

102− target: PanelState

104+ target: panelState

103105 property: "focusedPersistentSurfaceId"

104106 value: decoratedWindow.surface ? decoratedWindow.surface.persistentId : "x"

105107 }

tests/qmltests/Stage/tst_DesktopStage.qml+9−6

@@ -44,6 +44,10 @@ Item {

4444 value: false

4545 }

4646

47+ PanelState {

48+ id: panelState

49+ }

50+

4751 Component.onCompleted: {

4852 ApplicationMenusLimits.screenWidth = Qt.binding( function() { return stageLoader.width; } );

4953 ApplicationMenusLimits.screenHeight = Qt.binding( function() { return stageLoader.height; } );

@@ -63,16 +67,14 @@ Item {

6367 }

6468 }

6569

66− SurfaceManager { id: sMgr }

6770 ApplicationMenuDataLoader {

6871 id: appMenuData

69− surfaceManager: sMgr

7072 }

7173

7274 TopLevelWindowModel {

7375 id: topSurfaceList

7476 applicationManager: ApplicationManager

75− surfaceManager: sMgr

77+ surfaceManager: SurfaceManager

7678 }

7779

7880 Loader {

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

102104 topLevelSurfaceList: topSurfaceList

103105 interactive: true

104106 mode: "windowed"

107+ panelState: panelState

105108 }

106109 }

107110 }

@@ -631,19 +634,19 @@ Item {

631634 maximizeDelegate(facebookAppDelegate);

632635

633636 // verify the drop shadow is still not visible

634− verify(PanelState.dropShadow == false);

637+ verify(panelState.dropShadow == false);

635638

636639 // start a foreground app, not maximized

637640 var dialerAppDelegate = startApplication("dialer-app");

638641

639642 // verify the drop shadow becomes visible

640− tryCompareFunction(function() { return PanelState.dropShadow; }, true);

643+ tryCompareFunction(function() { return panelState.dropShadow; }, true);

641644

642645 // close the maximized app

643646 ApplicationManager.stopApplication("facebook-webapp");

644647

645648 // verify the drop shadow is gone

646− tryCompare(PanelState, "dropShadow", false);

649+ tryCompare(panelState, "dropShadow", false);

647650 }

648651

649652 function test_threeFingerTapShowsWindowControls_data() {

tests/qmltests/Stage/tst_PhoneStage.qml+1−3

@@ -31,10 +31,8 @@ Item {

3131

3232 property var greeter: { fullyShown: true }

3333

34− SurfaceManager { id: sMgr }

3534 ApplicationMenuDataLoader {

3635 id: appMenuData

37− surfaceManager: sMgr

3836 }

3937

4038 Stage {

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

5048 topLevelSurfaceList: TopLevelWindowModel {

5149 id: topLevelSurfaceList

5250 applicationManager: ApplicationManager

53− surfaceManager: sMgr

51+ surfaceManager: SurfaceManager

5452 }

5553 Component.onCompleted: {

5654 ApplicationManager.startApplication("unity8-dash");

tests/qmltests/Stage/tst_SurfaceContainer.qml−2

@@ -51,8 +51,6 @@ Rectangle {

5151 }

5252 }

5353

54− SurfaceManager {}

55−

5654 Loader {

5755 id: surfaceContainerLoader

5856 focus: true

tests/qmltests/Stage/tst_TabletStage.qml+1−3

@@ -35,10 +35,8 @@ Rectangle {

3535

3636 property var greeter: { fullyShown: true }

3737

38− SurfaceManager { id: sMgr }

3938 ApplicationMenuDataLoader {

4039 id: appMenuData

41− surfaceManager: sMgr

4240 }

4341

4442 Stage {

@@ -59,7 +57,7 @@ Rectangle {

5957 topLevelSurfaceList: TopLevelWindowModel {

6058 id: topLevelSurfaceList

6159 applicationManager: ApplicationManager

62− surfaceManager: sMgr

60+ surfaceManager: SurfaceManager

6361 }

6462 Component.onCompleted: {

6563 ApplicationManager.startApplication("unity8-dash");

tests/qmltests/Stage/tst_WindowDecoration.qml−2

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

4747 property string name: "webbrowser"

4848 }

4949

50− SurfaceManager { id: sMgr }

5150 ApplicationMenuDataLoader {

5251 id: appMenuData

53− surfaceManager: sMgr

5452 }

5553

5654 UnityMenuModel {

tests/qmltests/Stage/tst_WindowResizeArea.qml+1−8

@@ -19,7 +19,6 @@ import QtQuick.Layouts 1.1

1919import QtTest 1.0

2020import Unity.Test 0.1

2121import ".."

22−import "../../../qml/Components/PanelState"

2322import "../../../qml/Stage"

2423import Ubuntu.Components 1.3

2524import Ubuntu.Components.ListItems 1.3 as ListItem

@@ -31,12 +30,6 @@ Item {

3130 height: units.gu(60)

3231 width: units.gu(85)

3332

34− Binding {

35− target: PanelState

36− property: "panelHeight"

37− value: units.gu(3)

38− }

39−

4033 Component {

4134 id: fakeWindowComponent

4235

@@ -362,7 +355,7 @@ Item {

362355

363356 // Make sure it's again where we left it in normal state before destroying

364357 compare(fakeWindow.requestedX >= 0, true)

365− compare(fakeWindow.requestedY >= PanelState.panelHeight, true)

358+ compare(fakeWindow.requestedY >= 0, true)

366359 compare(fakeWindow.requestedX + fakeWindow.width <= root.width, true)

367360 compare(fakeWindow.requestedY + fakeWindow.height <= root.height, true)

368361

tests/qmltests/Tutorial/tst_Tutorial.qml+1−3

@@ -327,9 +327,7 @@ Rectangle {

327327 }

328328

329329 function ensureInputMethodSurface() {

330− var surfaceManager = findInvisibleChild(shell, "surfaceManager");

331− verify(surfaceManager);

332− surfaceManager.createInputMethodSurface();

330+ SurfaceManager.createInputMethodSurface();

333331

334332 tryCompareFunction(function() { return topLevelSurfaceList.inputMethodSurface !== null }, true);

335333 }

tests/qmltests/tst_OrientedShell.qml+19−5

@@ -30,7 +30,6 @@ import Utils 0.1

3030

3131import "../../qml"

3232import "../../qml/Components"

33−import "../../qml/Components/PanelState"

3433import "Stage"

3534

3635Rectangle {

@@ -82,6 +81,12 @@ Rectangle {

8281 deviceFilter: InputInfo.Keyboard

8382 }

8483

84+ QtObject {

85+ id: _screenWindow

86+ property bool primary: true

87+ }

88+ property alias screenWindow: _screenWindow

89+

8590 property int physicalOrientation0

8691 property int physicalOrientation90

8792 property int physicalOrientation180

@@ -446,6 +451,15 @@ Rectangle {

446451 property Item orientedShell: orientedShellLoader.status === Loader.Ready ? orientedShellLoader.item : null

447452 property Item shell

448453 property QtObject topLevelSurfaceList

454+ property var panelState: undefined

455+

456+ onOrientedShellChanged: {

457+ if (orientedShell) {

458+ panelState = findInvisibleChild(orientedShell, "panelState");

459+ } else {

460+ panelState = undefined;

461+ }

462+ }

449463

450464 SignalSpy { id: signalSpy }

451465 SignalSpy { id: signalSpy2 }

@@ -1512,13 +1526,13 @@ Rectangle {

15121526 print("exptectedAngle", expectedAngle, point.x, point.y)

15131527 switch (expectedAngle) {

15141528 case 0:

1515− return point.x === 0 && point.y === PanelState.panelHeight;

1529+ return point.x === 0 && point.y === panelState.panelHeight;

15161530 case 90:

1517− return point.x === orientedShell.width - PanelState.panelHeight && point.y === 0;

1531+ return point.x === orientedShell.width - panelState.panelHeight && point.y === 0;

15181532 case 180:

1519− return point.x === orientedShell.width && point.y === orientedShell.height - PanelState.panelHeight;

1533+ return point.x === orientedShell.width && point.y === orientedShell.height - panelState.panelHeight;

15201534 default: // 270

1521− return point.x === PanelState.panelHeight && point.y === orientedShell.height;

1535+ return point.x === panelState.panelHeight && point.y === orientedShell.height;

15221536 }

15231537 }

15241538

tests/qmltests/tst_Shell.qml+22−15

@@ -61,14 +61,21 @@ Rectangle {

6161 onShellChanged: {

6262 if (shell) {

6363 topLevelSurfaceList = testCase.findInvisibleChild(shell, "topLevelSurfaceList");

64− appMenuData.surfaceManager = testCase.findInvisibleChild(shell, "surfaceManager");

64+ panelState = testCase.findInvisibleChild(shell, "panelState");

6565 } else {

6666 topLevelSurfaceList = null;

67− appMenuData.surfaceManager = null;

67+ panelState = undefined;

6868 }

6969 }

7070

7171 property var topLevelSurfaceList: null

72+ property var panelState: undefined

73+

74+ QtObject {

75+ id: _screenWindow

76+ property bool primary: true

77+ }

78+ property alias screenWindow: _screenWindow

7279

7380 Item {

7481 id: shellContainer

@@ -262,6 +269,7 @@ Rectangle {

262269 anchors { left: parent.left; right: parent.right }

263270 activeFocusOnPress: false

264271 model: ["phone", "tablet", "desktop"]

272+ selectedIndex: 2

265273 onSelectedIndexChanged: {

266274 shellLoader.state = model[selectedIndex];

267275 }

@@ -275,6 +283,7 @@ Rectangle {

275283 anchors { left: parent.left; right: parent.right }

276284 activeFocusOnPress: false

277285 model: ["phone", "tablet", "desktop"]

286+ selectedIndex: 2

278287 }

279288 MouseTouchEmulationCheckbox {

280289 id: mouseEmulation

@@ -678,9 +687,7 @@ Rectangle {

678687 }

679688

680689 function ensureInputMethodSurface() {

681− var surfaceManager = findInvisibleChild(shell, "surfaceManager");

682− verify(surfaceManager);

683− surfaceManager.createInputMethodSurface();

690+ SurfaceManager.createInputMethodSurface();

684691

685692 tryCompareFunction(function() { return root.topLevelSurfaceList.inputMethodSurface !== null }, true);

686693 }

@@ -1866,21 +1873,21 @@ Rectangle {

18661873 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

18671874

18681875 tryCompare(appDelegate, "state", "normal");

1869− tryCompare(PanelState, "decorationsVisible", false)

1876+ tryCompare(panelState, "decorationsVisible", false)

18701877

18711878 mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);

18721879 tryCompare(appDelegate, "state", "maximized");

1873− tryCompare(PanelState, "decorationsVisible", true)

1880+ tryCompare(panelState, "decorationsVisible", true)

18741881

18751882 ApplicationManager.stopApplication(application.appId);

1876− tryCompare(PanelState, "decorationsVisible", false)

1883+ tryCompare(panelState, "decorationsVisible", false)

18771884

18781885 // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

18791886 // They won't be gone until those surface items are destroyed.

18801887 tryCompareFunction(function() { return application.surfaceList.count }, 0);

18811888

18821889 ApplicationManager.startApplication(application.appId);

1883− tryCompare(PanelState, "decorationsVisible", true)

1890+ tryCompare(panelState, "decorationsVisible", true)

18841891 }

18851892

18861893 function test_newAppHasValidGeometry() {

@@ -1937,7 +1944,7 @@ Rectangle {

19371944 mousePress(appDelegate, appDelegate.width / 2, units.gu(1))

19381945 mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))

19391946

1940− compare(appDelegate.y >= PanelState.panelHeight, true);

1947+ compare(appDelegate.y >= panelState.panelHeight, true);

19411948 }

19421949

19431950 function test_cantResizeWindowUnderPanel() {

@@ -1965,7 +1972,7 @@ Rectangle {

19651972 mouseMove(decoration, decoration.width/2, -units.gu(100));

19661973

19671974 // verify we don't go past the panel

1968− compare(appDelegate.y >= PanelState.panelHeight, true);

1975+ compare(appDelegate.y >= panelState.panelHeight, true);

19691976 }

19701977

19711978 function test_restoreWindowStateFixesIfUnderPanel() {

@@ -1989,7 +1996,7 @@ Rectangle {

19891996 tryCompareFunction(function () { return topLevelSurfaceList.applicationAt(0).appId; }, application.appId);

19901997

19911998 appDelegate = appRepeater.itemAt(0);

1992− compare(appDelegate.y >= PanelState.panelHeight, true);

1999+ compare(appDelegate.y >= panelState.panelHeight, true);

19932000 }

19942001

19952002 function test_lifecyclePolicyForNonTouchApp_data() {

@@ -2636,7 +2643,7 @@ Rectangle {

26362643 function test_oskDisplacesWindow_data() {

26372644 return [

26382645 {tag: "no need to displace", windowHeight: units.gu(10), windowY: units.gu(5), targetDisplacement: units.gu(5), oskEnabled: true},

2639− {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: PanelState.panelHeight, oskEnabled: true},

2646+ {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: panelState.panelHeight, oskEnabled: true},

26402647 {tag: "osk not on this screen", windowHeight: units.gu(40), windowY: units.gu(10), targetDisplacement: units.gu(10), oskEnabled: false},

26412648 ]

26422649 }

@@ -2659,8 +2666,8 @@ Rectangle {

26592666 dashAppDelegate.windowedY = data.windowY;

26602667 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

26612668 var initialY = dashAppDelegate.y;

2662− print("intial", initialY, "panel", PanelState.panelHeight);

2663− verify(initialY > PanelState.panelHeight);

2669+ print("intial", initialY, "panel", panelState.panelHeight);

2670+ verify(initialY > panelState.panelHeight);

26642671

26652672 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, root.height / 2, root.width, root.height / 2));

26662673 tryCompare(dashAppDelegate, "y", data.targetDisplacement);

tests/qmltests/tst_ShellApplication.qmlnew file+162

@@ -0,0 +1,162 @@

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 LightDM.FullLightDM 0.1 as LightDM

20+import LightDMController 0.1

21+import Unity.Application 0.1

22+import Unity.Test 0.1

23+

24+import "../../qml"

25+import "../../qml/Components"

26+import "Stage"

27+

28+Rectangle {

29+ id: root

30+ color: "grey"

31+ width: units.gu(100)

32+ height: units.gu(71)

33+

34+ QtObject {

35+ id: args

36+ property bool hasFullscreen: false

37+ property bool hasFrameless: false

38+ property bool hasGeometry: true

39+ property size windowGeometry: Qt.size(root.width, root.height)

40+ property string deviceName: "desktop"

41+ property string mode: "full-greeter"

42+ }

43+ property alias applicationArguments: args

44+

45+ Component.onCompleted: {

46+ // must set the mock mode before loading the Shell

47+ LightDMController.userMode = "single";

48+ }

49+

50+ Flickable {

51+ id: controls

52+ contentHeight: controlRect.height

53+

54+ anchors.top: root.top

55+ anchors.bottom: root.bottom

56+ anchors.right: root.right

57+ width: units.gu(30)

58+

59+ Rectangle {

60+ id: controlRect

61+ anchors { left: parent.left; right: parent.right }

62+ color: "darkgrey"

63+ height: childrenRect.height + units.gu(2)

64+

65+ Column {

66+ anchors { left: parent.left; right: parent.right; top: parent.top; margins: units.gu(1) }

67+ spacing: units.gu(1)

68+

69+ Flow {

70+ spacing: units.gu(1)

71+ anchors { left: parent.left; right: parent.right }

72+

73+ Button {

74+ text: "Show Greeter"

75+ activeFocusOnPress: false

76+ onClicked: {

77+ LightDM.Greeter.showGreeter();

78+ }

79+ }

80+ Button {

81+ text: "Hide Greeter"

82+ activeFocusOnPress: false

83+ onClicked: {

84+ LightDM.Greeter.hideGreeter()

85+ }

86+ }

87+ }

88+

89+ MouseTouchEmulationCheckbox {

90+ id: mouseEmulation

91+ checked: true

92+ }

93+

94+ Row {

95+ anchors { left: parent.left; right: parent.right }

96+ CheckBox {

97+ id: autohideLauncherCheckbox

98+ onCheckedChanged: {

99+ GSettingsController.setAutohideLauncher(checked)

100+ }

101+ }

102+ Label {

103+ text: "Autohide launcher"

104+ }

105+ }

106+

107+ Label { text: "Applications"; font.bold: true }

108+

109+ Button {

110+ text: "Start all apps"

111+ width: parent.width

112+ activeFocusOnPress: false

113+ onClicked: {

114+ for (var i = 0; i < ApplicationManager.availableApplications.length; i++) {

115+ var appId = ApplicationManager.availableApplications[i];

116+ ApplicationManager.startApplication(appId)

117+ }

118+ }

119+ }

120+

121+ Repeater {

122+ id: appCheckBoxRepeater

123+ model: ApplicationManager.availableApplications

124+ ApplicationCheckBox {

125+ appId: modelData

126+ }

127+ }

128+

129+ Label {

130+ text: "Fingerprint"

131+ }

132+ Row {

133+ Button {

134+ text: "Success"

135+ onClicked: {

136+ var biometryd = testCase.findInvisibleChild(shellContainer, "biometryd");

137+ var uid = 0;

138+ for (var i = 0; i < LightDM.Users.count; i++) {

139+ if (LightDM.Users.data(i, LightDM.UserRoles.NameRole) == AccountsService.user) {

140+ uid = LightDM.Users.data(i, LightDM.UserRoles.UidRole);

141+ break;

142+ }

143+ }

144+ biometryd.operation.mockSuccess(uid);

145+ }

146+ }

147+

148+ Button {

149+ text: "Failure"

150+ onClicked: {

151+ var biometryd = testCase.findInvisibleChild(shellContainer, "biometryd");

152+ biometryd.operation.mockFailure("error");

153+ }

154+ }

155+ }

156+ }

157+ }

158+ }

159+

160+ ShellApplication {

161+ }

162+}

tests/uqmlscene/main.cpp+2

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

479479 // TODO: as soon as the engine construction completes, the debug service is

480480 // listening for connections. But actually we aren't ready to debug anything.

481481 QQmlEngine engine;

482+ engine.rootContext()->setContextProperty("DebuggingController", new DebuggingController(&app));

483+

482484 QQmlComponent *component = new QQmlComponent(&engine);

483485 for (int i = 0; i < imports.size(); ++i)

484486 engine.addImportPath(imports.at(i));