xenial...2adba16 · unity8

CMakeLists.txt+5−1

since splitsnapshots

unifiedsplit

@@ -72,6 +72,7 @@ find_package(Qt5Sql 5.6 REQUIRED)

72find_package(Qt5Test 5.6 REQUIRED)

73

74pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=27)

75+pkg_check_modules(QTMIRSERVER REQUIRED qtmirserver>=0.6.0)

75pkg_check_modules(GEONAMES REQUIRED geonames>=0.2)

76pkg_check_modules(GEONAMES REQUIRED geonames>=0.2)

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

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

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

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

@@ -84,6 +85,7 @@ pkg_check_modules(QTDBUSTEST REQUIRED

84 libqtdbustest-1

85 libqtdbustest-1

85 libqtdbusmock-1

86 libqtdbusmock-1

86 )

87 )

88+pkg_check_modules(MIRAL REQUIRED miral)

87

89

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

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

89find_path(UBUNTUGESTUREPRIV

91find_path(UBUNTUGESTUREPRIV

@@ -118,7 +120,9 @@ if(SHELL_PLUGINDIR STREQUAL "")

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

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

119endif()

121endif()

120

122

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

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

124+

125+set (CMAKE_CXX_STANDARD 14)

122

126

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

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

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

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

debian/control+7−1

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

33 libqtdbustest1-dev,

34 libqt5svg5-dev,

35 libqt5xmlpatterns5-dev,

36+ libqtmirserver-dev (>= 0.6.0),

36 libsystemsettings-dev,

37 libsystemsettings-dev,

37 libubuntu-app-launch3-dev,

38 libubuntu-app-launch3-dev,

38 libubuntu-download-manager-common-dev,

39 libubuntu-download-manager-common-dev,

@@ -40,13 +41,14 @@ Build-Depends: cmake,

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

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

41 libudev-dev,

42 libudev-dev,

42 libudm-common-dev,

43 libudm-common-dev,

43− libunity-api-dev (>= 8.6),

44+ libunity-api-dev (>= 8.7),

44 libusermetricsoutput1-dev,

45 libusermetricsoutput1-dev,

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

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

46 libx11-dev[!arm64 !armhf],

47 libx11-dev[!arm64 !armhf],

47 libxcb1-dev[!arm64 !armhf],

48 libxcb1-dev[!arm64 !armhf],

48 libxi-dev[!arm64 !armhf],

49 libxi-dev[!arm64 !armhf],

49# End of X11 libs

50# End of X11 libs

51+ mirtest-dev,

50 pkg-config,

52 pkg-config,

51 python3-all:any,

53 python3-all:any,

52 python3-setuptools,

54 python3-setuptools,

@@ -73,6 +75,9 @@ Build-Depends: cmake,

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

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

74 ttf-ubuntu-font-family,

76 ttf-ubuntu-font-family,

75 xvfb,

77 xvfb,

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

79+ libboost-filesystem-dev,

80+ libboost-system-dev,

76Standards-Version: 3.9.4

81Standards-Version: 3.9.4

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

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

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

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

@@ -134,6 +139,7 @@ Depends: dmz-cursor-theme,

134 qml-module-ubuntu-web,

139 qml-module-ubuntu-web,

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

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

136 qtdeclarative5-ubuntu-telephony0.1,

141 qtdeclarative5-ubuntu-telephony0.1,

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

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

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

138 unity-launcher-impl-12,

144 unity-launcher-impl-12,

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

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

debian/unity8.install+5

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

16usr/share/unity8/DeviceConfiguration.qml

17usr/share/unity8/OrientedShell.qml

18usr/share/unity8/DisabledScreenNotice.qml

19+usr/share/unity8/ErrorApplication.qml

20+usr/share/unity8/qmldir

19usr/share/unity8/Shell.qml

21usr/share/unity8/Shell.qml

22+usr/share/unity8/ShellApplication.qml

23+usr/share/unity8/ShellNotifier.qml

24+usr/share/unity8/ShellScreen.qml

20usr/share/unity8/Stage

25usr/share/unity8/Stage

21usr/share/unity8/Tutorial

26usr/share/unity8/Tutorial

22usr/share/unity8/Wizard

27usr/share/unity8/Wizard

plugins/Cursor/CMakeLists.txt+1

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

15 CursorImageInfo.cpp

16 CursorImageProvider.cpp

17 MousePointer.cpp

18+ InputDispatcherFilter.cpp

18 # We need to run moc on this header

19 # We need to run moc on this header

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

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

20 )

21 )

plugins/Cursor/InputDispatcherFilter.cppnew file+175

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#include "InputDispatcherFilter.h"

18+#include "MousePointer.h"

19+

20+#include <QEvent>

21+#include <QGuiApplication>

22+#include <QQuickWindow>

23+#include <QScreen>

24+#include <QtMath>

25+#include <qpa/qplatformnativeinterface.h>

26+#include <qpa/qplatformscreen.h>

27+

28+InputDispatcherFilter *InputDispatcherFilter::instance()

29+{

30+ static InputDispatcherFilter filter;

31+ return &filter;

32+}

33+

34+InputDispatcherFilter::InputDispatcherFilter(QObject *parent)

35+ : QObject(parent)

36+ , m_pushing(false)

37+{

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

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

40+ if (m_inputDispatcher) {

41+ m_inputDispatcher->installEventFilter(this);

42+ }

43+}

44+

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

46+{

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

48+ m_pointers.insert(pointer);

49+}

50+

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

52+{

53+ m_pointers.remove(pointer);

54+}

55+

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

57+{

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

59+

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

61+ case QEvent::MouseMove:

62+ case QEvent::MouseButtonPress:

63+ case QEvent::MouseButtonRelease:

64+ {

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

66+ auto pointer = currentPointer();

67+ if (!pointer) return true;

68+

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

70+

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

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

73+

74+ // Adjust the position

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

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

77+

78+ QScreen* currentScreen = screenAt(newPos);

79+ if (currentScreen) {

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

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

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

83+

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

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

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

87+ m_pushing = true;

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

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

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

91+ m_pushing = true;

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

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

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

95+ m_pushing = true;

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

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

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

99+ m_pushing = true;

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

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

102+ m_pushing = true;

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

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

105+ m_pushing = true;

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

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

108+ m_pushing = true;

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

110+ if (m_pushing) {

111+ Q_EMIT pushStopped(currentScreen);

112+ m_pushing = false;

113+ }

114+ }

115+ }

116+

117+ // Send the event

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

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

120+ o->event(&eCopy);

121+ return true;

122+ }

123+ default:

124+ break;

125+ }

126+ return false;

127+}

128+

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

130+{

131+ QPointF adjusted = pt + movement;

132+

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

134+ if (screen) {

135+ return adjusted;

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

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

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

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

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

141+ } else {

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

143+

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

145+ Q_FOREACH(QScreen* screen, screens) {

146+ Q_FOREACH(MousePointer* pointer, m_pointers) {

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

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

149+ }

150+ }

151+ }

152+ }

153+ return adjusted;

154+}

155+

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

157+{

158+ Q_FOREACH(MousePointer* pointer, m_pointers) {

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

160+

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

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

163+ return screen;

164+ }

165+ return nullptr;

166+}

167+

168+MousePointer *InputDispatcherFilter::currentPointer() const

169+{

170+ Q_FOREACH(MousePointer* pointer, m_pointers) {

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

172+ return pointer;

173+ }

174+ return nullptr;

175+}

plugins/Cursor/InputDispatcherFilter.hnew file+62

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef INPUTDISPATCHERFILTER_H

18+#define INPUTDISPATCHERFILTER_H

19+

20+#include <QObject>

21+#include <QPointF>

22+#include <QSet>

23+

24+class MousePointer;

25+class QScreen;

26+

27+class InputDispatcherFilter : public QObject

28+{

29+ Q_OBJECT

30+public:

31+ static InputDispatcherFilter *instance();

32+

33+ void registerPointer(MousePointer* pointer);

34+ void unregisterPointer(MousePointer* pointer);

35+

36+Q_SIGNALS:

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

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

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

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

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

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

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

44+ void pushStopped(QScreen* screen);

45+

46+protected:

47+ InputDispatcherFilter(QObject* parent = nullptr);

48+

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

50+

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

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

53+

54+ MousePointer* currentPointer() const;

55+

56+private:

57+ QObject* m_inputDispatcher;

58+ QSet<MousePointer*> m_pointers;

59+ bool m_pushing;

60+};

61+

62+#endif // INPUTDISPATCHERFILTER_H

plugins/Cursor/MousePointer.cpp+63−78

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

16

17#include "MousePointer.h"

18#include "CursorImageProvider.h"

19−

19+#include "InputDispatcherFilter.h"

20−// Unity API

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

22

20

23#include <QQuickWindow>

21#include <QQuickWindow>

24−#include <QGuiApplication>

25−#include <QtMath>

26

22

27−#include <qpa/qwindowsysteminterface.h>

23+// Unity API

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

28

25

29MousePointer::MousePointer(QQuickItem *parent)

26MousePointer::MousePointer(QQuickItem *parent)

30 : MirMousePointerInterface(parent)

27 : MirMousePointerInterface(parent)

31 , m_cursorName(QStringLiteral("left_ptr"))

28 , m_cursorName(QStringLiteral("left_ptr"))

32 , m_themeName(QStringLiteral("default"))

29 , m_themeName(QStringLiteral("default"))

33{

30{

34−}

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

35−

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

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

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

37− Qt::KeyboardModifiers modifiers)

34+ Q_EMIT pushedLeftBoundary(amount, buttons);

38−{

39− if (!parentItem()) {

40− return;

41− }

42−

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

44− Q_EMIT mouseMoved();

45− }

35+ }

46−

36+ });

47− m_accumulatedMovement += movement;

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

48− // don't apply the fractional part

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

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

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

50− m_accumulatedMovement -= appliedMovement;

40+ Q_EMIT pushedRightBoundary(amount, buttons);

51−

41+ }

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

42+ });

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

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

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

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

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

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

56−

46+ Q_EMIT pushedTopBoundary(amount, buttons);

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

47+ }

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

48+ });

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

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

60− m_pushing = true;

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

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

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

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

52+ Q_EMIT pushedTopLeftCorner(amount, buttons);

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

53+ }

64− m_pushing = true;

54+ });

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

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

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

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

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

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

68− m_pushing = true;

58+ Q_EMIT pushedTopRightCorner(amount, buttons);

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

59+ }

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

60+ });

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

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

72− m_pushing = true;

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

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

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

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

64+ Q_EMIT pushedBottomLeftCorner(amount, buttons);

75− m_pushing = true;

65+ }

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

66+ });

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

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

78− m_pushing = true;

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

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

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

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

70+ Q_EMIT pushedBottomRightCorner(amount, buttons);

81− m_pushing = true;

71+ }

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

72+ });

83− if (m_pushing) {

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

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

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

84 Q_EMIT pushStopped();

76 Q_EMIT pushStopped();

85− m_pushing = false;

86 }

77 }

87− }

78+ });

88

79

89− applyItemConfinement(newX, newY);

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

90−

81+}

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

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

93

82

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

83+MousePointer::~MousePointer()

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

84+{

96− buttons, modifiers);

85+ registerScreen(nullptr);

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

97}

87}

98

88

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

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

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

121 }

111 }

122}

112}

123

113

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

125−{

126− if (!parentItem()) {

127− return;

128− }

129−

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

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

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

133−}

134−

135int MousePointer::topBoundaryOffset() const

114int MousePointer::topBoundaryOffset() const

136{

115{

137 return m_topBoundaryOffset;

116 return m_topBoundaryOffset;

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

182 if (m_registeredScreen) {

161 if (m_registeredScreen) {

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

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

184 if (previousCursor) {

163 if (previousCursor) {

185− previousCursor->setMousePointer(nullptr);

164+ previousCursor->unregisterMousePointer(this);

186 } else {

165 } else {

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

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

188 }

167 }

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

193 if (m_registeredScreen) {

172 if (m_registeredScreen) {

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

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

195 if (cursor) {

174 if (cursor) {

196− cursor->setMousePointer(this);

175+ cursor->registerMousePointer(this);

197 } else {

176 } else {

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

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

199 }

178 }

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

216 }

195 }

217}

196}

218

197

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

199+{

200+ setPosition(position);

201+ Q_EMIT mouseMoved();

202+}

203+

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

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

220{

205{

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

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

plugins/Cursor/MousePointer.h+5−4

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

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

32public:

33 MousePointer(QQuickItem *parent = nullptr);

34+ ~MousePointer();

34

35

35 void setCursorName(const QString &qtCursorName) override;

36 void setCursorName(const QString &qtCursorName) override;

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

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

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

38 void setThemeName(const QString &themeName) override;

39 void setThemeName(const QString &themeName) override;

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

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

40

41

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

43+

41 void setCustomCursor(const QCursor &) override;

44 void setCustomCursor(const QCursor &) override;

42

45

43 QQuickItem* confiningItem() const;

46 QQuickItem* confiningItem() const;

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

46 int topBoundaryOffset() const;

49 int topBoundaryOffset() const;

47 void setTopBoundaryOffset(int topBoundaryOffset);

50 void setTopBoundaryOffset(int topBoundaryOffset);

48

51

49−public Q_SLOTS:

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

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

51− Qt::KeyboardModifiers modifiers) override;

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

53

54Q_SIGNALS:

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

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

79 QPointer<QScreen> m_registeredScreen;

80 QString m_cursorName;

81 QString m_themeName;

82+ bool m_active;

82

83

83 // Accumulated, unapplied, mouse movement.

84 // Accumulated, unapplied, mouse movement.

84 QPointF m_accumulatedMovement;

85 QPointF m_accumulatedMovement;

plugins/GlobalShortcut/globalshortcut.cpp−15

@@ -56,11 +56,6 @@ void GlobalShortcut::setActive(bool active)

56 Q_EMIT activeChanged(active);

57}

58

59−void GlobalShortcut::componentComplete()

60−{

61− connect(this, &QQuickItem::windowChanged, this, &GlobalShortcut::setupFilterOnWindow);

62−}

63−

64void GlobalShortcut::keyPressEvent(QKeyEvent * event)

59void GlobalShortcut::keyPressEvent(QKeyEvent * event)

65{

60{

66 if (!m_active) return;

61 if (!m_active) return;

@@ -76,13 +71,3 @@ void GlobalShortcut::keyReleaseEvent(QKeyEvent * event)

76 event->accept();

71 event->accept();

77 Q_EMIT released(m_shortcut.toString());

72 Q_EMIT released(m_shortcut.toString());

78}

73}

79−

80−void GlobalShortcut::setupFilterOnWindow(QQuickWindow *window)

81−{

82− if (!window) {

83−// qWarning() << Q_FUNC_INFO << "Failed to setup filter on window";

84− return;

85− }

86−

87− registry->setupFilterOnWindow((qulonglong) window->winId());

88−}

plugins/GlobalShortcut/globalshortcut.h−4

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

53 void setActive(bool active);

54

55protected:

56− void componentComplete() override;

57 void keyPressEvent(QKeyEvent * event) override;

56 void keyPressEvent(QKeyEvent * event) override;

58 void keyReleaseEvent(QKeyEvent * event) override;

57 void keyReleaseEvent(QKeyEvent * event) override;

59

58

@@ -69,9 +68,6 @@ Q_SIGNALS:

69 void released(const QString &shortcut);

68 void released(const QString &shortcut);

70 void activeChanged(bool active);

69 void activeChanged(bool active);

71

70

72−private Q_SLOTS:

73− void setupFilterOnWindow(QQuickWindow* window);

74−

75private:

71private:

76 QVariant m_shortcut;

72 QVariant m_shortcut;

77 bool m_active = true;

73 bool m_active = true;

plugins/GlobalShortcut/globalshortcutregistry.cpp+23−15

@@ -21,11 +21,25 @@

21

22#include "globalshortcutregistry.h"

23

24−static qulonglong s_windowId = 0;

24+namespace {

25+QWindow* windowForShortcut(GlobalShortcut *sc) {

26+ QObject* parent= sc;

27+ while(parent) {

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

29+ auto window = item->window();

30+ if (window) return window;

31+ }

32+ parent = parent->parent();

33+ }

34+ return nullptr;

35+}

36+} // namespace

25

37

26GlobalShortcutRegistry::GlobalShortcutRegistry(QObject *parent)

38GlobalShortcutRegistry::GlobalShortcutRegistry(QObject *parent)

27 : QObject(parent)

39 : QObject(parent)

28{

40{

41+ connect(qGuiApp, &QGuiApplication::focusWindowChanged, this, &GlobalShortcutRegistry::setupFilterOnWindow);

42+ setupFilterOnWindow(qGuiApp->focusWindow());

29}

43}

30

44

31GlobalShortcutList GlobalShortcutRegistry::shortcuts() const

45GlobalShortcutList GlobalShortcutRegistry::shortcuts() const

@@ -91,7 +105,10 @@ bool GlobalShortcutRegistry::eventFilter(QObject *obj, QEvent *event)

91 const auto shortcuts = m_shortcuts.value(seq);

105 const auto shortcuts = m_shortcuts.value(seq);

92 Q_FOREACH(const auto &shortcut, shortcuts) {

106 Q_FOREACH(const auto &shortcut, shortcuts) {

93 if (shortcut) {

107 if (shortcut) {

108+ auto window = windowForShortcut(shortcut);

109+ if (!window || window == obj) { // accept shortcut if it's not attached to a window or it's window is active.

94− qApp->sendEvent(shortcut, &eCopy);

110+ qApp->sendEvent(shortcut, &eCopy);

111+ }

95 }

112 }

96 }

113 }

97 }

114 }

@@ -102,24 +119,15 @@ bool GlobalShortcutRegistry::eventFilter(QObject *obj, QEvent *event)

102 return QObject::eventFilter(obj, event);

119 return QObject::eventFilter(obj, event);

103}

120}

104

121

105−void GlobalShortcutRegistry::setupFilterOnWindow(qulonglong wid)

122+void GlobalShortcutRegistry::setupFilterOnWindow(QWindow* window)

106{

123{

107− if (wid == s_windowId) {

108− return;

109− }

110−

111 if (m_filteredWindow) {

124 if (m_filteredWindow) {

112 m_filteredWindow->removeEventFilter(this);

125 m_filteredWindow->removeEventFilter(this);

113 m_filteredWindow.clear();

126 m_filteredWindow.clear();

114− s_windowId = 0;

115 }

127 }

116

128

117− Q_FOREACH(QWindow *window, qApp->allWindows()) {

118− if (window && window->winId() == wid) {

129+ if (window) {

119− m_filteredWindow = window;

130+ m_filteredWindow = window;

120− window->installEventFilter(this);

131+ window->installEventFilter(this);

121− s_windowId = wid;

122− break;

123− }

124 }

132 }

125}

133}

plugins/GlobalShortcut/globalshortcutregistry.h+2−2

@@ -52,9 +52,9 @@ public:

52 void addShortcut(const QVariant &seq, GlobalShortcut * sc);

53

54 /**

55− * Sets up key events filtering on window @p wid

55+ * Sets up key events filtering on window @p window

56 */

57− void setupFilterOnWindow(qulonglong wid);

57+ void setupFilterOnWindow(QWindow* window);

58

59protected:

60 bool eventFilter(QObject *obj, QEvent *event) override;

plugins/UInput/plugin.cpp+7−1

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

19

20#include <QtQml/qqml.h>

21

22+

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

24+{

25+ return new UInput;

26+}

27+

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

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

23{

29{

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

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

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

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

26}

32}

plugins/WindowManager/CMakeLists.txt+28−7

@@ -1,25 +1,46 @@

1+include_directories(

2+ SYSTEM

3+ ${QTMIRSERVER_INCLUDE_DIRS}

4+ ${Qt5Gui_PRIVATE_INCLUDE_DIRS}

5+)

6+

7+include_directories(

8+ ${CMAKE_CURRENT_SOURCE_DIR}

9+ ${libunity8-private_SOURCE_DIR}

10+)

11+

1set(WINDOWMANAGER_SRC

12set(WINDOWMANAGER_SRC

2 AvailableDesktopArea.cpp

13 AvailableDesktopArea.cpp

3 TopLevelWindowModel.cpp

14 TopLevelWindowModel.cpp

4 Window.cpp

15 Window.cpp

5 WindowManagerPlugin.cpp

16 WindowManagerPlugin.cpp

6 WindowMargins.cpp

17 WindowMargins.cpp

18+ Screen.cpp

19+ ScreenAttached.cpp

20+ Screens.cpp

21+ ScreensConfiguration.cpp

22+ ScreenWindow.cpp

23+ WindowManagerObjects.cpp

24+ Workspace.cpp

25+ WorkspaceManager.cpp

26+ WorkspaceModel.cpp

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

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

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

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

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

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

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

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

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

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

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

12− )

33+)

13

34

14add_definitions(-DWINDOWMANAGERQML_LIBRARY)

35add_definitions(-DWINDOWMANAGERQML_LIBRARY)

15

36

16−include_directories(

17− SYSTEM

18− ${Qt5Gui_PRIVATE_INCLUDE_DIRS}

19−)

20−

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

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

22

38

39+target_link_libraries(windowmanager-qml

40+ ${QTMIRSERVER_LDFLAGS}

41+ unity8-private

42+)

43+

23qt5_use_modules(windowmanager-qml Qml Quick Gui)

44qt5_use_modules(windowmanager-qml Qml Quick Gui)

24

45

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

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

plugins/WindowManager/Screen.cppnew file+309

@@ -0,0 +1,309 @@

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+Screen::Screen(QObject *parent)

23+ : QObject(parent)

24+{

25+}

26+

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

28+{

29+ m_wrapped = screen;

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

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

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

33+ connect(screen, &qtmir::Screen::outputTypeChanged, this, &Screen::outputTypeNameChanged);

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

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

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

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

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

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

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

41+}

42+

43+void Screen::connectToScreen(Screen *screen)

44+{

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

46+ connect(screen, &Screen::currentWorkspaceChanged, this, &Screen::currentWorkspaceChanged);

47+}

48+

49+void Screen::setCurrentWorkspace2(Workspace *workspace)

50+{

51+ // Make sure we use the correct concrete class. Don't want to use a Proxy.

52+ workspace->setCurrentOn(this);

53+}

54+

55+bool Screen::used() const

56+{

57+ if (!m_wrapped) return false;

58+ return m_wrapped->used();

59+}

60+

61+QString Screen::name() const

62+{

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

64+ return m_wrapped->name();

65+}

66+

67+float Screen::scale() const

68+{

69+ if (!m_wrapped) return 1.0;

70+ return m_wrapped->scale();

71+}

72+

73+QSizeF Screen::physicalSize() const

74+{

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

76+ return m_wrapped->physicalSize();

77+}

78+

79+qtmir::FormFactor Screen::formFactor() const

80+{

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

82+ return m_wrapped->formFactor();

83+}

84+

85+qtmir::OutputTypes Screen::outputType() const

86+{

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

88+ return m_wrapped->outputType();

89+}

90+

91+MirPowerMode Screen::powerMode() const

92+{

93+ if (!m_wrapped) return mir_power_mode_on;

94+ return m_wrapped->powerMode();

95+}

96+

97+Qt::ScreenOrientation Screen::orientation() const

98+{

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

100+ return m_wrapped->orientation();

101+}

102+

103+QPoint Screen::position() const

104+{

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

106+ return m_wrapped->position();

107+}

108+

109+QQmlListProperty<qtmir::ScreenMode> Screen::availableModes()

110+{

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

112+ return m_wrapped->availableModes();

113+}

114+

115+uint Screen::currentModeIndex() const

116+{

117+ if (!m_wrapped) return -1;

118+ return m_wrapped->currentModeIndex();

119+}

120+

121+bool Screen::isActive() const

122+{

123+ if (!m_wrapped) return false;

124+ return m_wrapped->isActive();

125+}

126+

127+void Screen::activate()

128+{

129+ setActive(true);

130+}

131+

132+void Screen::setActive(bool active)

133+{

134+ if (!m_wrapped) return;

135+ m_wrapped->setActive(active);

136+}

137+

138+QScreen *Screen::qscreen() const

139+{

140+ if (!m_wrapped) return nullptr;

141+ return m_wrapped->qscreen();

142+}

143+

144+ScreenConfig *Screen::beginConfiguration() const

145+{

146+ if (!m_wrapped) return nullptr;

147+ return new ScreenConfig(m_wrapped->beginConfiguration());

148+}

149+

150+bool Screen::applyConfiguration(ScreenConfig *configuration)

151+{

152+ if (!m_wrapped) return false;

153+ return m_wrapped->applyConfiguration(configuration->m_config);

154+}

155+

156+QString Screen::outputTypeName() const

157+{

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

159+ case qtmir::Unknown:

160+ return tr("Unknown");

161+ case qtmir::VGA:

162+ return tr("VGA");

163+ case qtmir::DVII:

164+ case qtmir::DVID:

165+ case qtmir::DVIA:

166+ return tr("DVI");

167+ case qtmir::Composite:

168+ return tr("Composite");

169+ case qtmir::SVideo:

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

171+ case qtmir::LVDS:

172+ case qtmir::NinePinDIN:

173+ case qtmir::EDP:

174+ return tr("Internal");

175+ case qtmir::Component:

176+ return tr("Component");

177+ case qtmir::DisplayPort:

178+ return tr("DisplayPort");

179+ case qtmir::HDMIA:

180+ case qtmir::HDMIB:

181+ return tr("HDMI");

182+ case qtmir::TV:

183+ return tr("TV");

184+ }

185+ return QString();

186+}

187+

188+void Screen::sync(Screen *proxy)

189+{

190+ if (!proxy) return;

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

192+}

193+

194+ConcreteScreen::ConcreteScreen(qtmir::Screen* wrapped)

195+ : m_workspaces(new WorkspaceModel)

196+{

197+ connectToScreen(wrapped);

198+

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

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

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

202+ if (active) {

203+ setCurrentWorkspace(workspace);

204+ activate();

205+ }

206+ });

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

208+ activate();

209+ setCurrentWorkspace(workspace);

210+ }

211+ if (!m_currentWorspace) {

212+ setCurrentWorkspace(workspace);

213+ }

214+ });

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

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

217+ if (workspace == m_currentWorspace) {

218+ resetCurrentWorkspace();

219+ }

220+ });

221+ connect(this, &ConcreteScreen::activeChanged, this, [this](bool active) {

222+ if (active && m_currentWorspace) {

223+ m_currentWorspace->activate();

224+ }

225+ });

226+}

227+

228+void ConcreteScreen::resetCurrentWorkspace()

229+{

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

231+ if (m_currentWorspace != newCurrent) {

232+ m_currentWorspace = newCurrent;

233+ Q_EMIT currentWorkspaceChanged(newCurrent);

234+ }

235+}

236+

237+

238+WorkspaceModel *ConcreteScreen::workspaces() const

239+{

240+ return m_workspaces.data();

241+}

242+

243+Workspace *ConcreteScreen::currentWorkspace() const

244+{

245+ return m_currentWorspace.data();

246+}

247+

248+void ConcreteScreen::setCurrentWorkspace(Workspace *workspace)

249+{

250+ if (m_currentWorspace != workspace) {

251+ m_currentWorspace = workspace;

252+ Q_EMIT currentWorkspaceChanged(workspace);

253+ }

254+}

255+

256+ProxyScreen::ProxyScreen(Screen *const screen, ProxyScreens* screens)

257+ : m_workspaces(new ProxyWorkspaceModel(screen->workspaces(), this))

258+ , m_original(screen)

259+ , m_screens(screens)

260+{

261+ connectToScreen(screen);

262+

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

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

265+ auto p = qobject_cast<ProxyWorkspace*>(workspace);

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

267+ if (m_currentWorspace != p) {

268+ m_currentWorspace = p;

269+ Q_EMIT currentWorkspaceChanged(p);

270+ }

271+ }

272+ }

273+ };

274+ connect(screen, &Screen::currentWorkspaceChanged, this, updateCurrentWorkspaceFn);

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

276+}

277+

278+WorkspaceModel *ProxyScreen::workspaces() const

279+{

280+ return m_workspaces.data();

281+}

282+

283+Workspace *ProxyScreen::currentWorkspace() const

284+{

285+ return m_currentWorspace.data();

286+}

287+

288+void ProxyScreen::setCurrentWorkspace(Workspace *workspace)

289+{

290+ auto p = qobject_cast<ProxyWorkspace*>(workspace);

291+ if (p) {

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

293+ }

294+}

295+

296+bool ProxyScreen::isSyncing() const

297+{

298+ return m_screens->isSyncing();

299+}

300+

301+ScreenConfig::ScreenConfig(qtmir::ScreenConfiguration *config)

302+ : m_config(config)

303+{

304+}

305+

306+ScreenConfig::~ScreenConfig()

307+{

308+ delete m_config;

309+}

plugins/WindowManager/Screen.hnew file+152

@@ -0,0 +1,152 @@

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 ProxyScreen;

11+class ProxyScreens;

12+class ScreenConfig;

13+

14+class Screen: public QObject

15+{

16+ Q_OBJECT

17+

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

19+

20+ Q_PROPERTY(bool used READ used NOTIFY usedChanged)

21+ Q_PROPERTY(QString name READ name NOTIFY nameChanged)

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

23+ Q_PROPERTY(float scale READ scale NOTIFY scaleChanged)

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

25+ Q_PROPERTY(MirPowerMode powerMode READ powerMode NOTIFY powerModeChanged)

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

27+ Q_PROPERTY(QPoint position READ position NOTIFY positionChanged)

28+ Q_PROPERTY(uint currentModeIndex READ currentModeIndex NOTIFY currentModeIndexChanged)

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

30+ Q_PROPERTY(QSizeF physicalSize READ physicalSize NOTIFY physicalSizeChanged)

31+ Q_PROPERTY(QString outputTypeName READ outputTypeName NOTIFY outputTypeChanged)

32+ Q_PROPERTY(WorkspaceModel* workspaces READ workspaces CONSTANT)

33+ Q_PROPERTY(Workspace* currentWorkspace READ currentWorkspace WRITE setCurrentWorkspace2 NOTIFY currentWorkspaceChanged)

34+public:

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+ QString outputTypeName() const;

50+

51+ Q_INVOKABLE ScreenConfig *beginConfiguration() const;

52+ Q_INVOKABLE bool applyConfiguration(ScreenConfig *configuration);

53+

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

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

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

57+

58+ void sync(Screen* proxy);

59+

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

61+

62+public Q_SLOTS:

63+ void activate();

64+

65+Q_SIGNALS:

66+ void usedChanged();

67+ void nameChanged();

68+ void outputTypeChanged();

69+ void outputTypeNameChanged();

70+ void scaleChanged();

71+ void formFactorChanged();

72+ void powerModeChanged();

73+ void orientationChanged();

74+ void positionChanged();

75+ void currentModeIndexChanged();

76+ void physicalSizeChanged();

77+ void availableModesChanged();

78+ void activeChanged(bool active);

79+ void currentWorkspaceChanged(Workspace*);

80+

81+protected:

82+ Screen(QObject* parent = 0);

83+

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

85+ void connectToScreen(Screen* screen);

86+

87+private:

88+ void setCurrentWorkspace2(Workspace* workspace);

89+

90+protected:

91+ QPointer<qtmir::Screen> m_wrapped;

92+};

93+

94+

95+class ConcreteScreen : public Screen

96+{

97+ Q_OBJECT

98+public:

99+ explicit ConcreteScreen(qtmir::Screen*const wrapped);

100+

101+ // From qtmir::Screen

102+ WorkspaceModel* workspaces() const override;

103+ Workspace *currentWorkspace() const override;

104+ void setCurrentWorkspace(Workspace* workspace) override;

105+

106+protected:

107+ void resetCurrentWorkspace();

108+

109+ const QScopedPointer<WorkspaceModel> m_workspaces;

110+ QPointer<Workspace> m_currentWorspace;

111+};

112+

113+class ProxyScreen : public Screen

114+{

115+ Q_OBJECT

116+public:

117+ explicit ProxyScreen(Screen*const screen, ProxyScreens* screens);

118+

119+ // From qtmir::Screen

120+ WorkspaceModel* workspaces() const override;

121+ Workspace *currentWorkspace() const override;

122+ void setCurrentWorkspace(Workspace* workspace) override;

123+

124+ Screen* proxyObject() const { return m_original.data(); }

125+

126+ bool isSyncing() const;

127+

128+private:

129+ const QScopedPointer<WorkspaceModel> m_workspaces;

130+ const QPointer<Screen> m_original;

131+ const ProxyScreens* m_screens;

132+ QPointer<Workspace> m_currentWorspace;

133+};

134+

135+class ScreenConfig: public QObject

136+{

137+ Q_OBJECT

138+ Q_PRIVATE_PROPERTY(m_config, bool valid MEMBER used CONSTANT)

139+ Q_PRIVATE_PROPERTY(m_config, bool used MEMBER used)

140+ Q_PRIVATE_PROPERTY(m_config, float scale MEMBER scale)

141+ Q_PRIVATE_PROPERTY(m_config, qtmir::FormFactor formFactor MEMBER formFactor)

142+ Q_PRIVATE_PROPERTY(m_config, uint currentModeIndex MEMBER currentModeIndex)

143+ Q_PRIVATE_PROPERTY(m_config, QPoint position MEMBER topLeft)

144+

145+public:

146+ ScreenConfig(qtmir::ScreenConfiguration*);

147+ ~ScreenConfig();

148+

149+ qtmir::ScreenConfiguration* m_config;

150+};

151+

152+#endif // SCREEN_H

plugins/WindowManager/ScreenAttached.cppnew file+151

@@ -0,0 +1,151 @@

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+ : Screen(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+ Screen* screen{nullptr};

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

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

81+ screen = s;

82+ }

83+ }

84+ screenChanged2(screen);

85+}

86+

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

88+{

89+ if (screen == m_screen) return;

90+

91+ Screen* 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+ if (!oldScreen || screen->currentWorkspace() != oldScreen->currentWorkspace())

123+ Q_EMIT currentWorkspaceChanged(currentWorkspace());

124+

125+ if (oldScreen) {

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

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

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

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

130+ }

131+

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

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

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

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

136+ }

137+

138+ if (newModes != newModes) {

139+ Q_EMIT availableModesChanged();

140+ }

141+ } else {

142+ Q_EMIT availableModesChanged();

143+ }

144+

145+ connectToScreen(screen);

146+}

147+

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

149+{

150+ return new ScreenAttached(owner);

151+}

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 Screen

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(Screen* screen);

41+

42+private:

43+ QPointer<Screen> 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+ConcreteScreen *ScreenWindow::screenWrapper() const

34+{

35+ return m_screen.data();

36+}

37+

38+void ScreenWindow::setScreenWrapper(ConcreteScreen *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(ConcreteScreen *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+ ConcreteScreen *screenWrapper() const;

40+ void setScreenWrapper(ConcreteScreen *screen);

41+

42+Q_SIGNALS:

43+ void screenWrapperChanged(ConcreteScreen* screen);

44+

45+private:

46+ QPointer<ConcreteScreen> m_screen;

47+};

48+

49+#endif // UNITY_SCREENWINDOW_H

plugins/WindowManager/Screens.cppnew file+235

@@ -0,0 +1,235 @@

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

19+#include "Screen.h"

20+#include "WorkspaceManager.h"

21+

22+// qtmirserver

23+#include <qtmir/screens.h>

24+#include <QGuiApplication>

25+#include <QQmlEngine>

26+

27+// Qt

28+#include <QScreen>

29+#include <QWindow>

30+

31+ConcreteScreens* ConcreteScreens::m_self{nullptr};

32+

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

34+ : m_wrapped(model)

35+{

36+}

37+

38+Screens::~Screens()

39+{

40+ qDeleteAll(m_screens);

41+ m_screens.clear();

42+}

43+

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

45+{

46+ QHash<int, QByteArray> roles;

47+ roles[ScreenRole] = "screen";

48+ return roles;

49+}

50+

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

52+{

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

54+ return QVariant();

55+ }

56+

57+ switch(role) {

58+ case ScreenRole:

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

60+ } // switch

61+

62+ return QVariant();

63+}

64+

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

66+{

67+ return count();

68+}

69+

70+int Screens::count() const

71+{

72+ return m_screens.size();

73+}

74+

75+QVariant Screens::activeScreen() const

76+{

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

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

79+ }

80+ return QVariant();

81+}

82+

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

84+{

85+ bool ok = false;

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

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

88+

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

90+ screen->setActive(true);

91+}

92+

93+

94+ConcreteScreens::ConcreteScreens(const QSharedPointer<qtmir::Screens> &model, ScreensConfiguration* config)

95+ : Screens(model)

96+ , m_config(config)

97+{

98+ m_self = this;

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

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

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

102+

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

104+ auto screenWrapper(new ConcreteScreen(screen));

105+ m_config->load(screenWrapper);

106+

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

108+ m_screens.push_back(screenWrapper);

109+ }

110+}

111+

112+ConcreteScreens::~ConcreteScreens()

113+{

114+ Q_FOREACH(Screen* screen, m_screens) {

115+ m_config->save(screen);

116+ }

117+ delete m_config;

118+}

119+

120+ConcreteScreens *ConcreteScreens::self()

121+{

122+ return ConcreteScreens::m_self;

123+}

124+

125+ProxyScreens *ConcreteScreens::createProxy()

126+{

127+ return new ProxyScreens(this);

128+}

129+

130+void ConcreteScreens::sync(ProxyScreens *proxy)

131+{

132+ if (!proxy) return;

133+ proxy->setSyncing(true);

134+

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

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

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

138+ }

139+

140+ proxy->setSyncing(false);

141+}

142+

143+void ConcreteScreens::onScreenAdded(qtmir::Screen *added)

144+{

145+ Q_FOREACH(auto screenWrapper, m_screens) {

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

147+ }

148+

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

150+ auto screenWrapper(new ConcreteScreen(added));

151+ m_config->load(screenWrapper);

152+

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

154+ m_screens.push_back(screenWrapper);

155+ endInsertRows();

156+ Q_EMIT screenAdded(screenWrapper);

157+ Q_EMIT countChanged();

158+}

159+

160+void ConcreteScreens::onScreenRemoved(qtmir::Screen *removed)

161+{

162+ int index = 0;

163+ QMutableVectorIterator<Screen*> iter(m_screens);

164+ while(iter.hasNext()) {

165+ auto screenWrapper = iter.next();

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

167+ m_config->save(screenWrapper);

168+

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

170+ iter.remove();

171+ endRemoveRows();

172+

173+ Q_EMIT screenRemoved(screenWrapper);

174+ Q_EMIT countChanged();

175+

176+ screenWrapper->deleteLater();

177+ break;

178+ }

179+ index++;

180+ }

181+}

182+

183+

184+ProxyScreens::ProxyScreens(Screens * const screens)

185+ : Screens(screens->m_wrapped)

186+ , m_original(screens)

187+ , m_syncing(false)

188+{

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

190+ Q_FOREACH(auto screen, m_screens) {

191+ auto proxy = static_cast<ProxyScreen*>(screen);

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

193+ }

194+

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

196+ auto screenWrapper(new ProxyScreen(added, this));

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

198+ m_screens.push_back(screenWrapper);

199+ endInsertRows();

200+ Q_EMIT screenAdded(screenWrapper);

201+ Q_EMIT countChanged();

202+ });

203+

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

205+ int index = 0;

206+ QMutableVectorIterator<Screen*> iter(m_screens);

207+ while(iter.hasNext()) {

208+ auto proxy = static_cast<ProxyScreen*>(iter.next());

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

210+

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

212+ iter.remove();

213+ endRemoveRows();

214+

215+ Q_EMIT screenRemoved(proxy);

216+ Q_EMIT countChanged();

217+

218+ delete proxy;

219+ break;

220+ }

221+ index++;

222+ }

223+ });

224+

225+ Q_FOREACH(Screen* screen, screens->list()) {

226+ auto screenWrapper(new ProxyScreen(screen, this));

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

228+ m_screens.push_back(screenWrapper);

229+ }

230+}

231+

232+void ProxyScreens::setSyncing(bool syncing)

233+{

234+ m_syncing = syncing;

235+}

plugins/WindowManager/Screens.hnew file+111

@@ -0,0 +1,111 @@

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 Screen;

31+class ProxyScreens;

32+class ScreensConfiguration;

33+

34+class Screens : public QAbstractListModel

35+{

36+ Q_OBJECT

37+ Q_PROPERTY(int count READ count NOTIFY countChanged)

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

39+

40+public:

41+ enum ItemRoles {

42+ ScreenRole = Qt::UserRole + 1

43+ };

44+

45+ virtual ~Screens();

46+

47+ /* QAbstractItemModel */

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

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

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

51+

52+ int count() const;

53+ QVariant activeScreen() const;

54+

55+ const QVector<Screen*>& list() const { return m_screens; }

56+

57+public Q_SLOTS:

58+ void activateScreen(const QVariant& index);

59+

60+Q_SIGNALS:

61+ void countChanged();

62+ void activeScreenChanged();

63+

64+ void screenAdded(Screen* screen);

65+ void screenRemoved(Screen* screen);

66+

67+protected:

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

69+

70+ QVector<Screen*> m_screens;

71+ const QSharedPointer<qtmir::Screens> m_wrapped;

72+

73+ friend class ProxyScreens;

74+};

75+

76+class ConcreteScreens : public Screens

77+{

78+ Q_OBJECT

79+public:

80+ explicit ConcreteScreens(const QSharedPointer<qtmir::Screens>& model, ScreensConfiguration* config);

81+ ~ConcreteScreens();

82+

83+ Q_INVOKABLE ProxyScreens *createProxy();

84+ Q_INVOKABLE void sync(ProxyScreens *proxy);

85+

86+ static ConcreteScreens *self();

87+

88+protected Q_SLOTS:

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

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

91+

92+private:

93+ ScreensConfiguration* m_config;

94+

95+ static ConcreteScreens* m_self;

96+};

97+

98+class ProxyScreens : public Screens

99+{

100+public:

101+ explicit ProxyScreens(Screens*const screens);

102+

103+ void setSyncing(bool syncing);

104+ bool isSyncing() const { return m_syncing; }

105+

106+private:

107+ const QPointer<Screens> m_original;

108+ bool m_syncing;

109+};

110+

111+#endif // SCREENS_H

plugins/WindowManager/ScreensConfiguration.cppnew file+94

@@ -0,0 +1,94 @@

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

18+#include "Screen.h"

19+#include "Workspace.h"

20+#include "WorkspaceManager.h"

21+

22+#include <QJsonObject>

23+#include <QJsonDocument>

24+#include <QJsonArray>

25+#include <QFile>

26+#include <QStandardPaths>

27+

28+namespace

29+{

30+QJsonArray jsonScreens;

31+}

32+

33+ScreensConfiguration::ScreensConfiguration()

34+{

35+ const QString dbPath = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + QStringLiteral("/unity8/");

36+ QFile f(dbPath + "workspaces");

37+

38+ if (f.open(QIODevice::ReadOnly)) {

39+ QByteArray saveData = f.readAll();

40+ QJsonDocument loadDoc(QJsonDocument::fromJson(saveData));

41+ QJsonObject json(loadDoc.object());

42+ jsonScreens = json["screens"].toArray();

43+ }

44+}

45+

46+ScreensConfiguration::~ScreensConfiguration()

47+{

48+ const QString dbPath = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + QStringLiteral("/unity8/");

49+ QFile f(dbPath + "workspaces");

50+ if (f.open(QIODevice::WriteOnly)) {

51+ QJsonObject json;

52+ json["screens"] = jsonScreens;

53+ QJsonDocument saveDoc(json);

54+ f.write(saveDoc.toJson());

55+ }

56+}

57+

58+void ScreensConfiguration::load(Screen *screen)

59+{

60+ int workspaces = 2;

61+ for (auto iter = jsonScreens.begin(); iter != jsonScreens.end(); ++iter) {

62+ QJsonObject jsonScreen = (*iter).toObject();

63+ if (jsonScreen["name"] == screen->name()) {

64+ QJsonValue jsonWorkspaces = jsonScreen["workspaces"];

65+ workspaces = qMax(jsonWorkspaces.toInt(workspaces), 1);

66+ break;

67+ }

68+ }

69+

70+ for (int i = 0; i < workspaces; i++) {

71+ WorkspaceManager::instance()->createWorkspace()->assign(screen->workspaces());

72+ }

73+}

74+

75+void ScreensConfiguration::save(Screen *screen)

76+{

77+ QJsonObject newJsonScreen;

78+ newJsonScreen["name"] = screen->name();

79+ newJsonScreen["workspaces"] = qMax(screen->workspaces()->rowCount(), 1);

80+

81+ auto iter = jsonScreens.begin();

82+ for (; iter != jsonScreens.end(); ++iter) {

83+ QJsonObject jsonScreen = (*iter).toObject();

84+ if (jsonScreen["name"] == screen->name()) {

85+ break;

86+ }

87+ }

88+

89+ if (iter == jsonScreens.end()) {

90+ jsonScreens.push_back(newJsonScreen);

91+ } else {

92+ *iter = newJsonScreen;

93+ }

94+}

src/ShellView.h → plugins/WindowManager/ScreensConfiguration.hrenamed+10−12

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

1/*

3 *

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

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

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

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

15 */

16

17−#ifndef UNITY_SHELL_VIEW_H

17+#ifndef SCREENSCONFIGURATION_H

18−#define UNITY_SHELL_VIEW_H

18+#define SCREENSCONFIGURATION_H

19

20−#include <QQuickView>

20+class Screen;

21

22−class ShellView : public QQuickView

22+class ScreensConfiguration

23{

24− Q_OBJECT

25−

26public:

24public:

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

25+ explicit ScreensConfiguration();

26+ ~ScreensConfiguration();

28

27

29−private Q_SLOTS:

28+ void load(Screen* screen);

30− void onWidthChanged(int);

29+ void save(Screen* screen);

31− void onHeightChanged(int);

32};

30};

33

31

34−#endif // UNITY_SHELL_VIEW_H

32+#endif // SCREENSCONFIGURATION_H

plugins/WindowManager/TopLevelWindowModel.cpp+205−73

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

15 */

16

17#include "TopLevelWindowModel.h"

18+#include "WindowManagerObjects.h"

18

19

19// unity-api

20// unity-api

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

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

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

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

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

25

26

26// Qt

27// Qt

27−#include <QGuiApplication>

28#include <QDebug>

29

30// local

31#include "Window.h"

32+#include "Workspace.h"

32

33

33Q_LOGGING_CATEGORY(TOPLEVELWINDOWMODEL, "toplevelwindowmodel", QtInfoMsg)

34Q_LOGGING_CATEGORY(TOPLEVELWINDOWMODEL, "toplevelwindowmodel", QtInfoMsg)

34

35

@@ -37,7 +38,19 @@ Q_LOGGING_CATEGORY(TOPLEVELWINDOWMODEL, "toplevelwindowmodel", QtInfoMsg)

37

38

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

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

39

40

40−TopLevelWindowModel::TopLevelWindowModel()

41+TopLevelWindowModel::TopLevelWindowModel(Workspace* workspace)

42+ : m_workspace(workspace)

43+{

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());

51+}

52+

53+TopLevelWindowModel::~TopLevelWindowModel()

41{

54{

42}

55}

43

56

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

55 beginResetModel();

68 beginResetModel();

56

69

57 if (m_applicationManager) {

70 if (m_applicationManager) {

58− m_windowModel.clear();

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

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

60 }

72 }

61

73

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

64 if (m_applicationManager) {

76 if (m_applicationManager) {

65 connect(m_applicationManager, &QAbstractItemModel::rowsInserted,

77 connect(m_applicationManager, &QAbstractItemModel::rowsInserted,

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

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

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

80+ return;

81+

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

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

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

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

69− addApplication(application);

84+ addApplication(application);

70− }

85+ }

71− });

86+ });

72

87

73 connect(m_applicationManager, &QAbstractItemModel::rowsAboutToBeRemoved,

88 connect(m_applicationManager, &QAbstractItemModel::rowsAboutToBeRemoved,

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

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

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

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

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

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

77− removeApplication(application);

92+ removeApplication(application);

78− }

79− });

93+ }

80−

94+ });

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

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

83− addApplication(application);

84− }

85 }

95 }

86

96

97+ refreshWindows();

98+

87 endResetModel();

99 endResetModel();

88 m_modelState = IdleState;

100 m_modelState = IdleState;

89}

101}

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

96

108

97 DEBUG_MSG << "(" << surfaceManager << ")";

109 DEBUG_MSG << "(" << surfaceManager << ")";

98

110

111+ Q_ASSERT(m_modelState == IdleState);

112+ m_modelState = ResettingState;

113+

114+ beginResetModel();

115+

99 if (m_surfaceManager) {

116 if (m_surfaceManager) {

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

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

101 }

118 }

@@ -103,13 +120,16 @@ void TopLevelWindowModel::setSurfaceManager(unityapi::SurfaceManagerInterface *s

103 m_surfaceManager = surfaceManager;

120 m_surfaceManager = surfaceManager;

104

121

105 if (m_surfaceManager) {

122 if (m_surfaceManager) {

106− connect(m_surfaceManager, &unityapi::SurfaceManagerInterface::surfaceCreated, this, &TopLevelWindowModel::onSurfaceCreated);

123+ connect(m_surfaceManager, &unityapi::SurfaceManagerInterface::surfacesAddedToWorkspace, this, &TopLevelWindowModel::onSurfacesAddedToWorkspace);

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

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

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

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

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

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

110 }

127 }

111

128

112− Q_EMIT surfaceManagerChanged(m_surfaceManager);

129+ refreshWindows();

130+

131+ endResetModel();

132+ m_modelState = IdleState;

113}

133}

114

134

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

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

@@ -149,6 +169,7 @@ void TopLevelWindowModel::prependSurface(unityapi::MirSurfaceInterface *surface,

149 Q_ASSERT(surface != nullptr);

169 Q_ASSERT(surface != nullptr);

150

170

151 connectSurface(surface);

171 connectSurface(surface);

172+ m_allSurfaces.insert(surface);

152

173

153 bool filledPlaceholder = false;

174 bool filledPlaceholder = false;

154 for (int i = 0; i < m_windowModel.count() && !filledPlaceholder; ++i) {

175 for (int i = 0; i < m_windowModel.count() && !filledPlaceholder; ++i) {

@@ -225,15 +246,14 @@ void TopLevelWindowModel::connectWindow(Window *window)

225

246

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

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

227 if (window->surface()) {

248 if (window->surface()) {

228− // Condense changes to the focused window

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

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

231 if (focused) {

249 if (focused) {

232− Q_ASSERT(m_newlyFocusedWindow == nullptr);

250+ setFocusedWindow(window);

233− m_focusedWindowChanged = true;

251+ m_focusedWindowCleared = false;

234− m_newlyFocusedWindow = window;

235 } else if (m_focusedWindow == window) {

252 } else if (m_focusedWindow == window) {

236− m_focusedWindowChanged = true;

253+ // Condense changes to the focused window

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

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

256+ m_focusedWindowCleared = true;

237 } else {

257 } else {

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

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

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

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

@@ -338,6 +358,7 @@ void TopLevelWindowModel::onSurfaceDestroyed(unityapi::MirSurfaceInterface *surf

338 auto window = m_windowModel[i].window;

358 auto window = m_windowModel[i].window;

339 window->setSurface(nullptr);

359 window->setSurface(nullptr);

340 window->setFocused(false);

360 window->setFocused(false);

361+ m_allSurfaces.remove(surface);

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

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

342 }

363 }

343}

364}

@@ -353,48 +374,107 @@ Window *TopLevelWindowModel::createWindow(unityapi::MirSurfaceInterface *surface

353 return qmlWindow;

374 return qmlWindow;

354}

375}

355

376

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

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

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

357{

379{

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

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

381+ if (workspace != m_workspace->workspace()) {

382+ removeSurfaces(surfaces);

383+ return;

384+ }

359

385

386+ Q_FOREACH(auto surface, surfaces) {

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

388+

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

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

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

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

362− Window *window = createWindow(surface);

391+ Window *window = createWindow(surface);

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

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

364− window->setSurface(nullptr);

393+ window->setSurface(nullptr);

365− window->deleteLater();

394+ window->deleteLater();

366− });

395+ });

367− } else {

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

369− connectSurface(surface);

370− setInputMethodWindow(createWindow(surface));

371 } else {

396 } else {

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

398+ connectSurface(surface);

399+ setInputMethodWindow(createWindow(surface));

400+ } else {

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

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

373− if (application) {

402+ if (application) {

374− if (surface->state() == Mir::HiddenState) {

403+ if (surface->state() == Mir::HiddenState) {

375− // Ignore it until it's finally shown

404+ // Ignore it until it's finally shown

376− connect(surface, &unityapi::MirSurfaceInterface::stateChanged, this, [=](Mir::State newState) {

405+ connect(surface, &unityapi::MirSurfaceInterface::stateChanged, this, [=](Mir::State newState) {

377− Q_ASSERT(newState != Mir::HiddenState);

406+ Q_ASSERT(newState != Mir::HiddenState);

378− disconnect(surface, &unityapi::MirSurfaceInterface::stateChanged, this, 0);

407+ disconnect(surface, &unityapi::MirSurfaceInterface::stateChanged, this, 0);

408+ prependSurface(surface, application);

409+ });

410+ } else {

379 prependSurface(surface, application);

411 prependSurface(surface, application);

380− });

412+ }

381 } else {

413 } else {

382− prependSurface(surface, application);

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

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

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

417+ Window *promptWindow = createWindow(surface);

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

419+ promptWindow->setSurface(nullptr);

420+ promptWindow->deleteLater();

421+ });

383 }

422 }

384− } else {

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

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

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

388− Window *promptWindow = createWindow(surface);

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

390− promptWindow->setSurface(nullptr);

391− promptWindow->deleteLater();

392− });

393 }

423 }

394 }

424 }

395 }

425 }

396}

426}

397

427

428+void TopLevelWindowModel::removeSurfaces(const QVector<unity::shell::application::MirSurfaceInterface *> surfaces)

429+{

430+ int start = -1;

431+ int end = -1;

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

433+ auto surface = *iter;

434+ iter++;

435+

436+ // Do removals in adjacent blocks.

437+ start = end = indexOf(surface);

438+ if (start == -1) {

439+ // could be a child surface

440+ m_allSurfaces.remove(surface);

441+ continue;

442+ }

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

444+ int index = indexOf(*iter);

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

446+ break;

447+ }

448+ end++;

449+ iter++;

450+ }

451+

452+ if (m_modelState == IdleState) {

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

454+ m_modelState = RemovingState;

455+ } else {

456+ Q_ASSERT(m_modelState == ResettingState);

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

458+ }

459+

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

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

462+ window->setSurface(nullptr);

463+ window->setFocused(false);

464+

465+ m_windowModel.removeAt(start);

466+ m_allSurfaces.remove(surface);

467+ }

468+

469+ if (m_modelState == RemovingState) {

470+ endRemoveRows();

471+ Q_EMIT countChanged();

472+ Q_EMIT listChanged();

473+ m_modelState = IdleState;

474+ }

475+ }

476+}

477+

398void TopLevelWindowModel::deleteAt(int index)

478void TopLevelWindowModel::deleteAt(int index)

399{

479{

400 auto window = m_windowModel[index].window;

480 auto window = m_windowModel[index].window;

@@ -417,12 +497,14 @@ void TopLevelWindowModel::removeAt(int index)

417 }

497 }

418

498

419 auto window = m_windowModel[index].window;

499 auto window = m_windowModel[index].window;

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

420

501

421 if (!window->surface()) {

502 if (!window->surface()) {

422 window->setFocused(false);

503 window->setFocused(false);

423 }

504 }

424

505

425 m_windowModel.removeAt(index);

506 m_windowModel.removeAt(index);

507+ m_allSurfaces.remove(surface);

426

508

427 if (m_modelState == RemovingState) {

509 if (m_modelState == RemovingState) {

428 endRemoveRows();

510 endRemoveRows();

@@ -433,6 +515,7 @@ void TopLevelWindowModel::removeAt(int index)

433

515

434 if (m_focusedWindow == window) {

516 if (m_focusedWindow == window) {

435 setFocusedWindow(nullptr);

517 setFocusedWindow(nullptr);

518+ m_focusedWindowCleared = false;

436 }

519 }

437

520

438 INFO_MSG << " after " << toString();

521 INFO_MSG << " after " << toString();

@@ -451,6 +534,15 @@ void TopLevelWindowModel::setInputMethodWindow(Window *window)

451void TopLevelWindowModel::removeInputMethodWindow()

534void TopLevelWindowModel::removeInputMethodWindow()

452{

535{

453 if (m_inputMethodWindow) {

536 if (m_inputMethodWindow) {

537+ auto surface = m_inputMethodWindow->surface();

538+ if (surface) {

539+ m_allSurfaces.remove(surface);

540+ }

541+ if (m_focusedWindow == m_inputMethodWindow) {

542+ setFocusedWindow(nullptr);

543+ m_focusedWindowCleared = false;

544+ }

545+

454 delete m_inputMethodWindow;

546 delete m_inputMethodWindow;

455 m_inputMethodWindow = nullptr;

547 m_inputMethodWindow = nullptr;

456 Q_EMIT inputMethodSurfaceChanged(nullptr);

548 Q_EMIT inputMethodSurfaceChanged(nullptr);

@@ -462,7 +554,7 @@ void TopLevelWindowModel::onSurfacesRaised(const QVector<unityapi::MirSurfaceInt

462 DEBUG_MSG << "(" << surfaces << ")";

554 DEBUG_MSG << "(" << surfaces << ")";

463 const int raiseCount = surfaces.size();

555 const int raiseCount = surfaces.size();

464 for (int i = 0; i < raiseCount; i++) {

556 for (int i = 0; i < raiseCount; i++) {

465− int fromIndex = findIndexOf(surfaces[i]);

557+ int fromIndex = indexOf(surfaces[i]);

466 if (fromIndex != -1) {

558 if (fromIndex != -1) {

467 move(fromIndex, 0);

559 move(fromIndex, 0);

468 }

560 }

@@ -489,16 +581,6 @@ QVariant TopLevelWindowModel::data(const QModelIndex& index, int role) const

489 }

581 }

490}

582}

491

583

492−int TopLevelWindowModel::findIndexOf(const unityapi::MirSurfaceInterface *surface) const

493−{

494− for (int i=0; i<m_windowModel.count(); i++) {

495− if (m_windowModel[i].window->surface() == surface) {

496− return i;

497− }

498− }

499− return -1;

500−}

501−

502int TopLevelWindowModel::generateId()

584int TopLevelWindowModel::generateId()

503{

585{

504 int id = m_nextId;

586 int id = m_nextId;

@@ -700,12 +782,11 @@ void TopLevelWindowModel::onModificationsStarted()

700

782

701void TopLevelWindowModel::onModificationsEnded()

783void TopLevelWindowModel::onModificationsEnded()

702{

784{

703− if (m_focusedWindowChanged) {

785+ if (m_focusedWindowCleared) {

704− setFocusedWindow(m_newlyFocusedWindow);

786+ setFocusedWindow(nullptr);

705 }

787 }

706 // reset

788 // reset

707− m_focusedWindowChanged = false;

789+ m_focusedWindowCleared = false;

708− m_newlyFocusedWindow = nullptr;

709}

790}

710

791

711void TopLevelWindowModel::activateTopMostWindowWithoutId(int forbiddenId)

792void TopLevelWindowModel::activateTopMostWindowWithoutId(int forbiddenId)

@@ -719,3 +800,54 @@ void TopLevelWindowModel::activateTopMostWindowWithoutId(int forbiddenId)

719 }

800 }

720 }

801 }

721}

802}

803+

804+void TopLevelWindowModel::refreshWindows()

805+{

806+ DEBUG_MSG << "()";

807+ clear();

808+

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

810+

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

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

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

814+ Window *window = createWindow(surface);

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

816+ window->setSurface(nullptr);

817+ window->deleteLater();

818+ });

819+ } else {

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

821+ setInputMethodWindow(createWindow(surface));

822+ } else {

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

824+ if (application) {

825+ prependSurface(surface, application);

826+ } else {

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

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

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

830+ Window *promptWindow = createWindow(surface);

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

832+ promptWindow->setSurface(nullptr);

833+ promptWindow->deleteLater();

834+ });

835+ }

836+ }

837+ }

838+ });

839+}

840+

841+void TopLevelWindowModel::clear()

842+{

843+ DEBUG_MSG << "()";

844+

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

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

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

848+ delete entry.window;

849+ }

850+ m_allSurfaces.clear();

851+ setFocusedWindow(nullptr);

852+ m_focusedWindowCleared = false;

853+}

plugins/WindowManager/TopLevelWindowModel.h+20−24

@@ -20,11 +20,16 @@

20#include <QAbstractListModel>

21#include <QLoggingCategory>

22

23+#include <memory>

24+

23#include "WindowManagerGlobal.h"

25#include "WindowManagerGlobal.h"

24

26

25Q_DECLARE_LOGGING_CATEGORY(TOPLEVELWINDOWMODEL)

27Q_DECLARE_LOGGING_CATEGORY(TOPLEVELWINDOWMODEL)

26

28

27class Window;

29class Window;

30+class Workspace;

31+

32+namespace miral { class Workspace; }

28

33

29namespace unity {

34namespace unity {

30 namespace shell {

35 namespace shell {

@@ -72,16 +77,6 @@ class WINDOWMANAGERQML_EXPORT TopLevelWindowModel : public QAbstractListModel

72 */

77 */

73 Q_PROPERTY(Window* focusedWindow READ focusedWindow NOTIFY focusedWindowChanged)

78 Q_PROPERTY(Window* focusedWindow READ focusedWindow NOTIFY focusedWindowChanged)

74

79

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

76− READ surfaceManager

77− WRITE setSurfaceManager

78− NOTIFY surfaceManagerChanged)

79−

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

81− READ applicationManager

82− WRITE setApplicationManager

83− NOTIFY applicationManagerChanged)

84−

85 /**

80 /**

86 The id to be used on the next entry created

81 The id to be used on the next entry created

87 Useful for tests

82 Useful for tests

@@ -100,7 +95,8 @@ public:

100 ApplicationRole = Qt::UserRole + 1,

95 ApplicationRole = Qt::UserRole + 1,

101 };

96 };

102

97

103− TopLevelWindowModel();

98+ TopLevelWindowModel(Workspace* workspace);

99+ ~TopLevelWindowModel();

104

100

105 // From QAbstractItemModel

101 // From QAbstractItemModel

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

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

@@ -111,17 +107,11 @@ public:

111 return roleNames;

107 return roleNames;

112 }

108 }

113

109

114− // Own API

110+ // Own API;

115

111

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

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

117 Window* focusedWindow() const;

113 Window* focusedWindow() const;

118

114

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

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

121−

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

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

124−

125 int nextId() const { return m_nextId; }

115 int nextId() const { return m_nextId; }

126

116

127public:

117public:

@@ -164,12 +154,13 @@ public:

164 */

154 */

165 Q_INVOKABLE void raiseId(int id);

155 Q_INVOKABLE void raiseId(int id);

166

156

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

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

159+

167Q_SIGNALS:

160Q_SIGNALS:

168 void countChanged();

161 void countChanged();

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

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

170 void focusedWindowChanged(Window *focusedWindow);

163 void focusedWindowChanged(Window *focusedWindow);

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

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

173

164

174 /**

165 /**

175 * @brief Emitted when the list changes

166 * @brief Emitted when the list changes

@@ -181,7 +172,8 @@ Q_SIGNALS:

181 void nextIdChanged();

172 void nextIdChanged();

182

173

183private Q_SLOTS:

174private Q_SLOTS:

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

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

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

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

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

186

178

187 void onModificationsStarted();

179 void onModificationsStarted();

@@ -198,9 +190,9 @@ private:

198 void setInputMethodWindow(Window *window);

190 void setInputMethodWindow(Window *window);

199 void setFocusedWindow(Window *window);

191 void setFocusedWindow(Window *window);

200 void removeInputMethodWindow();

192 void removeInputMethodWindow();

201− int findIndexOf(const unity::shell::application::MirSurfaceInterface *surface) const;

202 void deleteAt(int index);

193 void deleteAt(int index);

203 void removeAt(int index);

194 void removeAt(int index);

195+ void removeSurfaces(const QVector<unity::shell::application::MirSurfaceInterface *> surfaces);

204

196

205 void addApplication(unity::shell::application::ApplicationInfoInterface *application);

197 void addApplication(unity::shell::application::ApplicationInfoInterface *application);

206 void removeApplication(unity::shell::application::ApplicationInfoInterface *application);

198 void removeApplication(unity::shell::application::ApplicationInfoInterface *application);

@@ -223,6 +215,8 @@ private:

223 void activateEmptyWindow(Window *window);

215 void activateEmptyWindow(Window *window);

224

216

225 void activateTopMostWindowWithoutId(int forbiddenId);

217 void activateTopMostWindowWithoutId(int forbiddenId);

218+ void refreshWindows();

219+ void clear();

226

220

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

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

228

222

@@ -239,6 +233,9 @@ private:

239 QVector<ModelEntry> m_windowModel;

233 QVector<ModelEntry> m_windowModel;

240 Window* m_inputMethodWindow{nullptr};

234 Window* m_inputMethodWindow{nullptr};

241 Window* m_focusedWindow{nullptr};

235 Window* m_focusedWindow{nullptr};

236+ Workspace* m_workspace{nullptr};

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

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

242

239

243 int m_nextId{1};

240 int m_nextId{1};

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

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

@@ -259,8 +256,7 @@ private:

259 ModelState m_modelState{IdleState};

256 ModelState m_modelState{IdleState};

260

257

261 // Valid between modificationsStarted and modificationsEnded

258 // Valid between modificationsStarted and modificationsEnded

262− bool m_focusedWindowChanged{false};

259+ bool m_focusedWindowCleared{false};

263− Window *m_newlyFocusedWindow{nullptr};

264};

260};

265

261

266#endif // TOPLEVELWINDOWMODEL_H

262#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+66

@@ -0,0 +1,66 @@

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

23+

24+namespace unity {

25+ namespace shell {

26+ namespace application {

27+ class SurfaceManagerInterface;

28+ class ApplicationManagerInterface;

29+ }

30+ }

31+}

32+

33+class WINDOWMANAGERQML_EXPORT WindowManagerObjects : public QObject

34+{

35+ Q_OBJECT

36+

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

38+ READ surfaceManager

39+ WRITE setSurfaceManager

40+ NOTIFY surfaceManagerChanged)

41+

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

43+ READ applicationManager

44+ WRITE setApplicationManager

45+ NOTIFY applicationManagerChanged)

46+public:

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

48+

49+ static WindowManagerObjects *instance();

50+

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

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

53+

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

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

56+

57+Q_SIGNALS:

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

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

60+

61+private:

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

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

64+};

65+

66+#endif // WINDOWMANAGEROBJECTS_H

plugins/WindowManager/WindowManagerPlugin.cpp+57−2

@@ -17,19 +17,74 @@

17#include "WindowManagerPlugin.h"

18

19#include "AvailableDesktopArea.h"

20+#include "Screen.h"

21+#include "ScreenAttached.h"

22+#include "Screens.h"

23+#include "ScreensConfiguration.h"

24+#include "ScreenWindow.h"

20#include "TopLevelWindowModel.h"

25#include "TopLevelWindowModel.h"

21#include "Window.h"

26#include "Window.h"

27+#include "WindowManagerObjects.h"

22#include "WindowMargins.h"

28#include "WindowMargins.h"

29+#include "WorkspaceManager.h"

30+#include "Workspace.h"

31+#include "WorkspaceModel.h"

23

32

24#include <QtQml>

33#include <QtQml>

34+#include <qtmir/qtmir.h>

35+

36+namespace {

37+

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

39+

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

41+{

42+ Q_UNUSED(engine)

43+ Q_UNUSED(scriptEngine)

44+ return WorkspaceManager::instance();

45+}

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

47+ Q_UNUSED(engine);

48+ Q_UNUSED(scriptEngine);

49+ return ConcreteScreens::self();

50+}

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

52+ Q_UNUSED(engine);

53+ Q_UNUSED(scriptEngine);

54+ return WindowManagerObjects::instance();

55+}

56+

57+} // namspace

25

58

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

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

27{

60{

28 qmlRegisterType<AvailableDesktopArea>(uri, 1, 0, "AvailableDesktopArea");

61 qmlRegisterType<AvailableDesktopArea>(uri, 1, 0, "AvailableDesktopArea");

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

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

62 qmlRegisterType<WindowMargins>(uri, 1, 0, "WindowMargins");

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

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

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

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

67+ qmlRegisterUncreatableType<ScreenConfig>(uri, 1, 0, "ScreenConfig", notInstantiatable);

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

31

69

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

70+ qRegisterMetaType<ConcreteScreen*>("ConcreteScreen*");

71+ qRegisterMetaType<ProxyScreens*>("ProxyScreens*");

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

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

33

74

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

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

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

77+

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

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

80+

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

82+}

83+

84+void WindowManagerPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

85+{

86+ QQmlExtensionPlugin::initializeEngine(engine, uri);

87+

88+ // Create Screens

89+ new ConcreteScreens(qtmir::get_screen_model(), new ScreensConfiguration());

35}

90}

plugins/WindowManager/WindowManagerPlugin.h+1

@@ -27,6 +27,7 @@ class WindowManagerPlugin : public QQmlExtensionPlugin

27

28public:

29 void registerTypes(const char *uri) override;

30+ void initializeEngine(QQmlEngine *engine, const char *uri) override;

30};

31};

31

32

32#endif // WINDOWMANAGER_PLUGIN_H

33#endif // WINDOWMANAGER_PLUGIN_H

plugins/WindowManager/Workspace.cppnew file+177

@@ -0,0 +1,177 @@

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

22+

23+#include "wmpolicyinterface.h"

24+

25+int nextWorkspace = 0;

26+

27+Workspace::Workspace(QObject *parent)

28+ : QObject(parent)

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

30+ , m_model(nullptr)

31+{

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

33+}

34+

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

36+ : QObject(nullptr)

37+ , m_workspace(other.m_workspace)

38+ , m_model(nullptr)

39+{

40+ setObjectName(other.objectName());

41+

42+ connect(&other, &Workspace::activeChanged, this, &Workspace::activeChanged);

43+}

44+

45+Workspace::~Workspace()

46+{

47+ if (m_model) {

48+ m_model->remove(this);

49+ }

50+}

51+

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

53+{

54+ if (m_model == model) return;

55+

56+ if (m_model) {

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

58+ m_model->remove(this);

59+ }

60+

61+ m_model = model;

62+

63+ if (model) {

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

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

66+ index = vIndex.toInt();

67+ }

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

69+

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

71+ m_model = nullptr;

72+ Q_EMIT unassigned();

73+ });

74+ Q_EMIT assigned();

75+ } else {

76+ Q_EMIT unassigned();

77+ }

78+}

79+

80+void Workspace::unassign()

81+{

82+ assign(nullptr);

83+}

84+

85+bool Workspace::isAssigned() const

86+{

87+ return m_model != nullptr;

88+}

89+

90+bool Workspace::isSameAs(Workspace *wks) const

91+{

92+ if (wks == this) return true;

93+ return wks->workspace() == workspace();

94+}

95+

96+

97+ConcreteWorkspace::ConcreteWorkspace(QObject *parent)

98+ : Workspace(parent)

99+ , m_active(false)

100+ , m_windowModel(new TopLevelWindowModel(this))

101+{

102+ connect(WorkspaceManager::instance(), &WorkspaceManager::activeWorkspaceChanged, this, [this](Workspace* activeWorkspace) {

103+ bool newActive = activeWorkspace == this;

104+ if (newActive != m_active) {

105+ m_active = newActive;

106+ Q_EMIT activeChanged(m_active);

107+

108+ if (m_active) {

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

110+ }

111+ }

112+ });

113+}

114+

115+ConcreteWorkspace::~ConcreteWorkspace()

116+{

117+ WorkspaceManager::instance()->destroyWorkspace(this);

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

119+}

120+

121+TopLevelWindowModel *ConcreteWorkspace::windowModel() const

122+{

123+ return m_windowModel.data();

124+}

125+

126+void ConcreteWorkspace::activate()

127+{

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

129+}

130+

131+void ConcreteWorkspace::setCurrentOn(Screen *screen)

132+{

133+ if (screen) {

134+ screen->setCurrentWorkspace(this);

135+ }

136+}

137+

138+

139+ProxyWorkspace::ProxyWorkspace(Workspace * const workspace)

140+ : Workspace(*workspace)

141+ , m_original(workspace)

142+{

143+}

144+

145+void ProxyWorkspace::assign(WorkspaceModel *model, const QVariant &index)

146+{

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

148+}

149+

150+void ProxyWorkspace::unassign()

151+{

152+ Workspace::unassign();

153+}

154+

155+bool ProxyWorkspace::isActive() const

156+{

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

158+}

159+

160+TopLevelWindowModel *ProxyWorkspace::windowModel() const

161+{

162+ return m_original ? m_original->windowModel() : nullptr;

163+}

164+

165+void ProxyWorkspace::activate()

166+{

167+ if (m_original) {

168+ m_original->activate();

169+ }

170+}

171+

172+void ProxyWorkspace::setCurrentOn(Screen *screen)

173+{

174+ if (screen && m_original) {

175+ screen->setCurrentWorkspace(m_original);

176+ }

177+}

plugins/WindowManager/Workspace.hnew file+122

@@ -0,0 +1,122 @@

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+#include <QSharedPointer>

24+

25+#include <memory>

26+#include <functional>

27+

28+#include "WindowManagerGlobal.h"

29+

30+class WorkspaceModel;

31+class TopLevelWindowModel;

32+class Screen;

33+

34+namespace miral { class Workspace; }

35+

36+namespace unity {

37+ namespace shell {

38+ namespace application {

39+ class MirSurfaceInterface;

40+ }

41+ }

42+}

43+

44+class WINDOWMANAGERQML_EXPORT Workspace : public QObject

45+{

46+ Q_OBJECT

47+ Q_PROPERTY(bool active READ isActive NOTIFY activeChanged)

48+ Q_PROPERTY(TopLevelWindowModel* windowModel READ windowModel CONSTANT)

49+public:

50+ virtual ~Workspace();

51+

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

53+ virtual void unassign();

54+

55+ virtual bool isActive() const = 0;

56+ virtual TopLevelWindowModel *windowModel() const = 0;

57+ virtual void setCurrentOn(Screen*) = 0;

58+

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

60+ bool isAssigned() const;

61+ Q_INVOKABLE bool isSameAs(Workspace*) const;

62+

63+public Q_SLOTS:

64+ virtual void activate() = 0;

65+

66+Q_SIGNALS:

67+ void assigned();

68+ void unassigned();

69+

70+ void activeChanged(bool);

71+

72+protected:

73+ Workspace(QObject *parent = nullptr);

74+ Workspace(Workspace const& other);

75+

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

77+ WorkspaceModel* m_model;

78+};

79+

80+class WINDOWMANAGERQML_EXPORT ConcreteWorkspace : public Workspace

81+{

82+public:

83+ ~ConcreteWorkspace();

84+

85+ bool isActive() const override { return m_active; }

86+ TopLevelWindowModel *windowModel() const override;

87+ void activate() override;

88+ void setCurrentOn(Screen*) override;

89+

90+private:

91+ explicit ConcreteWorkspace(QObject *parent = nullptr);

92+

93+ bool m_active;

94+ const QScopedPointer<TopLevelWindowModel> m_windowModel;

95+

96+ friend class WorkspaceManager;

97+};

98+

99+class ProxyWorkspace : public Workspace

100+{

101+ Q_OBJECT

102+public:

103+ explicit ProxyWorkspace(Workspace*const workspace);

104+ ~ProxyWorkspace() = default;

105+

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

107+

108+ bool isActive() const override;

109+ TopLevelWindowModel *windowModel() const override;

110+ void activate() override;

111+ void setCurrentOn(Screen*) override;

112+

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

114+

115+public Q_SLOTS:

116+ void unassign() override;

117+

118+private:

119+ const QPointer<Workspace> m_original;

120+};

121+

122+#endif // WINDOWMANAGER_WORKSPACE_H

plugins/WindowManager/WorkspaceManager.cppnew file+106

@@ -0,0 +1,106 @@

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 ConcreteWorkspace(this);

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

43+ m_allWorkspaces.insert(workspace);

44+

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

46+ setActiveWorkspace(nullptr);

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

48+ setActiveWorkspace(workspace);

49+ }

50+

51+ return workspace;

52+}

53+

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

55+{

56+ if (!workspace) return;

57+

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

59+ workspace->unassign();

60+ }

61+ m_allWorkspaces.remove(workspace);

62+

63+ if (m_activeWorkspace == workspace) {

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

65+ }

66+ if (m_activeWorkspace) {

67+ moveWorkspaceContentToWorkspace(m_activeWorkspace, workspace);

68+ }

69+

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

71+}

72+

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

74+{

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

76+ if (surfaceManager) {

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

78+ }

79+}

80+

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

82+{

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

84+ if (surfaceManager) {

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

86+ }

87+}

88+

89+Workspace *WorkspaceManager::activeWorkspace() const

90+{

91+ return m_activeWorkspace;

92+}

93+

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

95+{

96+ if (workspace != m_activeWorkspace) {

97+ m_activeWorkspace = workspace;

98+ Q_EMIT activeWorkspaceChanged(workspace);

99+ }

100+}

101+

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

103+{

104+ if (!workspace) return;

105+ workspace->activate();

106+}

plugins/WindowManager/WorkspaceManager.hnew 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+#ifndef WORKSPACEMANAGER_H

18+#define WORKSPACEMANAGER_H

19+

20+#include <QQmlListProperty>

21+

22+#include "WindowManagerGlobal.h"

23+#include "WorkspaceModel.h"

24+

25+class Workspace;

26+

27+namespace unity {

28+ namespace shell {

29+ namespace application {

30+ class MirSurfaceInterface;

31+ class SurfaceManagerInterface;

32+ }

33+ }

34+}

35+

36+class WINDOWMANAGERQML_EXPORT WorkspaceManager : public QObject

37+{

38+ Q_OBJECT

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

40+

41+public:

42+ WorkspaceManager();

43+ static WorkspaceManager* instance();

44+

45+ Workspace* activeWorkspace() const;

46+ void setActiveWorkspace(Workspace* workspace);

47+

48+ Workspace* createWorkspace();

49+ void destroyWorkspace(Workspace* workspace);

50+

51+ void destroyFloatingWorkspaces();

52+

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

54+ Workspace* workspace);

55+

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

57+

58+Q_SIGNALS:

59+ void activeWorkspaceChanged(Workspace*);

60+

61+private:

62+ void setActiveWorkspace2(Workspace* workspace);

63+

64+ QSet<Workspace*> m_allWorkspaces;

65+ Workspace* m_activeWorkspace;

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

67+};

68+

69+#endif // WORKSPACEMANAGER_H

plugins/WindowManager/WorkspaceModel.cppnew file+254

@@ -0,0 +1,254 @@

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

21+

22+#include <QQmlEngine>

23+

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

25+

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

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

28+

29+WorkspaceModel::WorkspaceModel(QObject *parent)

30+ : QAbstractListModel(parent)

31+{

32+}

33+

34+WorkspaceModel::~WorkspaceModel()

35+{

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

37+ m_workspaces.clear();

38+}

39+

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

41+{

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

43+}

44+

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

46+{

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

48+

49+ m_workspaces.insert(index, workspace);

50+

51+ endInsertRows();

52+

53+ Q_EMIT workspaceInserted(index, workspace);

54+ Q_EMIT countChanged();

55+}

56+

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

58+{

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

60+ if (index < 0) return;

61+

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

63+

64+ m_workspaces.removeAt(index);

65+ insertUnassigned(workspace);

66+

67+ endRemoveRows();

68+

69+ Q_EMIT workspaceRemoved(workspace);

70+ Q_EMIT countChanged();

71+}

72+

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

74+{

75+ if (from == to) return;

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

77+

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

79+ QModelIndex parent;

80+

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

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

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

84+ m_workspaces.insert(to, window);

85+#else

86+ m_workspaces.move(from, to);

87+#endif

88+ endMoveRows();

89+

90+ Q_EMIT workspaceMoved(from, to);

91+ }

92+}

93+

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

95+{

96+ return m_workspaces.indexOf(workspace);

97+}

98+

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

100+{

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

102+ return m_workspaces.at(index);

103+}

104+

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

106+{

107+ return m_workspaces.count();

108+}

109+

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

111+{

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

113+ return QVariant();

114+

115+ if (role == WorkspaceRole) {

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

117+ return QVariant::fromValue(workspace);

118+ } else {

119+ return QVariant();

120+ }

121+}

122+

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

124+{

125+ if (!proxy) return;

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

127+

128+ // check for removals

129+ int removedIndexWhichWasActive = -1;

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

131+ Q_FOREACH(auto workspace, dpCpy) {

132+

133+ bool found = false;

134+ Q_FOREACH(auto p, proxyList) {

135+ auto workspaceProxy = qobject_cast<ProxyWorkspace*>(p);

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

137+ found = true;

138+ break;

139+ }

140+ }

141+ if (!found) {

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

143+ removedIndexWhichWasActive = indexOf(workspace);

144+ }

145+ workspace->unassign();

146+ }

147+ }

148+

149+ // existing

150+ QSet<Workspace*> newWorkspaces;

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

152+ auto workspaceProxy = qobject_cast<ProxyWorkspace*>(proxyList[i]);

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

154+

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

156+

157+ if (oldIndex < 0) {

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

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

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

161+ }

162+ newWorkspaces.insert(workspace);

163+ }

164+

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

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

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

168+ workspace->assign(this);

169+ (new ProxyWorkspace(workspace))->assign(proxy);

170+ }

171+

172+ if (removedIndexWhichWasActive != -1) {

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

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

175+

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

177+ }

178+

179+ proxy->finishSync();

180+ finishSync();

181+}

182+

183+void WorkspaceModel::finishSync()

184+{

185+ QSet<Workspace*> dpCpy(m_unassignedWorkspaces);

186+ Q_FOREACH(auto workspace, dpCpy) {

187+ delete workspace;

188+ }

189+ m_unassignedWorkspaces.clear();

190+}

191+

192+void WorkspaceModel::insertUnassigned(Workspace *workspace)

193+{

194+ m_unassignedWorkspaces.insert(workspace);

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

196+ m_unassignedWorkspaces.remove(workspace);

197+ disconnect(workspace, &Workspace::assigned, this, 0);

198+ });

199+ connect(workspace, &QObject::destroyed, this, [=]() {

200+ m_unassignedWorkspaces.remove(workspace);

201+ });

202+}

203+

204+

205+ProxyWorkspaceModel::ProxyWorkspaceModel(WorkspaceModel * const model, ProxyScreen* screen)

206+ : m_original(model)

207+ , m_screen(screen)

208+{

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

210+ auto proxy = new ProxyWorkspace(workspace);

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

212+ proxy->assign(this);

213+ }

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

215+ if (isSyncing()) return;

216+

217+ (new ProxyWorkspace(inserted))->assign(this, index);

218+ });

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

220+ if (isSyncing()) return;

221+

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

223+ auto workspaceProxy = qobject_cast<ProxyWorkspace*>(get(i));

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

225+ if (w == removed) {

226+ remove(workspaceProxy);

227+ break;

228+ }

229+ }

230+ });

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

232+ if (isSyncing()) return;

233+

234+ move(from, to);

235+ });

236+}

237+

238+void ProxyWorkspaceModel::move(int from, int to)

239+{

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

241+}

242+

243+bool ProxyWorkspaceModel::isSyncing() const

244+{

245+ return m_screen->isSyncing();

246+}

247+

248+void ProxyWorkspaceModel::addWorkspace()

249+{

250+ auto newWorkspace = WorkspaceManager::instance()->createWorkspace();

251+ m_original->insertUnassigned(newWorkspace);

252+

253+ (new ProxyWorkspace(newWorkspace))->assign(this);

254+}

plugins/WindowManager/WorkspaceModel.hnew file+102

@@ -0,0 +1,102 @@

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 ProxyWorkspaceModel;

28+class ProxyScreen;

29+

30+class WorkspaceModel : public QAbstractListModel

31+{

32+ Q_OBJECT

33+ Q_PROPERTY(int count READ rowCount NOTIFY countChanged)

34+public:

35+ /**

36+ * @brief The Roles supported by the model

37+ *

38+ * WorkspaceRole - A workspace.

39+ */

40+ enum Roles {

41+ WorkspaceRole = Qt::UserRole

42+ };

43+

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

45+ ~WorkspaceModel();

46+

47+ void append(Workspace *workspace);

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

49+ void remove(Workspace* workspace);

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

51+

52+ int indexOf(Workspace *workspace) const;

53+ Workspace* get(int index) const;

54+

55+ // From QAbstractItemModel

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

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

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

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

60+ return roleNames;

61+ }

62+

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

64+

65+ void sync(WorkspaceModel* proxy);

66+ void finishSync();

67+

68+Q_SIGNALS:

69+ void countChanged();

70+

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

72+ void workspaceRemoved(Workspace *workspace);

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

74+

75+protected:

76+ void insertUnassigned(Workspace* workspace);

77+

78+ QVector<Workspace*> m_workspaces;

79+ QSet<Workspace*> m_unassignedWorkspaces;

80+

81+ friend class ProxyWorkspaceModel;

82+};

83+

84+class ProxyWorkspaceModel : public WorkspaceModel

85+{

86+ Q_OBJECT

87+public:

88+ explicit ProxyWorkspaceModel(WorkspaceModel*const model, ProxyScreen* screen);

89+

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

91+

92+ bool isSyncing() const;

93+

94+public Q_SLOTS:

95+ void addWorkspace();

96+

97+protected:

98+ const QPointer<WorkspaceModel> m_original;

99+ const ProxyScreen* m_screen;

100+};

101+

102+#endif // WORKSPACEMODEL_H

qml/ApplicationMenus/ApplicationMenuItemFactory.qml+4−4

@@ -45,7 +45,7 @@ Object {

45

46 Action {

47 id: action

48− text: menuData.label.replace("_", "&")

48+ text: menuData && menuData.label.replace("_", "&") || ""

49 }

50

51 ListItemLayout {

@@ -59,8 +59,8 @@ Object {

59 }

60

61 Label {

62− text: menuData.shortcut

62+ text: menuData && menuData.shortcut || ""

63− visible: menuData.shortcut && QuickUtils.keyboardAttached

63+ visible: menuData && menuData.shortcut && QuickUtils.keyboardAttached

64 SlotsLayout.position: SlotsLayout.Trailing

65 color: enabled ? theme.palette.normal.backgroundSecondaryText :

66 theme.palette.disabled.backgroundSecondaryText

@@ -86,7 +86,7 @@ Object {

86

87 Action {

88 id: action

89− text: menuData.label.replace("_", "&")

89+ text: menuData && menuData.label.replace("_", "&") || ""

90 }

91

92 ListItemLayout {

qml/ApplicationMenus/MenuBar.qml+5−1

@@ -19,6 +19,7 @@ import QtQuick.Layouts 1.1

19import Utils 0.1

20import Ubuntu.Components 1.3

21import GlobalShortcut 1.0

22+import "../Components/PanelState"

22

23

23Item {

24Item {

24 id: root

25 id: root

@@ -29,6 +30,7 @@ Item {

29 property bool enableKeyFilter: false

30 property bool enableKeyFilter: false

30 property real overflowWidth: width

31 property real overflowWidth: width

31 property bool windowMoving: false

32 property bool windowMoving: false

33+ property PanelState panelState

32

34

33 // read from outside

35 // read from outside

34 readonly property bool valid: rowRepeater.count > 0

36 readonly property bool valid: rowRepeater.count > 0

@@ -106,7 +108,9 @@ Item {

106

108

107 Component {

109 Component {

108 id: menuComponent

110 id: menuComponent

109− MenuPopup { }

111+ MenuPopup {

112+ panelState: root.panelState

113+ }

110 }

114 }

111

115

112 Repeater {

116 Repeater {

qml/ApplicationMenus/MenuPopup.qml+3−1

@@ -64,6 +64,7 @@ UbuntuShape {

64 }

65

66 property alias unityMenuModel: repeater.model

67+ property PanelState panelState

67

68

68 function show() {

69 function show() {

69 visible = true;

70 visible = true;

@@ -103,7 +104,7 @@ UbuntuShape {

103 property real __minimumWidth: units.gu(20)

104 property real __minimumWidth: units.gu(20)

104 property real __maximumWidth: ApplicationMenusLimits.screenWidth * 0.7

105 property real __maximumWidth: ApplicationMenusLimits.screenWidth * 0.7

105 property real __minimumHeight: units.gu(2)

106 property real __minimumHeight: units.gu(2)

106− property real __maximumHeight: ApplicationMenusLimits.screenHeight - PanelState.panelHeight

107+ property real __maximumHeight: ApplicationMenusLimits.screenHeight - panelState.panelHeight

107

108

108 signal dismissAll()

109 signal dismissAll()

109

110

@@ -492,6 +493,7 @@ UbuntuShape {

492

493

493 onLoaded: {

494 onLoaded: {

494 item.unityMenuModel = Qt.binding(function() { return submenuLoader.unityMenuModel; });

495 item.unityMenuModel = Qt.binding(function() { return submenuLoader.unityMenuModel; });

496+ item.panelState = Qt.binding(function() { return root.panelState; });

495 item.objectName = Qt.binding(function() { return submenuLoader.objectName + "menu"; });

497 item.objectName = Qt.binding(function() { return submenuLoader.objectName + "menu"; });

496 item.desiredX = Qt.binding(function() { return submenuLoader.desiredX; });

498 item.desiredX = Qt.binding(function() { return submenuLoader.desiredX; });

497 item.desiredY = Qt.binding(function() { return submenuLoader.desiredY; });

499 item.desiredY = Qt.binding(function() { return submenuLoader.desiredY; });

qml/CMakeLists.txt+1−1

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

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

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

2

3install(FILES ${QML_JS_FILES}

4 DESTINATION ${SHELL_APP_DIR}

qml/Components/PanelState/PanelState.qml−1

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

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

15 */

16

17−pragma Singleton

18import QtQuick 2.4

17import QtQuick 2.4

19

18

20QtObject {

19QtObject {

qml/Components/PanelState/qmldir+1−1

@@ -1 +1 @@

1−singleton PanelState 1.0 PanelState.qml

1+PanelState 1.0 PanelState.qml

qml/Components/VirtualTouchPad.qml+14−20

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

18import QtQuick.Layouts 1.1

19import Ubuntu.Components 1.3

20import Qt.labs.settings 1.0

21−import Unity.Screens 0.1

21+import WindowManager 1.0

22import UInput 0.1

23import "../Components"

24

25Item {

26 id: root

27− property var uinput: UInput {

28− Component.onCompleted: createMouse();

29− Component.onDestruction: removeMouse();

30− }

31

27

32 Component.onCompleted: {

28 Component.onCompleted: {

29+ UInput.createMouse();

33 if (!settings.touchpadTutorialHasRun) {

30 if (!settings.touchpadTutorialHasRun) {

34 root.runTutorial()

31 root.runTutorial()

35 }

32 }

36 }

33 }

34+ Component.onDestruction: UInput.removeMouse()

37

35

38 function runTutorial() {

36 function runTutorial() {

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

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

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

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

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

86 && clickTimer.running) {

84 && clickTimer.running) {

87 clickTimer.stop();

85 clickTimer.stop();

88− uinput.pressMouse(UInput.ButtonLeft)

86+ UInput.pressMouse(UInput.ButtonLeft)

89 isDoubleClick = true;

87 isDoubleClick = true;

90 }

88 }

91 isClick = true;

89 isClick = true;

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

104

102

105 onReleased: {

103 onReleased: {

106 if (isDoubleClick || isDrag) {

104 if (isDoubleClick || isDrag) {

107− uinput.releaseMouse(UInput.ButtonLeft)

105+ UInput.releaseMouse(UInput.ButtonLeft)

108 isDoubleClick = false;

106 isDoubleClick = false;

109 }

107 }

110 if (isClick) {

108 if (isClick) {

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

120 interval: 200

118 interval: 200

121 property int button: UInput.ButtonLeft

119 property int button: UInput.ButtonLeft

122 onTriggered: {

120 onTriggered: {

123− uinput.pressMouse(button);

121+ UInput.pressMouse(button);

124− uinput.releaseMouse(button);

122+ UInput.releaseMouse(button);

125 }

123 }

126 function scheduleClick(button) {

124 function scheduleClick(button) {

127 clickTimer.button = button;

125 clickTimer.button = button;

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

138 isDrag = true;

136 isDrag = true;

139 }

137 }

140

138

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

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

142 }

140 }

143

141

144 function scroll(touchPoints) {

142 function scroll(touchPoints) {

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

166 dh /= 2;

164 dh /= 2;

167 dv /= 2;

165 dv /= 2;

168

166

169− uinput.scrollMouse(dh, dv);

167+ UInput.scrollMouse(dh, dv);

170 }

168 }

171

169

172 touchPoints: [

170 touchPoints: [

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

189 objectName: "leftButton"

187 objectName: "leftButton"

190 Layout.fillWidth: true

188 Layout.fillWidth: true

191 Layout.fillHeight: true

189 Layout.fillHeight: true

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

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

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

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

194 property bool highlight: false

192 property bool highlight: false

195 UbuntuShape {

193 UbuntuShape {

196 anchors.fill: parent

194 anchors.fill: parent

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

204 objectName: "rightButton"

202 objectName: "rightButton"

205 Layout.fillWidth: true

203 Layout.fillWidth: true

206 Layout.fillHeight: true

204 Layout.fillHeight: true

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

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

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

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

209 property bool highlight: false

207 property bool highlight: false

210 UbuntuShape {

208 UbuntuShape {

211 anchors.fill: parent

209 anchors.fill: parent

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

239 }

237 }

240 }

238 }

241

239

242− Screens {

243− id: screens

244− }

245−

246 InputMethod {

240 InputMethod {

247 id: inputMethod

241 id: inputMethod

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

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

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

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

250 objectName: "inputMethod"

244 objectName: "inputMethod"

251 anchors.fill: parent

245 anchors.fill: parent

252 }

246 }

qml/DisabledScreenNotice.qml+2−1

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

28 property var screen: Screen

29 property var orientationLock: OrientationLock

30

31+ property alias deviceConfiguration: _deviceConfiguration

31 DeviceConfiguration {

32 DeviceConfiguration {

32− id: deviceConfiguration

33+ id: _deviceConfiguration

33 name: applicationArguments.deviceName

34 name: applicationArguments.deviceName

34 }

35 }

35

36

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

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

24import Unity.Session 0.1

25

26import "." 0.1

27+import ".." 0.1

27import "../Components"

28import "../Components"

28

29

29Showable {

30Showable {

@@ -225,7 +226,7 @@ Showable {

225 if (forcedUnlock && shown) {

226 if (forcedUnlock && shown) {

226 hideView();

227 hideView();

227 if (hideNow) {

228 if (hideNow) {

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

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

229 }

230 }

231 }

232 }

@@ -373,7 +374,7 @@ Showable {

373 onEmergencyCall: root.emergencyCall()

374 onEmergencyCall: root.emergencyCall()

374 onRequiredChanged: {

375 onRequiredChanged: {

375 if (!loader.item.required) {

376 if (!loader.item.required) {

376− root.hide();

377+ ShellNotifier.greeter.hide(false);

377 }

378 }

379 }

380 }

@@ -487,12 +488,29 @@ Showable {

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

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

488 }

489 }

489

490

491+ Connections {

492+ target: ShellNotifier.greeter

493+ onHide: {

494+ if (now) {

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

496+ } else {

497+ root.hide();

498+ }

499+ }

500+ }

501+

502+ Binding {

503+ target: ShellNotifier.greeter

504+ property: "shown"

505+ value: root.shown

506+ }

507+

490 Connections {

508 Connections {

491 target: DBusUnitySessionService

509 target: DBusUnitySessionService

492 onLockRequested: root.forceShow()

510 onLockRequested: root.forceShow()

493 onUnlocked: {

511 onUnlocked: {

494 root.forcedUnlock = true;

512 root.forcedUnlock = true;

495− root.hideNow();

513+ ShellNotifier.greeter.hide(true);

496 }

514 }

497 }

515 }

498

516

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+5−8

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

18import QtQuick.Window 2.2

19import Unity.InputInfo 0.1

20import Unity.Session 0.1

21−import Unity.Screens 0.1

21+import WindowManager 1.0

22import Utils 0.1

23import GSettings 1.0

24import "Components"

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

32 implicitWidth: units.gu(40)

33 implicitHeight: units.gu(71)

34

35+ property alias deviceConfiguration: _deviceConfiguration

36+ property alias orientations: d.orientations

37+

35 onWidthChanged: calculateUsageMode();

38 onWidthChanged: calculateUsageMode();

36

39

37 DeviceConfiguration {

40 DeviceConfiguration {

38− id: deviceConfiguration

41+ id: _deviceConfiguration

39 name: applicationArguments.deviceName

42 name: applicationArguments.deviceName

40 }

43 }

41

44

42− property alias orientations: d.orientations

43−

44 Item {

45 Item {

45 id: d

46 id: d

46

47

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

157 return false;

158 return false;

158 }

159 }

159

160

160− Screens {

161− id: screens

162− }

163−

164 property int orientation

161 property int orientation

165 onPhysicalOrientationChanged: {

162 onPhysicalOrientationChanged: {

166 if (!orientationLocked) {

163 if (!orientationLocked) {

qml/Panel/Panel.qml+17−15

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

48 property bool hasKeyboard: false

49

50 property string mode: "staged"

51+ property PanelState panelState

51

52

52 MouseArea {

53 MouseArea {

53 id: backMouseEater

54 id: backMouseEater

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

64 }

65 }

65

66

66 Binding {

67 Binding {

67− target: PanelState

68+ target: panelState

68 property: "panelHeight"

69 property: "panelHeight"

69 value: minimizedPanelHeight

70 value: minimizedPanelHeight

70 }

71 }

71

72

72 RegisteredApplicationMenuModel {

73 RegisteredApplicationMenuModel {

73 id: registeredMenuModel

74 id: registeredMenuModel

74− persistentSurfaceId: PanelState.focusedPersistentSurfaceId

75+ persistentSurfaceId: panelState.focusedPersistentSurfaceId

75 }

76 }

76

77

77 QtObject {

78 QtObject {

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

82 !indicators.shown &&

83 !indicators.shown &&

83 (decorationMouseArea.containsMouse || menuBarLoader.menusRequested)

84 (decorationMouseArea.containsMouse || menuBarLoader.menusRequested)

84

85

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

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

86− PanelState.decorationsAlwaysVisible

87+ panelState.decorationsAlwaysVisible

87

88

88 property bool showPointerMenu: revealControls &&

89 property bool showPointerMenu: revealControls &&

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

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

90

91

91 property bool enablePointerMenu: revealControls &&

92 property bool enablePointerMenu: revealControls &&

92 applicationMenus.available &&

93 applicationMenus.available &&

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

138 fill: panelAreaBackground

139 fill: panelAreaBackground

139 bottomMargin: -units.gu(1)

140 bottomMargin: -units.gu(1)

140 }

141 }

141− visible: PanelState.dropShadow

142+ visible: panelState.dropShadow

142 source: "graphics/rectangular_dropshadow.sci"

143 source: "graphics/rectangular_dropshadow.sci"

143 }

144 }

144

145

@@ -195,12 +196,12 @@ Item {

195 visible: opacity != 0

196 visible: opacity != 0

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

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

197

198

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

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

199 windowIsMaximized: true

200 windowIsMaximized: true

200− onCloseClicked: PanelState.closeClicked()

201+ onCloseClicked: panelState.closeClicked()

201− onMinimizeClicked: PanelState.minimizeClicked()

202+ onMinimizeClicked: panelState.minimizeClicked()

202− onMaximizeClicked: PanelState.restoreClicked()

203+ onMaximizeClicked: panelState.restoreClicked()

203− closeButtonShown: PanelState.closeButtonShown

204+ closeButtonShown: panelState.closeButtonShown

204 }

205 }

205

206

206 Loader {

207 Loader {

@@ -220,11 +221,12 @@ Item {

220 sourceComponent: MenuBar {

221 sourceComponent: MenuBar {

221 id: bar

222 id: bar

222 objectName: "menuBar"

223 objectName: "menuBar"

223− anchors.left: parent.left

224+ anchors.left: menuBarLoader.left

224 anchors.margins: units.gu(1)

225 anchors.margins: units.gu(1)

225 height: menuBarLoader.height

226 height: menuBarLoader.height

226− enableKeyFilter: valid && PanelState.decorationsVisible

227+ enableKeyFilter: valid && panelState.decorationsVisible

227 unityMenuModel: __applicationMenus.model

228 unityMenuModel: __applicationMenus.model

229+ panelState: root.panelState

228

230

229 Connections {

231 Connections {

230 target: __applicationMenus

232 target: __applicationMenus

@@ -236,7 +238,7 @@ Item {

236 onShownChanged: bar.dismiss();

238 onShownChanged: bar.dismiss();

237 }

239 }

238

240

239− onDoubleClicked: PanelState.restoreClicked()

241+ onDoubleClicked: panelState.restoreClicked()

240 onPressed: mouse.accepted = false // let the parent mouse area handle this, so it can both unsnap window and show menu

242 onPressed: mouse.accepted = false // let the parent mouse area handle this, so it can both unsnap window and show menu

241 }

243 }

242 }

244 }

@@ -343,7 +345,7 @@ Item {

343 opacity: __applicationMenus.visible && !__applicationMenus.expanded ? 1 : 0

345 opacity: __applicationMenus.visible && !__applicationMenus.expanded ? 1 : 0

344 visible: opacity != 0

346 visible: opacity != 0

345 Behavior on opacity { NumberAnimation { duration: UbuntuAnimation.SnapDuration } }

347 Behavior on opacity { NumberAnimation { duration: UbuntuAnimation.SnapDuration } }

346− text: PanelState.title

348+ text: panelState.title

347 }

349 }

348

350

349 PanelMenu {

351 PanelMenu {

qml/Shell.qml+38−22

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

1−/*

1+/*

3 *

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

@@ -38,6 +38,7 @@ import "Notifications"

38import "Stage"

39import "Tutorial"

40import "Wizard"

41+import "Components/PanelState"

41import Unity.Notifications 1.0 as NotificationBackend

42import Unity.Notifications 1.0 as NotificationBackend

42import Unity.Session 0.1

43import Unity.Session 0.1

43import Unity.DashCommunicator 0.1

44import Unity.DashCommunicator 0.1

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

96

97

97 readonly property var mainApp: stage.mainApp

98 readonly property var mainApp: stage.mainApp

98

99

100+ readonly property var topLevelSurfaceList: {

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

102+ return WMScreen.currentWorkspace.windowModel

103+ }

104+

99 onMainAppChanged: {

105 onMainAppChanged: {

100 if (mainApp) {

106 if (mainApp) {

101 _onMainAppChanged(mainApp.appId);

107 _onMainAppChanged(mainApp.appId);

@@ -267,23 +273,17 @@ StyledItem {

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

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

268 }

274 }

269

275

276+ PanelState {

277+ id: panelState

278+ objectName: "panelState"

279+ }

280+

270 Item {

281 Item {

271 id: stages

282 id: stages

272 objectName: "stages"

283 objectName: "stages"

273 width: parent.width

284 width: parent.width

274 height: parent.height

285 height: parent.height

275

286

276− SurfaceManager {

277− id: surfaceMan

278− objectName: "surfaceManager"

279− }

280− TopLevelWindowModel {

281− id: topLevelSurfaceList

282− objectName: "topLevelSurfaceList"

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

284− surfaceManager: surfaceMan

285− }

286−

287 Stage {

288 id: stage

289 objectName: "stage"

@@ -294,7 +294,7 @@ StyledItem {

294 background: wallpaperResolver.background

295

296 applicationManager: ApplicationManager

297− topLevelSurfaceList: topLevelSurfaceList

297+ topLevelSurfaceList: shell.topLevelSurfaceList

298 inputMethodRect: inputMethod.visibleRect

299 rightEdgePushProgress: rightEdgeBarrier.progress

300 availableDesktopArea: availableDesktopAreaItem

@@ -323,6 +323,7 @@ StyledItem {

323 altTabPressed: physicalKeysMapper.altTabPressed

324 oskEnabled: shell.oskEnabled

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

326+ panelState: panelState

326

327

327 onSpreadShownChanged: {

328 onSpreadShownChanged: {

328 panel.indicators.hide();

329 panel.indicators.hide();

@@ -363,7 +364,7 @@ StyledItem {

363 InputMethod {

364 InputMethod {

364 id: inputMethod

365 id: inputMethod

365 objectName: "inputMethod"

366 objectName: "inputMethod"

366− surface: topLevelSurfaceList.inputMethodSurface

367+ surface: shell.topLevelSurfaceList.inputMethodSurface

367 anchors {

368 anchors {

368 fill: parent

369 fill: parent

369 topMargin: panel.panelHeight

370 topMargin: panel.panelHeight

@@ -377,8 +378,13 @@ StyledItem {

377 objectName: "greeterLoader"

378 objectName: "greeterLoader"

378 anchors.fill: parent

379 anchors.fill: parent

379 anchors.topMargin: panel.panelHeight

380 anchors.topMargin: panel.panelHeight

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

381+ sourceComponent: {

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

383+ if (screenWindow.primary) return integratedGreeter;

384+ return secondaryGreeter;

385+ }

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

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

387+ }

382 onLoaded: {

388 onLoaded: {

383 item.objectName = "greeter"

389 item.objectName = "greeter"

384 }

390 }

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

428 }

434 }

429 }

435 }

430

436

437+ Component {

438+ id: secondaryGreeter

439+ SecondaryGreeter {

440+ hides: [launcher, panel.indicators]

441+ }

442+ }

443+

431 Timer {

444 Timer {

432 // See powerConnection for why this is useful

445 // See powerConnection for why this is useful

433 id: showGreeterDelayed

446 id: showGreeterDelayed

@@ -538,13 +551,14 @@ StyledItem {

538 && !stage.spreadShown

551 && !stage.spreadShown

539 }

552 }

540

553

541− readonly property bool focusedSurfaceIsFullscreen: topLevelSurfaceList.focusedWindow

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

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

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

543 : false

556 : false

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

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

545 || greeter.hasLockedApp

558 || greeter.hasLockedApp

546 greeterShown: greeter && greeter.shown

559 greeterShown: greeter && greeter.shown

547 hasKeyboard: shell.hasKeyboard

560 hasKeyboard: shell.hasKeyboard

561+ panelState: panelState

548 }

562 }

549

563

550 Launcher {

564 Launcher {

@@ -793,11 +807,11 @@ StyledItem {

793 Cursor {

807 Cursor {

794 id: cursor

808 id: cursor

795 objectName: "cursor"

809 objectName: "cursor"

796− visible: shell.hasMouse

810+

797 z: itemGrabber.z + 1

811 z: itemGrabber.z + 1

798 topBoundaryOffset: panel.panelHeight

812 topBoundaryOffset: panel.panelHeight

799−

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

800− confiningItem: stage.itemConfiningMouseCursor

814+ visible: enabled

801

815

802 property bool mouseNeverMoved: true

816 property bool mouseNeverMoved: true

803 Binding {

817 Binding {

@@ -809,6 +823,8 @@ StyledItem {

809 when: cursor.mouseNeverMoved && cursor.visible

823 when: cursor.mouseNeverMoved && cursor.visible

810 }

824 }

811

825

826+ confiningItem: stage.itemConfiningMouseCursor

827+

812 height: units.gu(3)

828 height: units.gu(3)

813

829

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

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

@@ -872,7 +888,7 @@ StyledItem {

872

888

873 // non-visual objects

889 // non-visual objects

874 KeymapSwitcher {

890 KeymapSwitcher {

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

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

876 }

892 }

877 BrightnessControl {}

893 BrightnessControl {}

878

894

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/DecoratedWindow.qml+3−1

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

38 property alias maximizeButtonShown: decoration.maximizeButtonShown

39 property alias interactive: applicationWindow.interactive

40 readonly property alias orientationChangesEnabled: applicationWindow.orientationChangesEnabled

41+ property PanelState panelState

41

42

42 // Changing this will actually add/remove a decoration, meaning, requestedHeight will take the decoration into account.

43 // Changing this will actually add/remove a decoration, meaning, requestedHeight will take the decoration into account.

43 property bool hasDecoration: true

44 property bool hasDecoration: true

@@ -218,6 +219,7 @@ FocusScope {

218

219

219 title: applicationWindow.title

220 title: applicationWindow.title

220 windowMoving: moveHandler.moving && !altDragHandler.dragging

221 windowMoving: moveHandler.moving && !altDragHandler.dragging

222+ panelState: root.panelState

221

223

222 opacity: root.hasDecoration ? Math.min(1, root.showDecoration) : 0

224 opacity: root.hasDecoration ? Math.min(1, root.showDecoration) : 0

223 Behavior on opacity { UbuntuNumberAnimation { } }

225 Behavior on opacity { UbuntuNumberAnimation { } }

@@ -241,7 +243,7 @@ FocusScope {

241 enableMenus: {

243 enableMenus: {

242 return active &&

244 return active &&

243 surface &&

245 surface &&

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

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

245 }

247 }

246 menu: sharedAppModel.model

248 menu: sharedAppModel.model

247

249

qml/Stage/FakeMaximizeDelegate.qml+12−11

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

35 property int leftMargin

36 property real appContainerWidth

37 property real appContainerHeight

38+ property PanelState panelState

38

39

39 readonly property real hintThreshold: 0.1

40 readonly property real hintThreshold: 0.1

40

41

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

178 ParallelAnimation {

179 ParallelAnimation {

179 id: fakeMaximizeAnimation

180 id: fakeMaximizeAnimation

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

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

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

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

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

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

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

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

184 }

185 }

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

186 ParallelAnimation {

187 ParallelAnimation {

187 id: fakeMaximizeLeftAnimation

188 id: fakeMaximizeLeftAnimation

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

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

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

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

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

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

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

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

192 }

193 }

193

194

194 ParallelAnimation {

195 ParallelAnimation {

195 id: fakeMaximizeRightAnimation

196 id: fakeMaximizeRightAnimation

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

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

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

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

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

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

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

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

200 }

201 }

201

202

202 ParallelAnimation {

203 ParallelAnimation {

203 id: fakeMaximizeTopLeftAnimation

204 id: fakeMaximizeTopLeftAnimation

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

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

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

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

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

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

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

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

208 }

209 }

209

210

210 ParallelAnimation {

211 ParallelAnimation {

211 id: fakeMaximizeTopRightAnimation

212 id: fakeMaximizeTopRightAnimation

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

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

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

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

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

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

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

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

216 }

217 }

217

218

218 ParallelAnimation {

219 ParallelAnimation {

219 id: fakeMaximizeBottomLeftAnimation

220 id: fakeMaximizeBottomLeftAnimation

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

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

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

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

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

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

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

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

224 }

225 }

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

226 ParallelAnimation {

227 ParallelAnimation {

227 id: fakeMaximizeBottomRightAnimation

228 id: fakeMaximizeBottomRightAnimation

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

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

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

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

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

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

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

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

232 }

233 }

qml/Stage/Stage.qml+13−10

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

48 property rect inputMethodRect

49 property real rightEdgePushProgress: 0

50 property Item availableDesktopArea

51+ property PanelState panelState

51

52

52 // Configuration

53 // Configuration

53 property string mode: "staged"

54 property string mode: "staged"

@@ -381,20 +382,20 @@ FocusScope {

381 Component.onCompleted: priv.updateMainAndSideStageIndexes();

382 Component.onCompleted: priv.updateMainAndSideStageIndexes();

382

383

383 Connections {

384 Connections {

384− target: PanelState

385+ target: panelState

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

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

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

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

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

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

388 }

389 }

389

390

390 Binding {

391 Binding {

391− target: PanelState

392+ target: panelState

392 property: "decorationsVisible"

393 property: "decorationsVisible"

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

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

394 }

395 }

395

396

396 Binding {

397 Binding {

397− target: PanelState

398+ target: panelState

398 property: "title"

399 property: "title"

399 value: {

400 value: {

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

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

@@ -409,7 +410,7 @@ FocusScope {

409 }

410 }

410

411

411 Binding {

412 Binding {

412− target: PanelState

413+ target: panelState

413 property: "focusedPersistentSurfaceId"

414 property: "focusedPersistentSurfaceId"

414 value: {

415 value: {

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

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

@@ -423,21 +424,21 @@ FocusScope {

423 }

424 }

424

425

425 Binding {

426 Binding {

426− target: PanelState

427+ target: panelState

427 property: "dropShadow"

428 property: "dropShadow"

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

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

429 }

430 }

430

431

431 Binding {

432 Binding {

432− target: PanelState

433+ target: panelState

433 property: "closeButtonShown"

434 property: "closeButtonShown"

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

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

435 }

436 }

436

437

437 Component.onDestruction: {

438 Component.onDestruction: {

438− PanelState.title = "";

439+ panelState.title = "";

439− PanelState.decorationsVisible = false;

440+ panelState.decorationsVisible = false;

440− PanelState.dropShadow = false;

441+ panelState.dropShadow = false;

441 }

442 }

442

443

443 Instantiator {

444 Instantiator {

@@ -1606,7 +1607,7 @@ FocusScope {

1606 ]

1607 ]

1607

1608

1608 Binding {

1609 Binding {

1609− target: PanelState

1610+ target: panelState

1610 property: "decorationsAlwaysVisible"

1611 property: "decorationsAlwaysVisible"

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

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

1612 }

1613 }

@@ -1652,6 +1653,7 @@ FocusScope {

1652 highlightSize: windowInfoItem.iconMargin / 2

1653 highlightSize: windowInfoItem.iconMargin / 2

1653 altDragEnabled: root.mode == "windowed"

1654 altDragEnabled: root.mode == "windowed"

1654 boundsItem: root.availableDesktopArea

1655 boundsItem: root.availableDesktopArea

1656+ panelState: root.panelState

1655

1657

1656 requestedWidth: appDelegate.requestedWidth

1658 requestedWidth: appDelegate.requestedWidth

1657 requestedHeight: appDelegate.requestedHeight

1659 requestedHeight: appDelegate.requestedHeight

@@ -1860,6 +1862,7 @@ FocusScope {

1860 leftMargin: root.availableDesktopArea.x

1862 leftMargin: root.availableDesktopArea.x

1861 appContainerWidth: appContainer.width

1863 appContainerWidth: appContainer.width

1862 appContainerHeight: appContainer.height

1864 appContainerHeight: appContainer.height

1865+ panelState: root.panelState

1863 }

1866 }

1864

1867

1865 MouseArea {

1868 MouseArea {

qml/Stage/WindowDecoration.qml+2

@@ -34,6 +34,7 @@ MouseArea {

34 property var menu: undefined

35 property bool enableMenus: true

36 property bool windowMoving: false

37+ property PanelState panelState

37

38

38 readonly property real buttonsWidth: buttons.width + row.spacing

39 readonly property real buttonsWidth: buttons.width + row.spacing

39

40

@@ -146,6 +147,7 @@ MouseArea {

146 enableKeyFilter: valid && root.active && root.enableMenus

147 enableKeyFilter: valid && root.active && root.enableMenus

147 unityMenuModel: root.menu

148 unityMenuModel: root.menu

148 windowMoving: root.windowMoving

149 windowMoving: root.windowMoving

150+ panelState: root.panelState

149

151

150 onPressed: root.onPressed(mouse)

152 onPressed: root.onPressed(mouse)

151 onPressedChangedEx: root.pressedChangedEx(pressed, pressedButtons, mouseX, mouseY)

153 onPressedChangedEx: root.pressedChangedEx(pressed, pressedButtons, mouseX, mouseY)

qml/qmldirnew file+1

@@ -0,0 +1 @@

1+singleton ShellNotifier 0.1 ShellNotifier.qml

src/ApplicationArguments.cpp+11−2

@@ -16,7 +16,16 @@

16

17#include "ApplicationArguments.h"

18

19−ApplicationArguments::ApplicationArguments(QObject *parent)

19+ApplicationArguments::ApplicationArguments(QCoreApplication *app)

20− : QObject(parent)

20+ : QObject(app)

21+ , UnityCommandLineParser(*app)

21{

22{

22}

23}

24+

25+void ApplicationArguments::setDeviceName(const QString &deviceName)

26+{

27+ if (deviceName != m_deviceName) {

28+ m_deviceName = deviceName;

29+ Q_EMIT deviceNameChanged(m_deviceName);

30+ }

31+}

src/ApplicationArguments.h+17−15

@@ -23,31 +23,33 @@

23#include <QSize>

24#include <QString>

25

26+#include "UnityCommandLineParser.h"

27+

26−class ApplicationArguments : public QObject

28+class ApplicationArguments : public QObject,

29+ public UnityCommandLineParser

27{

30{

28 Q_OBJECT

31 Q_OBJECT

29 Q_PROPERTY(QString deviceName READ deviceName NOTIFY deviceNameChanged)

32 Q_PROPERTY(QString deviceName READ deviceName NOTIFY deviceNameChanged)

30 Q_PROPERTY(QString mode READ mode CONSTANT)

33 Q_PROPERTY(QString mode READ mode CONSTANT)

34+

35+ Q_PROPERTY(bool hasGeometry READ hasGeometry CONSTANT)

36+ Q_PROPERTY(QSize windowGeometry READ windowGeometry CONSTANT)

37+ Q_PROPERTY(bool hasTestability READ hasTestability CONSTANT)

38+ Q_PROPERTY(bool hasFrameless READ hasFrameless CONSTANT)

39+ Q_PROPERTY(bool hasFullscreen READ hasFullscreen CONSTANT)

40+#ifdef UNITY8_ENABLE_TOUCH_EMULATION

41+ Q_PROPERTY(bool hasMouseToTouch READ hasMouseToTouch CONSTANT)

42+#endif

43+

31public:

44public:

32− ApplicationArguments(QObject *parent = nullptr);

45+ ApplicationArguments(QCoreApplication *app);

33

46

34− void setDeviceName(const QString &deviceName) {

47+ void setDeviceName(const QString &deviceName);

35− if (deviceName != m_deviceName) {

36− m_deviceName = deviceName;

37− Q_EMIT deviceNameChanged(m_deviceName);

38− }

39− }

40− QString deviceName() const { return m_deviceName; }

41

48

42− void setMode(const QString &mode) { m_mode = mode; }

49+ bool hasGeometry() const { return m_windowGeometry.isValid(); }

43− QString mode() const { return m_mode; }

44

50

45Q_SIGNALS:

51Q_SIGNALS:

46 void deviceNameChanged(const QString&);

52 void deviceNameChanged(const QString&);

47−

48−private:

49− QString m_deviceName;

50− QString m_mode;

51};

53};

52

54

53#endif // APPLICATION_ARGUMENTS_H

55#endif // APPLICATION_ARGUMENTS_H

src/CMakeLists.txt+12−4

@@ -9,6 +9,7 @@ include_directories(

9 ${Qt5Quick_PRIVATE_INCLUDE_DIRS}

10 ${GSETTINGS_QT_INCLUDE_DIRS}

11 ${CONNECTIVITY_INCLUDE_DIRS}

12+ ${QTMIRSERVER_INCLUDE_DIRS}

12)

13)

13

14

14include_directories(

15include_directories(

@@ -29,12 +30,12 @@ set(SOURCE_FILES

29 ApplicationArguments.cpp

30 ApplicationArguments.cpp

30 main.cpp

31 main.cpp

31 CachingNetworkManagerFactory.cpp

32 CachingNetworkManagerFactory.cpp

32− SecondaryWindow.cpp

33+ DisplayConfigurationStorage.cpp

33− ShellApplication.cpp

34+ UnityApplication.cpp

34− ShellView.cpp

35 UnityCommandLineParser.cpp

36 UnixSignalHandler.cpp

37 DebuggingController.cpp

38+ WindowManagementPolicy.cpp

38 ${QML_FILES} # This is to make qml and image files appear in the IDE's project tree

39 ${QML_FILES} # This is to make qml and image files appear in the IDE's project tree

39)

40)

40

41

@@ -49,7 +50,14 @@ qt5_use_modules(${SHELL_APP} DBus Gui Qml Quick Test)

49if (NOT "${ANDROID_PROPERTIES_INCLUDE_DIRS}" STREQUAL "")

50if (NOT "${ANDROID_PROPERTIES_INCLUDE_DIRS}" STREQUAL "")

50 set_target_properties(${SHELL_APP} PROPERTIES INCLUDE_DIRECTORIES ${ANDROID_PROPERTIES_INCLUDE_DIRS})

51 set_target_properties(${SHELL_APP} PROPERTIES INCLUDE_DIRECTORIES ${ANDROID_PROPERTIES_INCLUDE_DIRS})

51endif()

52endif()

52−target_link_libraries(${SHELL_APP} ${ANDROID_PROPERTIES_LDFLAGS} ${GSETTINGS_QT_LDFLAGS} UbuntuGestures connectivity-qt1 unity8-private)

53+target_link_libraries(${SHELL_APP}

54+ ${ANDROID_PROPERTIES_LDFLAGS}

55+ ${GSETTINGS_QT_LDFLAGS}

56+ ${QTMIRSERVER_LDFLAGS}

57+ UbuntuGestures

58+ connectivity-qt1

59+ unity8-private

60+)

53

61

54if (ENABLE_TOUCH_EMULATION)

62if (ENABLE_TOUCH_EMULATION)

55 target_link_libraries(${SHELL_APP} ${MOUSETOUCHADAPTOR_LIBS_LDFLAGS})

63 target_link_libraries(${SHELL_APP} ${MOUSETOUCHADAPTOR_LIBS_LDFLAGS})

src/DisplayConfigurationStorage.cppnew file+90

@@ -0,0 +1,90 @@

1+#include "DisplayConfigurationStorage.h"

2+

3+#include <QFile>

4+#include <QStandardPaths>

5+#include <QJsonObject>

6+#include <QJsonDocument>

7+

8+namespace {

9+

10+inline QString stringFromEdid(const miral::Edid& edid)

11+{

12+ QString str;

13+ str += QString::fromStdString(edid.vendor);

14+ str += QString("%1%2").arg(edid.product_code).arg(edid.serial_number);

15+

16+ for (int i = 0; i < 4; i++) {

17+ str += QString::fromStdString(edid.descriptors[i].string_value());

18+ }

19+ return str;

20+}

21+

22+}

23+

24+DisplayConfigurationStorage::DisplayConfigurationStorage()

25+{

26+}

27+

28+void DisplayConfigurationStorage::save(const miral::DisplayId &displayId, const miral::DisplayConfigurationOptions &options)

29+{

30+ const QString dbPath = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + QStringLiteral("/unity8/");

31+ QFile f(dbPath + stringFromEdid(displayId.edid) + ".edid");

32+

33+ QJsonObject json;

34+ if (options.used.is_set()) json.insert("used", options.used.value());

35+ if (options.clone_output_index.is_set()) json.insert("clone_output_index", static_cast<int>(options.clone_output_index.value()));

36+ if (options.mode.is_set()) {

37+ auto const& mode = options.mode.value();

38+

39+ QString sz(QString("%1x%2").arg(mode.size.width.as_int()).arg(mode.size.height.as_int()));

40+ QJsonObject jsonMode({

41+ {"size", sz},

42+ {"refresh_rate", mode.refresh_rate }

43+ });

44+ json.insert("mode", jsonMode);

45+ }

46+ if (options.orientation.is_set()) json.insert("orientation", static_cast<int>(options.orientation.value()));

47+ if (options.form_factor.is_set()) json.insert("form_factor", static_cast<int>(options.form_factor.value()));

48+ if (options.scale.is_set()) json.insert("scale", options.scale.value());

49+

50+ if (f.open(QIODevice::WriteOnly)) {

51+ QJsonDocument saveDoc(json);

52+ f.write(saveDoc.toJson());

53+ }

54+}

55+

56+bool DisplayConfigurationStorage::load(const miral::DisplayId &displayId, miral::DisplayConfigurationOptions &options) const

57+{

58+ const QString dbPath = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + QStringLiteral("/unity8/");

59+ QFile f(dbPath + stringFromEdid(displayId.edid) + ".edid");

60+

61+ if (f.open(QIODevice::ReadOnly)) {

62+ QByteArray saveData = f.readAll();

63+ QJsonDocument loadDoc(QJsonDocument::fromJson(saveData));

64+

65+ QJsonObject json(loadDoc.object());

66+ if (json.contains("used")) options.used = json["used"].toBool();

67+ if (json.contains("clone_output_index")) options.clone_output_index = json["clone_output_index"].toInt();

68+ if (json.contains("mode")) {

69+ QJsonObject jsonMode = json["mode"].toObject();

70+

71+ if (jsonMode.contains("size") && jsonMode.contains("refresh_rate")) {

72+ QString sz(jsonMode["size"].toString());

73+ QStringList geo = sz.split("x", QString::SkipEmptyParts);

74+ if (geo.count() == 2) {

75+ miral::DisplayConfigurationOptions::DisplayMode mode;

76+ mode.size = mir::geometry::Size(geo[0].toInt(), geo[1].toInt());

77+ mode.refresh_rate = jsonMode["refresh_rate"].toDouble();

78+ options.mode = mode;

79+ }

80+ }

81+ }

82+ if (json.contains("orientation")) options.orientation = static_cast<MirOrientation>(json["orientation"].toInt());

83+ if (json.contains("form_factor")) options.form_factor = static_cast<MirFormFactor>(json["form_factor"].toInt());

84+ if (json.contains("scale")) options.scale = json["form_factor"].toDouble();

85+

86+ return true;

87+ }

88+

89+ return false;

90+}

src/DisplayConfigurationStorage.hnew file+15

@@ -0,0 +1,15 @@

1+#ifndef UNITY_DISPLAYCONFIGURATIONSTORAGE_H

2+#define UNITY_DISPLAYCONFIGURATIONSTORAGE_H

3+

4+#include <qtmir/miral/display_configuration_storage.h>

5+

6+class DisplayConfigurationStorage : public miral::DisplayConfigurationStorage

7+{

8+public:

9+ DisplayConfigurationStorage();

10+

11+ void save(const miral::DisplayId& displayId, const miral::DisplayConfigurationOptions& options) override;

12+ bool load(const miral::DisplayId& displayId, miral::DisplayConfigurationOptions& options) const override;

13+};

14+

15+#endif // UNITY_DISPLAYCONFIGURATIONSTORAGE_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−221

@@ -1,221 +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 <QGSettings>

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−

37−ShellApplication::ShellApplication(int & argc, char ** argv, bool isMirServer)

38− : QGuiApplication(argc, argv)

39−{

40− setApplicationName(QStringLiteral("unity8"));

41− setOrganizationName(QStringLiteral("Canonical"));

42−

43− connect(this, &QGuiApplication::screenAdded, this, &ShellApplication::onScreenAdded);

44−

45− setupQmlEngine(isMirServer);

46−

47− UnityCommandLineParser parser(*this);

48−

49− if (!parser.deviceName().isEmpty()) {

50− m_deviceName = parser.deviceName();

51− } else {

52− char buffer[200];

53− property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);

54− m_deviceName = QString(buffer);

55− }

56− m_qmlArgs.setDeviceName(m_deviceName);

57−

58− m_qmlArgs.setMode(parser.mode());

59−

60− // The testability driver is only loaded by QApplication but not by QGuiApplication.

61− // However, QApplication depends on QWidget which would add some unneeded overhead => Let's load the testability driver on our own.

62− if (parser.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {

63− QLibrary testLib(QStringLiteral("qttestability"));

64− if (testLib.load()) {

65− typedef void (*TasInitialize)(void);

66− TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");

67− if (initFunction) {

68− initFunction();

69− } else {

70− qCritical("Library qttestability resolve failed!");

71− }

72− } else {

73− qCritical("Library qttestability load failed!");

74− }

75− }

76−

77− bindtextdomain("unity8", translationDirectory().toUtf8().data());

78− textdomain("unity8");

79−

80− QScopedPointer<QGSettings> gSettings(new QGSettings("com.canonical.Unity8"));

81− gSettings->reset(QStringLiteral("alwaysShowOsk"));

82−

83− m_shellView = new ShellView(m_qmlEngine, &m_qmlArgs);

84−

85− if (parser.windowGeometry().isValid()) {

86− m_shellView->setWidth(parser.windowGeometry().width());

87− m_shellView->setHeight(parser.windowGeometry().height());

88− }

89−

90− if (parser.hasFrameless()) {

91− m_shellView->setFlags(Qt::FramelessWindowHint);

92− }

93−

94−

95− #ifdef UNITY8_ENABLE_TOUCH_EMULATION

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

97− // Needed only when manually testing on a desktop.

98− if (parser.hasMouseToTouch()) {

99− m_mouseTouchAdaptor = MouseTouchAdaptor::instance();

100− }

101− #endif

102−

103− new DebuggingController(this);

104−

105− // Some hard-coded policy for now.

106− // NB: We don't support more than two screens at the moment

107− //

108− // TODO: Support an arbitrary number of screens and different policies

109− // (eg cloned desktop, several desktops, etc)

110− if (isMirServer && screens().count() == 2) {

111− m_shellView->setScreen(screens().at(1));

112− m_qmlArgs.setDeviceName(QStringLiteral("desktop"));

113−

114− m_secondaryWindow = new SecondaryWindow(m_qmlEngine);

115− m_secondaryWindow->setScreen(screens().at(0));

116− // QWindow::showFullScreen() also calls QWindow::requestActivate() and we don't want that!

117− m_secondaryWindow->setWindowState(Qt::WindowFullScreen);

118− m_secondaryWindow->setVisible(true);

119− }

120−

121− if (parser.mode().compare("greeter") == 0) {

122− QSize primaryScreenSize = this->primaryScreen()->size();

123− m_shellView->setHeight(primaryScreenSize.height());

124− m_shellView->setWidth(primaryScreenSize.width());

125− m_shellView->show();

126− m_shellView->requestActivate();

127− if (!QProcess::startDetached("initctl emit --no-wait unity8-greeter-started")) {

128− qDebug() << "Unable to send unity8-greeter-started event to Upstart";

129− }

130− } else if (isMirServer || parser.hasFullscreen()) {

131− m_shellView->showFullScreen();

132− } else {

133− m_shellView->show();

134− }

135−}

136−

137−ShellApplication::~ShellApplication()

138−{

139− destroyResources();

140−}

141−

142−void ShellApplication::destroyResources()

143−{

144− // Deletion order is important. Don't use QScopedPointers and the like

145− // Otherwise the process will hang on shutdown (bug somewhere I guess).

146− delete m_shellView;

147− m_shellView = nullptr;

148−

149− delete m_secondaryWindow;

150− m_secondaryWindow = nullptr;

151−

152− #ifdef UNITY8_ENABLE_TOUCH_EMULATION

153− delete m_mouseTouchAdaptor;

154− m_mouseTouchAdaptor = nullptr;

155− #endif

156−

157− delete m_qmlEngine;

158− m_qmlEngine = nullptr;

159−}

160−

161−void ShellApplication::setupQmlEngine(bool isMirServer)

162−{

163− m_qmlEngine = new QQmlEngine(this);

164−

165− m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));

166−

167− prependImportPaths(m_qmlEngine, ::overrideImportPaths());

168− if (!isMirServer) {

169− prependImportPaths(m_qmlEngine, ::nonMirImportPaths());

170− }

171− appendImportPaths(m_qmlEngine, ::fallbackImportPaths());

172−

173− m_qmlEngine->setNetworkAccessManagerFactory(new CachingNetworkManagerFactory);

174−

175− QObject::connect(m_qmlEngine, &QQmlEngine::quit, this, &QGuiApplication::quit);

176−}

177−

178−void ShellApplication::onScreenAdded(QScreen * /*screen*/)

179−{

180− // TODO: Support an arbitrary number of screens and different policies

181− // (eg cloned desktop, several desktops, etc)

182− if (screens().count() == 2) {

183− m_shellView->setScreen(screens().at(1));

184− m_qmlArgs.setDeviceName(QStringLiteral("desktop"));

185− // Changing the QScreen where a QWindow is drawn makes it also lose focus (besides having

186− // its backing QPlatformWindow recreated). So lets refocus it.

187− m_shellView->requestActivate();

188− // QWindow::destroy() is called when it changes between screens. We have to manually make it visible again

189− // <dandrader> This bug is supposedly fixed in Qt 5.5.1, although I can still reproduce it there. :-/

190− m_shellView->setVisible(true);

191−

192− m_secondaryWindow = new SecondaryWindow(m_qmlEngine);

193− m_secondaryWindow->setScreen(screens().at(0));

194−

195− // QWindow::showFullScreen() also calls QWindow::requestActivate() and we don't want that!

196− m_secondaryWindow->setWindowState(Qt::WindowFullScreen);

197− m_secondaryWindow->setVisible(true);

198− }

199−}

200−

201−void ShellApplication::onScreenAboutToBeRemoved(QScreen *screen)

202−{

203− // TODO: Support an arbitrary number of screens and different policies

204− // (eg cloned desktop, several desktops, etc)

205− if (screen == m_shellView->screen()) {

206− const QList<QScreen *> allScreens = screens();

207− Q_ASSERT(allScreens.count() > 1);

208− Q_ASSERT(allScreens.at(0) != screen);

209− Q_ASSERT(m_secondaryWindow);

210− delete m_secondaryWindow;

211− m_secondaryWindow = nullptr;

212− m_shellView->setScreen(allScreens.first());

213− m_qmlArgs.setDeviceName(m_deviceName);

214− // Changing the QScreen where a QWindow is drawn makes it also lose focus (besides having

215− // its backing QPlatformWindow recreated). So lets refocus it.

216− m_shellView->requestActivate();

217− // QWindow::destroy() is called when it changes between screens. We have to manually make it visible again

218− // <dandrader> This bug is supposedly fixed in Qt 5.5.1, although I can still reproduce it there. :-/

219− m_shellView->setVisible(true);

220− }

221−}

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+152

@@ -0,0 +1,152 @@

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

27+

28+#include <libintl.h>

29+

30+// libandroid-properties

31+#include <hybris/properties/properties.h>

32+

33+// qtmir

34+#include <qtmir/displayconfigurationstorage.h>

35+

36+// local

37+#include <paths.h>

38+#include "CachingNetworkManagerFactory.h"

39+#include "UnityCommandLineParser.h"

40+#include "DebuggingController.h"

41+#include "WindowManagementPolicy.h"

42+#include "DisplayConfigurationStorage.h"

43+

44+#include <QDebug>

45+

46+

47+

48+UnityApplication::UnityApplication(int & argc, char ** argv)

49+ : qtmir::MirServerApplication(argc, argv, { qtmir::SetWindowManagementPolicy<WindowManagementPolicy>(),

50+ qtmir::SetDisplayConfigurationStorage<DisplayConfigurationStorage>() })

51+ , m_qmlArgs(this)

52+{

53+ setApplicationName(QStringLiteral("unity8"));

54+ setOrganizationName(QStringLiteral("Canonical"));

55+

56+ setupQmlEngine();

57+

58+ if (m_qmlArgs.deviceName().isEmpty()) {

59+ char buffer[200];

60+ property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);

61+ m_qmlArgs.setDeviceName(QString(buffer));

62+ }

63+

64+ // The testability driver is only loaded by QApplication but not by QGuiApplication.

65+ // However, QApplication depends on QWidget which would add some unneeded overhead => Let's load the testability driver on our own.

66+ if (m_qmlArgs.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {

67+ QLibrary testLib(QStringLiteral("qttestability"));

68+ if (testLib.load()) {

69+ typedef void (*TasInitialize)(void);

70+ TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");

71+ if (initFunction) {

72+ initFunction();

73+ } else {

74+ qCritical("Library qttestability resolve failed!");

75+ }

76+ } else {

77+ qCritical("Library qttestability load failed!");

78+ }

79+ }

80+

81+ bindtextdomain("unity8", translationDirectory().toUtf8().data());

82+ textdomain("unity8");

83+

84+ QScopedPointer<QGSettings> gSettings(new QGSettings("com.canonical.Unity8"));

85+ gSettings->reset(QStringLiteral("alwaysShowOsk"));

86+

87+

88+ QByteArray pxpguEnv = qgetenv("GRID_UNIT_PX");

89+ bool ok;

90+ int pxpgu = pxpguEnv.toInt(&ok);

91+ if (!ok) {

92+ pxpgu = 8;

93+ }

94+ m_qmlEngine->rootContext()->setContextProperty("internalGu", pxpgu);

95+ m_qmlEngine->rootContext()->setContextProperty(QStringLiteral("applicationArguments"), &m_qmlArgs);

96+ m_qmlEngine->rootContext()->setContextProperty("DebuggingController", new DebuggingController(this));

97+

98+ auto component(new QQmlComponent(m_qmlEngine, m_qmlArgs.qmlfie()));

99+ component->create();

100+ if (component->status() == QQmlComponent::Error) {

101+ m_qmlEngine->rootContext()->setContextProperty(QStringLiteral("errorString"), component->errorString());

102+ auto errorComponent(new QQmlComponent(m_qmlEngine,

103+ QUrl::fromLocalFile(::qmlDirectory() + "/ErrorApplication.qml")));

104+ errorComponent->create();

105+ qDebug() << errorComponent->errorString();

106+ return;

107+ }

108+

109+ #ifdef UNITY8_ENABLE_TOUCH_EMULATION

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

111+ // Needed only when manually testing on a desktop.

112+ if (m_qmlArgs.hasMouseToTouch()) {

113+ m_mouseTouchAdaptor = MouseTouchAdaptor::instance();

114+ }

115+ #endif

116+

117+ if (m_qmlArgs.mode().compare("greeter") == 0) {

118+ if (!QProcess::startDetached("initctl emit --no-wait unity8-greeter-started")) {

119+ qDebug() << "Unable to send unity8-greeter-started event to Upstart";

120+ }

121+ }

122+}

123+

124+UnityApplication::~UnityApplication()

125+{

126+ destroyResources();

127+}

128+

129+void UnityApplication::destroyResources()

130+{

131+ #ifdef UNITY8_ENABLE_TOUCH_EMULATION

132+ delete m_mouseTouchAdaptor;

133+ m_mouseTouchAdaptor = nullptr;

134+ #endif

135+

136+ delete m_qmlEngine;

137+ m_qmlEngine = nullptr;

138+}

139+

140+void UnityApplication::setupQmlEngine()

141+{

142+ m_qmlEngine = new QQmlEngine(this);

143+

144+ m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));

145+

146+ prependImportPaths(m_qmlEngine, ::overrideImportPaths());

147+ appendImportPaths(m_qmlEngine, ::fallbackImportPaths());

148+

149+ m_qmlEngine->setNetworkAccessManagerFactory(new CachingNetworkManagerFactory);

150+

151+ QObject::connect(m_qmlEngine, &QQmlEngine::quit, this, &QGuiApplication::quit);

152+}

src/ShellApplication.h → src/UnityApplication.hrenamed+9−19

@@ -14,11 +14,11 @@

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

15 */

16

17−#ifndef SHELLAPPLICATION_H

17+#ifndef UNITYAPPLICATION_H

18−#define SHELLAPPLICATION_H

18+#define UNITYAPPLICATION_H

19

20#include <QGuiApplication>

21−#include <QQmlEngine>

21+#include <QQmlApplicationEngine>

22#include <QQuickView>

23#include <QScopedPointer>

24

@@ -28,30 +28,20 @@

28#include "MouseTouchAdaptor.h"

29#endif

30

31−#include "SecondaryWindow.h"

31+#include <qtmir/mirserverapplication.h>

32−#include "ShellView.h"

33

32

34−class ShellApplication : public QGuiApplication

33+class UnityApplication : public qtmir::MirServerApplication

35{

34{

36 Q_OBJECT

35 Q_OBJECT

37public:

36public:

38− ShellApplication(int & argc, char ** argv, bool isMirServer);

37+ UnityApplication(int & argc, char ** argv);

39− virtual ~ShellApplication();

38+ virtual ~UnityApplication();

40

39

41 void destroyResources();

40 void destroyResources();

42−public Q_SLOTS:

43− // called by qtmir

44− void onScreenAboutToBeRemoved(QScreen *screen);

45−

46−private Q_SLOTS:

47− void onScreenAdded(QScreen*);

48

41

49private:

42private:

50− void setupQmlEngine(bool isMirServer);

43+ void setupQmlEngine();

51− QString m_deviceName;

52 ApplicationArguments m_qmlArgs;

44 ApplicationArguments m_qmlArgs;

53− ShellView *m_shellView{nullptr};

54− SecondaryWindow *m_secondaryWindow{nullptr};

55

45

56 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

46 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

57 MouseTouchAdaptor *m_mouseTouchAdaptor{nullptr};

47 MouseTouchAdaptor *m_mouseTouchAdaptor{nullptr};

@@ -60,4 +50,4 @@ private:

60 QQmlEngine *m_qmlEngine{nullptr};

50 QQmlEngine *m_qmlEngine{nullptr};

61};

51};

62

52

63−#endif // SHELLAPPLICATION_H

53+#endif // UNITYAPPLICATION_H

src/UnityCommandLineParser.cpp+8

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

15 */

16

17#include "UnityCommandLineParser.h"

18+#include <paths.h>

18

19

19#include <QDebug>

20#include <QDebug>

20

21

@@ -60,6 +61,11 @@ UnityCommandLineParser::UnityCommandLineParser(const QCoreApplication &app)

60 QStringLiteral("mode"), QStringLiteral("full-greeter"));

61 QStringLiteral("mode"), QStringLiteral("full-greeter"));

61 parser.addOption(modeOption);

62 parser.addOption(modeOption);

62

63

64+ QCommandLineOption qmlfileOption(QStringLiteral("qmlfile"),

65+ QStringLiteral("The base qml file to load"),

66+ QStringLiteral("qmlfile"), ::qmlDirectory() + "/ShellApplication.qml");

67+ parser.addOption(qmlfileOption);

68+

63 // Treat args with single dashes the same as arguments with two dashes

69 // Treat args with single dashes the same as arguments with two dashes

64 // Ex: -fullscreen == --fullscreen

70 // Ex: -fullscreen == --fullscreen

65 parser.setSingleDashWordOptionMode(QCommandLineParser::ParseAsLongOptions);

71 parser.setSingleDashWordOptionMode(QCommandLineParser::ParseAsLongOptions);

@@ -85,6 +91,8 @@ UnityCommandLineParser::UnityCommandLineParser(const QCoreApplication &app)

85 m_hasFullscreen = parser.isSet(fullscreenOption);

91 m_hasFullscreen = parser.isSet(fullscreenOption);

86 m_deviceName = parser.value(devicenameOption);

92 m_deviceName = parser.value(devicenameOption);

87 resolveMode(parser, modeOption);

93 resolveMode(parser, modeOption);

94+

95+ m_qmlfile = parser.value(qmlfileOption);

88}

96}

89

97

90int UnityCommandLineParser::parsePixelsValue(const QString &str)

98int UnityCommandLineParser::parsePixelsValue(const QString &str)

src/UnityCommandLineParser.h+4−1

@@ -36,8 +36,10 @@ public:

36 bool hasFullscreen() const { return m_hasFullscreen; }

37 QString deviceName() const { return m_deviceName; }

38 QString mode() const { return m_mode; }

39−private:

40

39

40+ QString qmlfie() const { return m_qmlfile; }

41+

42+protected:

41 int parsePixelsValue(const QString &str);

43 int parsePixelsValue(const QString &str);

42 static float getenvFloat(const char* name, float defaultValue);

44 static float getenvFloat(const char* name, float defaultValue);

43 void resolveMode(QCommandLineParser &parser, QCommandLineOption &modeOption);

45 void resolveMode(QCommandLineParser &parser, QCommandLineOption &modeOption);

@@ -55,6 +57,7 @@ private:

55 bool m_hasFullscreen;

57 bool m_hasFullscreen;

56 QString m_deviceName;

58 QString m_deviceName;

57 QString m_mode;

59 QString m_mode;

60+ QString m_qmlfile;

58};

61};

59

62

60#endif // UNITY_COMMAND_LINE_PARSER_H

63#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, std::shared_ptr<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, std::shared_ptr<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

8 abstractdbusservicemonitor.cpp

9 unitydbusobject.cpp

10 unitydbusvirtualobject.cpp

11+ wmpolicyinterface.cpp

11 )

12 )

12

13

13add_library(${LIB_NAME} SHARED

14add_library(${LIB_NAME} SHARED

src/SecondaryWindow.h → src/libunity8-private/wmpolicyinterface.cpprenamed+6−12

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

1/*

3 *

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

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

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

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

15 */

16

17−#ifndef UNITY_SECONDARY_WINDOW_H

17+#include "wmpolicyinterface.h"

18−#define UNITY_SECONDARY_WINDOW_H

19

18

20−#include <QQuickView>

19+WMPolicyInterface* wmPolicyInterface = nullptr;

21

20

22−class SecondaryWindow : public QQuickView

21+WMPolicyInterface *WMPolicyInterface::instance()

23{

22{

24− Q_OBJECT

23+ return wmPolicyInterface;

25−

26−public:

27− SecondaryWindow(QQmlEngine *engine);

28−};

24+}

29−

30−#endif // UNITY_SECONDARY_WINDOW_H

src/libunity8-private/wmpolicyinterface.hnew file+46

@@ -0,0 +1,46 @@

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+ virtual ~WMPolicyInterface() {}

34+

35+ static WMPolicyInterface *instance();

36+

37+ virtual std::shared_ptr<miral::Workspace> createWorkspace() = 0;

38+

39+ virtual void releaseWorkspace(const std::shared_ptr<miral::Workspace> &workspace) = 0;

40+

41+ virtual void setActiveWorkspace(const std::shared_ptr<miral::Workspace> &workspace) = 0;

42+};

43+

44+extern Q_DECL_EXPORT WMPolicyInterface* wmPolicyInterface;

45+

46+#endif // WMPOLICYINTERFACE_H

src/main.cpp+4−8

@@ -15,9 +15,10 @@

15 */

16

17// local

18−#include "ShellApplication.h"

18+#include "UnityApplication.h"

19#include "qmldebuggerutils.h"

20#include "UnixSignalHandler.h"

21+#include <paths.h>

21

22

22#include <QTranslator>

23#include <QTranslator>

23#include <QLibraryInfo>

24#include <QLibraryInfo>

@@ -27,17 +28,12 @@ int main(int argc, const char *argv[])

27{

28{

28 qSetMessagePattern("[%{time yyyy-MM-dd:hh:mm:ss.zzz}] %{if-category}%{category}: %{endif}%{message}");

29 qSetMessagePattern("[%{time yyyy-MM-dd:hh:mm:ss.zzz}] %{if-category}%{category}: %{endif}%{message}");

29

30

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−

36 if (enableQmlDebugger(argc, argv)) {

31 if (enableQmlDebugger(argc, argv)) {

37 QQmlDebuggingEnabler qQmlEnableDebuggingHelper(true);

32 QQmlDebuggingEnabler qQmlEnableDebuggingHelper(true);

38 }

33 }

39

34

40− ShellApplication *application = new ShellApplication(argc, (char**)argv, isMirServer);

35+ auto *application = new UnityApplication(argc,

36+ (char**)argv);

41

37

42 UnixSignalHandler signalHandler([]{

38 UnixSignalHandler signalHandler([]{

43 QGuiApplication::exit(0);

39 QGuiApplication::exit(0);

tests/CMakeLists.txt+1

@@ -47,6 +47,7 @@ macro(unity8_parse_arguments)

47 list(APPEND ld_paths

48 ${UNITY_MOCKPATH}/liblightdm

49 ${UNITY_MOCKPATH}/libusermetrics

50+ ${UNITY_MOCKPATH}/WindowManager

50 )

51 )

51

52

52 string(REPLACE ";" ":" ld_library_path "${ld_paths}")

53 string(REPLACE ";" ":" ld_library_path "${ld_paths}")

tests/mocks/CMakeLists.txt+1

@@ -43,6 +43,7 @@ add_subdirectory(SessionBroadcast)

43add_subdirectory(Ubuntu)

44add_subdirectory(Unity)

45add_subdirectory(QtMultimedia)

46+add_subdirectory(WindowManager)

46add_subdirectory(Wizard)

47add_subdirectory(Wizard)

47add_subdirectory(Utils)

48add_subdirectory(Utils)

48add_subdirectory(UInput)

49add_subdirectory(UInput)

tests/mocks/Cursor/Cursor.qml+49−2

@@ -15,8 +15,11 @@

15 */

16

17import QtQuick 2.4

18+import UInput 0.1

19+

20+Canvas {

21+ id: root

18

22

19−Item {

20 property int topBoundaryOffset // effectively panel height

23 property int topBoundaryOffset // effectively panel height

21 property Item confiningItem

24 property Item confiningItem

22

25

@@ -30,5 +33,49 @@ Item {

30 signal pushStopped()

33 signal pushStopped()

31 signal mouseMoved()

34 signal mouseMoved()

32

35

36+ width: units.gu(2)

37+ height: units.gu(2)

38+ antialiasing: true

39+

40+ onPaint: {

41+ var ctx = getContext("2d");

42+ ctx.save();

43+ ctx.clearRect(0,0,width, height);

44+ ctx.strokeStyle = "#000000";

45+ ctx.lineWidth = 1

46+ ctx.fillStyle = "#ffffff";

47+ ctx.globalAlpha = 1.0;

48+ ctx.lineJoin = "round";

49+ ctx.beginPath();

50+

51+ // put rectangle in the middle

52+ // draw the rectangle

53+ ctx.moveTo(width/2,height);

54+ ctx.lineTo(width, height/2);

55+ ctx.lineTo(0,0);

56+

57+ ctx.closePath();

58+ ctx.fill();

59+ ctx.stroke();

60+ ctx.restore();

61+ }

62+

63+ Connections {

64+ target: UInput

33− onMouseMoved: opacity = 1;

65+ onMouseMoved: {

66+ var newX = root.x;

67+ newX += dx;

68+ if (newX < 0) newX = 0;

69+ else if (newX >= parent.width) newX = parent.width-1;

70+

71+ var newY = root.y;

72+ newY += dy;

73+ if (newY < 0) newY = 0;

74+ else if (newY >= parent.height) newY = parent.height-1;

75+

76+ root.x = newX;

77+ root.y = newY;

78+ root.mouseMoved();

79+ }

80+ }

34}

81}

tests/mocks/GSettings.1.0/plugin.cpp+12

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

18#include "fake_gsettings.h"

19

20#include <QtQml/qqml.h>

21+#include <QQmlEngine>

22+#include <QQmlContext>

21

23

22static QObject* controllerProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)

24static QObject* controllerProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)

23{

25{

@@ -31,3 +33,13 @@ void FakeGSettingsQmlPlugin::registerTypes(const char *uri)

31 qmlRegisterUncreatableType<GSettingsSchemaQml>(uri, 1, 0, "GSettingsSchema",

33 qmlRegisterUncreatableType<GSettingsSchemaQml>(uri, 1, 0, "GSettingsSchema",

32 "GSettingsSchema can only be used inside of a GSettings component");

34 "GSettingsSchema can only be used inside of a GSettings component");

33}

35}

36+

37+void FakeGSettingsQmlPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

38+{

39+ QQmlExtensionPlugin::initializeEngine(engine, uri);

40+

41+ QString usageType = qgetenv("UNITY_MOCK_DESKTOP");

42+ if (!usageType.isEmpty()) {

43+ GSettingsControllerQml::instance()->setUsageMode("Windowed");

44+ }

45+}

tests/mocks/GSettings.1.0/plugin.h+1

@@ -26,6 +26,7 @@ class FakeGSettingsQmlPlugin : public QQmlExtensionPlugin

26

27public:

28 void registerTypes(const char *uri) override;

29+ void initializeEngine(QQmlEngine *engine, const char *uri) override;

29};

30};

30

31

31#endif // PLUGIN_H

32#endif // PLUGIN_H

tests/mocks/UInput/plugin.cpp+6−1

@@ -19,8 +19,13 @@

19

20#include <QtQml/qqml.h>

21

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

23+{

24+ return new MockUInput;

25+}

26+

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

27void MockUInputPlugin::registerTypes(const char *uri)

23{

28{

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

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

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

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

26}

31}

tests/mocks/Unity/Application/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+

1set(FakeUnityApplicationQml_SOURCES

10set(FakeUnityApplicationQml_SOURCES

2 plugin.cpp

11 plugin.cpp

3 ApplicationInfo.cpp

12 ApplicationInfo.cpp

@@ -19,11 +28,27 @@ set(FakeUnityApplicationQml_SOURCES

19 resources/surfaces.qrc

28 resources/surfaces.qrc

20)

29)

21

30

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+)

23

42

24add_library(NonMirUnityApplicationQml MODULE ${FakeUnityApplicationQml_SOURCES})

43add_library(NonMirUnityApplicationQml MODULE ${FakeUnityApplicationQml_SOURCES})

25set_target_properties(NonMirUnityApplicationQml PROPERTIES OUTPUT_NAME FakeUnityApplicationQml)

44set_target_properties(NonMirUnityApplicationQml PROPERTIES OUTPUT_NAME FakeUnityApplicationQml)

26

45

46+target_link_libraries(NonMirUnityApplicationQml

47+ ${MIRTEST_LDFLAGS}

48+ ${MIRAL_LDFLAGS}

49+ mockwindowmanagmentpolicy

50+)

51+

27qt5_use_modules(FakeUnityApplicationQml Core Quick DBus)

52qt5_use_modules(FakeUnityApplicationQml Core Quick DBus)

28qt5_use_modules(NonMirUnityApplicationQml Core Quick DBus)

53qt5_use_modules(NonMirUnityApplicationQml Core Quick DBus)

29

54

tests/mocks/Unity/Application/SurfaceManager.cpp+118−11

@@ -18,10 +18,12 @@

18

19#include "ApplicationInfo.h"

20#include "VirtualKeyboard.h"

21+#include "../../WindowManager/WindowManagementPolicy.h"

21

22

22#include <paths.h>

23#include <paths.h>

24+#include <mirtest/mir/test/doubles/stub_surface.h>

23

25

24−#define SURFACEMANAGER_DEBUG 0

26+#define SURFACEMANAGER_DEBUG 1

25

27

26#if SURFACEMANAGER_DEBUG

28#if SURFACEMANAGER_DEBUG

27#define DEBUG_MSG(params) qDebug().nospace() << "SurfaceManager[" << (void*)this << "]::" << __func__ << params

29#define DEBUG_MSG(params) qDebug().nospace() << "SurfaceManager[" << (void*)this << "]::" << __func__ << params

@@ -31,6 +33,12 @@

31

33

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

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

33

35

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+

34SurfaceManager *SurfaceManager::m_instance = nullptr;

42SurfaceManager *SurfaceManager::m_instance = nullptr;

35

43

36SurfaceManager *SurfaceManager::instance()

44SurfaceManager *SurfaceManager::instance()

@@ -44,20 +52,63 @@ SurfaceManager::SurfaceManager(QObject *)

44

52

45 Q_ASSERT(m_instance == nullptr);

53 Q_ASSERT(m_instance == nullptr);

46 m_instance = this;

54 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+ });

47}

70}

48

71

49SurfaceManager::~SurfaceManager()

72SurfaceManager::~SurfaceManager()

50{

73{

51 DEBUG_MSG("");

74 DEBUG_MSG("");

52

75

53− if (m_virtualKeyboard) {

76+ releaseInputMethodSurface();

54− m_virtualKeyboard->setLive(false);

55− }

56

77

57 Q_ASSERT(m_instance == this);

78 Q_ASSERT(m_instance == this);

58 m_instance = nullptr;

79 m_instance = nullptr;

59}

80}

60

81

82+MirSurfaceInterface *SurfaceManager::surfaceFor(const miral::Window& window) const

83+{

84+ auto iter = m_windowToSurface.find({window});

85+ if (iter != m_windowToSurface.end()) {

86+ return *iter;

87+ }

88+ return nullptr;

89+}

90+

91+QVector<MirSurfaceInterface*> SurfaceManager::surfacesFor(const std::vector<miral::Window> &windows) const

92+{

93+ QVector<unityapi::MirSurfaceInterface*> surfaces;

94+ for (size_t i = 0; i < windows.size(); i++) {

95+ auto mirSurface = surfaceFor(windows[i]);

96+ if (mirSurface) {

97+ surfaces.push_back(mirSurface);

98+ }

99+ }

100+ return surfaces;

101+}

102+

103+miral::Window SurfaceManager::windowFor(MirSurfaceInterface *surface) const

104+{

105+ auto iter = m_surfaceToWindow.find(surface);

106+ if (iter != m_surfaceToWindow.end()) {

107+ return iter->window;

108+ }

109+ return miral::Window();

110+}

111+

61MirSurface *SurfaceManager::createSurface(const QString& name,

112MirSurface *SurfaceManager::createSurface(const QString& name,

62 Mir::Type type,

113 Mir::Type type,

63 Mir::State state,

114 Mir::State state,

@@ -75,7 +126,12 @@ MirSurface *SurfaceManager::createSurface(const QString& name,

75

126

76void SurfaceManager::registerSurface(MirSurface *surface)

127void SurfaceManager::registerSurface(MirSurface *surface)

77{

128{

129+ auto fakeSurface = std::make_shared<mir::test::doubles::StubSurface>();

130+ WindowWrapper window{miral::Window(nullptr, fakeSurface), fakeSurface};

131+

78 m_surfaces.prepend(surface);

132 m_surfaces.prepend(surface);

133+ m_windowToSurface.insert(window, surface);

134+ m_surfaceToWindow.insert(surface, window);

79

135

80 if (!surface->parentSurface()) {

136 if (!surface->parentSurface()) {

81 surface->setMinimumWidth(m_newSurfaceMinimumWidth);

137 surface->setMinimumWidth(m_newSurfaceMinimumWidth);

@@ -90,16 +146,24 @@ void SurfaceManager::registerSurface(MirSurface *surface)

90 this->onStateRequested(surface, state);

146 this->onStateRequested(surface, state);

91 });

147 });

92

148

93− const QString persistentId = surface->persistentId();

94 connect(surface, &QObject::destroyed, this, [=]() {

149 connect(surface, &QObject::destroyed, this, [=]() {

150+ auto iter = m_surfaceToWindow.find(surface);

151+ if (iter != m_surfaceToWindow.end()) {

152+ WindowWrapper key = m_surfaceToWindow.value(surface);

153+ WindowManagementPolicy::instance()->removeWindow(key.window);

95− this->onSurfaceDestroyed(surface, persistentId);

154+ this->onSurfaceDestroyed(surface);

155+ }

96 });

156 });

97−

98}

157}

99

158

100void SurfaceManager::notifySurfaceCreated(unityapi::MirSurfaceInterface *surface)

159void SurfaceManager::notifySurfaceCreated(unityapi::MirSurfaceInterface *surface)

101{

160{

161+ if (Q_UNLIKELY(!m_surfaceToWindow.contains(surface))) {

102− Q_EMIT surfaceCreated(surface);

162+ Q_EMIT surfaceCreated(surface);

163+ return;

164+ }

165+

166+ WindowManagementPolicy::instance()->addWindow(m_surfaceToWindow[surface].window);

103}

167}

104

168

105void SurfaceManager::setNewSurfaceMinimumWidth(int value)

169void SurfaceManager::setNewSurfaceMinimumWidth(int value)

@@ -209,6 +273,32 @@ void SurfaceManager::activate(unityapi::MirSurfaceInterface *apiSurface)

209 DEBUG_MSG("("<<surface<<") ended");

273 DEBUG_MSG("("<<surface<<") ended");

210}

274}

211

275

276+void SurfaceManager::forEachSurfaceInWorkspace(const std::shared_ptr<miral::Workspace> &workspace,

277+ const std::function<void(unity::shell::application::MirSurfaceInterface*)> &callback)

278+{

279+ WindowManagementPolicy::instance()->forEachWindowInWorkspace(workspace, [&](const miral::Window &window) {

280+ auto surface = surfaceFor(window);

281+ if (surface) {

282+ callback(surface);

283+ }

284+ });

285+}

286+

287+void SurfaceManager::moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface* surface,

288+ const std::shared_ptr<miral::Workspace> &workspace)

289+{

290+ auto window = windowFor(surface);

291+ if (window) {

292+ WindowManagementPolicy::instance()->moveWindowToWorkspace(window, workspace);

293+ }

294+}

295+

296+void SurfaceManager::moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to,

297+ const std::shared_ptr<miral::Workspace> &from)

298+{

299+ WindowManagementPolicy::instance()->moveWorkspaceContentToWorkspace(to, from);

300+}

301+

212void SurfaceManager::onStateRequested(MirSurface *surface, Mir::State state)

302void SurfaceManager::onStateRequested(MirSurface *surface, Mir::State state)

213{

303{

214 DEBUG_MSG("("<<surface<<","<<state<<") started");

304 DEBUG_MSG("("<<surface<<","<<state<<") started");

@@ -230,9 +320,17 @@ void SurfaceManager::onStateRequested(MirSurface *surface, Mir::State state)

230 DEBUG_MSG("("<<surface<<","<<state<<") ended");

320 DEBUG_MSG("("<<surface<<","<<state<<") ended");

231}

321}

232

322

233−void SurfaceManager::onSurfaceDestroyed(MirSurface *surface, const QString& persistentId)

323+void SurfaceManager::onSurfaceDestroyed(MirSurface *surface)

234{

324{

235 m_surfaces.removeAll(surface);

325 m_surfaces.removeAll(surface);

326+

327+ auto iter = m_surfaceToWindow.find(surface);

328+ if (iter != m_surfaceToWindow.end()) {

329+ WindowWrapper key = iter.value();

330+ m_windowToSurface.remove(key);

331+ m_surfaceToWindow.erase(iter);

332+ }

333+

236 if (m_focusedSurface == surface) {

334 if (m_focusedSurface == surface) {

237 m_focusedSurface = nullptr;

335 m_focusedSurface = nullptr;

238

336

@@ -244,7 +342,7 @@ void SurfaceManager::onSurfaceDestroyed(MirSurface *surface, const QString& pers

244 m_underModification = false;

342 m_underModification = false;

245 Q_EMIT modificationsEnded();

343 Q_EMIT modificationsEnded();

246 }

344 }

247− Q_EMIT surfaceDestroyed(persistentId);

345+ Q_EMIT surfaceRemoved(surface);

248}

346}

249

347

250void SurfaceManager::focusFirstAvailableSurface()

348void SurfaceManager::focusFirstAvailableSurface()

@@ -276,6 +374,15 @@ void SurfaceManager::createInputMethodSurface()

276 if (!m_virtualKeyboard) {

374 if (!m_virtualKeyboard) {

277 m_virtualKeyboard = new VirtualKeyboard;

375 m_virtualKeyboard = new VirtualKeyboard;

278 registerSurface(m_virtualKeyboard);

376 registerSurface(m_virtualKeyboard);

377+

378+ WindowManagementPolicy::instance()->addWindow(m_surfaceToWindow[m_virtualKeyboard].window);

379+ }

380+}

381+

382+void SurfaceManager::releaseInputMethodSurface()

383+{

279− Q_EMIT surfaceCreated(m_virtualKeyboard);

384+ if (m_virtualKeyboard) {

385+ m_virtualKeyboard->setLive(false);

386+ m_virtualKeyboard = nullptr;

280 }

387 }

281}

388}

tests/mocks/Unity/Application/SurfaceManager.h+23−3

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

20#include <QObject>

21

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

23+#include <miral/window.h>

23

24

24#include "MirSurface.h"

25#include "MirSurface.h"

25#include "VirtualKeyboard.h"

26#include "VirtualKeyboard.h"

26

27

27class ApplicationInfo;

28class ApplicationInfo;

28

29

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+

29class SurfaceManager : public unity::shell::application::SurfaceManagerInterface

37class SurfaceManager : public unity::shell::application::SurfaceManagerInterface

30{

38{

31 Q_OBJECT

39 Q_OBJECT

@@ -46,6 +54,13 @@ public:

46 void raise(unity::shell::application::MirSurfaceInterface *surface) override;

54 void raise(unity::shell::application::MirSurfaceInterface *surface) override;

47 void activate(unity::shell::application::MirSurfaceInterface *surface) override;

55 void activate(unity::shell::application::MirSurfaceInterface *surface) override;

48

56

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+

49 Q_INVOKABLE MirSurface* createSurface(const QString& name,

64 Q_INVOKABLE MirSurface* createSurface(const QString& name,

50 Mir::Type type,

65 Mir::Type type,

51 Mir::State state,

66 Mir::State state,

@@ -76,10 +91,9 @@ public:

76

91

77public Q_SLOTS:

92public Q_SLOTS:

78 void createInputMethodSurface();

93 void createInputMethodSurface();

94+ void releaseInputMethodSurface();

79

95

80Q_SIGNALS:

96Q_SIGNALS:

81− void surfaceDestroyed(const QString& persistentSurfaceId);

82−

83 void newSurfaceMinimumWidthChanged(int value);

97 void newSurfaceMinimumWidthChanged(int value);

84 void newSurfaceMaximumWidthChanged(int value);

98 void newSurfaceMaximumWidthChanged(int value);

85 void newSurfaceMinimumHeightChanged(int value);

99 void newSurfaceMinimumHeightChanged(int value);

@@ -89,12 +103,15 @@ Q_SIGNALS:

89

103

90private Q_SLOTS:

104private Q_SLOTS:

91 void onStateRequested(MirSurface *surface, Mir::State state);

105 void onStateRequested(MirSurface *surface, Mir::State state);

92− void onSurfaceDestroyed(MirSurface *surface, const QString& persistentId);

106+ void onSurfaceDestroyed(MirSurface *surface);

93

107

94private:

108private:

95 void doRaise(unity::shell::application::MirSurfaceInterface *surface);

109 void doRaise(unity::shell::application::MirSurfaceInterface *surface);

96 void focusFirstAvailableSurface();

110 void focusFirstAvailableSurface();

97 void registerSurface(MirSurface *surface);

111 void registerSurface(MirSurface *surface);

112+ unity::shell::application::MirSurfaceInterface* surfaceFor(const miral::Window &window) const;

113+ QVector<unity::shell::application::MirSurfaceInterface*> surfacesFor(const std::vector<miral::Window> &windows) const;

114+ miral::Window windowFor(unity::shell::application::MirSurfaceInterface* surface) const;

98

115

99 static SurfaceManager *m_instance;

116 static SurfaceManager *m_instance;

100

117

@@ -110,6 +127,9 @@ private:

110

127

111 QList<MirSurface*> m_surfaces;

128 QList<MirSurface*> m_surfaces;

112

129

130+ QHash<WindowWrapper, unity::shell::application::MirSurfaceInterface*> m_windowToSurface;

131+ QHash<unity::shell::application::MirSurfaceInterface*, WindowWrapper> m_surfaceToWindow;

132+

113 VirtualKeyboard *m_virtualKeyboard{nullptr};

133 VirtualKeyboard *m_virtualKeyboard{nullptr};

114};

134};

115

135

tests/mocks/Unity/Application/plugin.cpp+7−1

@@ -38,6 +38,12 @@ QObject* mirSingleton(QQmlEngine*, QJSEngine*)

38{

39 return new MirMock;

40}

41+

42+QObject* surfaceManagerSingleton(QQmlEngine*, QJSEngine*)

43+{

44+ return new SurfaceManager;

45+}

46+

41} // anonymous namespace

47} // anonymous namespace

42

48

43void FakeUnityApplicationQmlPlugin::registerTypes(const char *uri)

49void FakeUnityApplicationQmlPlugin::registerTypes(const char *uri)

@@ -59,7 +65,7 @@ void FakeUnityApplicationQmlPlugin::registerTypes(const char *uri)

59

65

60 qmlRegisterSingletonType<ApplicationManager>(uri, 0, 1, "ApplicationManager", applicationManagerSingleton);

66 qmlRegisterSingletonType<ApplicationManager>(uri, 0, 1, "ApplicationManager", applicationManagerSingleton);

61 qmlRegisterSingletonType<MirMock>(uri, 0, 1, "Mir", mirSingleton);

67 qmlRegisterSingletonType<MirMock>(uri, 0, 1, "Mir", mirSingleton);

62− qmlRegisterType<SurfaceManager>(uri, 0, 1, "SurfaceManager");

68+ qmlRegisterSingletonType<SurfaceManager>(uri, 0, 1, "SurfaceManager", surfaceManagerSingleton);

63}

69}

64

70

65void FakeUnityApplicationQmlPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

71void FakeUnityApplicationQmlPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

tests/mocks/Unity/CMakeLists.txt−1

@@ -6,7 +6,6 @@ add_subdirectory(InputInfo)

6add_subdirectory(Launcher)

7add_subdirectory(Notifications)

8add_subdirectory(DashCommunicator)

9−add_subdirectory(Screens)

10add_subdirectory(Platform)

9add_subdirectory(Platform)

11

10

12pkg_search_module(GOBJECT gobject-2.0 REQUIRED)

11pkg_search_module(GOBJECT gobject-2.0 REQUIRED)

tests/mocks/Unity/InputInfo/mockcontroller.cpp+10

@@ -18,10 +18,20 @@

18

19#include "qinputdeviceinfo_mock_p.h"

20

21+#include <QQuickView>

22+#include <QQmlComponent>

23+#include <QQuickItem>

24+#include <paths.h>

25+

21MockController::MockController(QObject *parent):

26MockController::MockController(QObject *parent):

22 QObject(parent)

27 QObject(parent)

23{

28{

29+}

24

30

31+MockController *MockController::instance()

32+{

33+ static MockController* controller = new MockController();

34+ return controller;

25}

35}

26

36

27QInputDevice *MockController::addMockDevice(const QString &devicePath, QInputDevice::InputType type)

37QInputDevice *MockController::addMockDevice(const QString &devicePath, QInputDevice::InputType type)

tests/mocks/Unity/InputInfo/mockcontroller.h+3−1

@@ -24,9 +24,11 @@ class MockController: public QObject

24{

25 Q_OBJECT

26public:

27− MockController(QObject *parent = 0);

27+ MockController(QObject *parent = nullptr);

28 ~MockController() = default;

29

30+ static MockController *instance();

31+

30 Q_INVOKABLE QInputDevice* addMockDevice(const QString &devicePath, QInputDevice::InputType type);

32 Q_INVOKABLE QInputDevice* addMockDevice(const QString &devicePath, QInputDevice::InputType type);

31 Q_INVOKABLE void removeDevice(const QString &devicePath);

33 Q_INVOKABLE void removeDevice(const QString &devicePath);

32};

34};

tests/mocks/Unity/InputInfo/plugin.cpp+1−2

@@ -26,9 +26,8 @@

26

27static QObject *backendProvider(QQmlEngine *engine, QJSEngine *scriptEngine)

28{

29− Q_UNUSED(engine)

30 Q_UNUSED(scriptEngine)

29 Q_UNUSED(scriptEngine)

31− return new MockController(engine);

30+ return MockController::instance();

32}

31}

33

32

34void InputInfoPlugin::registerTypes(const char *uri)

33void InputInfoPlugin::registerTypes(const char *uri)

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+61

@@ -0,0 +1,61 @@

1+include_directories(

2+ SYSTEM

3+ ${QTMIRSERVER_INCLUDE_DIRS}

4+ ${Qt5Gui_PRIVATE_INCLUDE_DIRS}

5+)

6+

7+include_directories(

8+ ${CMAKE_CURRENT_SOURCE_DIR}

9+ ${CMAKE_CURRENT_BINARY_DIR}

10+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager

11+ ${libunity8-private_SOURCE_DIR}

12+)

13+

14+add_library(mockwindowmanagmentpolicy SHARED

15+ WindowManagementPolicy.cpp

16+)

17+target_link_libraries(mockwindowmanagmentpolicy

18+ ${MIRAL_LDFLAGS}

19+ unity8-private

20+)

21+qt5_use_modules(mockwindowmanagmentpolicy Core)

22+

23+install(TARGETS mockwindowmanagmentpolicy

24+ DESTINATION ${SHELL_INSTALL_QML}/mocks/WindowManager

25+ )

26+

27+set(WINDOWMANAGER_SRC

28+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/AvailableDesktopArea.cpp

29+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Screen.cpp

30+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/ScreenAttached.cpp

31+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Screens.cpp

32+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/ScreenWindow.cpp

33+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/TopLevelWindowModel.cpp

34+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Window.cpp

35+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/WindowMargins.cpp

36+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/WindowManagerObjects.cpp

37+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/WorkspaceManager.cpp

38+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/WorkspaceModel.cpp

39+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Workspace.cpp

40+ MockScreens.cpp

41+ MockScreenWindow.cpp

42+ MockScreensConfiguration.cpp

43+ WindowManagerPlugin.cpp

44+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h

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

46+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h

47+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h

48+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceListInterface.h

49+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/SurfaceManagerInterface.h

50+)

51+

52+add_library(MockWindowManager-qml SHARED ${WINDOWMANAGER_SRC})

53+

54+target_link_libraries(MockWindowManager-qml

55+ ${QTMIRSERVER_LDFLAGS}

56+ mockwindowmanagmentpolicy

57+)

58+

59+qt5_use_modules(MockWindowManager-qml Qml Quick Gui)

60+

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

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

@@ -14,16 +14,21 @@

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

15 */

16

17−#include "plugin.h"

17+#include "MockScreenWindow.h"

18−#include "screens.h"

18+#include "MockScreens.h"

19

20−#include <QScreen>

20+// Qt

21+#include <QGuiApplication>

22+#include <QDebug>

21

23

22−void UnityScreensPlugin::registerTypes(const char* uri)

24+MockScreenWindow::MockScreenWindow(QQuickWindow *parent)

25+ : ScreenWindow(parent)

23{

26{

24− Q_ASSERT(QLatin1String(uri) == QLatin1String("Unity.Screens"));

27+ connect(this, &ScreenWindow::screenWrapperChanged, this, [this]() {

25−

28+ MockScreens::instance()->connectWindow(this);

26− qRegisterMetaType<QScreen*>("QScreen*");

29+ });

30+}

27

31

28− qmlRegisterType<Screens>(uri, 0, 1, "Screens");

32+MockScreenWindow::~MockScreenWindow()

33+{

29}

34}

tests/mocks/Unity/Screens/plugin.h → tests/mocks/WindowManager/MockScreenWindow.hrenamed+11−6

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

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

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

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

15 */

16

17−#include <QQmlExtensionPlugin>

17+#ifndef MOCK_SCREENWINDOW_H

18−#include <QtQml/qqml.h>

18+#define MOCK_SCREENWINDOW_H

19

20−class UnityScreensPlugin : public QQmlExtensionPlugin {

20+#include "ScreenWindow.h"

21+

22+class MockScreenWindow : public ScreenWindow

23+{

21 Q_OBJECT

24 Q_OBJECT

22− Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface/1.0")

23public:

25public:

24− void registerTypes(const char* uri) override;

26+ explicit MockScreenWindow(QQuickWindow *parent = 0);

27+ ~MockScreenWindow();

25};

28};

29+

30+#endif // MOCK_SCREENWINDOW_H

tests/mocks/WindowManager/MockScreens.cppnew file+227

@@ -0,0 +1,227 @@

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+public:

35+ MockScreen()

36+ {

37+ m_sizes.append(new qtmir::ScreenMode(50, QSize(640,480)));

38+ m_sizes.append(new qtmir::ScreenMode(60, QSize(1280,1024)));

39+ m_sizes.append(new qtmir::ScreenMode(60, QSize(1440,900)));

40+ m_sizes.append(new qtmir::ScreenMode(60, QSize(1920,1080)));

41+ m_physicalSize = QSize(800,568);

42+ }

43+ ~MockScreen() {

44+ qDeleteAll(m_sizes);

45+ m_sizes.clear();

46+ }

47+

48+ void connectToWindow(QWindow* w)

49+ {

50+ if (m_connectedWindow == w) return;

51+

52+ if (m_connectedWindow) {

53+ disconnect(m_connectedWindow.data());

54+ m_sizes.takeFirst()->deleteLater();

55+ }

56+

57+ m_connectedWindow = w;

58+

59+ if (w) {

60+ connect(w, &QWindow::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, &QWindow::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+ connect(w, &QWindow::activeChanged, this, [w, this]() {

76+ if (w->isActive()) setActive(true);

77+ });

78+ if (w->isActive()) setActive(true);

79+

80+ m_sizes.push_front(new qtmir::ScreenMode(50, w->size()));

81+ Q_EMIT availableModesChanged();

82+

83+ }

84+ }

85+

86+ miral::DisplayId displayId() const override { return m_id; }

87+ bool used() const override { return m_used; }

88+ QString name() const override { return m_name; }

89+ float scale() const override { return m_scale; }

90+ QSizeF physicalSize() const override { return m_physicalSize; }

91+ qtmir::FormFactor formFactor() const override { return m_formFactor; }

92+ qtmir::OutputTypes outputType() const override { return m_outputType; }

93+ MirPowerMode powerMode() const override { return m_powerMode; }

94+ Qt::ScreenOrientation orientation() const override { return m_orientation; }

95+ QPoint position() const override { return m_position; }

96+ uint currentModeIndex() const override { return m_currentModeIndex; }

97+ bool isActive() const override { return m_active; }

98+

99+ QQmlListProperty<qtmir::ScreenMode> availableModes() override {

100+ return QQmlListProperty<qtmir::ScreenMode>(this, m_sizes);

101+ }

102+

103+ void setActive(bool active) override {

104+ if (m_active != active) {

105+ m_active = active;

106+ Q_EMIT activeChanged(m_active);

107+ }

108+ }

109+

110+ QScreen* qscreen() const override {

111+ if (qGuiApp->topLevelWindows().count() > 0) {

112+ return qGuiApp->topLevelWindows()[0]->screen();

113+ }

114+ return qGuiApp->primaryScreen();

115+ }

116+

117+ qtmir::ScreenConfiguration *beginConfiguration() const override {

118+ auto config = new qtmir::ScreenConfiguration;

119+ config->valid = true;

120+ config->id = m_id.output_id;

121+ config->used = m_used;

122+ config->topLeft = m_position;

123+ config->currentModeIndex = m_currentModeIndex;

124+ config->powerMode = m_powerMode;

125+ config->scale = m_scale;

126+ config->formFactor = m_formFactor;

127+ return config;

128+ }

129+

130+ bool applyConfiguration(qtmir::ScreenConfiguration *configuration) override {

131+ m_used = configuration->used;

132+ m_position = configuration->topLeft;

133+ m_currentModeIndex = configuration->currentModeIndex;

134+ m_powerMode = configuration->powerMode;

135+ m_scale = configuration->scale;

136+ m_formFactor = configuration->formFactor;

137+ return true;

138+ }

139+

140+public:

141+ miral::DisplayId m_id;

142+ bool m_active{false};

143+ bool m_used{true};

144+ QString m_name;

145+ qtmir::OutputTypes m_outputType{qtmir::Unknown};

146+ MirPowerMode m_powerMode{mir_power_mode_on};

147+ Qt::ScreenOrientation m_orientation{Qt::PrimaryOrientation};

148+ float m_scale{1.0};

149+ qtmir::FormFactor m_formFactor{qtmir::FormFactorMonitor};

150+ QPoint m_position;

151+ uint m_currentModeIndex{0};

152+ QList<qtmir::ScreenMode*> m_sizes;

153+ QSizeF m_physicalSize;

154+

155+ QPointer<QWindow> m_connectedWindow;

156+};

157+}

158+

159+MockScreens::MockScreens()

160+{

161+ bool ok = false;

162+ int screenCount = qEnvironmentVariableIntValue("UNITY_MOCK_SCREEN_COUNT", &ok);

163+ if (!ok) screenCount = 1;

164+ QPoint lastPoint(0,0);

165+ for (int i = 0; i < screenCount; ++i) {

166+ auto screen = new MockScreen();

167+ screen->m_id.output_id = miral::OutputId{i};

168+ screen->m_active = i == 0;

169+ screen->m_name = QString("Monitor %1").arg(i);

170+ screen->m_position = QPoint(lastPoint.x(), lastPoint.y());

171+ screen->m_currentModeIndex = 3;

172+ m_mocks.append(screen);

173+

174+ lastPoint.rx() += screen->m_sizes[screen->m_currentModeIndex]->size.width();

175+

176+ connect(screen, &qtmir::Screen::activeChanged, this, [=](bool active) {

177+ Q_FOREACH(auto otherScreen, m_mocks) {

178+ if (active && otherScreen != screen) {

179+ otherScreen->setActive(false);

180+ }

181+ }

182+ });

183+ }

184+}

185+

186+MockScreens::~MockScreens()

187+{

188+ qDeleteAll(m_mocks);

189+ m_mocks.clear();

190+}

191+

192+QVector<qtmir::Screen *> MockScreens::screens() const

193+{

194+ return m_mocks;

195+}

196+

197+qtmir::Screen *MockScreens::activeScreen() const

198+{

199+ Q_FOREACH(auto screen, m_mocks) {

200+ if (screen->isActive()) return screen;

201+ }

202+ return nullptr;

203+}

204+

205+QSharedPointer<MockScreens> MockScreens::instance()

206+{

207+ if (!m_screens) {

208+ QSharedPointer<MockScreens> screens(new MockScreens());

209+ m_screens = screens.toWeakRef();

210+ return screens;

211+ } else {

212+ return m_screens.lock();

213+ }

214+}

215+

216+void MockScreens::connectWindow(ScreenWindow *w)

217+{

218+ ConcreteScreen* screen = w->screenWrapper();

219+ if (!screen) return;

220+

221+ auto mockScreen = qobject_cast<MockScreen*>(screen->wrapped());

222+ if (mockScreen) {

223+ mockScreen->connectToWindow(w);

224+ }

225+}

226+

227+#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 ConcreteScreen;

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/MockScreensConfiguration.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 "ScreensConfiguration.h"

18+#include "Screen.h"

19+#include "Workspace.h"

20+#include "WorkspaceManager.h"

21+

22+namespace

23+{

24+const int DefaultWorkspacesCount = 2;

25+QHash<QString, int> screensConfig;

26+}

27+

28+ScreensConfiguration::ScreensConfiguration()

29+{

30+}

31+

32+ScreensConfiguration::~ScreensConfiguration()

33+{

34+}

35+

36+void ScreensConfiguration::load(Screen *screen)

37+{

38+ int workspaces = screensConfig.value(screen->name(), DefaultWorkspacesCount);

39+ for (int i = 0; i < workspaces; i++) {

40+ WorkspaceManager::instance()->createWorkspace()->assign(screen->workspaces());

41+ }

42+}

43+

44+void ScreensConfiguration::save(Screen *screen)

45+{

46+ screensConfig[screen->name()] = screen->workspaces()->rowCount();

47+}

tests/mocks/WindowManager/WindowManagementPolicy.cppnew file+128

@@ -0,0 +1,128 @@

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::removeWindow(const miral::Window &window)

77+{

78+ WorkspaceWindows::iterator i = m_windows.begin();

79+ while (i != m_windows.end()) {

80+ if (i.value() == window) {

81+ Q_EMIT windowsAboutToBeRemovedFromWorkspace(i.key(), { window });

82+ i = m_windows.erase(i);

83+ } else {

84+ ++i;

85+ }

86+ }

87+ Q_EMIT windowRemoved(window);

88+}

89+

90+void WindowManagementPolicy::forEachWindowInWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::function<void(const miral::Window &)> &callback)

91+{

92+ WorkspaceWindows::iterator i = m_windows.find(workspace);

93+ while (i != m_windows.end() && i.key() == workspace) {

94+ callback(i.value());

95+ ++i;

96+ }

97+}

98+

99+void WindowManagementPolicy::moveWindowToWorkspace(const miral::Window &window, const std::shared_ptr<miral::Workspace> &workspace)

100+{

101+ auto from = m_windows.key(window);

102+ if (from) {

103+ auto iter = m_windows.find(from, window);

104+ Q_EMIT windowsAboutToBeRemovedFromWorkspace(from, { window });

105+ m_windows.erase(iter);

106+ }

107+

108+ m_windows.insert(workspace, window);

109+ Q_EMIT windowsAddedToWorkspace(workspace, { window });

110+}

111+

112+void WindowManagementPolicy::moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to, const std::shared_ptr<miral::Workspace> &from)

113+{

114+ std::vector<miral::Window> windows;

115+

116+ WorkspaceWindows::iterator i = m_windows.find(from);

117+ while (i != m_windows.end() && i.key() == from) {

118+ windows.push_back(i.value());

119+ ++i;

120+ }

121+ Q_EMIT windowsAboutToBeRemovedFromWorkspace(from, windows);

122+ m_windows.remove(from);

123+

124+ Q_FOREACH(miral::Window window, windows) {

125+ m_windows.insert(to, window);

126+ }

127+ Q_EMIT windowsAddedToWorkspace(to, windows);

128+}

tests/mocks/WindowManager/WindowManagementPolicy.hnew 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+#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+ void removeWindow(const miral::Window& window);

52+

53+ void forEachWindowInWorkspace(std::shared_ptr<miral::Workspace> const &workspace,

54+ std::function<void(miral::Window const&)> const &callback);

55+

56+ void moveWindowToWorkspace(const miral::Window &window, const std::shared_ptr<miral::Workspace> &workspace);

57+

58+ void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to,

59+ const std::shared_ptr<miral::Workspace> &from);

60+

61+Q_SIGNALS:

62+ void windowAdded(const miral::Window& window);

63+ void windowRemoved(const miral::Window& window);

64+ void windowsAddedToWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows);

65+ void windowsAboutToBeRemovedFromWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows);

66+

67+private:

68+ std::weak_ptr<miral::Workspace> m_activeWorkspace;

69+ std::shared_ptr<miral::Workspace> m_dummyWorkspace;

70+ std::unordered_set<std::shared_ptr<miral::Workspace>> m_workspaces;

71+

72+ typedef QMultiMap<std::shared_ptr<miral::Workspace>, miral::Window> WorkspaceWindows;

73+ WorkspaceWindows m_windows;

74+};

75+#endif // UNITY_WINDOWMANAGEMENTPOLICY_H

tests/mocks/WindowManager/WindowManagerPlugin.cppnew file+89

@@ -0,0 +1,89 @@

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

20+#include "MockScreens.h"

21+#include "MockScreenWindow.h"

22+#include "Screen.h"

23+#include "ScreenAttached.h"

24+#include "Screens.h"

25+#include "ScreensConfiguration.h"

26+#include "TopLevelWindowModel.h"

27+#include "Window.h"

28+#include "WindowMargins.h"

29+#include "WindowManagementPolicy.h"

30+#include "WindowManagerObjects.h"

31+#include "WorkspaceManager.h"

32+#include "Workspace.h"

33+#include "WorkspaceModel.h"

34+

35+#include <QtQml>

36+

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

38+

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

40+{

41+ Q_UNUSED(engine)

42+ Q_UNUSED(scriptEngine)

43+ return WorkspaceManager::instance();

44+}

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

46+ Q_UNUSED(engine);

47+ Q_UNUSED(scriptEngine);

48+ return ConcreteScreens::self();

49+}

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

51+ Q_UNUSED(engine);

52+ Q_UNUSED(scriptEngine);

53+ return WindowManagerObjects::instance();

54+}

55+

56+void WindowManagerPlugin::registerTypes(const char *uri)

57+{

58+ qmlRegisterType<AvailableDesktopArea>(uri, 1, 0, "AvailableDesktopArea");

59+ qmlRegisterType<WindowMargins>(uri, 1, 0, "WindowMargins");

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

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

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

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

64+ qmlRegisterUncreatableType<ScreenConfig>(uri, 1, 0, "ScreenConfig", notInstantiatable);

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

66+

67+ qRegisterMetaType<ConcreteScreen*>("ConcreteScreen*");

68+ qRegisterMetaType<ProxyScreens*>("ProxyScreens*");

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

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

71+

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

73+ qRegisterMetaType<QAbstractListModel*>("QAbstractListModel*");

74+

75+ qmlRegisterType<MockScreenWindow>(uri, 1, 0, "ScreenWindow");

76+ qmlRegisterRevision<QWindow,1>(uri, 1, 0);

77+

78+ qmlRegisterUncreatableType<WMScreen>(uri, 1, 0, "WMScreen", notInstantiatable);

79+}

80+

81+void WindowManagerPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

82+{

83+ QQmlExtensionPlugin::initializeEngine(engine, uri);

84+

85+ // Make sure we've initialized the wm policy.

86+ WindowManagementPolicy::instance();

87+ // Create Screens

88+ new ConcreteScreens(MockScreens::instance(), new ScreensConfiguration());

89+}

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/plugins/GlobalShortcut/GlobalShortcutTest.cpp+1

@@ -38,6 +38,7 @@ private Q_SLOTS:

38 m_inactiveShortcut = dynamic_cast<GlobalShortcut*>(m_view->rootObject()->property("inactiveShortcut").value<QObject*>());

39 QVERIFY(m_inactiveShortcut);

40 m_view->show();

41+ m_view->requestActivate();

41 QTest::qWaitForWindowExposed(m_view);

42 QTest::qWaitForWindowExposed(m_view);

42 }

43 }

43

44

tests/plugins/WindowManager/CMakeLists.txt+5−1

@@ -2,6 +2,7 @@ include_directories(

2 ${CMAKE_SOURCE_DIR}/plugins/WindowManager

3 ${CMAKE_CURRENT_BINARY_DIR}

4 ${CMAKE_SOURCE_DIR}/tests/mocks

5+ ${libunity8-private_SOURCE_DIR}

5 )

6 )

6

7

7add_executable(TopLevelWindowModelTestExec

8add_executable(TopLevelWindowModelTestExec

@@ -19,7 +20,10 @@ add_executable(TopLevelWindowModelTestExec

19 )

20 )

20qt5_use_modules(TopLevelWindowModelTestExec Test Core Gui Qml Quick)

21qt5_use_modules(TopLevelWindowModelTestExec Test Core Gui Qml Quick)

21

22

22−target_link_libraries(TopLevelWindowModelTestExec windowmanager-qml)

23+target_link_libraries(TopLevelWindowModelTestExec

24+ windowmanager-qml

25+ unity8-private

26+ )

23

27

24install(TARGETS TopLevelWindowModelTestExec

28install(TARGETS TopLevelWindowModelTestExec

25 DESTINATION "${SHELL_PRIVATE_LIBDIR}/tests/plugins/WindowManager"

29 DESTINATION "${SHELL_PRIVATE_LIBDIR}/tests/plugins/WindowManager"

tests/plugins/WindowManager/UnityApplicationMocks.h+25

@@ -25,6 +25,8 @@

25// from tests/mocks

26#include <Unity/Application/MirSurfaceListModel.h>

27

28+#include "wmpolicyinterface.h"

29+

28using namespace unity::shell::application;

30using namespace unity::shell::application;

29

31

30class MirSurface : public MirSurfaceInterface

32class MirSurface : public MirSurfaceInterface

@@ -87,6 +89,13 @@ class SurfaceManager : public SurfaceManagerInterface

87 Q_OBJECT

89 Q_OBJECT

88

90

89public:

91public:

92+ void forEachSurfaceInWorkspace(const std::shared_ptr<miral::Workspace>&,

93+ const std::function<void(unity::shell::application::MirSurfaceInterface*)>&) override {}

94+ void moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface*,

95+ const std::shared_ptr<miral::Workspace>&) override {}

96+ void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace>&,

97+ const std::shared_ptr<miral::Workspace>&) override {}

98+

90 void raise(MirSurfaceInterface *) override {}

99 void raise(MirSurfaceInterface *) override {}

91 void activate(MirSurfaceInterface *) override {}

100 void activate(MirSurfaceInterface *) override {}

92};

101};

@@ -207,4 +216,20 @@ private:

207 QList<Application*> m_applications;

216 QList<Application*> m_applications;

208};

217};

209

218

219+namespace miral {

220+class Workspace {};

221+}

222+

223+class WindowManagementPolicy : public WMPolicyInterface

224+{

225+public:

226+ WindowManagementPolicy() {}

227+

228+ std::shared_ptr<miral::Workspace> createWorkspace() override { return std::make_shared<miral::Workspace>(); }

229+

230+ void releaseWorkspace(const std::shared_ptr<miral::Workspace>&) override {}

231+

232+ void setActiveWorkspace(const std::shared_ptr<miral::Workspace>&) override {}

233+};

234+

210#endif // UNITYAPPLICATIONMOCKS_H

235#endif // UNITYAPPLICATIONMOCKS_H

tests/plugins/WindowManager/tst_TopLevelWindowModel.cpp+20−8

@@ -19,8 +19,13 @@

19// WindowManager plugin

20#include <TopLevelWindowModel.h>

21#include <Window.h>

22+#include <WindowManagerObjects.h>

23+#include <Workspace.h>

24+#include <WorkspaceManager.h>

22

25

23#include "UnityApplicationMocks.h"

26#include "UnityApplicationMocks.h"

27+#include "wmpolicyinterface.h"

28+

24

29

25class tst_TopLevelWindowModel : public QObject

30class tst_TopLevelWindowModel : public QObject

26{

31{

@@ -34,6 +39,7 @@ private Q_SLOTS:

34 void secondSurfaceIsHidden();

39 void secondSurfaceIsHidden();

35

40

36private:

41private:

42+ Workspace* workspace{nullptr};

37 ApplicationManager *applicationManager{nullptr};

43 ApplicationManager *applicationManager{nullptr};

38 SurfaceManager *surfaceManager{nullptr};

44 SurfaceManager *surfaceManager{nullptr};

39 TopLevelWindowModel *topLevelWindowModel{nullptr};

45 TopLevelWindowModel *topLevelWindowModel{nullptr};

@@ -41,24 +47,30 @@ private:

41

47

42void tst_TopLevelWindowModel::init()

48void tst_TopLevelWindowModel::init()

43{

49{

50+ wmPolicyInterface = new WindowManagementPolicy();

51+

44 applicationManager = new ApplicationManager;

52 applicationManager = new ApplicationManager;

45 surfaceManager = new SurfaceManager;

53 surfaceManager = new SurfaceManager;

54+ WindowManagerObjects::instance()->setApplicationManager(applicationManager);

55+ WindowManagerObjects::instance()->setSurfaceManager(surfaceManager);

46

56

47− topLevelWindowModel = new TopLevelWindowModel;

57+ workspace = WorkspaceManager::instance()->createWorkspace();

48− topLevelWindowModel->setApplicationManager(applicationManager);

49− topLevelWindowModel->setSurfaceManager(surfaceManager);

58+ topLevelWindowModel = workspace->windowModel();

50}

59}

51

60

52void tst_TopLevelWindowModel::cleanup()

61void tst_TopLevelWindowModel::cleanup()

53{

62{

54− delete topLevelWindowModel;

63+ delete workspace;

55− topLevelWindowModel = nullptr;

64+ workspace = nullptr;

56

65

57 delete surfaceManager;

66 delete surfaceManager;

58 surfaceManager = nullptr;

67 surfaceManager = nullptr;

59

68

60 delete applicationManager;

69 delete applicationManager;

61 applicationManager = nullptr;

70 applicationManager = nullptr;

71+

72+ delete wmPolicyInterface;

73+ wmPolicyInterface = nullptr;

62}

74}

63

75

64void tst_TopLevelWindowModel::singleSurfaceStartsHidden()

76void tst_TopLevelWindowModel::singleSurfaceStartsHidden()

@@ -73,7 +85,7 @@ void tst_TopLevelWindowModel::singleSurfaceStartsHidden()

73 auto surface = new MirSurface;

85 auto surface = new MirSurface;

74 surface->m_state = Mir::HiddenState;

86 surface->m_state = Mir::HiddenState;

75 application->m_surfaceList.addSurface(surface);

87 application->m_surfaceList.addSurface(surface);

76− Q_EMIT surfaceManager->surfaceCreated(surface);

88+ Q_EMIT surfaceManager->surfacesAddedToWorkspace(workspace->workspace(), {surface});

77

89

78 QCOMPARE(topLevelWindowModel->rowCount(), 1);

90 QCOMPARE(topLevelWindowModel->rowCount(), 1);

79 // not showing the surface as it's still hidden

91 // not showing the surface as it's still hidden

@@ -97,7 +109,7 @@ void tst_TopLevelWindowModel::secondSurfaceIsHidden()

97

109

98 auto firstSurface = new MirSurface;

110 auto firstSurface = new MirSurface;

99 application->m_surfaceList.addSurface(firstSurface);

111 application->m_surfaceList.addSurface(firstSurface);

100− Q_EMIT surfaceManager->surfaceCreated(firstSurface);

112+ Q_EMIT surfaceManager->surfacesAddedToWorkspace(workspace->workspace(), {firstSurface});

101

113

102 QCOMPARE(topLevelWindowModel->rowCount(), 1);

114 QCOMPARE(topLevelWindowModel->rowCount(), 1);

103 QCOMPARE((void*)topLevelWindowModel->windowAt(0)->surface(), (void*)firstSurface);

115 QCOMPARE((void*)topLevelWindowModel->windowAt(0)->surface(), (void*)firstSurface);

@@ -105,7 +117,7 @@ void tst_TopLevelWindowModel::secondSurfaceIsHidden()

105 auto secondSurface = new MirSurface;

117 auto secondSurface = new MirSurface;

106 secondSurface->m_state = Mir::HiddenState;

118 secondSurface->m_state = Mir::HiddenState;

107 application->m_surfaceList.addSurface(secondSurface);

119 application->m_surfaceList.addSurface(secondSurface);

108− Q_EMIT surfaceManager->surfaceCreated(secondSurface);

120+ Q_EMIT surfaceManager->surfacesAddedToWorkspace(workspace->workspace(), {secondSurface});

109

121

110 // still only the first surface is exposed by TopLevelWindowModel

122 // still only the first surface is exposed by TopLevelWindowModel

111 QCOMPARE(topLevelWindowModel->rowCount(), 1);

123 QCOMPARE(topLevelWindowModel->rowCount(), 1);

tests/qmltests/ApplicationMenuDataLoader.qml+3−6

@@ -22,19 +22,16 @@ import Unity.Indicators 0.1 as Indicators

22

23Object {

24

25− property alias surfaceManager: sMgrHandler.target

26−

27 Connections {

25 Connections {

28− id: sMgrHandler

29− target: null

26+ target: SurfaceManager

30 onSurfaceCreated: {

27 onSurfaceCreated: {

31 var fakeMenuPath = "/" + surface.persistentId.replace(/\W+/g, "");

28 var fakeMenuPath = "/" + surface.persistentId.replace(/\W+/g, "");

32

29

33 ApplicationMenuRegistry.RegisterSurfaceMenu(surface.persistentId, fakeMenuPath, fakeMenuPath, ":1");

30 ApplicationMenuRegistry.RegisterSurfaceMenu(surface.persistentId, fakeMenuPath, fakeMenuPath, ":1");

34 Indicators.UnityMenuModelCache.setCachedModelData(fakeMenuPath, generateTestData(4, 3, 2, 3, "menu"));

31 Indicators.UnityMenuModelCache.setCachedModelData(fakeMenuPath, generateTestData(4, 3, 2, 3, "menu"));

35 }

32 }

36− onSurfaceDestroyed: {

33+ onSurfaceRemoved: {

37− ApplicationMenuRegistry.UnregisterSurfaceMenu(persistentSurfaceId, "/app");

34+ ApplicationMenuRegistry.UnregisterSurfaceMenu(surface.persistentId, "/app");

38 }

35 }

39 }

36 }

40

37

tests/qmltests/ApplicationMenus/tst_MenuBar.qml+2−2

@@ -24,6 +24,7 @@ import Unity.Test 0.1

24import Utils 0.1

25

26import "../../../qml/ApplicationMenus"

27+import "../../../qml/Components/PanelState"

27import ".."

28import ".."

28

29

29Item {

30Item {

@@ -42,10 +43,8 @@ Item {

42 value: false

43 value: false

43 }

44 }

44

45

45− SurfaceManager { id: sMgr }

46 ApplicationMenuDataLoader {

47 id: appMenuData

48− surfaceManager: sMgr

49 }

48 }

50

49

51 Rectangle {

50 Rectangle {

@@ -67,6 +66,7 @@ Item {

67 id: menuBackend

66 id: menuBackend

68 modelData: appMenuData.generateTestData(10,5,2,3)

67 modelData: appMenuData.generateTestData(10,5,2,3)

69 }

68 }

69+ panelState: PanelState {}

70 }

71 }

72

tests/qmltests/ApplicationMenus/tst_MenuPopup.qml+2

@@ -24,6 +24,7 @@ import Unity.Test 0.1

24import Utils 0.1

25

26import "../../../qml/ApplicationMenus"

27+import "../../../qml/Components/PanelState"

27import ".."

28import ".."

28

29

29Item {

30Item {

@@ -59,6 +60,7 @@ Item {

59 }}

60 }}

60 ]

61 ]

61 }

62 }

63+ panelState: PanelState {}

62 }

64 }

63 }

65 }

64

66

tests/qmltests/CMakeLists.txt+1

@@ -5,6 +5,7 @@ add_unity8_qmltest(. OrientedShell)

5add_unity8_qmltest(. DisabledScreenNotice)

6add_unity8_qmltest(. Shell)

7add_unity8_qmltest(. ShellWithPin)

8+add_unity8_qmltest(. ShellApplication)

8add_unity8_qmltest(. DeviceConfiguration)

9add_unity8_qmltest(. DeviceConfiguration)

9add_unity8_qmltest_data(. EdgeBarrierControls)

10add_unity8_qmltest_data(. EdgeBarrierControls)

10add_unity8_qmltest_data(. ApplicationMenuDataLoader)

11add_unity8_qmltest_data(. ApplicationMenuDataLoader)

tests/qmltests/Components/tst_VirtualTouchPad.qml+2−2

@@ -39,11 +39,11 @@ Rectangle {

39

40 SignalSpy {

41 id: mouseEventSpy1

42− target: touchScreenPad.uinput

42+ target: UInput

43 }

44 SignalSpy {

45 id: mouseEventSpy2

46− target: touchScreenPad.uinput

46+ target: UInput

47 }

48

49 UnityTestCase {

tests/qmltests/Panel/tst_ActiveCallHint.qml−2

@@ -41,8 +41,6 @@ Item {

41 elapsedTimerRunning: true

42 }

43

44− SurfaceManager {}

45−

46 ActiveCallHint {

44 ActiveCallHint {

47 id: callHint

45 id: callHint

48 anchors {

46 anchors {

tests/qmltests/Panel/tst_Panel.qml+18−16

@@ -42,10 +42,10 @@ PanelTest {

42 value: keyboardAttached.checked

43 }

44

45− SurfaceManager { id: sMgr }

45+ readonly property alias panelState: panel.panelState

46+

46 ApplicationMenuDataLoader {

47 ApplicationMenuDataLoader {

47 id: appMenuData

48 id: appMenuData

48− surfaceManager: sMgr

49 }

50

51 Component.onCompleted: {

@@ -99,6 +99,8 @@ PanelTest {

99 model: root.indicatorsModel

100 hides: [ panel.applicationMenus ]

101 }

102+

103+ panelState: PanelState {}

102 }

104 }

103 }

105 }

104 }

106 }

@@ -153,7 +155,7 @@ PanelTest {

153 Layout.fillWidth: true

155 Layout.fillWidth: true

154 CheckBox {

156 CheckBox {

155 id: windowControlsCB

157 id: windowControlsCB

156− onClicked: PanelState.decorationsVisible = checked

158+ onClicked: panelState.decorationsVisible = checked

157 }

159 }

158 Label {

160 Label {

159 text: "Show window decorations"

161 text: "Show window decorations"

@@ -164,7 +166,7 @@ PanelTest {

164 RowLayout {

166 RowLayout {

165 Layout.fillWidth: true

167 Layout.fillWidth: true

166 CheckBox {

168 CheckBox {

167− onClicked: PanelState.title = checked ? "Fake window title" : ""

169+ onClicked: panelState.title = checked ? "Fake window title" : ""

168 }

170 }

169 Label {

171 Label {

170 text: "Show fake window title"

172 text: "Show fake window title"

@@ -250,7 +252,7 @@ PanelTest {

250

252

251 SignalSpy {

253 SignalSpy {

252 id: windowControlButtonsSpy

254 id: windowControlButtonsSpy

253− target: PanelState

255+ target: panelState

254 signalName: "closeClicked"

256 signalName: "closeClicked"

255 }

257 }

256

258

@@ -260,8 +262,8 @@ PanelTest {

260 panel.fullscreenMode = false;

262 panel.fullscreenMode = false;

261 callManager.foregroundCall = null;

263 callManager.foregroundCall = null;

262

264

263− PanelState.title = "";

265+ panelState.title = "";

264− PanelState.decorationsVisible = false;

266+ panelState.decorationsVisible = false;

265

267

266 // Wait for the indicators to get into position.

268 // Wait for the indicators to get into position.

267 // (switches between normal and fullscreen modes are animated)

269 // (switches between normal and fullscreen modes are animated)

@@ -456,7 +458,7 @@ PanelTest {

456 }

458 }

457

459

458 function test_hint(data) {

460 function test_hint(data) {

459− PanelState.title = "Fake Title"

461+ panelState.title = "Fake Title"

460 panel.fullscreenMode = data.fullscreen;

462 panel.fullscreenMode = data.fullscreen;

461 callManager.foregroundCall = data.call;

463 callManager.foregroundCall = data.call;

462

464

@@ -498,7 +500,7 @@ PanelTest {

498 // menus, first by running the hint animation, then after dragging down will

500 // menus, first by running the hint animation, then after dragging down will

499 // expose more of the panel. Releasing the touch will complete the show.

501 // expose more of the panel. Releasing the touch will complete the show.

500 function test_drag_applicationMenu_down_shows_menu(data) {

502 function test_drag_applicationMenu_down_shows_menu(data) {

501− PanelState.title = "Fake Title";

503+ panelState.title = "Fake Title";

502 panel.fullscreenMode = data.fullscreen;

504 panel.fullscreenMode = data.fullscreen;

503 callManager.foregroundCall = data.call;

505 callManager.foregroundCall = data.call;

504

506

@@ -589,7 +591,7 @@ PanelTest {

589 }

591 }

590

592

591 function test_darkenedAreaEatsAllApplicationMenuEvents() {

593 function test_darkenedAreaEatsAllApplicationMenuEvents() {

592− PanelState.title = "Fake Title"

594+ panelState.title = "Fake Title"

593

595

594 // The center of the area not covered by the indicators menu

596 // The center of the area not covered by the indicators menu

595 // Ie, the visible darkened area behind the menu

597 // Ie, the visible darkened area behind the menu

@@ -710,7 +712,7 @@ PanelTest {

710 var windowControlArea = findChild(panel, "windowControlArea");

712 var windowControlArea = findChild(panel, "windowControlArea");

711 verify(windowControlArea, "Window control area should have been created in windowed mode")

713 verify(windowControlArea, "Window control area should have been created in windowed mode")

712

714

713− PanelState.decorationsVisible = true;

715+ panelState.decorationsVisible = true;

714 // click in very topleft corner and verify the close button got clicked too

716 // click in very topleft corner and verify the close button got clicked too

715 mouseMove(panel, 0, 0);

717 mouseMove(panel, 0, 0);

716 mouseClick(panel, 0, 0, undefined /*button*/, undefined /*modifiers*/, 100 /*short delay*/);

718 mouseClick(panel, 0, 0, undefined /*button*/, undefined /*modifiers*/, 100 /*short delay*/);

@@ -773,7 +775,7 @@ PanelTest {

773 }

775 }

774

776

775 function test_stagedApplicationMenuBarShowOnMouseHover() {

777 function test_stagedApplicationMenuBarShowOnMouseHover() {

776− PanelState.title = "Fake Title";

778+ panelState.title = "Fake Title";

777 panel.mode = "staged";

779 panel.mode = "staged";

778 mouseEmulation.checked = false;

780 mouseEmulation.checked = false;

779

781

@@ -791,7 +793,7 @@ PanelTest {

791 }

793 }

792

794

793 function test_windowedApplicationMenuShowOnMouseHoverWhenDecorationsShown() {

795 function test_windowedApplicationMenuShowOnMouseHoverWhenDecorationsShown() {

794− PanelState.title = "Fake Title";

796+ panelState.title = "Fake Title";

795 panel.mode = "windowed";

797 panel.mode = "windowed";

796 mouseEmulation.checked = false;

798 mouseEmulation.checked = false;

797

799

@@ -807,7 +809,7 @@ PanelTest {

807 tryCompare(appTitle, "visible", true, undefined, "App title should still be visible on mouse hover when panel decorations are not visible");

809 tryCompare(appTitle, "visible", true, undefined, "App title should still be visible on mouse hover when panel decorations are not visible");

808 tryCompare(appMenuBar, "visible", false, undefined, "App menu bar should be visible on mouse hover when panel decorations are not visible");

810 tryCompare(appMenuBar, "visible", false, undefined, "App menu bar should be visible on mouse hover when panel decorations are not visible");

809

811

810− PanelState.decorationsVisible = true;

812+ panelState.decorationsVisible = true;

811

813

812 tryCompare(appTitle, "visible", false, undefined, "App title should still be visible on mouse hover when panel decorations are visible");

814 tryCompare(appTitle, "visible", false, undefined, "App title should still be visible on mouse hover when panel decorations are visible");

813 tryCompare(appMenuBar, "visible", true, undefined, "App menu bar should be visible on mouse hover when panel decorations not visible");

815 tryCompare(appMenuBar, "visible", true, undefined, "App menu bar should be visible on mouse hover when panel decorations not visible");

@@ -855,7 +857,7 @@ PanelTest {

855

857

856 var indicatorsBar = findChild(panel.applicationMenus, "indicatorsBar");

858 var indicatorsBar = findChild(panel.applicationMenus, "indicatorsBar");

857

859

858− PanelState.title = "Fake Title"

860+ panelState.title = "Fake Title"

859 pullDownApplicationsMenu(0 /*xPos*/);

861 pullDownApplicationsMenu(0 /*xPos*/);

860 compare(aboutToShowCalledSpy.count, 1);

862 compare(aboutToShowCalledSpy.count, 1);

861

863

@@ -888,7 +890,7 @@ PanelTest {

888

890

889 var indicatorsBar = findChild(panel.applicationMenus, "indicatorsBar");

891 var indicatorsBar = findChild(panel.applicationMenus, "indicatorsBar");

890

892

891− PanelState.title = "Fake Title"

893+ panelState.title = "Fake Title"

892 pullDownApplicationsMenu(0 /*xPos*/);

894 pullDownApplicationsMenu(0 /*xPos*/);

893

895

894 tryCompare(indicatorsBar, "currentItemIndex", 0);

896 tryCompare(indicatorsBar, "currentItemIndex", 0);

tests/qmltests/Stage/tst_ApplicationWindow.qml−2

@@ -37,8 +37,6 @@ Rectangle {

37 }

38 property QtObject fakeApplication: null

39

40− SurfaceManager{}

41−

42 Loader {

40 Loader {

43 id: applicationWindowLoader

41 id: applicationWindowLoader

44 focus: true

42 focus: true

tests/qmltests/Stage/tst_DecoratedWindow.qml+5−3

@@ -46,10 +46,12 @@ Rectangle {

46 value: false

47 }

48

49− SurfaceManager { id: sMgr }

50 ApplicationMenuDataLoader {

49 ApplicationMenuDataLoader {

51 id: appMenuData

50 id: appMenuData

52− surfaceManager: sMgr

51+ }

52+

53+ PanelState {

54+ id: panelState

53 }

55 }

54

56

55 Item {

57 Item {

@@ -99,7 +101,7 @@ Rectangle {

99 surface: fakeApplication && fakeApplication.surfaceList.count > 0 ? fakeApplication.surfaceList.get(0) : null

101 surface: fakeApplication && fakeApplication.surfaceList.count > 0 ? fakeApplication.surfaceList.get(0) : null

100

102

101 Binding {

103 Binding {

102− target: PanelState

104+ target: panelState

103 property: "focusedPersistentSurfaceId"

105 property: "focusedPersistentSurfaceId"

104 value: decoratedWindow.surface ? decoratedWindow.surface.persistentId : "x"

106 value: decoratedWindow.surface ? decoratedWindow.surface.persistentId : "x"

105 }

107 }

tests/qmltests/Stage/tst_DesktopStage.qml+7−11

@@ -63,17 +63,11 @@ Item {

63 }

64 }

65

66− SurfaceManager { id: sMgr }

67 ApplicationMenuDataLoader {

66 ApplicationMenuDataLoader {

68 id: appMenuData

67 id: appMenuData

69− surfaceManager: sMgr

70 }

68 }

71

69

72− TopLevelWindowModel {

70+ readonly property var topSurfaceList: WorkspaceManager.activeWorkspace.windowModel

73− id: topSurfaceList

74− applicationManager: ApplicationManager

75− surfaceManager: sMgr

76− }

77

71

78 Loader {

72 Loader {

79 id: stageLoader

73 id: stageLoader

@@ -103,11 +97,12 @@ Item {

103 availableDesktopArea: availableDesktopAreaItem

97 availableDesktopArea: availableDesktopAreaItem

104 interactive: true

98 interactive: true

105 mode: "windowed"

99 mode: "windowed"

100+ panelState: PanelState {}

106

101

107 Item {

102 Item {

108 id: availableDesktopAreaItem

103 id: availableDesktopAreaItem

109 anchors.fill: parent

104 anchors.fill: parent

110− anchors.topMargin: PanelState.panelHeight

105+ anchors.topMargin: parent.panelState.panelHeight

111 }

106 }

112 }

107 }

113 }

108 }

@@ -180,6 +175,7 @@ Item {

180

175

181 stage: stageLoader.status === Loader.Ready ? stageLoader.item : null

176 stage: stageLoader.status === Loader.Ready ? stageLoader.item : null

182 topLevelSurfaceList: topSurfaceList

177 topLevelSurfaceList: topSurfaceList

178+ property var panelState: stage ? stage.panelState : null

183

179

184 function init() {

180 function init() {

185 // wait until unity8-dash is up and running.

181 // wait until unity8-dash is up and running.

@@ -638,19 +634,19 @@ Item {

638 maximizeDelegate(facebookAppDelegate);

634 maximizeDelegate(facebookAppDelegate);

639

635

640 // verify the drop shadow is still not visible

636 // verify the drop shadow is still not visible

641− verify(PanelState.dropShadow == false);

637+ verify(panelState.dropShadow == false);

642

638

643 // start a foreground app, not maximized

639 // start a foreground app, not maximized

644 var dialerAppDelegate = startApplication("dialer-app");

640 var dialerAppDelegate = startApplication("dialer-app");

645

641

646 // verify the drop shadow becomes visible

642 // verify the drop shadow becomes visible

647− tryCompareFunction(function() { return PanelState.dropShadow; }, true);

643+ tryCompareFunction(function() { return panelState.dropShadow; }, true);

648

644

649 // close the maximized app

645 // close the maximized app

650 ApplicationManager.stopApplication("facebook-webapp");

646 ApplicationManager.stopApplication("facebook-webapp");

651

647

652 // verify the drop shadow is gone

648 // verify the drop shadow is gone

653− tryCompare(PanelState, "dropShadow", false);

649+ tryCompare(panelState, "dropShadow", false);

654 }

650 }

655

651

656 function test_threeFingerTapShowsWindowControls_data() {

652 function test_threeFingerTapShowsWindowControls_data() {

tests/qmltests/Stage/tst_PhoneStage.qml+7−7

@@ -19,6 +19,7 @@ import QtTest 1.0

19import Unity.Test 0.1 as UT

20import ".."

21import "../../../qml/Components"

22+import "../../../qml/Components/PanelState"

22import "../../../qml/Stage"

23import "../../../qml/Stage"

23import Ubuntu.Components 1.3

24import Ubuntu.Components 1.3

24import Unity.Application 0.1

25import Unity.Application 0.1

@@ -31,10 +32,10 @@ Item {

31

32

32 property var greeter: { fullyShown: true }

33 property var greeter: { fullyShown: true }

33

34

34− SurfaceManager { id: sMgr }

35+ readonly property var topLevelSurfaceList: WorkspaceManager.activeWorkspace.windowModel

36+

35 ApplicationMenuDataLoader {

37 ApplicationMenuDataLoader {

36 id: appMenuData

38 id: appMenuData

37− surfaceManager: sMgr

38 }

39 }

39

40

40 Stage {

41 Stage {

@@ -47,19 +48,17 @@ Item {

47 orientations: Orientations {}

48 orientations: Orientations {}

48 applicationManager: ApplicationManager

49 applicationManager: ApplicationManager

49 mode: "staged"

50 mode: "staged"

50− topLevelSurfaceList: TopLevelWindowModel {

51− id: topLevelSurfaceList

51+ topLevelSurfaceList: root.topLevelSurfaceList

52− applicationManager: ApplicationManager

53− surfaceManager: sMgr

54− }

55 availableDesktopArea: availableDesktopAreaItem

52 availableDesktopArea: availableDesktopAreaItem

56 Item {

53 Item {

57 id: availableDesktopAreaItem

54 id: availableDesktopAreaItem

58 anchors.fill: parent

55 anchors.fill: parent

59 }

56 }

57+

60 Component.onCompleted: {

58 Component.onCompleted: {

61 ApplicationManager.startApplication("unity8-dash");

59 ApplicationManager.startApplication("unity8-dash");

62 }

60 }

61+ panelState: PanelState {}

63 }

62 }

64

63

65 Flickable {

64 Flickable {

@@ -561,6 +560,7 @@ Item {

561 performEdgeSwipeToShowAppSpread();

560 performEdgeSwipeToShowAppSpread();

562

561

563 var appDelegate = findChild(stage, "appDelegate_" + webbrowserSurfaceId);

562 var appDelegate = findChild(stage, "appDelegate_" + webbrowserSurfaceId);

563+ verify(appDelegate);

564 var dragArea = findChild(appDelegate, "dragArea");

565 verify(dragArea);

566 tryCompare(dragArea, "closeable", true);

tests/qmltests/Stage/tst_SurfaceContainer.qml−2

@@ -51,8 +51,6 @@ Rectangle {

51 }

52 }

53

54− SurfaceManager {}

55−

56 Loader {

54 Loader {

57 id: surfaceContainerLoader

55 id: surfaceContainerLoader

58 focus: true

56 focus: true

tests/qmltests/Stage/tst_TabletStage.qml+43−43

@@ -26,6 +26,7 @@ import WindowManager 1.0

26import ".."

27import "../../../qml/Stage"

28import "../../../qml/Components"

29+import "../../../qml/Components/PanelState"

29

30

30Rectangle {

31Rectangle {

31 id: root

32 id: root

@@ -35,10 +36,10 @@ Rectangle {

35

36

36 property var greeter: { fullyShown: true }

37 property var greeter: { fullyShown: true }

37

38

38− SurfaceManager { id: sMgr }

39+ readonly property var topLevelSurfaceList: WorkspaceManager.activeWorkspace.windowModel

40+

39 ApplicationMenuDataLoader {

41 ApplicationMenuDataLoader {

40 id: appMenuData

42 id: appMenuData

41− surfaceManager: sMgr

42 }

43 }

43

44

44 Stage {

45 Stage {

@@ -56,17 +57,16 @@ Rectangle {

56 focus: true

57 focus: true

57 mode: "stagedWithSideStage"

58 mode: "stagedWithSideStage"

58 applicationManager: ApplicationManager

59 applicationManager: ApplicationManager

59− topLevelSurfaceList: TopLevelWindowModel {

60+ topLevelSurfaceList: root.topLevelSurfaceList

60− id: topLevelSurfaceList

61+ panelState: PanelState {}

61− applicationManager: ApplicationManager

62− surfaceManager: sMgr

63− }

64 availableDesktopArea: availableDesktopAreaItem

62 availableDesktopArea: availableDesktopAreaItem

65 Item {

63 Item {

66 id: availableDesktopAreaItem

64 id: availableDesktopAreaItem

67 anchors.fill: parent

65 anchors.fill: parent

68 }

66 }

67+

69 Component.onCompleted: {

68 Component.onCompleted: {

69+ print("starting dash")

70 ApplicationManager.startApplication("unity8-dash");

71 }

72 }

@@ -138,21 +138,21 @@ Rectangle {

138 name: "TabletStage"

139 when: windowShown

140

141− readonly property alias topSurfaceList: stage.topLevelSurfaceList

141+ readonly property alias topLevelSurfaceList: root.topLevelSurfaceList

142 property Item sideStage: stage ? findChild(stage, "sideStage") : null

143

144 function init() {

145 stageSaver.clear();

146

147 ApplicationManager.startApplication("unity8-dash");

148− tryCompare(topSurfaceList, "count", 1);

148+ tryCompare(topLevelSurfaceList, "count", 1);

149− compare(topSurfaceList.applicationAt(0).appId, "unity8-dash");

149+ compare(topLevelSurfaceList.applicationAt(0).appId, "unity8-dash");

150

151 // this is very strange, but sometimes the test starts without

152 // Stage components having finished loading themselves

153 var appWindow = null

154 while (!appWindow) {

155− appWindow = findAppWindowForSurfaceId(topSurfaceList.idAt(0));

155+ appWindow = findAppWindowForSurfaceId(topLevelSurfaceList.idAt(0));

156 if (!appWindow) {

157 console.log("didn't find unity8-dash appWindow in Stage. Trying again...");

158 wait(50);

@@ -164,7 +164,7 @@ Rectangle {

164 tryCompare(appRepeater, "count", 1);

165 tryCompare(appRepeater.itemAt(0), "x", 0);

166

167− waitUntilAppSurfaceShowsUp(topSurfaceList.idAt(0));

167+ waitUntilAppSurfaceShowsUp(topLevelSurfaceList.idAt(0));

168 sideStage.hideNow()

169 tryCompare(sideStage, "x", stage.width)

170 }

@@ -279,7 +279,7 @@ Rectangle {

279 function test_tappingSwitchesFocusBetweenStages() {

280 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

281

282− var webbrowserSurfaceId = topSurfaceList.nextId;

282+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

283 webbrowserCheckBox.checked = true;

284 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

285 var webbrowserDelegate = findChild(stage, "appDelegate_" + webbrowserSurfaceId);

@@ -290,7 +290,7 @@ Rectangle {

290

291 tryCompare(webbrowserWindow.surface, "activeFocus", true);

292

293− var dialerSurfaceId = topSurfaceList.nextId;

293+ var dialerSurfaceId = topLevelSurfaceList.nextId;

294 dialerCheckBox.checked = true;

295 waitUntilAppSurfaceShowsUp(dialerSurfaceId);

296

@@ -322,7 +322,7 @@ Rectangle {

322 function test_closeAppInSideStage() {

323 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

324

325− var dialerSurfaceId = topSurfaceList.nextId;

325+ var dialerSurfaceId = topLevelSurfaceList.nextId;

326 dialerCheckBox.checked = true;

327 waitUntilAppSurfaceShowsUp(dialerSurfaceId);

328

@@ -348,7 +348,7 @@ Rectangle {

348 }

349

350 function test_suspendsAndResumesAppsInMainStage() {

351− var webbrowserSurfaceId = topSurfaceList.nextId;

351+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

352 webbrowserCheckBox.checked = true;

353 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

354 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

@@ -357,7 +357,7 @@ Rectangle {

357

358 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

359

360− var gallerySurfaceId = topSurfaceList.nextId;

360+ var gallerySurfaceId = topLevelSurfaceList.nextId;

361 galleryCheckBox.checked = true;

362 waitUntilAppSurfaceShowsUp(gallerySurfaceId);

363 var galleryApp = ApplicationManager.findApplication(galleryCheckBox.appId);

@@ -388,7 +388,7 @@ Rectangle {

388 // launch two main stage apps

389 // gallery will be on foreground and webbrowser on background

390

391− var webbrowserSurfaceId = topSurfaceList.nextId;

391+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

392 webbrowserCheckBox.checked = true;

393 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

394 var webbrowserDelegate = findChild(stage, "appDelegate_" + webbrowserSurfaceId);

@@ -396,7 +396,7 @@ Rectangle {

396 compare(webbrowserDelegate.stage, ApplicationInfoInterface.MainStage);

397 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

398

399− var gallerySurfaceId = topSurfaceList.nextId;

399+ var gallerySurfaceId = topLevelSurfaceList.nextId;

400 galleryCheckBox.checked = true;

401 waitUntilAppSurfaceShowsUp(gallerySurfaceId);

402 var galleryApp = ApplicationManager.findApplication(galleryCheckBox.appId);

@@ -408,14 +408,14 @@ Rectangle {

408 // then launch two side stage apps

409 // facebook will be on foreground and dialer on background

410

411− var dialerSurfaceId = topSurfaceList.nextId;

411+ var dialerSurfaceId = topLevelSurfaceList.nextId;

412 dialerCheckBox.checked = true;

413 waitUntilAppSurfaceShowsUp(dialerSurfaceId);

414 var dialerApp = ApplicationManager.findApplication(dialerCheckBox.appId);

415 var dialerDelegate = findChild(stage, "appDelegate_" + dialerSurfaceId);

416 compare(dialerDelegate.stage, ApplicationInfoInterface.SideStage);

417

418− var facebookSurfaceId = topSurfaceList.nextId;

418+ var facebookSurfaceId = topLevelSurfaceList.nextId;

419 facebookCheckBox.checked = true;

420 waitUntilAppSurfaceShowsUp(facebookSurfaceId);

421 var facebookApp = ApplicationManager.findApplication(facebookCheckBox.appId);

@@ -450,14 +450,14 @@ Rectangle {

450 function test_foregroundAppsAreSuspendedWhenStageIsSuspended() {

451 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

452

453− var webbrowserSurfaceId = topSurfaceList.nextId;

453+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

454 webbrowserCheckBox.checked = true;

455 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

456 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

457 var webbrowserDelegate = findChild(stage, "appDelegate_" + webbrowserSurfaceId);

458 compare(webbrowserDelegate.stage, ApplicationInfoInterface.MainStage);

459

460− var dialerSurfaceId = topSurfaceList.nextId;

460+ var dialerSurfaceId = topLevelSurfaceList.nextId;

461 dialerCheckBox.checked = true;

462 waitUntilAppSurfaceShowsUp(dialerSurfaceId);

463 var dialerApp = ApplicationManager.findApplication(dialerCheckBox.appId);

@@ -531,7 +531,7 @@ Rectangle {

531 tryCompare(stagesPriv, "mainStageAppId", "unity8-dash");

532 tryCompare(stagesPriv, "sideStageAppId", "");

533

534− var appSurfaceId = topSurfaceList.nextId;

534+ var appSurfaceId = topLevelSurfaceList.nextId;

535 var app = ApplicationManager.startApplication(data.appId);

536 waitUntilAppSurfaceShowsUp(appSurfaceId);

537

@@ -555,7 +555,7 @@ Rectangle {

555 tryCompare(stagesPriv, "mainStageAppId", "unity8-dash");

556 tryCompare(stagesPriv, "sideStageAppId", "");

557

558− var webbrowserSurfaceId = topSurfaceList.nextId;

558+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

559 webbrowserCheckBox.checked = true;

560 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

561

@@ -580,7 +580,7 @@ Rectangle {

580 tryCompare(stagesPriv, "mainStageAppId", "unity8-dash");

581 tryCompare(stagesPriv, "sideStageAppId", "");

582

583− var webbrowserSurfaceId = topSurfaceList.nextId;

583+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

584 webbrowserCheckBox.checked = true;

585 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

586

@@ -598,7 +598,7 @@ Rectangle {

598 function test_loadSideStageByDraggingFromMainStage() {

599 sideStage.showNow();

600 print("sidestage now shown. launching browser")

601− var webbrowserSurfaceId = topSurfaceList.nextId;

601+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

602 webbrowserCheckBox.checked = true;

603 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

604

@@ -619,7 +619,7 @@ Rectangle {

619 tryCompareFunction(function() {

620 return WindowStateStorage.getStage(webbrowserCheckBox.appId, ApplicationInfoInterface.MainStage) === ApplicationInfoInterface.SideStage

621 }, true);

622− var webbrowserSurfaceId = topSurfaceList.nextId;

622+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

623 webbrowserCheckBox.checked = true;

624 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

625

@@ -635,7 +635,7 @@ Rectangle {

635

636 /*

637 1- Suspended app gets killed behind the scenes, causing its surface to go zombie.

638− 2- Surface gets screenshotted and removed. Its slot in the topSurfaceList remains,

638+ 2- Surface gets screenshotted and removed. Its slot in the topLevelSurfaceList remains,

639 though (so ApplicationWindow can display the screenshot in its place).

640 3- User taps on the screenshot of the long-gone surface.

641

@@ -643,11 +643,11 @@ Rectangle {

643 Application gets relaunched. Its new surface will seamlessly replace the screenshot.

644 */

645 function test_selectSuspendedAppWithoutSurface() {

646− compare(topSurfaceList.applicationAt(0).appId, "unity8-dash");

646+ compare(topLevelSurfaceList.applicationAt(0).appId, "unity8-dash");

647− var dashSurfaceId = topSurfaceList.idAt(0);

647+ var dashSurfaceId = topLevelSurfaceList.idAt(0);

648− var dashWindow = topSurfaceList.windowAt(0);

648+ var dashWindow = topLevelSurfaceList.windowAt(0);

649

650− var webbrowserSurfaceId = topSurfaceList.nextId;

650+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

651 webbrowserCheckBox.checked = true;

652 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

653 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

@@ -664,22 +664,22 @@ Rectangle {

664

665 // wait until the surface is gone

666 tryCompare(webbrowserApp.surfaceList, "count", 0);

667− compare(topSurfaceList.surfaceAt(topSurfaceList.indexForId(webbrowserSurfaceId)), null);

667+ compare(topLevelSurfaceList.surfaceAt(topLevelSurfaceList.indexForId(webbrowserSurfaceId)), null);

668

669 switchToSurface(webbrowserSurfaceId);

670

671 // webbrowser should have been brought to front

672− tryCompareFunction(function(){return topSurfaceList.idAt(0);}, webbrowserSurfaceId);

672+ tryCompareFunction(function(){return topLevelSurfaceList.idAt(0);}, webbrowserSurfaceId);

673

674 // and it should eventually get a new surface and get resumed

675− tryCompareFunction(function(){return topSurfaceList.surfaceAt(0) !== null;}, true);

675+ tryCompareFunction(function(){return topLevelSurfaceList.surfaceAt(0) !== null;}, true);

676− compare(topSurfaceList.count, 2); // still two top-level items

676+ compare(topLevelSurfaceList.count, 2); // still two top-level items

677 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

678 compare(webbrowserApp.surfaceList.count, 1);

679 }

680

681 function test_draggingSurfaceKeepsSurfaceFocus() {

682− var webbrowserSurfaceId = topSurfaceList.nextId;

682+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

683 webbrowserCheckBox.checked = true;

684 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

685

@@ -697,8 +697,8 @@ Rectangle {

697

698 function test_dashDoesNotDragToSidestage() {

699 sideStage.showNow();

700− compare(topSurfaceList.applicationAt(0).appId, "unity8-dash");

700+ compare(topLevelSurfaceList.applicationAt(0).appId, "unity8-dash");

701− var dashSurfaceId = topSurfaceList.idAt(0);

701+ var dashSurfaceId = topLevelSurfaceList.idAt(0);

702

703 var appDelegate = findChild(stage, "appDelegate_" + dashSurfaceId);

704 verify(appDelegate);

@@ -720,7 +720,7 @@ Rectangle {

720

721 function test_switchRestoreStageOnRotation() {

722 WindowStateStorage.saveStage(webbrowserCheckBox.appId, ApplicationInfoInterface.SideStage)

723− var webbrowserSurfaceId = topSurfaceList.nextId;

723+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

724 webbrowserCheckBox.checked = true;

725 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

726

@@ -739,7 +739,7 @@ Rectangle {

739 }

740

741 function test_restoreSavedStageOnCloseReopen() {

742− var webbrowserSurfaceId = topSurfaceList.nextId;

742+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

743 webbrowserCheckBox.checked = true;

744 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

745

@@ -757,7 +757,7 @@ Rectangle {

757 // back to landscape

758 stage.shellOrientation = Qt.LandscapeOrientation;

759

760− webbrowserSurfaceId = topSurfaceList.nextId;

760+ webbrowserSurfaceId = topLevelSurfaceList.nextId;

761 webbrowserCheckBox.checked = true;

762 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

763

tests/qmltests/Stage/tst_WindowDecoration.qml−2

@@ -47,10 +47,8 @@ Item {

47 property string name: "webbrowser"

48 }

49

50− SurfaceManager { id: sMgr }

51 ApplicationMenuDataLoader {

50 ApplicationMenuDataLoader {

52 id: appMenuData

51 id: appMenuData

53− surfaceManager: sMgr

54 }

52 }

55

53

56 UnityMenuModel {

54 UnityMenuModel {

tests/qmltests/Stage/tst_WindowResizeArea.qml+1−8

@@ -19,7 +19,6 @@ import QtQuick.Layouts 1.1

19import QtTest 1.0

20import Unity.Test 0.1

21import ".."

22−import "../../../qml/Components/PanelState"

23import "../../../qml/Stage"

22import "../../../qml/Stage"

24import Ubuntu.Components 1.3

23import Ubuntu.Components 1.3

25import Ubuntu.Components.ListItems 1.3 as ListItem

24import Ubuntu.Components.ListItems 1.3 as ListItem

@@ -31,12 +30,6 @@ Item {

31 height: units.gu(60)

30 height: units.gu(60)

32 width: units.gu(85)

31 width: units.gu(85)

33

32

34− Binding {

35− target: PanelState

36− property: "panelHeight"

37− value: units.gu(3)

38− }

39−

40 Component {

33 Component {

41 id: fakeWindowComponent

34 id: fakeWindowComponent

42

35

@@ -362,7 +355,7 @@ Item {

362

355

363 // Make sure it's again where we left it in normal state before destroying

356 // Make sure it's again where we left it in normal state before destroying

364 compare(fakeWindow.requestedX >= 0, true)

357 compare(fakeWindow.requestedX >= 0, true)

365− compare(fakeWindow.requestedY >= PanelState.panelHeight, true)

358+ compare(fakeWindow.requestedY >= 0, true)

366 compare(fakeWindow.requestedX + fakeWindow.width <= root.width, true)

359 compare(fakeWindow.requestedX + fakeWindow.width <= root.width, true)

367 compare(fakeWindow.requestedY + fakeWindow.height <= root.height, true)

360 compare(fakeWindow.requestedY + fakeWindow.height <= root.height, true)

368

361

tests/qmltests/Tutorial/tst_Tutorial.qml+5−23

@@ -37,20 +37,10 @@ Rectangle {

37 height: units.gu(71)

38

39 QtObject {

40− id: applicationArguments

40+ id: _screenWindow

41−

41+ property bool primary: true

42− function hasGeometry() {

43− return false;

44− }

45−

46− function width() {

47− return 0;

48− }

49−

50− function height() {

51− return 0;

52− }

53 }

42 }

43+ property alias screenWindow: _screenWindow

54

44

55 Telephony.CallEntry {

45 Telephony.CallEntry {

56 id: phoneCall

46 id: phoneCall

@@ -256,13 +246,7 @@ Rectangle {

256 property real halfWidth: shell ? shell.width / 2 : 0

246 property real halfWidth: shell ? shell.width / 2 : 0

257 property real halfHeight: shell ? shell.height / 2 : 0

247 property real halfHeight: shell ? shell.height / 2 : 0

258

248

259− onShellChanged: {

249+ topLevelSurfaceList: shell ? shell.topLevelSurfaceList : null;

260− if (shell) {

261− topLevelSurfaceList = testCase.findInvisibleChild(shell, "topLevelSurfaceList");

262− } else {

263− topLevelSurfaceList = null;

264− }

265− }

266

250

267 function init() {

251 function init() {

268 prepareShell();

252 prepareShell();

@@ -327,9 +311,7 @@ Rectangle {

327 }

311 }

328

312

329 function ensureInputMethodSurface() {

313 function ensureInputMethodSurface() {

330− var surfaceManager = findInvisibleChild(shell, "surfaceManager");

331− verify(surfaceManager);

332− surfaceManager.createInputMethodSurface();

314+ SurfaceManager.createInputMethodSurface();

333

315

334 tryCompareFunction(function() { return topLevelSurfaceList.inputMethodSurface !== null }, true);

316 tryCompareFunction(function() { return topLevelSurfaceList.inputMethodSurface !== null }, true);

335 }

317 }

tests/qmltests/tst_OrientedShell.qml+22−10

@@ -30,7 +30,6 @@ import Utils 0.1

30

31import "../../qml"

32import "../../qml/Components"

33−import "../../qml/Components/PanelState"

34import "Stage"

33import "Stage"

35

34

36Rectangle {

35Rectangle {

@@ -82,6 +81,12 @@ Rectangle {

82 deviceFilter: InputInfo.Keyboard

81 deviceFilter: InputInfo.Keyboard

83 }

82 }

84

83

84+ QtObject {

85+ id: _screenWindow

86+ property bool primary: true

87+ }

88+ property alias screenWindow: _screenWindow

89+

85 property int physicalOrientation0

90 property int physicalOrientation0

86 property int physicalOrientation90

91 property int physicalOrientation90

87 property int physicalOrientation180

92 property int physicalOrientation180

@@ -444,8 +449,17 @@ Rectangle {

444 when: windowShown

449 when: windowShown

445

450

446 property Item orientedShell: orientedShellLoader.status === Loader.Ready ? orientedShellLoader.item : null

451 property Item orientedShell: orientedShellLoader.status === Loader.Ready ? orientedShellLoader.item : null

447− property Item shell

452+ property Item shell: null

448− property QtObject topLevelSurfaceList

453+ property QtObject topLevelSurfaceList : shell ? shell.topLevelSurfaceList : null

454+ property var panelState: undefined

455+

456+ onOrientedShellChanged: {

457+ if (orientedShell) {

458+ panelState = findInvisibleChild(orientedShell, "panelState");

459+ } else {

460+ panelState = undefined;

461+ }

462+ }

449

463

450 SignalSpy { id: signalSpy }

464 SignalSpy { id: signalSpy }

451 SignalSpy { id: signalSpy2 }

465 SignalSpy { id: signalSpy2 }

@@ -504,7 +518,6 @@ Rectangle {

504 function cleanup() {

518 function cleanup() {

505 tryCompare(shell, "waitingOnGreeter", false, 10000); // make sure greeter didn't leave us in disabled state

519 tryCompare(shell, "waitingOnGreeter", false, 10000); // make sure greeter didn't leave us in disabled state

506 shell = null;

520 shell = null;

507− topLevelSurfaceList = null;

508

521

509 tearDown();

522 tearDown();

510 }

523 }

@@ -1463,8 +1476,7 @@ Rectangle {

1463 removeTimeConstraintsFromSwipeAreas(orientedShellLoader.item);

1476 removeTimeConstraintsFromSwipeAreas(orientedShellLoader.item);

1464

1477

1465 shell = findChild(orientedShell, "shell");

1478 shell = findChild(orientedShell, "shell");

1466−

1479+ verify(shell);

1467− topLevelSurfaceList = findInvisibleChild(shell, "topLevelSurfaceList");

1468 verify(topLevelSurfaceList);

1480 verify(topLevelSurfaceList);

1469

1481

1470 tryCompare(shell, "waitingOnGreeter", false); // reset by greeter when ready

1482 tryCompare(shell, "waitingOnGreeter", false); // reset by greeter when ready

@@ -1512,13 +1524,13 @@ Rectangle {

1512 print("exptectedAngle", expectedAngle, point.x, point.y)

1524 print("exptectedAngle", expectedAngle, point.x, point.y)

1513 switch (expectedAngle) {

1525 switch (expectedAngle) {

1514 case 0:

1526 case 0:

1515− return point.x === 0 && point.y === PanelState.panelHeight;

1527+ return point.x === 0 && point.y === panelState.panelHeight;

1516 case 90:

1528 case 90:

1517− return point.x === orientedShell.width - PanelState.panelHeight && point.y === 0;

1529+ return point.x === orientedShell.width - panelState.panelHeight && point.y === 0;

1518 case 180:

1530 case 180:

1519− return point.x === orientedShell.width && point.y === orientedShell.height - PanelState.panelHeight;

1531+ return point.x === orientedShell.width && point.y === orientedShell.height - panelState.panelHeight;

1520 default: // 270

1532 default: // 270

1521− return point.x === PanelState.panelHeight && point.y === orientedShell.height;

1533+ return point.x === panelState.panelHeight && point.y === orientedShell.height;

1522 }

1534 }

1523 }

1535 }

1524

1536

tests/qmltests/tst_Shell.qml+26−25

@@ -38,7 +38,6 @@ import Unity.Indicators 0.1 as Indicators

38

39import "../../qml"

40import "../../qml/Components"

41−import "../../qml/Components/PanelState"

42import "Stage"

41import "Stage"

43

42

44Rectangle {

43Rectangle {

@@ -57,18 +56,22 @@ Rectangle {

57 id: appMenuData

56 id: appMenuData

58 }

57 }

59

58

60− property var shell: shellLoader.item ? shellLoader.item : null

59+ readonly property var shell: shellLoader.item ? shellLoader.item : null

61 onShellChanged: {

60 onShellChanged: {

62 if (shell) {

61 if (shell) {

63− topLevelSurfaceList = testCase.findInvisibleChild(shell, "topLevelSurfaceList");

62+ panelState = testCase.findInvisibleChild(shell, "panelState");

64− appMenuData.surfaceManager = testCase.findInvisibleChild(shell, "surfaceManager");

65 } else {

63 } else {

66− topLevelSurfaceList = null;

64+ panelState = null;

67− appMenuData.surfaceManager = null;

68 }

65 }

69 }

66 }

67+ property var panelState: null

68+ readonly property alias topLevelSurfaceList: testCase.topLevelSurfaceList

70

69

71− property var topLevelSurfaceList: null

70+ QtObject {

71+ id: _screenWindow

72+ property bool primary: true

73+ }

74+ property alias screenWindow: _screenWindow

72

75

73 Item {

76 Item {

74 id: shellContainer

77 id: shellContainer

@@ -560,6 +563,7 @@ Rectangle {

560 when: windowShown

563 when: windowShown

561

564

562 property Item shell: shellLoader.status === Loader.Ready ? shellLoader.item : null

565 property Item shell: shellLoader.status === Loader.Ready ? shellLoader.item : null

566+ topLevelSurfaceList: shell ? shell.topLevelSurfaceList : null

563

567

564 function init() {

568 function init() {

565 if (shellLoader.active) {

569 if (shellLoader.active) {

@@ -598,7 +602,6 @@ Rectangle {

598 waitForGreeterToStabilize();

602 waitForGreeterToStabilize();

599

603

600 // from StageTestCase

604 // from StageTestCase

601− topLevelSurfaceList = findInvisibleChild(shell, "topLevelSurfaceList");

602 verify(topLevelSurfaceList);

605 verify(topLevelSurfaceList);

603 stage = findChild(shell, "stage");

606 stage = findChild(shell, "stage");

604

607

@@ -678,9 +681,7 @@ Rectangle {

678 }

681 }

679

682

680 function ensureInputMethodSurface() {

683 function ensureInputMethodSurface() {

681− var surfaceManager = findInvisibleChild(shell, "surfaceManager");

682− verify(surfaceManager);

683− surfaceManager.createInputMethodSurface();

684+ SurfaceManager.createInputMethodSurface();

684

685

685 tryCompareFunction(function() { return root.topLevelSurfaceList.inputMethodSurface !== null }, true);

686 tryCompareFunction(function() { return root.topLevelSurfaceList.inputMethodSurface !== null }, true);

686 }

687 }

@@ -1885,21 +1886,21 @@ Rectangle {

1885 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

1886 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

1886

1887

1887 tryCompare(appDelegate, "state", "normal");

1888 tryCompare(appDelegate, "state", "normal");

1888− tryCompare(PanelState, "decorationsVisible", false)

1889+ tryCompare(panelState, "decorationsVisible", false)

1889

1890

1890 mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);

1891 mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);

1891 tryCompare(appDelegate, "state", "maximized");

1892 tryCompare(appDelegate, "state", "maximized");

1892− tryCompare(PanelState, "decorationsVisible", true)

1893+ tryCompare(panelState, "decorationsVisible", true)

1893

1894

1894 ApplicationManager.stopApplication(application.appId);

1895 ApplicationManager.stopApplication(application.appId);

1895− tryCompare(PanelState, "decorationsVisible", false)

1896+ tryCompare(panelState, "decorationsVisible", false)

1896

1897

1897 // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

1898 // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

1898 // They won't be gone until those surface items are destroyed.

1899 // They won't be gone until those surface items are destroyed.

1899 tryCompareFunction(function() { return application.surfaceList.count }, 0);

1900 tryCompareFunction(function() { return application.surfaceList.count }, 0);

1900

1901

1901 ApplicationManager.startApplication(application.appId);

1902 ApplicationManager.startApplication(application.appId);

1902− tryCompare(PanelState, "decorationsVisible", true)

1903+ tryCompare(panelState, "decorationsVisible", true)

1903 }

1904 }

1904

1905

1905 function test_newAppHasValidGeometry() {

1906 function test_newAppHasValidGeometry() {

@@ -1956,7 +1957,7 @@ Rectangle {

1956 mousePress(appDelegate, appDelegate.width / 2, units.gu(1))

1957 mousePress(appDelegate, appDelegate.width / 2, units.gu(1))

1957 mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))

1958 mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))

1958

1959

1959− compare(appDelegate.y >= PanelState.panelHeight, true);

1960+ compare(appDelegate.y >= panelState.panelHeight, true);

1960 }

1961 }

1961

1962

1962 function test_cantResizeWindowUnderPanel() {

1963 function test_cantResizeWindowUnderPanel() {

@@ -1984,7 +1985,7 @@ Rectangle {

1984 mouseMove(decoration, decoration.width/2, -units.gu(100));

1985 mouseMove(decoration, decoration.width/2, -units.gu(100));

1985

1986

1986 // verify we don't go past the panel

1987 // verify we don't go past the panel

1987− compare(appDelegate.y >= PanelState.panelHeight, true);

1988+ compare(appDelegate.y >= panelState.panelHeight, true);

1988 }

1989 }

1989

1990

1990 function test_restoreWindowStateFixesIfUnderPanel() {

1991 function test_restoreWindowStateFixesIfUnderPanel() {

@@ -2008,7 +2009,7 @@ Rectangle {

2008 tryCompareFunction(function () { return topLevelSurfaceList.applicationAt(0).appId; }, application.appId);

2009 tryCompareFunction(function () { return topLevelSurfaceList.applicationAt(0).appId; }, application.appId);

2009

2010

2010 appDelegate = appRepeater.itemAt(0);

2011 appDelegate = appRepeater.itemAt(0);

2011− compare(appDelegate.y >= PanelState.panelHeight, true);

2012+ compare(appDelegate.y >= panelState.panelHeight, true);

2012 }

2013 }

2013

2014

2014 function test_lifecyclePolicyForNonTouchApp_data() {

2015 function test_lifecyclePolicyForNonTouchApp_data() {

@@ -2671,9 +2672,9 @@ Rectangle {

2671

2672

2672 function test_oskDisplacesWindow_data() {

2673 function test_oskDisplacesWindow_data() {

2673 return [

2674 return [

2674− {tag: "no need to displace", windowHeight: units.gu(10), windowY: units.gu(5), targetDisplacement: units.gu(5), oskEnabled: true},

2675+ {tag: "no need to displace", windowHeight: units.gu(10), windowY: units.gu(5), targetDisplacement: function() { return units.gu(5); }, oskEnabled: true},

2675− {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: PanelState.panelHeight, oskEnabled: true},

2676+ {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: function() { return panelState.panelHeight; }, oskEnabled: true},

2676− {tag: "osk not on this screen", windowHeight: units.gu(40), windowY: units.gu(10), targetDisplacement: units.gu(10), oskEnabled: false},

2677+ {tag: "osk not on this screen", windowHeight: units.gu(40), windowY: units.gu(10), targetDisplacement: function() { return units.gu(10); }, oskEnabled: false},

2677 ]

2678 ]

2678 }

2679 }

2679

2680

@@ -2695,11 +2696,11 @@ Rectangle {

2695 dashAppDelegate.windowedY = data.windowY;

2696 dashAppDelegate.windowedY = data.windowY;

2696 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2697 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2697 var initialY = dashAppDelegate.y;

2698 var initialY = dashAppDelegate.y;

2698− print("intial", initialY, "panel", PanelState.panelHeight);

2699+ print("intial", initialY, "panel", panelState.panelHeight);

2699− verify(initialY > PanelState.panelHeight);

2700+ verify(initialY > panelState.panelHeight);

2700

2701

2701 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, root.height / 2, root.width, root.height / 2));

2702 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, root.height / 2, root.width, root.height / 2));

2702− tryCompare(dashAppDelegate, "y", data.targetDisplacement);

2703+ tryCompare(dashAppDelegate, "y", data.targetDisplacement());

2703

2704

2704 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2705 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2705 tryCompare(dashAppDelegate, "y", initialY);

2706 tryCompare(dashAppDelegate, "y", initialY);

@@ -3132,7 +3133,7 @@ Rectangle {

3132 // double click the panel

3133 // double click the panel

3133 var panel = findChild(shell, "panel");

3134 var panel = findChild(shell, "panel");

3134 verify(panel);

3135 verify(panel);

3135− mouseDoubleClickSequence(panel, panel.width/2, PanelState.panelHeight/2, Qt.LeftButton, Qt.NoModifier, 300);

3136+ mouseDoubleClickSequence(panel, panel.width/2, panelState.panelHeight/2, Qt.LeftButton, Qt.NoModifier, 300);

3136 tryCompare(appDelegate, "state", "restored");

3137 tryCompare(appDelegate, "state", "restored");

3137 }

3138 }

3138

3139

tests/qmltests/tst_ShellApplication.qmlnew file+218

@@ -0,0 +1,218 @@

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+import Unity.InputInfo 0.1

24+

25+import "../../qml"

26+import "../../qml/Components"

27+import "Stage"

28+

29+Rectangle {

30+ id: root

31+ color: "grey"

32+ width: units.gu(100)

33+ height: units.gu(71)

34+

35+ QtObject {

36+ id: args

37+ property bool hasFullscreen: false

38+ property bool hasFrameless: false

39+ property bool hasGeometry: true

40+ property size windowGeometry: Qt.size(root.width, root.height)

41+ property string deviceName: "desktop"

42+ property string mode: "full-greeter"

43+ }

44+ property alias applicationArguments: args

45+

46+ Component.onCompleted: {

47+ // must set the mock mode before loading the Shell

48+ LightDMController.userMode = "single";

49+ }

50+

51+ Flickable {

52+ id: controls

53+ contentHeight: controlRect.height

54+

55+ anchors.top: root.top

56+ anchors.bottom: root.bottom

57+ anchors.right: root.right

58+ width: units.gu(30)

59+

60+ Rectangle {

61+ id: controlRect

62+ anchors { left: parent.left; right: parent.right }

63+ color: "darkgrey"

64+ height: childrenRect.height + units.gu(2)

65+

66+ Column {

67+ anchors { left: parent.left; right: parent.right; top: parent.top; margins: units.gu(1) }

68+ spacing: units.gu(1)

69+

70+ Flow {

71+ spacing: units.gu(1)

72+ anchors { left: parent.left; right: parent.right }

73+

74+ Button {

75+ text: "Show Greeter"

76+ activeFocusOnPress: false

77+ onClicked: {

78+ LightDM.Greeter.showGreeter();

79+ }

80+ }

81+ Button {

82+ text: "Hide Greeter"

83+ activeFocusOnPress: false

84+ onClicked: {

85+ LightDM.Greeter.hideGreeter()

86+ }

87+ }

88+ }

89+ Button {

90+ anchors {

91+ left: parent.left

92+ right: parent.right

93+ }

94+ action: addMouseAction

95+ color: addMouseAction.checked ? UbuntuColors.red : UbuntuColors.green

96+ }

97+

98+ Button {

99+ anchors {

100+ left: parent.left

101+ right: parent.right

102+ }

103+ action: addKBAction

104+ color: addKBAction.checked ? UbuntuColors.red : UbuntuColors.green

105+ }

106+

107+ MouseTouchEmulationCheckbox {

108+ id: mouseEmulation

109+ checked: true

110+ }

111+

112+ Row {

113+ anchors { left: parent.left; right: parent.right }

114+ CheckBox {

115+ id: autohideLauncherCheckbox

116+ onCheckedChanged: {

117+ GSettingsController.setAutohideLauncher(checked)

118+ }

119+ }

120+ Label {

121+ text: "Autohide launcher"

122+ }

123+ }

124+

125+ Label { text: "Applications"; font.bold: true }

126+

127+ Button {

128+ text: "Start all apps"

129+ width: parent.width

130+ activeFocusOnPress: false

131+ onClicked: {

132+ for (var i = 0; i < ApplicationManager.availableApplications.length; i++) {

133+ var appId = ApplicationManager.availableApplications[i];

134+ ApplicationManager.startApplication(appId)

135+ }

136+ }

137+ }

138+

139+ Repeater {

140+ id: appCheckBoxRepeater

141+ model: ApplicationManager.availableApplications

142+ ApplicationCheckBox {

143+ appId: modelData

144+ }

145+ }

146+

147+ Label {

148+ text: "Fingerprint"

149+ }

150+ Row {

151+ Button {

152+ text: "Success"

153+ onClicked: {

154+ var biometryd = testCase.findInvisibleChild(shellContainer, "biometryd");

155+ var uid = 0;

156+ for (var i = 0; i < LightDM.Users.count; i++) {

157+ if (LightDM.Users.data(i, LightDM.UserRoles.NameRole) == AccountsService.user) {

158+ uid = LightDM.Users.data(i, LightDM.UserRoles.UidRole);

159+ break;

160+ }

161+ }

162+ biometryd.operation.mockSuccess(uid);

163+ }

164+ }

165+

166+ Button {

167+ text: "Failure"

168+ onClicked: {

169+ var biometryd = testCase.findInvisibleChild(shellContainer, "biometryd");

170+ biometryd.operation.mockFailure("error");

171+ }

172+ }

173+ }

174+ }

175+ }

176+ }

177+

178+ Action {

179+ id: addMouseAction

180+ text: checked ? "Remove Mouse" : "Add Mouse"

181+ onTriggered: {

182+ if (checked) {

183+ console.log("ADD")

184+ MockInputDeviceBackend.addMockDevice("/mouse0", InputInfo.Mouse);

185+ } else {

186+ console.log("REMOVE")

187+ MockInputDeviceBackend.removeDevice("/mouse0");

188+ }

189+ }

190+ iconName: "input-mouse-symbolic"

191+ checkable: true

192+ checked: false

193+ }

194+

195+ Action {

196+ id: addKBAction

197+ text: checked ? "Remove Keyboard" : "Add Keyboard"

198+ onTriggered: {

199+ if (checked) {

200+ MockInputDeviceBackend.addMockDevice("/kbd0", InputInfo.Keyboard);

201+ } else {

202+ MockInputDeviceBackend.removeDevice("/kbd0");

203+ }

204+ }

205+ iconName: "input-keyboard-symbolic"

206+ checkable: true

207+ checked: false

208+ }

209+

210+ ShellApplication {

211+ }

212+

213+ UnityTestCase {

214+ id: testCase

215+ name: "ShellApplication"

216+ when: windowShown

217+ }

218+}

tests/qmltests/tst_ShellWithPin.qml+4−16

@@ -40,20 +40,10 @@ Item {

40 }

41

42 QtObject {

43− id: applicationArguments

43+ id: _screenWindow

44−

44+ property bool primary: true

45− function hasGeometry() {

46− return false;

47− }

48−

49− function width() {

50− return 0;

51− }

52−

53− function height() {

54− return 0;

55− }

56 }

45 }

46+ property alias screenWindow: _screenWindow

57

47

58 Row {

48 Row {

59 id: contentRow

49 id: contentRow

@@ -123,6 +113,7 @@ Item {

123 when: windowShown

113 when: windowShown

124

114

125 property Item shell: shellLoader.status === Loader.Ready ? shellLoader.item : null

115 property Item shell: shellLoader.status === Loader.Ready ? shellLoader.item : null

116+ topLevelSurfaceList: shell ? shell.topLevelSurfaceList : null

126

117

127 function init() {

118 function init() {

128 tryCompare(shell, "waitingOnGreeter", false); // will be set when greeter is all ready

119 tryCompare(shell, "waitingOnGreeter", false); // will be set when greeter is all ready

@@ -138,7 +129,6 @@ Item {

138

129

139 // from StageTestCase

130 // from StageTestCase

140 stage = findChild(shell, "stage");

131 stage = findChild(shell, "stage");

141− topLevelSurfaceList = findInvisibleChild(shell, "topLevelSurfaceList");

142 verify(topLevelSurfaceList);

132 verify(topLevelSurfaceList);

143

133

144 startApplication("unity8-dash");

134 startApplication("unity8-dash");

@@ -147,8 +137,6 @@ Item {

147 function cleanup() {

137 function cleanup() {

148 tryCompare(shell, "waitingOnGreeter", false); // make sure greeter didn't leave us in disabled state

138 tryCompare(shell, "waitingOnGreeter", false); // make sure greeter didn't leave us in disabled state

149

139

150− topLevelSurfaceList = null;

151−

152 shellLoader.itemDestroyed = false

140 shellLoader.itemDestroyed = false

153

141

154 shellLoader.active = false

142 shellLoader.active = false

tests/uqmlscene/main.cpp+2

@@ -479,6 +479,8 @@ int main(int argc, char ** argv)

479 // TODO: as soon as the engine construction completes, the debug service is

480 // listening for connections. But actually we aren't ready to debug anything.

481 QQmlEngine engine;

482+ engine.rootContext()->setContextProperty("DebuggingController", new DebuggingController(&app));

483+

482 QQmlComponent *component = new QQmlComponent(&engine);

484 QQmlComponent *component = new QQmlComponent(&engine);

483 for (int i = 0; i < imports.size(); ++i)

485 for (int i = 0; i < imports.size(); ++i)

484 engine.addImportPath(imports.at(i));

486 engine.addImportPath(imports.at(i));

tests/utils/modules/Unity/Test/StageTestCase.qml+1−1

@@ -62,7 +62,7 @@ UnityTestCase {

62

63 return findChild(stage, "appDelegate_" + surfaceId);

64 } catch(err) {

65− throw new Error("startApplication("+appId+") called from line " + util.callerLine(1) + " failed!");

65+ throw new Error("startApplication("+appId+") called from line " + util.callerLine(1) + " failed! - " + err);

66 }

67 }

68}

tests/utils/modules/Unity/Test/UnityTestCase.qml+14

@@ -17,6 +17,7 @@

17import QtQuick 2.4

18import QtTest 1.0

19import Unity.Application 0.1

20+import WindowManager 1.0

20import Ubuntu.Components 1.3

21import Ubuntu.Components 1.3

21import Ubuntu.Test 1.0 as UbuntuTest

22import Ubuntu.Test 1.0 as UbuntuTest

22import Unity.Test 0.1 as UT

23import Unity.Test 0.1 as UT

@@ -47,6 +48,18 @@ TestCase {

47 }

48 }

49 }

49

50

51+ Binding {

52+ target: WindowManagerObjects

53+ property: "surfaceManager"

54+ value: SurfaceManager

55+ }

56+

57+ Binding {

58+ target: WindowManagerObjects

59+ property: "applicationManager"

60+ value: ApplicationManager

61+ }

62+

50 // Fake implementation to be provided to items under test

63 // Fake implementation to be provided to items under test

51 property var fakeDateTime: new function() {

64 property var fakeDateTime: new function() {

52 this.currentTimeMs = 0

65 this.currentTimeMs = 0

@@ -641,5 +654,6 @@ TestCase {

641 tryCompare(application, "state", ApplicationInfo.Stopped);

654 tryCompare(application, "state", ApplicationInfo.Stopped);

642 }

655 }

643 compare(ApplicationManager.count, 0);

656 compare(ApplicationManager.count, 0);

657+ SurfaceManager.releaseInputMethodSurface();

644 }

658 }

645}

659}