xenial...945dd8e · 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+305

@@ -0,0 +1,305 @@

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+qtmir::OutputId Screen::outputId() const

56+{

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

58+ return m_wrapped->outputId();

59+}

60+

61+bool Screen::used() const

62+{

63+ if (!m_wrapped) return false;

64+ return m_wrapped->used();

65+}

66+

67+QString Screen::name() const

68+{

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

70+ return m_wrapped->name();

71+}

72+

73+float Screen::scale() const

74+{

75+ if (!m_wrapped) return 1.0;

76+ return m_wrapped->scale();

77+}

78+

79+QSizeF Screen::physicalSize() const

80+{

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

82+ return m_wrapped->physicalSize();

83+}

84+

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

86+{

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

88+ return m_wrapped->formFactor();

89+}

90+

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

92+{

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

94+ return m_wrapped->outputType();

95+}

96+

97+MirPowerMode Screen::powerMode() const

98+{

99+ if (!m_wrapped) return mir_power_mode_on;

100+ return m_wrapped->powerMode();

101+}

102+

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

104+{

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

106+ return m_wrapped->orientation();

107+}

108+

109+QPoint Screen::position() const

110+{

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

112+ return m_wrapped->position();

113+}

114+

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

116+{

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

118+ return m_wrapped->availableModes();

119+}

120+

121+uint Screen::currentModeIndex() const

122+{

123+ if (!m_wrapped) return -1;

124+ return m_wrapped->currentModeIndex();

125+}

126+

127+bool Screen::isActive() const

128+{

129+ if (!m_wrapped) return false;

130+ return m_wrapped->isActive();

131+}

132+

133+void Screen::activate()

134+{

135+ setActive(true);

136+}

137+

138+void Screen::setActive(bool active)

139+{

140+ if (!m_wrapped) return;

141+ m_wrapped->setActive(active);

142+}

143+

144+QScreen *Screen::qscreen() const

145+{

146+ if (!m_wrapped) return nullptr;

147+ return m_wrapped->qscreen();

148+}

149+

150+qtmir::ScreenConfiguration *Screen::beginConfiguration() const

151+{

152+ if (!m_wrapped) return nullptr;

153+ return m_wrapped->beginConfiguration();

154+}

155+

156+bool Screen::applyConfiguration(qtmir::ScreenConfiguration *configuration)

157+{

158+ if (!m_wrapped) return false;

159+ return m_wrapped->applyConfiguration(configuration);

160+}

161+

162+QString Screen::outputTypeName() const

163+{

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

165+ case qtmir::Unknown:

166+ return tr("Unknown");

167+ case qtmir::VGA:

168+ return tr("VGA");

169+ case qtmir::DVII:

170+ case qtmir::DVID:

171+ case qtmir::DVIA:

172+ return tr("DVI");

173+ case qtmir::Composite:

174+ return tr("Composite");

175+ case qtmir::SVideo:

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

177+ case qtmir::LVDS:

178+ case qtmir::NinePinDIN:

179+ case qtmir::EDP:

180+ return tr("Internal");

181+ case qtmir::Component:

182+ return tr("Component");

183+ case qtmir::DisplayPort:

184+ return tr("DisplayPort");

185+ case qtmir::HDMIA:

186+ case qtmir::HDMIB:

187+ return tr("HDMI");

188+ case qtmir::TV:

189+ return tr("TV");

190+ }

191+ return QString();

192+}

193+

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

195+{

196+ if (!proxy) return;

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

198+}

199+

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

201+ : m_workspaces(new WorkspaceModel)

202+{

203+ connectToScreen(wrapped);

204+

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

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

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

208+ if (active) {

209+ setCurrentWorkspace(workspace);

210+ activate();

211+ }

212+ });

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

214+ activate();

215+ setCurrentWorkspace(workspace);

216+ }

217+ if (!m_currentWorspace) {

218+ setCurrentWorkspace(workspace);

219+ }

220+ });

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

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

223+ if (workspace == m_currentWorspace) {

224+ resetCurrentWorkspace();

225+ }

226+ });

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

228+ if (active && m_currentWorspace) {

229+ m_currentWorspace->activate();

230+ }

231+ });

232+}

233+

234+void ConcreteScreen::resetCurrentWorkspace()

235+{

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

237+ if (m_currentWorspace != newCurrent) {

238+ m_currentWorspace = newCurrent;

239+ Q_EMIT currentWorkspaceChanged(newCurrent);

240+ }

241+}

242+

243+

244+WorkspaceModel *ConcreteScreen::workspaces() const

245+{

246+ return m_workspaces.data();

247+}

248+

249+Workspace *ConcreteScreen::currentWorkspace() const

250+{

251+ return m_currentWorspace.data();

252+}

253+

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

255+{

256+ if (m_currentWorspace != workspace) {

257+ m_currentWorspace = workspace;

258+ Q_EMIT currentWorkspaceChanged(workspace);

259+ }

260+}

261+

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

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

264+ , m_original(screen)

265+ , m_screens(screens)

266+{

267+ connectToScreen(screen);

268+

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

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

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

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

273+ if (m_currentWorspace != p) {

274+ m_currentWorspace = p;

275+ Q_EMIT currentWorkspaceChanged(p);

276+ }

277+ }

278+ }

279+ };

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

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

282+}

283+

284+WorkspaceModel *ProxyScreen::workspaces() const

285+{

286+ return m_workspaces.data();

287+}

288+

289+Workspace *ProxyScreen::currentWorkspace() const

290+{

291+ return m_currentWorspace.data();

292+}

293+

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

295+{

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

297+ if (p) {

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

299+ }

300+}

301+

302+bool ProxyScreen::isSyncing() const

303+{

304+ return m_screens->isSyncing();

305+}

plugins/WindowManager/Screen.hnew file+135

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

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+

13+class Screen: public QObject

14+{

15+ Q_OBJECT

16+

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

18+ Q_PROPERTY(bool used READ used NOTIFY usedChanged)

19+ Q_PROPERTY(QString name READ name NOTIFY nameChanged)

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

21+ Q_PROPERTY(float scale READ scale NOTIFY scaleChanged)

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

23+ Q_PROPERTY(MirPowerMode powerMode READ powerMode NOTIFY powerModeChanged)

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

25+ Q_PROPERTY(QPoint position READ position NOTIFY positionChanged)

26+ Q_PROPERTY(uint currentModeIndex READ currentModeIndex NOTIFY currentModeIndexChanged)

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

28+ Q_PROPERTY(QSizeF physicalSize READ physicalSize NOTIFY physicalSizeChanged)

29+ Q_PROPERTY(QString outputTypeName READ outputTypeName NOTIFY outputTypeChanged)

30+ Q_PROPERTY(WorkspaceModel* workspaces READ workspaces CONSTANT)

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

32+public:

33+ // From qtmir::Screen

34+ qtmir::OutputId outputId() const;

35+ bool used() const;

36+ QString name() const;

37+ float scale() const;

38+ QSizeF physicalSize() const;

39+ qtmir::FormFactor formFactor() const;

40+ qtmir::OutputTypes outputType() const;

41+ MirPowerMode powerMode() const;

42+ Qt::ScreenOrientation orientation() const;

43+ QPoint position() const;

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

45+ uint currentModeIndex() const;

46+ bool isActive() const;

47+ void setActive(bool active);

48+ QScreen* qscreen() const;

49+ QString outputTypeName() const;

50+

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

52+ bool applyConfiguration(qtmir::ScreenConfiguration *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+#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+245

@@ -0,0 +1,245 @@

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::indexOf(Screen *screen) const

71+{

72+ return m_screens.indexOf(screen);

73+}

74+

75+Screen *Screens::get(int index) const

76+{

77+ return m_screens.at(index);

78+}

79+

80+int Screens::count() const

81+{

82+ return m_screens.size();

83+}

84+

85+QVariant Screens::activeScreen() const

86+{

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

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

89+ }

90+ return QVariant();

91+}

92+

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

94+{

95+ bool ok = false;

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

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

98+

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

100+ screen->setActive(true);

101+}

102+

103+

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

105+ : Screens(model)

106+ , m_config(config)

107+{

108+ m_self = this;

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

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

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

112+

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

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

115+ m_config->load(screenWrapper);

116+

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

118+ m_screens.push_back(screenWrapper);

119+ }

120+}

121+

122+ConcreteScreens::~ConcreteScreens()

123+{

124+ Q_FOREACH(Screen* screen, m_screens) {

125+ m_config->save(screen);

126+ }

127+ delete m_config;

128+}

129+

130+ConcreteScreens *ConcreteScreens::self()

131+{

132+ return ConcreteScreens::m_self;

133+}

134+

135+ProxyScreens *ConcreteScreens::createProxy()

136+{

137+ return new ProxyScreens(this);

138+}

139+

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

141+{

142+ if (!proxy) return;

143+ proxy->setSyncing(true);

144+

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

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

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

148+ }

149+

150+ proxy->setSyncing(true);

151+}

152+

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

154+{

155+ Q_FOREACH(auto screenWrapper, m_screens) {

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

157+ }

158+

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

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

161+ m_config->load(screenWrapper);

162+

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

164+ m_screens.push_back(screenWrapper);

165+ endInsertRows();

166+ Q_EMIT screenAdded(screenWrapper);

167+ Q_EMIT countChanged();

168+}

169+

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

171+{

172+ int index = 0;

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

174+ while(iter.hasNext()) {

175+ auto screenWrapper = iter.next();

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

177+ m_config->save(screenWrapper);

178+

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

180+ iter.remove();

181+ endRemoveRows();

182+

183+ Q_EMIT screenRemoved(screenWrapper);

184+ Q_EMIT countChanged();

185+

186+ screenWrapper->deleteLater();

187+ break;

188+ }

189+ index++;

190+ }

191+}

192+

193+

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

195+ : Screens(screens->m_wrapped)

196+ , m_original(screens)

197+ , m_syncing(false)

198+{

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

200+ Q_FOREACH(auto screen, m_screens) {

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

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

203+ }

204+

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

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

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

208+ m_screens.push_back(screenWrapper);

209+ endInsertRows();

210+ Q_EMIT screenAdded(screenWrapper);

211+ Q_EMIT countChanged();

212+ });

213+

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

215+ int index = 0;

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

217+ while(iter.hasNext()) {

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

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

220+

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

222+ iter.remove();

223+ endRemoveRows();

224+

225+ Q_EMIT screenRemoved(proxy);

226+ Q_EMIT countChanged();

227+

228+ delete proxy;

229+ break;

230+ }

231+ index++;

232+ }

233+ });

234+

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

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

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

238+ m_screens.push_back(screenWrapper);

239+ }

240+}

241+

242+void ProxyScreens::setSyncing(bool syncing)

243+{

244+ m_syncing = syncing;

245+}

plugins/WindowManager/Screens.hnew file+114

@@ -0,0 +1,114 @@

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+ Q_INVOKABLE int indexOf(Screen*) const;

53+ Q_INVOKABLE Screen* get(int index) const;

54+

55+ int count() const;

56+ QVariant activeScreen() const;

57+

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

59+

60+public Q_SLOTS:

61+ void activateScreen(const QVariant& index);

62+

63+Q_SIGNALS:

64+ void countChanged();

65+ void activeScreenChanged();

66+

67+ void screenAdded(Screen* screen);

68+ void screenRemoved(Screen* screen);

69+

70+protected:

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

72+

73+ QVector<Screen*> m_screens;

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

75+

76+ friend class ProxyScreens;

77+};

78+

79+class ConcreteScreens : public Screens

80+{

81+ Q_OBJECT

82+public:

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

84+ ~ConcreteScreens();

85+

86+ Q_INVOKABLE ProxyScreens *createProxy();

87+ Q_INVOKABLE void sync(ProxyScreens *proxy);

88+

89+ static ConcreteScreens *self();

90+

91+protected Q_SLOTS:

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

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

94+

95+private:

96+ ScreensConfiguration* m_config;

97+

98+ static ConcreteScreens* m_self;

99+};

100+

101+class ProxyScreens : public Screens

102+{

103+public:

104+ explicit ProxyScreens(Screens*const screens);

105+

106+ void setSyncing(bool syncing);

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

108+

109+private:

110+ const QPointer<Screens> m_original;

111+ bool m_syncing;

112+};

113+

114+#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+56−2

@@ -17,19 +17,73 @@

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+ qmlRegisterSingletonType<WindowManagerObjects>(uri, 1, 0, "WindowManagerObjects", objectsSingleton);

31

68

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

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

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

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

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

33

73

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

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

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

76+

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

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

79+

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

81+}

82+

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

84+{

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

86+

87+ // Create Screens

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

35}

89}

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+ Q_INVOKABLE int indexOf(Workspace *workspace) const;

53+ Q_INVOKABLE 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+43−25

@@ -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,12 @@ 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 stage.temporarySelectedWorkspace ? stage.temporarySelectedWorkspace.windowModel : WMScreen.currentWorkspace.windowModel

103+ }

104+ onTopLevelSurfaceListChanged: print("********************** have new TLSL", topLevelSurfaceList)

105+

99 onMainAppChanged: {

106 onMainAppChanged: {

100 if (mainApp) {

107 if (mainApp) {

101 _onMainAppChanged(mainApp.appId);

108 _onMainAppChanged(mainApp.appId);

@@ -183,11 +190,12 @@ StyledItem {

183 }

190 }

184

191

185 function startApp(appId) {

192 function startApp(appId) {

193+ stage.closeSpread();

186− if (ApplicationManager.findApplication(appId)) {

194+ if (!ApplicationManager.findApplication(appId)) {

187− ApplicationManager.requestFocusApplication(appId);

188− } else {

189 ApplicationManager.startApplication(appId);

195 ApplicationManager.startApplication(appId);

190 }

196 }

197+ print("focusing", appId)

198+ ApplicationManager.requestFocusApplication(appId);

191 }

199 }

192

200

193 function startLockedApp(app) {

201 function startLockedApp(app) {

@@ -267,23 +275,17 @@ StyledItem {

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

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

268 }

276 }

269

277

278+ PanelState {

279+ id: panelState

280+ objectName: "panelState"

281+ }

282+

270 Item {

283 Item {

271 id: stages

284 id: stages

272 objectName: "stages"

285 objectName: "stages"

273 width: parent.width

286 width: parent.width

274 height: parent.height

287 height: parent.height

275

288

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 {

289 Stage {

288 id: stage

290 id: stage

289 objectName: "stage"

291 objectName: "stage"

@@ -294,7 +296,7 @@ StyledItem {

294 background: wallpaperResolver.background

296 background: wallpaperResolver.background

295

297

296 applicationManager: ApplicationManager

298 applicationManager: ApplicationManager

297− topLevelSurfaceList: topLevelSurfaceList

299+ topLevelSurfaceList: shell.topLevelSurfaceList

298 inputMethodRect: inputMethod.visibleRect

300 inputMethodRect: inputMethod.visibleRect

299 rightEdgePushProgress: rightEdgeBarrier.progress

301 rightEdgePushProgress: rightEdgeBarrier.progress

300 availableDesktopArea: availableDesktopAreaItem

302 availableDesktopArea: availableDesktopAreaItem

@@ -323,6 +325,7 @@ StyledItem {

323 altTabPressed: physicalKeysMapper.altTabPressed

325 altTabPressed: physicalKeysMapper.altTabPressed

324 oskEnabled: shell.oskEnabled

326 oskEnabled: shell.oskEnabled

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

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

328+ panelState: panelState

326

329

327 onSpreadShownChanged: {

330 onSpreadShownChanged: {

328 panel.indicators.hide();

331 panel.indicators.hide();

@@ -363,7 +366,7 @@ StyledItem {

363 InputMethod {

366 InputMethod {

364 id: inputMethod

367 id: inputMethod

365 objectName: "inputMethod"

368 objectName: "inputMethod"

366− surface: topLevelSurfaceList.inputMethodSurface

369+ surface: shell.topLevelSurfaceList.inputMethodSurface

367 anchors {

370 anchors {

368 fill: parent

371 fill: parent

369 topMargin: panel.panelHeight

372 topMargin: panel.panelHeight

@@ -377,8 +380,13 @@ StyledItem {

377 objectName: "greeterLoader"

380 objectName: "greeterLoader"

378 anchors.fill: parent

381 anchors.fill: parent

379 anchors.topMargin: panel.panelHeight

382 anchors.topMargin: panel.panelHeight

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

383+ sourceComponent: {

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

385+ if (screenWindow.primary) return integratedGreeter;

386+ return secondaryGreeter;

387+ }

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

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

389+ }

382 onLoaded: {

390 onLoaded: {

383 item.objectName = "greeter"

391 item.objectName = "greeter"

384 }

392 }

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

428 }

436 }

429 }

437 }

430

438

439+ Component {

440+ id: secondaryGreeter

441+ SecondaryGreeter {

442+ hides: [launcher, panel.indicators]

443+ }

444+ }

445+

431 Timer {

446 Timer {

432 // See powerConnection for why this is useful

447 // See powerConnection for why this is useful

433 id: showGreeterDelayed

448 id: showGreeterDelayed

@@ -538,13 +553,14 @@ StyledItem {

538 && !stage.spreadShown

553 && !stage.spreadShown

539 }

554 }

540

555

541− readonly property bool focusedSurfaceIsFullscreen: topLevelSurfaceList.focusedWindow

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

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

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

543 : false

558 : false

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

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

545 || greeter.hasLockedApp

560 || greeter.hasLockedApp

546 greeterShown: greeter && greeter.shown

561 greeterShown: greeter && greeter.shown

547 hasKeyboard: shell.hasKeyboard

562 hasKeyboard: shell.hasKeyboard

563+ panelState: panelState

548 }

564 }

549

565

550 Launcher {

566 Launcher {

@@ -793,11 +809,11 @@ StyledItem {

793 Cursor {

809 Cursor {

794 id: cursor

810 id: cursor

795 objectName: "cursor"

811 objectName: "cursor"

796− visible: shell.hasMouse

812+

797 z: itemGrabber.z + 1

813 z: itemGrabber.z + 1

798 topBoundaryOffset: panel.panelHeight

814 topBoundaryOffset: panel.panelHeight

799−

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

800− confiningItem: stage.itemConfiningMouseCursor

816+ visible: enabled

801

817

802 property bool mouseNeverMoved: true

818 property bool mouseNeverMoved: true

803 Binding {

819 Binding {

@@ -809,6 +825,8 @@ StyledItem {

809 when: cursor.mouseNeverMoved && cursor.visible

825 when: cursor.mouseNeverMoved && cursor.visible

810 }

826 }

811

827

828+ confiningItem: stage.itemConfiningMouseCursor

829+

812 height: units.gu(3)

830 height: units.gu(3)

813

831

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

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

@@ -872,7 +890,7 @@ StyledItem {

872

890

873 // non-visual objects

891 // non-visual objects

874 KeymapSwitcher {

892 KeymapSwitcher {

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

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

876 }

894 }

877 BrightnessControl {}

895 BrightnessControl {}

878

896

qml/ShellApplication.qmlnew file+60

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

1+/*

3+*

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

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

6+* the Free Software Foundation; version 3.

7+*

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

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

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

11+* GNU General Public License for more details.

12+*

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

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

15+*/

16+

17+import QtQuick 2.4

18+import QtQuick.Window 2.2

19+import WindowManager 1.0

20+import Unity.Application 0.1

21+

22+Instantiator {

23+ id: root

24+ model: Screens

25+

26+ ShellScreen {

27+ id: window

28+ objectName: "screen"+index

29+ screen: model.screen

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

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

32+

33+ Binding {

34+ when: applicationArguments.hasGeometry

35+ target: window

36+ property: "width"

37+ value: applicationArguments.windowGeometry.width

38+ }

39+ Binding {

40+ when: applicationArguments.hasGeometry

41+ target: window

42+ property: "height"

43+ value: applicationArguments.windowGeometry.height

44+ }

45+

46+ Component.onCompleted: screen.active = primary

47+ primary: index == 0

48+ }

49+

50+ property var windowManagerSurfaceManagerBinding: Binding {

51+ target: WindowManagerObjects

52+ property: "surfaceManager"

53+ value: SurfaceManager

54+ }

55+ property var windowManagerApplicationManagerBinding: Binding {

56+ target: WindowManagerObjects

57+ property: "applicationManager"

58+ value: ApplicationManager

59+ }

60+}

qml/ShellNotifier.qmlnew file+30

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+/*

18+ Shared signals & properties on multi-window desktop

19+ */

20+

21+pragma Singleton

22+import QtQuick 2.4

23+

24+QtObject {

25+ property var greeter: QtObject {

26+ signal hide(bool now)

27+

28+ property bool shown: true

29+ }

30+}

qml/ShellScreen.qmlnew file+64

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

1+/*

3+*

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

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

6+* the Free Software Foundation; version 3.

7+*

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

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

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

11+* GNU General Public License for more details.

12+*

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

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

15+*/

16+

17+import QtQuick 2.4

18+import Ubuntu.Components 1.3

19+import WindowManager 1.0

20+import Cursor 1.1

21+import "Components"

22+

23+ScreenWindow {

24+ id: screenWindow

25+

26+ color: "black"

27+ title: "Unity8 Shell"

28+ property bool primary: false

29+

30+ DeviceConfiguration {

31+ id: deviceConfiguration

32+ name: applicationArguments.deviceName

33+ }

34+

35+ Loader {

36+ id: loader

37+ width: screenWindow.width

38+ height: screenWindow.height

39+

40+ sourceComponent: {

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

42+ return disabledScreenComponent;

43+ }

44+ return shellComponent;

45+ }

46+ }

47+

48+ Component {

49+ id: shellComponent

50+ OrientedShell {

51+ implicitWidth: screenWindow.width

52+ implicitHeight: screenWindow.height

53+

54+ deviceConfiguration {

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

56+ }

57+ }

58+ }

59+

60+ Component {

61+ id: disabledScreenComponent

62+ DisabledScreenNotice {}

63+ }

64+}

qml/Stage/ApplicationWindow.qml+14−206

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

50 // transitions in stateGroup take place.

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

52 // other instructions.

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

53 if (surface) {

54 if (surface) {

54 surfaceContainer.surface = surface;

55 surfaceContainer.surface = surface;

55− d.liveSurface = surface.live;

56− d.hadSurface = false;

57 surfaceInitTimer.start();

56 surfaceInitTimer.start();

58 } else {

57 } else {

59− if (d.surfaceInitialized) {

60− d.hadSurface = true;

61− }

62 d.surfaceInitialized = false;

58 d.surfaceInitialized = false;

63 surfaceContainer.surface = null;

59 surfaceContainer.surface = null;

64 }

60 }

65 }

61 }

66

62

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

67 QtObject {

64 QtObject {

68 id: d

65 id: d

69

66

70− property bool liveSurface: false;

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

71− property var con: Connections {

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

72− target: root.surface

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

74− }

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

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

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

78− && applicationState !== ApplicationInfoInterface.Running

79− onNeedToTakeScreenshotChanged: {

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

81− screenshotImage.take();

82− }

83− }

84

69

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

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

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

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

@@ -131,34 +116,10 @@ FocusScope {

131 id: surfaceInitTimer

116 id: surfaceInitTimer

132 interval: 100

117 interval: 100

133 onTriggered: {

118 onTriggered: {

134− if (root.surface && root.surface.live) {d.surfaceInitialized = true;}

119+ if (root.surface && root.surface.live) {

135− }

120+ d.surfaceInitialized = true;

136− }

121+ d.hadSurface = true;

137−

138− Timer {

139− id: surfaceIsOldTimer

140− interval: 1000

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

142− }

143−

144− Image {

145− id: screenshotImage

146− objectName: "screenshotImage"

147− anchors.fill: parent

148− fillMode: Image.PreserveAspectCrop

149− horizontalAlignment: Image.AlignLeft

150− verticalAlignment: Image.AlignTop

151− antialiasing: !root.interactive

152− z: 1

153−

154− function take() {

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

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

157− surfaceContainer.grabToImage(

158− function(result) {

159− screenshotImage.source = result.url;

160− },

122+ }

161− Qt.size(root.width / 2, root.height / 2));

162 }

123 }

163 }

124 }

164

125

@@ -167,7 +128,7 @@ FocusScope {

167 visible: active

128 visible: active

168 active: false

129 active: false

169 anchors.fill: parent

130 anchors.fill: parent

170− z: screenshotImage.z + 1

131+ z: 1

171 sourceComponent: Component {

132 sourceComponent: Component {

172 Splash {

133 Splash {

173 id: splash

134 id: splash

@@ -238,167 +199,14 @@ FocusScope {

238 id: stateGroup

199 id: stateGroup

239 objectName: "applicationWindowStateGroup"

200 objectName: "applicationWindowStateGroup"

240 states: [

201 states: [

241− State {

202+ State{

242− name: "void"

243− when:

244− d.hadSurface && (!root.surface || !d.surfaceInitialized)

245− &&

246− screenshotImage.status !== Image.Ready

247− },

248− State {

249− name: "splashScreen"

250− when:

251− !d.hadSurface && (!root.surface || !d.surfaceInitialized)

252− &&

253− screenshotImage.status !== Image.Ready

254− },

255− State {

256 name: "surface"

203 name: "surface"

257− when:

258− (root.surface && d.surfaceInitialized)

204+ when: (root.surface && d.surfaceInitialized) || d.hadSurface

259− &&

260− (d.liveSurface ||

261− (d.applicationState !== ApplicationInfoInterface.Running

262− && screenshotImage.status !== Image.Ready))

263− PropertyChanges {

264− target: root

265− implicitWidth: surfaceContainer.implicitWidth

266− implicitHeight: surfaceContainer.implicitHeight

267− }

268− },

269− State {

270− name: "screenshot"

271− when:

272− screenshotImage.status === Image.Ready

273− &&

274− (d.applicationState !== ApplicationInfoInterface.Running

275− || !root.surface || !d.surfaceInitialized)

276 },

205 },

277 State {

206 State {

278− // This is a dead end. From here we expect the surface to be removed from the model

279− // shortly after we stop referencing to it in our SurfaceContainer.

280− name: "closed"

207+ name: "splash"

281− when:

282− // The surface died while the application is running. It must have been closed

283− // by the shell or the application decided to destroy it by itself

284− root.surface && d.surfaceInitialized && !d.liveSurface

208+ when: !root.surface && !d.surfaceInitialized && !d.hadSurface

285− && d.applicationState === ApplicationInfoInterface.Running

286− }

287− ]

288−

289− transitions: [

290− Transition {

291− from: ""; to: "splashScreen"

292− PropertyAction { target: splashLoader; property: "active"; value: true }

293− PropertyAction { target: surfaceContainer

294− property: "visible"; value: false }

295− },

296− Transition {

297− from: "splashScreen"; to: "surface"

298− SequentialAnimation {

299− PropertyAction { target: surfaceContainer

300− property: "opacity"; value: 0.0 }

301− PropertyAction { target: surfaceContainer

302− property: "visible"; value: true }

303− UbuntuNumberAnimation { target: surfaceContainer; property: "opacity";

304− from: 0.0; to: 1.0

305− duration: UbuntuAnimation.BriskDuration }

306− ScriptAction { script: {

307− splashLoader.active = false;

308− surfaceIsOldTimer.start();

309− } }

310− }

311− },

312− Transition {

313− from: "surface"; to: "splashScreen"

314− SequentialAnimation {

315− ScriptAction { script: {

316− surfaceIsOldTimer.stop();

317− d.surfaceOldEnoughToBeResized = false;

318− splashLoader.active = true;

319− surfaceContainer.visible = true;

320− } }

321− UbuntuNumberAnimation { target: splashLoader; property: "opacity";

322− from: 0.0; to: 1.0

323− duration: UbuntuAnimation.BriskDuration }

324− PropertyAction { target: surfaceContainer

325− property: "visible"; value: false }

326− }

327− },

328− Transition {

329− from: "surface"; to: "screenshot"

330− SequentialAnimation {

331− ScriptAction { script: {

332− surfaceIsOldTimer.stop();

333− d.surfaceOldEnoughToBeResized = false;

334− screenshotImage.visible = true;

335− } }

336− UbuntuNumberAnimation { target: screenshotImage; property: "opacity";

337− from: 0.0; to: 1.0

338− duration: UbuntuAnimation.BriskDuration }

339− ScriptAction { script: {

340− surfaceContainer.visible = false;

341− surfaceContainer.surface = null;

342− d.hadSurface = true;

343− } }

344− }

345− },

346− Transition {

347− from: "screenshot"; to: "surface"

348− SequentialAnimation {

349− PropertyAction { target: surfaceContainer

350− property: "visible"; value: true }

351− UbuntuNumberAnimation { target: screenshotImage; property: "opacity";

352− from: 1.0; to: 0.0

353− duration: UbuntuAnimation.BriskDuration }

354− ScriptAction { script: {

355− screenshotImage.visible = false;

356− screenshotImage.source = "";

357− surfaceIsOldTimer.start();

358− } }

359− }

360− },

361− Transition {

362− from: "splashScreen"; to: "screenshot"

363− SequentialAnimation {

364− PropertyAction { target: screenshotImage

365− property: "visible"; value: true }

366− UbuntuNumberAnimation { target: screenshotImage; property: "opacity";

367− from: 0.0; to: 1.0

368− duration: UbuntuAnimation.BriskDuration }

369− PropertyAction { target: splashLoader; property: "active"; value: false }

209+ PropertyChanges { target: splashLoader; active: true }

370− }

371− },

372− Transition {

373− from: "surface"; to: "void"

374− ScriptAction { script: {

375− surfaceIsOldTimer.stop();

376− d.surfaceOldEnoughToBeResized = false;

377− surfaceContainer.visible = false;

378− } }

379− },

380− Transition {

381− from: "void"; to: "surface"

382− SequentialAnimation {

383− PropertyAction { target: surfaceContainer; property: "opacity"; value: 0.0 }

384− PropertyAction { target: surfaceContainer; property: "visible"; value: true }

385− UbuntuNumberAnimation { target: surfaceContainer; property: "opacity";

386− from: 0.0; to: 1.0

387− duration: UbuntuAnimation.BriskDuration }

388− ScriptAction { script: {

389− surfaceIsOldTimer.start();

390− } }

391− }

392− },

393− Transition {

394− to: "closed"

395− SequentialAnimation {

396− ScriptAction { script: {

397− surfaceContainer.visible = false;

398− surfaceContainer.surface = null;

399− d.hadSurface = true;

400− } }

401− }

402 }

210 }

403 ]

211 ]

404 }

212 }

qml/Stage/DecoratedWindow.qml+13−11

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

@@ -125,15 +126,15 @@ FocusScope {

125 name: "preview"; when: root.scaleToPreviewProgress > 0

126 name: "preview"; when: root.scaleToPreviewProgress > 0

126 PropertyChanges {

127 PropertyChanges {

127 target: root

128 target: root

128− implicitWidth: MathUtils.linearAnimation(0, 1, applicationWindow.oldRequestedWidth, root.scaleToPreviewSize, root.scaleToPreviewProgress)

129+ implicitWidth: MathUtils.linearAnimation(0, 1, applicationWindow.requestedWidth, root.scaleToPreviewSize, root.scaleToPreviewProgress)

129− implicitHeight: MathUtils.linearAnimation(0, 1, applicationWindow.oldRequestedHeight, root.scaleToPreviewSize, root.scaleToPreviewProgress)

130+ implicitHeight: MathUtils.linearAnimation(0, 1, applicationWindow.requestedHeight, root.scaleToPreviewSize, root.scaleToPreviewProgress)

130 }

131 }

131 PropertyChanges {

132 PropertyChanges {

132 target: applicationWindow;

133 target: applicationWindow;

133− requestedWidth: applicationWindow.oldRequestedWidth

134+// requestedWidth: applicationWindow.oldRequestedWidth

134− requestedHeight: applicationWindow.oldRequestedHeight

135+// requestedHeight: applicationWindow.oldRequestedHeight

135− width: MathUtils.linearAnimation(0, 1, applicationWindow.oldRequestedWidth, applicationWindow.minSize, root.scaleToPreviewProgress)

136+ width: MathUtils.linearAnimation(0, 1, applicationWindow.requestedWidth, applicationWindow.minSize, root.scaleToPreviewProgress)

136− height: MathUtils.linearAnimation(0, 1, applicationWindow.oldRequestedHeight, applicationWindow.minSize, root.scaleToPreviewProgress)

137+ height: MathUtils.linearAnimation(0, 1, applicationWindow.requestedHeight, applicationWindow.minSize, root.scaleToPreviewProgress)

137 itemScale: root.implicitWidth / width

138 itemScale: root.implicitWidth / width

138 }

139 }

140 }

@@ -172,10 +173,10 @@ FocusScope {

172 height: implicitHeight

173 height: implicitHeight

173 requestedHeight: !counterRotate ? root.requestedHeight - d.requestedDecorationHeight : root.requestedWidth

174 requestedHeight: !counterRotate ? root.requestedHeight - d.requestedDecorationHeight : root.requestedWidth

174 requestedWidth: !counterRotate ? root.requestedWidth : root.requestedHeight - d.requestedDecorationHeight

175 requestedWidth: !counterRotate ? root.requestedWidth : root.requestedHeight - d.requestedDecorationHeight

175− property int oldRequestedWidth: requestedWidth

176+// property int oldRequestedWidth: requestedWidth

176− property int oldRequestedHeight: requestedHeight

177+// property int oldRequestedHeight: requestedHeight

177− onRequestedWidthChanged: oldRequestedWidth = requestedWidth

178+// onRequestedWidthChanged: oldRequestedWidth = requestedWidth

178− onRequestedHeightChanged: oldRequestedHeight = requestedHeight

179+// onRequestedHeightChanged: oldRequestedHeight = requestedHeight

179 focus: true

180 focus: true

180

181

181 property real itemScale: 1

182 property real itemScale: 1

@@ -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/Spread/ScreensAndWorkspaces.qmlnew file+222

@@ -0,0 +1,222 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Ubuntu.Components.Popups 1.3

4+import WindowManager 1.0

5+import Unity.Application 0.1

6+import ".."

7+

8+Item {

9+ id: root

10+

11+ property string background

12+

13+ property var screensProxy: Screens.createProxy();

14+

15+ property var lastClickedWorkspace: null

16+ property var activeWorkspace: null

17+ onActiveWorkspaceChanged: print("********************* active workspace changed:", activeWorkspace)

18+

19+ signal closeSpread();

20+

21+ Row {

22+ id: row

23+ anchors.bottom: parent.bottom

24+ anchors.horizontalCenter: parent.horizontalCenter

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

26+// anchors.left: parent.left

27+ spacing: units.gu(1)

28+

29+

30+ Repeater {

31+ model: screensProxy

32+

33+ delegate: Item {

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

35+ width: workspaces.width

36+

37+ UbuntuShape {

38+ id: header

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

40+ height: units.gu(7)

41+ backgroundColor: "white"

42+ z: 1

43+

44+ DropArea {

45+ anchors.fill: parent

46+ keys: ["workspace"]

47+

48+ onEntered: {

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

50+ drag.source.inDropArea = true;

51+ }

52+

53+ onExited: {

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

55+ drag.source.inDropArea = false;

56+ }

57+

58+ onDropped: {

59+ drag.source.inDropArea = false;

60+ }

61+ }

62+

63+ Column {

64+ anchors.fill: parent

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

66+

67+ Label {

68+ text: model.screen.name

69+ color: "black"

70+ }

71+

72+ Label {

73+ text: model.screen.outputTypeName

74+ color: "black"

75+ fontSize: "x-small"

76+ }

77+

78+ Label {

79+ text: screen.availableModes[screen.currentModeIndex].size.width + "x" + screen.availableModes[screen.currentModeIndex].size.height

80+ color: "black"

81+ fontSize: "x-small"

82+ }

83+ }

84+

85+ MouseArea {

86+ anchors.fill: parent

87+

88+ onClicked: {

89+ var obj = screensMenuComponent.createObject(header)

90+ obj.open(mouseX, mouseY)

91+ }

92+ }

93+

94+ Component {

95+ id: screensMenuComponent

96+ UbuntuShape {

97+ id: screensMenu

98+ width: units.gu(20)

99+ height: contentColumn.childrenRect.height

100+ backgroundColor: "white"

101+

102+ function open(mouseX, mouseY) {

103+ x = Math.max(0, Math.min(mouseX - width / 2, parent.width - width))

104+ y = mouseY + units.gu(1)

105+ }

106+

107+ InverseMouseArea {

108+ anchors.fill: parent

109+ onClicked: {

110+ screensMenu.destroy()

111+ }

112+ }

113+

114+ Column {

115+ id: contentColumn

116+ width: parent.width

117+ ListItem {

118+ height: layout.height

119+ highlightColor: "transparent"

120+ ListItemLayout {

121+ id: layout

122+ title.text: qsTr("Add workspace")

123+ title.color: "black"

124+ }

125+ onClicked: {

126+ screen.workspaces.addWorkspace();

127+ Screens.sync(root.screensProxy);

128+ screensMenu.destroy();

129+ }

130+ }

131+ }

132+ }

133+ }

134+ }

135+

136+ Workspaces {

137+ id: workspaces

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

139+ width: {

140+ var width = 0;

141+ if (screensProxy.count == 1) {

142+ width = Math.min(implicitWidth, root.width - units.gu(8));

143+ } else {

144+ width = Math.min(implicitWidth, model.screen.active ? root.width - units.gu(48) : units.gu(40))

145+ }

146+ return Math.max(workspaces.minimumWidth, width);

147+ }

148+

149+ Behavior on width { UbuntuNumberAnimation {} }

150+ anchors.bottom: parent.bottom

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

152+ anchors.horizontalCenter: parent.horizontalCenter

153+ screen: model.screen

154+ background: root.background

155+

156+ workspaceModel: model.screen.workspaces

157+ activeWorkspace: root.activeWorkspace

158+ readOnly: false

159+

160+ onCommitScreenSetup: Screens.sync(root.screensProxy)

161+ onCloseSpread: root.closeSpread();

162+

163+ onClicked: {

164+ root.lastClickedWorkspace = workspace;

165+ }

166+ }

167+ }

168+ }

169+ }

170+

171+ Rectangle {

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

173+ width: units.gu(5)

174+ color: "#33000000"

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

176+ MouseArea {

177+ id: leftScrollArea

178+ anchors.fill: parent

179+ hoverEnabled: true

180+ onPressed: mouse.accepted = false;

181+ }

182+ DropArea {

183+ id: leftFakeDropArea

184+ anchors.fill: parent

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

186+ }

187+ }

188+ Rectangle {

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

190+ width: units.gu(5)

191+ color: "#33000000"

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

193+ MouseArea {

194+ id: rightScrollArea

195+ anchors.fill: parent

196+ hoverEnabled: true

197+ onPressed: mouse.accepted = false;

198+ }

199+ DropArea {

200+ id: rightFakeDropArea

201+ anchors.fill: parent

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

203+ }

204+ }

205+ Timer {

206+ repeat: true

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

208+ interval: UbuntuAnimation.SlowDuration

209+ triggeredOnStart: true

210+ onTriggered: {

211+ var newOffset = row.anchors.horizontalCenterOffset;

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

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

214+ newOffset += units.gu(20)

215+ } else {

216+ newOffset -= units.gu(20)

217+ }

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

219+ row.anchors.horizontalCenterOffset = newOffset;

220+ }

221+ }

222+}

qml/Stage/Spread/Spread.qml+7−8

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

28 property var spreadFlickable

29

30 // some config options

31− property real contentMargin: 0.16 * root.height

31+ property real contentMargin: 0.1 * root.height

32− property real contentTopMargin: contentMargin

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

33− property real contentBottomMargin: 0.35 * contentMargin

33+ property real contentBottomMargin: contentMargin

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

34+ property real windowTitleTopMargin: contentMargin - windowTitle.height

35 property int stackItemCount: 3

36 property real leftRotationAngle: 22

37 property real rightRotationAngle: 32

@@ -52,7 +52,7 @@ Item {

52

53 readonly property real spreadWidth: rightStackXPos - leftStackXPos

54 readonly property real spreadHeight: root.height

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

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

56 readonly property real spreadItemWidth: stackHeight

57

58 readonly property real dynamicLeftRotationAngle: leftRotationAngle * rotationAngleFactor

@@ -92,10 +92,9 @@ Item {

92

93 readonly property real visibleItemCount: (spreadWidth / spreadItemWidth) / (1 - itemOverlap)

94

95− readonly property real spreadTotalWidth: Math.max(2,totalItemCount) * spreadWidth / visibleItemCount

95+ readonly property real spreadTotalWidth: totalItemCount * spreadWidth / visibleItemCount

96−

97− readonly property real centeringOffset: Math.max(spreadWidth - spreadTotalWidth ,0) / (2 * spreadWidth)

98

96

97+ readonly property real centeringOffset: Math.max(spreadWidth - spreadTotalWidth + (leftStackXPos - leftMargin) * 2, 0) / (2 * spreadWidth)

99

98

100 readonly property var curve: BezierCurve {

99 readonly property var curve: BezierCurve {

101 controlPoint2: {'x': 0.19, 'y': 0.00}

100 controlPoint2: {'x': 0.19, 'y': 0.00}

qml/Stage/Spread/SpreadDelegateInputArea.qml+36−17

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

28

29 readonly property alias distance: d.distance

30

31+ property var stage: null

32+ property var dragDelegate: null

33+

31 signal clicked()

34 signal clicked()

32 signal close()

35 signal close()

33

36

@@ -84,33 +87,27 @@ Item {

84 }

87 }

85 }

88 }

86

89

87− // Event eater

88− MouseArea {

89− anchors.fill: parent

90− onClicked: root.clicked()

91− onWheel: wheel.accepted = true

92− }

93−

94 MultiPointTouchArea {

90 MultiPointTouchArea {

95 anchors.fill: parent

91 anchors.fill: parent

96− mouseEnabled: false

97 maximumTouchPoints: 1

92 maximumTouchPoints: 1

98 property int offset: 0

93 property int offset: 0

99

94

95+ // tp.startY seems to be broken for mouse interaction... lets track it ourselves

96+ property int startY: 0

97+

100 touchPoints: [

98 touchPoints: [

101 TouchPoint {

99 TouchPoint {

102 id: tp

100 id: tp

103 }

101 }

104 ]

102 ]

105

103

106− onCanceled: {

104+ onPressed: {

107− d.moving = false

105+ startY = tp.y

108− animation.animate("center");

109 }

106 }

110

107

111 onTouchUpdated: {

108 onTouchUpdated: {

112− if (!d.moving) {

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

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

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

114 d.moving = true;

111 d.moving = true;

115 d.dragEvents = []

112 d.dragEvents = []

116 offset = tp.y - tp.startY;

113 offset = tp.y - tp.startY;

@@ -119,17 +116,32 @@ Item {

119 }

116 }

120 }

117 }

121

118

122− if (root.closeable) {

119+

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

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

121+ if (value < 0) {

122+ var coords = mapToItem(stage, tp.x, tp.y);

123+ dragDelegate.Drag.hotSpot.x = dragDelegate.width / 2

124+ dragDelegate.Drag.hotSpot.y = units.gu(2)

125+ dragDelegate.x = coords.x - dragDelegate.Drag.hotSpot.x

126+ dragDelegate.y = coords.y - dragDelegate.Drag.hotSpot.y

127+ dragDelegate.Drag.active = true;

128+ dragDelegate.surface = model.window.surface;

129+

124 } else {

130 } else {

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

131+ if (root.closeable) {

132+ d.distance = value

133+ } else {

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

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

135+ }

127 }

136 }

128

137

129 d.pushDragEvent(tp);

138 d.pushDragEvent(tp);

130 }

139 }

131

140

132 onReleased: {

141 onReleased: {

142+ var result = dragDelegate.Drag.drop();

143+ dragDelegate.surface = null;

144+

133 if (!d.moving) {

145 if (!d.moving) {

134 root.clicked()

146 root.clicked()

135 }

147 }

@@ -149,6 +161,13 @@ Item {

149 animation.animate("center")

161 animation.animate("center")

150 }

162 }

151 }

163 }

164+

165+ onCanceled: {

166+ dragDelegate.Drag.active = false;

167+ dragDelegate.surface = null;

168+ d.moving = false

169+ animation.animate("center");

170+ }

152 }

171 }

153

172

154 UbuntuNumberAnimation {

173 UbuntuNumberAnimation {

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

@@ -0,0 +1,275 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Unity.Application 0.1

4+import WindowManager 1.0

5+import ".."

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

7+

8+Item {

9+ id: previewSpace

10+ clip: true

11+

12+ property var workspace

13+

14+ property string background

15+ property int screenHeight

16+

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

18+

19+ property bool containsDragLeft: false

20+ property bool containsDragRight: false

21+ property bool isActive: false

22+ property bool isSelected: false

23+

24+ Image {

25+ source: previewSpace.background

26+ anchors.fill: parent

27+ sourceSize.width: width

28+ sourceSize.height: height

29+

30+ Repeater {

31+ id: topLevelSurfaceRepeater

32+ model: visible ? workspace.windowModel : null

33+ delegate: Item {

34+ width: surfaceItem.width

35+ height: surfaceItem.height + decorationHeight * previewScale

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

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

38+ z: topLevelSurfaceRepeater.count - index

39+ visible: model.window.state !== Mir.MinimizedState && model.window.state !== Mir.HiddenState

40+

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

42+

43+ WindowDecoration {

44+ width: surfaceItem.implicitWidth

45+ height: parent.decorationHeight

46+ transform: Scale {

47+ origin.x: 0

48+ origin.y: 0

49+ xScale: previewScale

50+ yScale: previewScale

51+ }

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

53+ z: 3

54+ }

55+

56+ MirSurfaceItem {

57+ id: surfaceItem

58+ y: parent.decorationHeight * previewScale

59+ width: implicitWidth * previewScale

60+ height: implicitHeight * previewScale

61+ surfaceWidth: -1

62+ surfaceHeight: -1

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

64+ surface: model.window.surface

65+ }

66+ }

67+ }

68+

69+ }

70+

71+ Rectangle {

72+ anchors.fill: parent

73+ border.color: UbuntuColors.ash

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

75+ color: "transparent"

76+ visible: previewSpace.isActive

77+ }

78+

79+ Rectangle {

80+ anchors.fill: parent

81+ border.color: UbuntuColors.blue

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

83+ color: "transparent"

84+ visible: previewSpace.isSelected

85+ }

86+

87+ Rectangle {

88+ anchors.fill: parent

89+ anchors.rightMargin: parent.width / 2

90+ color: "#55000000"

91+ visible: previewSpace.containsDragLeft

92+

93+ Column {

94+ anchors.centerIn: parent

95+ spacing: units.gu(1)

96+ Icon {

97+ source: "../graphics/multi-monitor_drop-here.png"

98+ height: units.gu(4)

99+ width: height

100+ anchors.horizontalCenter: parent.horizontalCenter

101+ }

102+ Label {

103+ text: qsTr("Drop here")

104+ }

105+ }

106+ }

107+

108+ Rectangle {

109+ anchors.fill: parent

110+ anchors.leftMargin: parent.width / 2

111+ color: "#55000000"

112+ visible: previewSpace.containsDragRight

113+

114+ Column {

115+ anchors.centerIn: parent

116+ spacing: units.gu(1)

117+ Icon {

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

119+ height: units.gu(4)

120+ width: height

121+ anchors.horizontalCenter: parent.horizontalCenter

122+ }

123+ Label {

124+ text: qsTr("Drop and go")

125+ }

126+ }

127+ }

128+}

129+

130+ // Repeater {

131+ // id: topLevelSurfaceRepeater

132+ // model: visible ? topLevelSurfaceList : null

133+ // delegate: Rectangle {

134+ // width: surfaceItem.width

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

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

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

138+ // color: "blue"

139+ // z: topLevelSurfaceRepeater.count - index

140+

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

142+

143+ // WindowDecoration {

144+ // width: surfaceItem.implicitWidth

145+ // height: parent.decorationHeight

146+ // transform: Scale {

147+ // origin.x: 0

148+ // origin.y: 0

149+ // xScale: previewScale

150+ // yScale: previewScale

151+ // }

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

153+ // z: 3

154+ // }

155+

156+ // MirSurfaceItem {

157+ // id: surfaceItem

158+ // y: parent.decorationHeight * previewScale

159+ // width: implicitWidth * previewScale

160+ // height: implicitHeight * previewScale

161+ // surfaceWidth: -1

162+ // surfaceHeight: -1

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

164+ // surface: model.window.surface

165+ // }

166+ // }

167+ // }

168+// }

169+// }

170+

171+

172+// MouseArea {

173+// id: mouseArea

174+// anchors.centerIn: parent

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

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

177+// height: width

178+// hoverEnabled: true

179+// opacity: containsMouse ? 1 : 0

180+

181+// Rectangle {

182+// anchors.fill: parent

183+// color: "#80000000"

184+// radius: height / 2

185+// }

186+

187+// NumberAnimation {

188+// target: canvas

189+// property: "progress"

190+// duration: 2000

191+// running: mouseArea.containsMouse

192+// from: 0

193+// to: 1

194+// }

195+

196+// Canvas {

197+// id: canvas

198+// height: parent.height

199+// width: height

200+// anchors.centerIn: parent

201+

202+// property real progress: 0.5

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

204+// onProgressChanged: {

205+// requestPaint();

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

207+// Screens.activateScreen(index);

208+// }

209+// }

210+

211+// rotation: -90

212+

213+// onPaint: {

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

215+// ctx.save();

216+// ctx.reset();

217+

218+// ctx.lineWidth = lineWidth;

219+

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

221+// ctx.beginPath();

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

223+// ctx.stroke();

224+// ctx.closePath();

225+

226+// ctx.strokeStyle = "white"

227+// ctx.beginPath();

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

229+// ctx.stroke();

230+// ctx.closePath();

231+

232+// ctx.restore();

233+// }

234+// }

235+

236+// Icon {

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

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

239+// width: height

240+// anchors.centerIn: parent

241+// }

242+// }

243+// }

244+

245+// FloatingFlickable {

246+// id: flickable

247+// anchors.fill: parent

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

249+// property real progress: contentX / contentWidth

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

251+// }

252+

253+// MouseArea {

254+// anchors.fill: parent

255+// hoverEnabled: true

256+// property int scrollAreaWidth: width / 3

257+

258+// onMouseXChanged: {

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

260+

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

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

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

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

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

266+// }

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

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

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

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

271+// }

272+// }

273+// }

274+// }

275+//}

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

@@ -0,0 +1,421 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import WindowManager 1.0

4+import "MathUtils.js" as MathUtils

5+import "../../Components"

6+

7+Item {

8+ id: root

9+ implicitWidth: listView.contentWidth

10+ readonly property int minimumWidth: {

11+ var count = Math.min(3, listView.count);

12+ return listView.itemWidth * count + listView.spacing * (count - 1)

13+ }

14+

15+ property QtObject screen: null

16+ property alias workspaceModel: listView.model

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

18+ property int selectedIndex: -1

19+ property bool readOnly: true

20+ property var activeWorkspace: null

21+

22+ signal commitScreenSetup();

23+ signal closeSpread();

24+ signal clicked(var workspace);

25+

26+ DropArea {

27+ anchors.fill: root

28+

29+ keys: ['workspace']

30+

31+ onEntered: {

32+ var index = listView.getDropIndex(drag);

33+ drag.source.workspace.assign(workspaceModel, index)

34+ drag.source.inDropArea = true;

35+ }

36+

37+ onPositionChanged: {

38+ var index = listView.getDropIndex(drag);

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

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

41+ listView.dropItemIndex = index;

42+ }

43+

44+ onExited: {

45+ drag.source.workspace.unassign()

46+ listView.dropItemIndex = -1;

47+ listView.hoveredWorkspaceIndex = -1;

48+ drag.source.inDropArea = false;

49+ }

50+

51+ onDropped: {

52+ drop.accept(Qt.MoveAction);

53+ listView.dropItemIndex = -1;

54+ drag.source.inDropArea = false;

55+ }

56+ }

57+ DropArea {

58+ anchors.fill: parent

59+ keys: ["application"]

60+

61+ onPositionChanged: {

62+ listView.progressiveScroll(drag.x)

63+ listView.updateDropProperties(drag)

64+ }

65+ onExited: {

66+ listView.hoveredWorkspaceIndex = -1

67+ }

68+ onDropped: {

69+ var surface = drag.source.surface;

70+ drag.source.surface = null;

71+ var workspace = listView.model.get(listView.hoveredWorkspaceIndex);

72+ WorkspaceManager.moveSurfaceToWorkspace(surface, workspace);

73+ drop.accept(Qt.MoveAction)

74+ if (listView.hoveredHalf == "right") {

75+ root.closeSpread();

76+ workspace.activate();

77+ }

78+ surface.activate();

79+ listView.hoveredWorkspaceIndex = -1

80+ }

81+ }

82+

83+ Item {

84+ // We need to clip the listview as it has left/right margins and it would

85+ // overlap with items next to it and eat mouse input. However, we can't

86+ // just clip at the actual bounds as the delegates have the close button

87+ // on hover which reaches a bit outside, so lets some margins for the clipping

88+ anchors.fill: parent

89+ anchors.margins: -units.gu(2)

90+ clip: true

91+

92+

93+ ListView {

94+ id: listView

95+ anchors {

96+ fill: parent

97+ topMargin: -parent.anchors.margins

98+ bottomMargin: -parent.anchors.margins

99+ leftMargin: -itemWidth - parent.anchors.margins

100+ rightMargin: -itemWidth - parent.anchors.margins

101+ }

102+ boundsBehavior: Flickable.StopAtBounds

103+

104+ Behavior on contentX {

105+ SmoothedAnimation { duration: 200 }

106+ }

107+

108+ property var clickedWorkspace: null

109+

110+ orientation: ListView.Horizontal

111+ spacing: units.gu(1)

112+ leftMargin: itemWidth

113+ rightMargin: itemWidth

114+

115+ Connections {

116+ target: screen

117+ onAvailableModesChanged: {

118+ print("blabla", screen.availableModes[screen.currentModeIndex].size.width, screen.availableModes[screen.currentModeIndex].size.height)

119+ }

120+ }

121+

122+ property int screenWidth: screen.availableModes[screen.currentModeIndex].size.width

123+ property int screenHeight: screen.availableModes[screen.currentModeIndex].size.height

124+ property int itemWidth: height * screenWidth / screenHeight

125+ property int foldingAreaWidth: itemWidth / 2

126+ property int maxAngle: 40

127+

128+ property real realContentX: contentX - originX + leftMargin

129+ property int dropItemIndex: -1

130+ property int hoveredWorkspaceIndex: -1

131+ property string hoveredHalf: "" // left or right

132+

133+ function getDropIndex(drag) {

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

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

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

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

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

139+ return index;

140+ }

141+

142+ function updateDropProperties(drag) {

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

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

145+ if (index < 0) {

146+ listView.hoveredWorkspaceIndex = -1;

147+ listView.hoveredHalf = "";

148+ return;

149+ }

150+

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

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

153+ listView.hoveredWorkspaceIndex = index;

154+ print("updating drag:", (drag.x + listView.realContentX) % (listView.itemWidth + listView.spacing))

155+ var pixelsInTile = (drag.x + listView.realContentX) % (listView.itemWidth + listView.spacing);

156+ listView.hoveredHalf = (pixelsInTile / listView.itemWidth) < .5 ? "left" : "right";

157+ }

158+

159+ function progressiveScroll(mouseX) {

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

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

162+ }

163+

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

165+

166+ delegate: Item {

167+ id: workspaceDelegate

168+ objectName: "delegate" + index

169+ height: parent.height

170+ width: listView.itemWidth

171+ Behavior on width { UbuntuNumberAnimation {} }

172+ visible: listView.dropItemIndex !== index

173+

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

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

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

177+

178+ property int itemAngle: {

179+ if (index == 0) {

180+ if (distanceFromLeft < 0) {

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

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

183+ }

184+ return 0

185+ }

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

187+ if (distanceFromRight < 0) {

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

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

190+ }

191+ return 0

192+ }

193+

194+ if (distanceFromLeft < listView.foldingAreaWidth) {

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

196+ var progress = distanceFromLeft / listView.foldingAreaWidth

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

198+ }

199+ if (distanceFromRight < listView.foldingAreaWidth) {

200+ var progress = distanceFromRight / listView.foldingAreaWidth

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

202+ }

203+ return 0

204+ }

205+

206+ property int itemOffset: {

207+ if (index == 0) {

208+ if (distanceFromLeft < 0) {

209+ return -distanceFromLeft

210+ }

211+ return 0

212+ }

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

214+ if (distanceFromRight < 0) {

215+ return distanceFromRight

216+ }

217+ return 0

218+ }

219+

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

221+ return -itemX

222+ }

223+ if (distanceFromLeft < listView.foldingAreaWidth) {

224+ return (listView.foldingAreaWidth - distanceFromLeft) / 2

225+ }

226+

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

228+ return distanceFromRight

229+ }

230+

231+ if (distanceFromRight < listView.foldingAreaWidth) {

232+ return -(listView.foldingAreaWidth - distanceFromRight) / 2

233+ }

234+

235+ return 0

236+ }

237+

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

239+

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

241+ transform: [

242+ Rotation {

243+ angle: itemAngle

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

245+ origin { x: itemAngle < 0 ? listView.itemWidth : 0; y: height / 2 }

246+ },

247+ Translate {

248+ x: itemOffset

249+ }

250+ ]

251+

252+ WorkspacePreview {

253+ id: workspacePreview

254+ height: listView.height

255+ width: listView.itemWidth

256+ background: root.background

257+ screenHeight: listView.screenHeight

258+ containsDragLeft: listView.hoveredWorkspaceIndex == index && listView.hoveredHalf == "left"

259+ containsDragRight: listView.hoveredWorkspaceIndex == index && listView.hoveredHalf == "right"

260+ isActive: workspace == root.activeWorkspace

261+ isSelected: index === root.selectedIndex

262+ workspace: model.workspace

263+ }

264+ MouseArea {

265+ anchors.fill: parent

266+ onClicked: {

267+ root.clicked(model.workspace)

268+ }

269+ onDoubleClicked: {

270+ model.workspace.activate();

271+ root.closeSpread();

272+ }

273+ }

274+

275+ MouseArea {

276+ id: closeMouseArea

277+ objectName: "closeMouseArea"

278+ anchors { left: parent.left; top: parent.top; leftMargin: -height / 2; topMargin: -height / 2 }

279+ hoverEnabled: true

280+ height: units.gu(4)

281+ width: height

282+ visible: !root.readOnly && listView.count > 1

283+

284+ onClicked: {

285+ model.workspace.unassign();

286+ root.commitScreenSetup();

287+ }

288+ Image {

289+ id: closeImage

290+ source: "../graphics/window-close.svg"

291+ anchors.fill: closeMouseArea

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

293+ sourceSize.width: width

294+ sourceSize.height: height

295+ readonly property var mousePos: hoverMouseArea.mapToItem(workspaceDelegate, hoverMouseArea.mouseX, hoverMouseArea.mouseY)

296+ readonly property bool shown: (hoverMouseArea.containsMouse || parent.containsMouse)

297+ && mousePos.y < workspaceDelegate.width / 4

298+ && mousePos.y > -units.gu(2)

299+ && mousePos.x > -units.gu(2)

300+ && mousePos.x < workspaceDelegate.height / 4

301+ opacity: shown ? 1 : 0

302+ visible: opacity > 0

303+ Behavior on opacity { UbuntuNumberAnimation { duration: UbuntuAnimation.SnapDuration } }

304+

305+ }

306+ }

307+ }

308+

309+ MouseArea {

310+ id: hoverMouseArea

311+ anchors.fill: parent

312+ hoverEnabled: true

313+ propagateComposedEvents: true

314+ anchors.leftMargin: listView.leftMargin

315+ anchors.rightMargin: listView.rightMargin

316+ enabled: !root.readOnly

317+

318+ property int draggedIndex: -1

319+

320+ property int startX: 0

321+ property int startY: 0

322+

323+ onMouseXChanged: {

324+ if (!pressed || dragging) {

325+ listView.progressiveScroll(mouseX)

326+ }

327+ }

328+ onMouseYChanged: {

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

330+ drag.axis = Drag.XAndYAxis;

331+ }

332+ }

333+

334+ onReleased: {

335+ var result = fakeDragItem.Drag.drop();

336+ // if (result == Qt.IgnoreAction) {

337+ // WorkspaceManager.destroyWorkspace(fakeDragItem.workspace);

338+ // }

339+ root.commitScreenSetup();

340+ drag.target = null;

341+ }

342+

343+ property bool dragging: drag.active

344+ onDraggingChanged: {

345+ if (drag.active) {

346+ print("drai", draggedIndex)

347+ var ws = listView.model.get(draggedIndex);

348+ print("ws:", ws)

349+ ws.unassign();

350+ // listView.model.remove(draggedIndex, 1)

351+ }

352+ }

353+

354+ onPressed: {

355+ startX = mouseX;

356+ startY = mouseY;

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

358+

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

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

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

362+

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

364+ fakeDragItem.x = itemCoords.x

365+ fakeDragItem.y = itemCoords.y

366+ fakeDragItem.workspace = listView.model.get(draggedIndex)

367+

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

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

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

371+

372+ drag.axis = Drag.YAxis;

373+ drag.target = fakeDragItem;

374+ }

375+

376+ WorkspacePreview {

377+ id: fakeDragItem

378+ height: listView.height

379+ width: listView.itemWidth

380+ background: root.background

381+ screenHeight: screen.availableModes[screen.currentModeIndex].size.height

382+ visible: Drag.active

383+

384+ Drag.active: hoverMouseArea.drag.active

385+ Drag.keys: ['workspace']

386+

387+ property bool inDropArea: false

388+

389+ Rectangle {

390+ anchors.fill: parent

391+ color: "#33000000"

392+ opacity: parent.inDropArea ? 0 : 1

393+ Behavior on opacity { UbuntuNumberAnimation { } }

394+ Rectangle {

395+ anchors.centerIn: parent

396+ width: units.gu(6)

397+ height: units.gu(6)

398+ radius: width / 2

399+ color: "#aa000000"

400+ }

401+

402+ Icon {

403+ height: units.gu(3)

404+ width: height

405+ anchors.centerIn: parent

406+ name: "edit-delete"

407+ color: "white"

408+ }

409+ }

410+

411+ states: [

412+ State {

413+ when: fakeDragItem.Drag.active

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

415+ }

416+ ]

417+ }

418+ }

419+ }

420+ }

421+}

qml/Stage/Stage.qml+203−106

@@ -48,6 +48,9 @@ FocusScope {

48 property rect inputMethodRect

49 property real rightEdgePushProgress: 0

50 property Item availableDesktopArea

51+ property PanelState panelState

52+

53+ readonly property var temporarySelectedWorkspace: state == "spread" ? screensAndWorkspaces.lastClickedWorkspace : null

51

54

52 // Configuration

55 // Configuration

53 property string mode: "staged"

56 property string mode: "staged"

@@ -243,6 +246,25 @@ FocusScope {

243 }

246 }

244 }

247 }

245

248

249+ GlobalShortcut {

250+ id: showWorkspaceSwitcherShortcutLeft

251+ shortcut: Qt.AltModifier|Qt.ControlModifier|Qt.Key_Left

252+ active: !workspaceSwitcher.active

253+ onTriggered: {

254+ root.focus = true;

255+ workspaceSwitcher.showLeft()

256+ }

257+ }

258+ GlobalShortcut {

259+ id: showWorkspaceSwitcherShortcutRight

260+ shortcut: Qt.AltModifier|Qt.ControlModifier|Qt.Key_Right

261+ active: !workspaceSwitcher.active

262+ onTriggered: {

263+ root.focus = true;

264+ workspaceSwitcher.showRight()

265+ }

266+ }

267+

246 QtObject {

268 QtObject {

247 id: priv

269 id: priv

248 objectName: "DesktopStagePrivate"

270 objectName: "DesktopStagePrivate"

@@ -378,23 +400,23 @@ FocusScope {

378 readonly property real windowDecorationHeight: units.gu(3)

400 readonly property real windowDecorationHeight: units.gu(3)

379 }

401 }

380

402

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

403+ Component.onCompleted: priv.updateMainAndSideStageIndexes()

382

404

383 Connections {

405 Connections {

384− target: PanelState

406+ target: panelState

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

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

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

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

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

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

388 }

410 }

389

411

390 Binding {

412 Binding {

391− target: PanelState

413+ target: panelState

392 property: "decorationsVisible"

414 property: "decorationsVisible"

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

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

394 }

416 }

395

417

396 Binding {

418 Binding {

397− target: PanelState

419+ target: panelState

398 property: "title"

420 property: "title"

399 value: {

421 value: {

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

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

@@ -409,7 +431,7 @@ FocusScope {

409 }

431 }

410

432

411 Binding {

433 Binding {

412− target: PanelState

434+ target: panelState

413 property: "focusedPersistentSurfaceId"

435 property: "focusedPersistentSurfaceId"

414 value: {

436 value: {

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

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

@@ -423,21 +445,21 @@ FocusScope {

423 }

445 }

424

446

425 Binding {

447 Binding {

426− target: PanelState

448+ target: panelState

427 property: "dropShadow"

449 property: "dropShadow"

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

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

429 }

451 }

430

452

431 Binding {

453 Binding {

432− target: PanelState

454+ target: panelState

433 property: "closeButtonShown"

455 property: "closeButtonShown"

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

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

435 }

457 }

436

458

437 Component.onDestruction: {

459 Component.onDestruction: {

438− PanelState.title = "";

460+ panelState.title = "";

439− PanelState.decorationsVisible = false;

461+ panelState.decorationsVisible = false;

440− PanelState.dropShadow = false;

462+ panelState.dropShadow = false;

441 }

463 }

442

464

443 Instantiator {

465 Instantiator {

@@ -483,6 +505,7 @@ FocusScope {

483 PropertyChanges { target: cancelSpreadMouseArea; enabled: true }

505 PropertyChanges { target: cancelSpreadMouseArea; enabled: true }

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

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

485 PropertyChanges { target: wallpaper; visible: false }

507 PropertyChanges { target: wallpaper; visible: false }

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

486 },

509 },

487 State {

510 State {

488 name: "stagedRightEdge"; when: root.spreadEnabled && (rightEdgeDragArea.dragging || rightEdgePushProgress > 0) && root.mode == "staged"

511 name: "stagedRightEdge"; when: root.spreadEnabled && (rightEdgeDragArea.dragging || rightEdgePushProgress > 0) && root.mode == "staged"

@@ -530,11 +553,18 @@ FocusScope {

530 Transition {

553 Transition {

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

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

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

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

556+ PropertyAction { target: screensAndWorkspaces; property: "activeWorkspace"; value: WMScreen.currentWorkspace }

557+ ScriptAction { script: { print("blabal***********************", WMScreen.currentWorkspace) } }

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

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

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

534 },

560 },

535 Transition {

561 Transition {

536 to: "spread"

562 to: "spread"

563+ PropertyAction { target: screensAndWorkspaces; property: "activeWorkspace"; value: WMScreen.currentWorkspace }

564+ ScriptAction { script: { print("blabal***********************", WMScreen.currentWorkspace) } }

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

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

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

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

538 },

568 },

539 Transition {

569 Transition {

540 from: "spread"

570 from: "spread"

@@ -550,6 +580,7 @@ FocusScope {

550 }

580 }

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

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

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

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

583+ PropertyAction { target: screensAndWorkspaces; property: "lastClickedWorkspace"; value: null }

553 }

584 }

554 },

585 },

555 Transition {

586 Transition {

@@ -592,10 +623,21 @@ FocusScope {

592 visible: false

623 visible: false

593 }

624 }

594

625

626+ ScreensAndWorkspaces {

627+ id: screensAndWorkspaces

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

629+ height: Math.max(units.gu(30), parent.height * .3)

630+ background: root.background

631+ opacity: 0

632+ visible: opacity > 0

633+ onCloseSpread: priv.goneToSpread = false;

634+ onLastClickedWorkspaceChanged: activeWorkspace = lastClickedWorkspace

635+ }

636+

595 Spread {

637 Spread {

596 id: spreadItem

638 id: spreadItem

597 objectName: "spreadItem"

639 objectName: "spreadItem"

598− anchors.fill: appContainer

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

599 leftMargin: root.availableDesktopArea.x

641 leftMargin: root.availableDesktopArea.x

600 model: root.topLevelSurfaceList

642 model: root.topLevelSurfaceList

601 spreadFlickable: floatingFlickable

643 spreadFlickable: floatingFlickable

@@ -610,6 +652,83 @@ FocusScope {

610 appRepeater.itemAt(highlightedIndex).close();

652 appRepeater.itemAt(highlightedIndex).close();

611 }

653 }

612 }

654 }

655+

656+ FloatingFlickable {

657+ id: floatingFlickable

658+ objectName: "spreadFlickable"

659+ anchors.fill: parent

660+ enabled: false

661+ contentWidth: spreadItem.spreadTotalWidth

662+

663+ function snap(toIndex) {

664+ var delegate = appRepeater.itemAt(toIndex)

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

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

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

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

669+ snapAnimation.start();

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

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

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

673+ snapAnimation.start();

674+ }

675+ }

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

677+ }

678+

679+ MouseArea {

680+ id: hoverMouseArea

681+ objectName: "hoverMouseArea"

682+ anchors.fill: parent

683+ propagateComposedEvents: true

684+ hoverEnabled: true

685+ enabled: false

686+ visible: enabled

687+

688+ property int scrollAreaWidth: width / 3

689+ property bool progressiveScrollingEnabled: false

690+

691+ onPressed: mouse.accepted = false

692+

693+ onMouseXChanged: {

694+ mouse.accepted = false

695+

696+ if (hoverMouseArea.pressed) {

697+ return;

698+ }

699+

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

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

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

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

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

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

706+ spreadItem.highlightedIndex = i;

707+ break;

708+ }

709+ }

710+

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

712+ var margins = floatingFlickable.width * 0.05;

713+

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

715+ progressiveScrollingEnabled = true

716+ }

717+

718+ // do we need to scroll?

719+ if (mouseX < scrollAreaWidth + margins) {

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

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

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

723+ }

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

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

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

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

728+ }

729+ }

730+ }

731+ }

613 }

732 }

614

733

615 Connections {

734 Connections {

@@ -704,6 +823,24 @@ FocusScope {

704 }

823 }

705 }

824 }

706

825

826+ MirSurfaceItem {

827+ id: fakeDragItem

828+ property real previewScale: .5

829+ height: (screensAndWorkspaces.height - units.gu(8)) / 2

830+ // w : h = iw : ih

831+ width: implicitWidth * height / implicitHeight

832+ surfaceWidth: -1

833+ surfaceHeight: -1

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

835+ Behavior on opacity { UbuntuNumberAnimation {} }

836+ visible: opacity > 0

837+

838+ Drag.active: surface != null

839+ Drag.keys: ["application"]

840+

841+ z: 1000

842+ }

843+

707 Repeater {

844 Repeater {

708 id: appRepeater

845 id: appRepeater

709 model: topLevelSurfaceList

846 model: topLevelSurfaceList

@@ -732,6 +869,9 @@ FocusScope {

732 }

869 }

733 z: normalZ

870 z: normalZ

734

871

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

873+ Behavior on opacity { UbuntuNumberAnimation {} }

874+

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

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

736 // match what the actual surface size is.

876 // match what the actual surface size is.

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

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

@@ -912,7 +1052,6 @@ FocusScope {

912 function claimFocus() {

1052 function claimFocus() {

913 if (root.state == "spread") {

1053 if (root.state == "spread") {

914 spreadItem.highlightedIndex = index

1054 spreadItem.highlightedIndex = index

915− priv.goneToSpread = false;

916 }

1055 }

917 if (root.mode == "stagedWithSideStage") {

1056 if (root.mode == "stagedWithSideStage") {

918 if (appDelegate.stage == ApplicationInfoInterface.SideStage && !sideStage.shown) {

1057 if (appDelegate.stage == ApplicationInfoInterface.SideStage && !sideStage.shown) {

@@ -1246,8 +1385,6 @@ FocusScope {

1246 y: spreadMaths.targetY

1385 y: spreadMaths.targetY

1247 z: index

1386 z: index

1248 height: spreadItem.spreadItemHeight

1387 height: spreadItem.spreadItemHeight

1249− requestedWidth: decoratedWindow.oldRequestedWidth

1250− requestedHeight: decoratedWindow.oldRequestedHeight

1251 visible: spreadMaths.itemVisible

1388 visible: spreadMaths.itemVisible

1252 }

1389 }

1253 PropertyChanges { target: dragArea; enabled: true }

1390 PropertyChanges { target: dragArea; enabled: true }

@@ -1267,8 +1404,6 @@ FocusScope {

1267 y: stagedRightEdgeMaths.animatedY

1404 y: stagedRightEdgeMaths.animatedY

1268 z: stagedRightEdgeMaths.animatedZ

1405 z: stagedRightEdgeMaths.animatedZ

1269 height: stagedRightEdgeMaths.animatedHeight

1406 height: stagedRightEdgeMaths.animatedHeight

1270− requestedWidth: decoratedWindow.oldRequestedWidth

1271− requestedHeight: decoratedWindow.oldRequestedHeight

1272 visible: appDelegate.x < root.width

1407 visible: appDelegate.x < root.width

1273 }

1408 }

1274 PropertyChanges {

1409 PropertyChanges {

@@ -1298,8 +1433,6 @@ FocusScope {

1298 y: windowedRightEdgeMaths.animatedY

1433 y: windowedRightEdgeMaths.animatedY

1299 z: windowedRightEdgeMaths.animatedZ

1434 z: windowedRightEdgeMaths.animatedZ

1300 height: stagedRightEdgeMaths.animatedHeight

1435 height: stagedRightEdgeMaths.animatedHeight

1301− requestedWidth: decoratedWindow.oldRequestedWidth

1302− requestedHeight: decoratedWindow.oldRequestedHeight

1303 }

1436 }

1304 PropertyChanges {

1437 PropertyChanges {

1305 target: decoratedWindow

1438 target: decoratedWindow

@@ -1322,11 +1455,15 @@ FocusScope {

1322 target: appDelegate

1455 target: appDelegate

1323 x: stageMaths.itemX

1456 x: stageMaths.itemX

1324 y: root.availableDesktopArea.y

1457 y: root.availableDesktopArea.y

1325− requestedWidth: appContainer.width

1326− requestedHeight: root.availableDesktopArea.height

1327 visuallyMaximized: true

1458 visuallyMaximized: true

1328 visible: appDelegate.x < root.width

1459 visible: appDelegate.x < root.width

1329 }

1460 }

1461+ PropertyChanges {

1462+ target: appDelegate

1463+ requestedWidth: appContainer.width

1464+ requestedHeight: root.availableDesktopArea.height

1465+ restoreEntryValues: false

1466+ }

1330 PropertyChanges {

1467 PropertyChanges {

1331 target: decoratedWindow

1468 target: decoratedWindow

1332 hasDecoration: false

1469 hasDecoration: false

@@ -1355,11 +1492,15 @@ FocusScope {

1355 x: stageMaths.itemX

1492 x: stageMaths.itemX

1356 y: root.availableDesktopArea.y

1493 y: root.availableDesktopArea.y

1357 z: stageMaths.itemZ

1494 z: stageMaths.itemZ

1358− requestedWidth: stageMaths.itemWidth

1359− requestedHeight: root.availableDesktopArea.height

1360 visuallyMaximized: true

1495 visuallyMaximized: true

1361 visible: appDelegate.x < root.width

1496 visible: appDelegate.x < root.width

1362 }

1497 }

1498+ PropertyChanges {

1499+ target: appDelegate

1500+ requestedWidth: stageMaths.itemWidth

1501+ requestedHeight: root.availableDesktopArea.height

1502+ restoreEntryValues: false

1503+ }

1363 PropertyChanges {

1504 PropertyChanges {

1364 target: decoratedWindow

1505 target: decoratedWindow

1365 hasDecoration: false

1506 hasDecoration: false

@@ -1381,8 +1522,12 @@ FocusScope {

1381 requestedY: 0;

1522 requestedY: 0;

1382 visuallyMinimized: false;

1523 visuallyMinimized: false;

1383 visuallyMaximized: true

1524 visuallyMaximized: true

1525+ }

1526+ PropertyChanges {

1527+ target: appDelegate

1384 requestedWidth: root.availableDesktopArea.width;

1528 requestedWidth: root.availableDesktopArea.width;

1385 requestedHeight: appContainer.height;

1529 requestedHeight: appContainer.height;

1530+ restoreEntryValues: false

1386 }

1531 }

1387 PropertyChanges { target: touchControls; enabled: true }

1532 PropertyChanges { target: touchControls; enabled: true }

1388 },

1533 },

@@ -1392,8 +1537,12 @@ FocusScope {

1392 target: appDelegate;

1537 target: appDelegate;

1393 requestedX: 0

1538 requestedX: 0

1394 requestedY: 0

1539 requestedY: 0

1540+ }

1541+ PropertyChanges {

1542+ target: appDelegate

1395− requestedWidth: appContainer.width;

1543+ requestedWidth: appContainer.width

1396− requestedHeight: appContainer.height;

1544+ requestedHeight: appContainer.height

1545+ restoreEntryValues: false

1397 }

1546 }

1398 PropertyChanges { target: decoratedWindow; hasDecoration: false }

1547 PropertyChanges { target: decoratedWindow; hasDecoration: false }

1399 },

1548 },

@@ -1408,6 +1557,12 @@ FocusScope {

1408 PropertyChanges { target: touchControls; enabled: true }

1557 PropertyChanges { target: touchControls; enabled: true }

1409 PropertyChanges { target: resizeArea; enabled: true }

1558 PropertyChanges { target: resizeArea; enabled: true }

1410 PropertyChanges { target: decoratedWindow; shadowOpacity: .3}

1559 PropertyChanges { target: decoratedWindow; shadowOpacity: .3}

1560+ PropertyChanges {

1561+ target: appDelegate

1562+ requestedWidth: windowedWidth

1563+ requestedHeight: windowedHeight

1564+ restoreEntryValues: false

1565+ }

1411 },

1566 },

1412 State {

1567 State {

1413 name: "restored";

1568 name: "restored";

@@ -1508,6 +1663,10 @@ FocusScope {

1508 }

1663 }

1509 }

1664 }

1510 ]

1665 ]

1666+ onStateChanged: {

1667+ print("item", index, "state changed", state)

1668+ }

1669+

1511 transitions: [

1670 transitions: [

1512 Transition {

1671 Transition {

1513 from: "staged,stagedWithSideStage"

1672 from: "staged,stagedWithSideStage"

@@ -1521,6 +1680,7 @@ FocusScope {

1521 UbuntuNumberAnimation { target: appDelegate; properties: "x,y,requestedX,requestedY,requestedWidth,requestedHeight"; duration: priv.animationDuration}

1680 UbuntuNumberAnimation { target: appDelegate; properties: "x,y,requestedX,requestedY,requestedWidth,requestedHeight"; duration: priv.animationDuration}

1522 },

1681 },

1523 Transition {

1682 Transition {

1683+ from: "normal,restored,maximized,maximizedHorizontally,maximizedVertically,maximizedLeft,maximizedRight,maximizedTopLeft,maximizedBottomLeft,maximizedTopRight,maximizedBottomRight,staged,stagedWithSideStage,windowedRightEdge,stagedRightEdge";

1524 to: "spread"

1684 to: "spread"

1525 // DecoratedWindow wants the scaleToPreviewSize set before enabling scaleToPreview

1685 // DecoratedWindow wants the scaleToPreviewSize set before enabling scaleToPreview

1526 PropertyAction { target: appDelegate; properties: "z,visible" }

1686 PropertyAction { target: appDelegate; properties: "z,visible" }

@@ -1606,7 +1766,7 @@ FocusScope {

1606 ]

1766 ]

1607

1767

1608 Binding {

1768 Binding {

1609− target: PanelState

1769+ target: panelState

1610 property: "decorationsAlwaysVisible"

1770 property: "decorationsAlwaysVisible"

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

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

1612 }

1772 }

@@ -1627,6 +1787,7 @@ FocusScope {

1627 borderThickness: units.gu(2)

1787 borderThickness: units.gu(2)

1628 enabled: false

1788 enabled: false

1629 visible: enabled

1789 visible: enabled

1790+ readyToAssesBounds: !appDelegate._constructing

1630

1791

1631 onPressed: {

1792 onPressed: {

1632 appDelegate.activate();

1793 appDelegate.activate();

@@ -1650,18 +1811,13 @@ FocusScope {

1650 width: implicitWidth

1811 width: implicitWidth

1651 height: implicitHeight

1812 height: implicitHeight

1652 highlightSize: windowInfoItem.iconMargin / 2

1813 highlightSize: windowInfoItem.iconMargin / 2

1653− altDragEnabled: root.mode == "windowed"

1654 boundsItem: root.availableDesktopArea

1814 boundsItem: root.availableDesktopArea

1815+ panelState: root.panelState

1816+ altDragEnabled: root.mode == "windowed"

1655

1817

1656 requestedWidth: appDelegate.requestedWidth

1818 requestedWidth: appDelegate.requestedWidth

1657 requestedHeight: appDelegate.requestedHeight

1819 requestedHeight: appDelegate.requestedHeight

1658

1820

1659− property int oldRequestedWidth: -1

1660− property int oldRequestedHeight: -1

1661−

1662− onRequestedWidthChanged: oldRequestedWidth = requestedWidth

1663− onRequestedHeightChanged: oldRequestedHeight = requestedHeight

1664−

1665 onCloseClicked: { appDelegate.close(); }

1821 onCloseClicked: { appDelegate.close(); }

1666 onMaximizeClicked: {

1822 onMaximizeClicked: {

1667 if (appDelegate.canBeMaximized) {

1823 if (appDelegate.canBeMaximized) {

@@ -1742,6 +1898,8 @@ FocusScope {

1742 anchors.fill: decoratedWindow

1898 anchors.fill: decoratedWindow

1743 enabled: false

1899 enabled: false

1744 closeable: !appDelegate.isDash

1900 closeable: !appDelegate.isDash

1901+ stage: root

1902+ dragDelegate: fakeDragItem

1745

1903

1746 onClicked: {

1904 onClicked: {

1747 spreadItem.highlightedIndex = index;

1905 spreadItem.highlightedIndex = index;

@@ -1784,12 +1942,15 @@ FocusScope {

1784 objectName: "closeMouseArea"

1942 objectName: "closeMouseArea"

1785 anchors { left: parent.left; top: parent.top; leftMargin: -height / 2; topMargin: -height / 2 + spreadMaths.closeIconOffset }

1943 anchors { left: parent.left; top: parent.top; leftMargin: -height / 2; topMargin: -height / 2 + spreadMaths.closeIconOffset }

1786 readonly property var mousePos: hoverMouseArea.mapToItem(appDelegate, hoverMouseArea.mouseX, hoverMouseArea.mouseY)

1944 readonly property var mousePos: hoverMouseArea.mapToItem(appDelegate, hoverMouseArea.mouseX, hoverMouseArea.mouseY)

1787− visible: !appDelegate.isDash && dragArea.distance == 0

1945+ readonly property bool shown: !appDelegate.isDash && dragArea.distance == 0

1788 && index == spreadItem.highlightedIndex

1946 && index == spreadItem.highlightedIndex

1789 && mousePos.y < (decoratedWindow.height / 3)

1947 && mousePos.y < (decoratedWindow.height / 3)

1790 && mousePos.y > -units.gu(4)

1948 && mousePos.y > -units.gu(4)

1791 && mousePos.x > -units.gu(4)

1949 && mousePos.x > -units.gu(4)

1792 && mousePos.x < (decoratedWindow.width * 2 / 3)

1950 && mousePos.x < (decoratedWindow.width * 2 / 3)

1951+ opacity: shown ? 1 : 0

1952+ visible: opacity > 0

1953+ Behavior on opacity { UbuntuNumberAnimation { duration: UbuntuAnimation.SnapDuration } }

1793 height: units.gu(6)

1954 height: units.gu(6)

1794 width: height

1955 width: height

1795

1956

@@ -1860,83 +2021,19 @@ FocusScope {

1860 leftMargin: root.availableDesktopArea.x

2021 leftMargin: root.availableDesktopArea.x

1861 appContainerWidth: appContainer.width

2022 appContainerWidth: appContainer.width

1862 appContainerHeight: appContainer.height

2023 appContainerHeight: appContainer.height

2024+ panelState: root.panelState

1863 }

2025 }

1864

2026

1865− MouseArea {

2027+ WorkspaceSwitcher {

1866− id: hoverMouseArea

2028+ id: workspaceSwitcher

1867− objectName: "hoverMouseArea"

2029+ anchors.centerIn: parent

1868− anchors.fill: appContainer

2030+ height: units.gu(20)

1869− propagateComposedEvents: true

2031+ background: root.background

1870− hoverEnabled: true

2032+ onActiveChanged: {

1871− enabled: false

2033+ if (!active) {

1872− visible: enabled

2034+ appContainer.focus = true;

1873−

1874− property int scrollAreaWidth: width / 3

1875− property bool progressiveScrollingEnabled: false

1876−

1877− onMouseXChanged: {

1878− mouse.accepted = false

1879−

1880− if (hoverMouseArea.pressed) {

1881− return;

1882− }

1883−

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

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

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

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

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

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

1890− spreadItem.highlightedIndex = i;

1891− break;

1892− }

1893− }

1894−

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

1896− var margins = floatingFlickable.width * 0.05;

1897−

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

1899− progressiveScrollingEnabled = true

1900− }

1901−

1902− // do we need to scroll?

1903− if (mouseX < scrollAreaWidth + margins) {

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

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

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

1907− }

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

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

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

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

1912− }

1913− }

1914− }

1915−

1916− onPressed: mouse.accepted = false

1917− }

1918−

1919− FloatingFlickable {

1920− id: floatingFlickable

1921− objectName: "spreadFlickable"

1922− anchors.fill: appContainer

1923− enabled: false

1924− contentWidth: spreadItem.spreadTotalWidth

1925−

1926− function snap(toIndex) {

1927− var delegate = appRepeater.itemAt(toIndex)

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

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

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

1931− snapAnimation.to = Math.max(0, floatingFlickable.contentX - offset);

1932− snapAnimation.start();

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

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

1935− snapAnimation.to = Math.max(0, floatingFlickable.contentX - offset);

1936− snapAnimation.start();

1937 }

2035 }

1938 }

2036 }

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

1940 }

2037 }

1941

2038

1942 PropertyAnimation {

2039 PropertyAnimation {

qml/Stage/SurfaceContainer.qml+2

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

66 fillMode: MirSurfaceItem.PadOrCrop

67 consumesInput: true

68

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

70+

69 surfaceWidth: root.requestedWidth

71 surfaceWidth: root.requestedWidth

70 surfaceHeight: root.requestedHeight

72 surfaceHeight: root.requestedHeight

71

73

qml/Stage/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/Stage/WindowResizeArea.qml+27−4

@@ -36,35 +36,58 @@ MouseArea {

36 property int minWidth: 0

37 property int minHeight: 0

38

39+ property bool readyToAssesBounds: false

40+ onReadyToAssesBoundsChanged: d.reassesBounds()

41+

39 QtObject {

42 QtObject {

40 id: d

43 id: d

41

44

42 readonly property int maxSafeInt: 2147483647

45 readonly property int maxSafeInt: 2147483647

43 readonly property int maxSizeIncrement: units.gu(40)

46 readonly property int maxSizeIncrement: units.gu(40)

44

47

48+ function reassesBounds() {

49+ if (!readyToAssesBounds) return;

50+

51+ if (target.windowedWidth < minimumWidth) {

52+ target.windowedWidth = minimumWidth;

53+ }

54+ if (target.windowedHeight < minimumHeight) {

55+ target.windowedHeight = minimumHeight;

56+ }

57+ if (target.windowedHeight < minimumHeight) {

58+ target.windowedHeight = minimumHeight;

59+ }

60+ if (target.windowedWidth > maximumWidth) {

61+ target.windowedWidth = maximumWidth;

62+ }

63+ if (target.windowedHeight > maximumHeight) {

64+ target.windowedHeight = maximumHeight;

65+ }

66+ }

67+

45 readonly property int minimumWidth: root.target ? Math.max(root.minWidth, root.target.minimumWidth) : root.minWidth

68 readonly property int minimumWidth: root.target ? Math.max(root.minWidth, root.target.minimumWidth) : root.minWidth

46 onMinimumWidthChanged: {

69 onMinimumWidthChanged: {

47− if (target.windowedWidth < minimumWidth) {

70+ if (readyToAssesBounds && target.windowedWidth < minimumWidth) {

48 target.windowedWidth = minimumWidth;

71 target.windowedWidth = minimumWidth;

49 }

72 }

50 }

73 }

51 readonly property int minimumHeight: root.target ? Math.max(root.minHeight, root.target.minimumHeight) : root.minHeight

74 readonly property int minimumHeight: root.target ? Math.max(root.minHeight, root.target.minimumHeight) : root.minHeight

52 onMinimumHeightChanged: {

75 onMinimumHeightChanged: {

53− if (target.windowedHeight < minimumHeight) {

76+ if (readyToAssesBounds && target.windowedHeight < minimumHeight) {

54 target.windowedHeight = minimumHeight;

77 target.windowedHeight = minimumHeight;

55 }

78 }

56 }

79 }

57 readonly property int maximumWidth: root.target && root.target.maximumWidth >= minimumWidth && root.target.maximumWidth > 0

80 readonly property int maximumWidth: root.target && root.target.maximumWidth >= minimumWidth && root.target.maximumWidth > 0

58 ? root.target.maximumWidth : maxSafeInt

81 ? root.target.maximumWidth : maxSafeInt

59 onMaximumWidthChanged: {

82 onMaximumWidthChanged: {

60− if (target.windowedWidth > maximumWidth) {

83+ if (readyToAssesBounds && target.windowedWidth > maximumWidth) {

61 target.windowedWidth = maximumWidth;

84 target.windowedWidth = maximumWidth;

62 }

85 }

63 }

86 }

64 readonly property int maximumHeight: root.target && root.target.maximumHeight >= minimumHeight && root.target.maximumHeight > 0

87 readonly property int maximumHeight: root.target && root.target.maximumHeight >= minimumHeight && root.target.maximumHeight > 0

65 ? root.target.maximumHeight : maxSafeInt

88 ? root.target.maximumHeight : maxSafeInt

66 onMaximumHeightChanged: {

89 onMaximumHeightChanged: {

67− if (target.windowedHeight > maximumHeight) {

90+ if (readyToAssesBounds && target.windowedHeight > maximumHeight) {

68 target.windowedHeight = maximumHeight;

91 target.windowedHeight = maximumHeight;

69 }

92 }

70 }

93 }

qml/Stage/WindowStateSaver.qml+4−1

@@ -43,7 +43,10 @@ QtObject {

43 (target.fullscreen ? 0 : root.leftMargin)); });

44 target.windowedY = Qt.binding(function() { return Math.max(Math.min(windowGeometry.y, screenHeight - target.windowedHeight), minimumY); });

45

46− target.updateNormalGeometry();

46+ target.normalWidth = target.windowedWidth;

47+ target.normalHeight = target.windowedHeight;

48+ target.normalX = target.windowedX;

49+ target.normalY = target.windowedY;

47

50

48 // initialize the x/y to restore to

51 // initialize the x/y to restore to

49 target.restoredX = target.normalX;

52 target.restoredX = target.normalX;

qml/Stage/WorkspacePreview.qmlnew file+212

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

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Unity.Screens 0.1

4+import Unity.Application 0.1

5+import "../Components"

6+

7+UbuntuShape {

8+ id: previewSpace

9+

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

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

12+ color: "white"

13+ property string background

14+

15+ property int screenWidth: model.geometry.width

16+ property int screenHeight: model.geometry.height

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

18+

19+ Item {

20+ id: header

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

22+ height: units.gu(7)

23+

24+ Column {

25+ anchors.fill: parent

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

27+

28+ Label {

29+ text: model.name

30+ color: "black"

31+ }

32+

33+ Label {

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

35+ color: "black"

36+ fontSize: "x-small"

37+ }

38+

39+ Label {

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

41+ color: "black"

42+ fontSize: "x-small"

43+ }

44+ }

45+ }

46+

47+

48+ Rectangle {

49+ anchors.fill: parent

50+ anchors.topMargin: header.height

51+ color: "blue"

52+

53+ Repeater {

54+ id: workspaceRepeater

55+ model: 15

56+

57+ delegate: Item {

58+ x: index * previewSpace.screenWidth * previewScale

59+ height: previewSpace.screenHeight * previewScale

60+ width: previewSpace.screenWidth * previewScale

61+ clip: true

62+

63+ Wallpaper {

64+ source: previewSpace.background

65+ anchors.fill: parent

66+

67+ // Repeater {

68+ // id: topLevelSurfaceRepeater

69+ // model: visible ? topLevelSurfaceList : null

70+ // delegate: Rectangle {

71+ // width: surfaceItem.width

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

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

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

75+ // color: "blue"

76+ // z: topLevelSurfaceRepeater.count - index

77+

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

79+

80+ // WindowDecoration {

81+ // width: surfaceItem.implicitWidth

82+ // height: parent.decorationHeight

83+ // transform: Scale {

84+ // origin.x: 0

85+ // origin.y: 0

86+ // xScale: previewScale

87+ // yScale: previewScale

88+ // }

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

90+ // z: 3

91+ // }

92+

93+ // MirSurfaceItem {

94+ // id: surfaceItem

95+ // y: parent.decorationHeight * previewScale

96+ // width: implicitWidth * previewScale

97+ // height: implicitHeight * previewScale

98+ // surfaceWidth: -1

99+ // surfaceHeight: -1

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

101+ // surface: model.window.surface

102+ // }

103+ // }

104+ // }

105+ }

106+ }

107+

108+

109+// MouseArea {

110+// id: mouseArea

111+// anchors.centerIn: parent

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

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

114+// height: width

115+// hoverEnabled: true

116+// opacity: containsMouse ? 1 : 0

117+

118+// Rectangle {

119+// anchors.fill: parent

120+// color: "#80000000"

121+// radius: height / 2

122+// }

123+

124+// NumberAnimation {

125+// target: canvas

126+// property: "progress"

127+// duration: 2000

128+// running: mouseArea.containsMouse

129+// from: 0

130+// to: 1

131+// }

132+

133+// Canvas {

134+// id: canvas

135+// height: parent.height

136+// width: height

137+// anchors.centerIn: parent

138+

139+// property real progress: 0.5

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

141+// onProgressChanged: {

142+// requestPaint();

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

144+// Screens.activateScreen(index);

145+// }

146+// }

147+

148+// rotation: -90

149+

150+// onPaint: {

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

152+// ctx.save();

153+// ctx.reset();

154+

155+// ctx.lineWidth = lineWidth;

156+

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

158+// ctx.beginPath();

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

160+// ctx.stroke();

161+// ctx.closePath();

162+

163+// ctx.strokeStyle = "white"

164+// ctx.beginPath();

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

166+// ctx.stroke();

167+// ctx.closePath();

168+

169+// ctx.restore();

170+// }

171+// }

172+

173+// Icon {

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

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

176+// width: height

177+// anchors.centerIn: parent

178+// }

179+// }

180+ }

181+

182+ FloatingFlickable {

183+ id: flickable

184+ anchors.fill: parent

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

186+ property real progress: contentX / contentWidth

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

188+ }

189+

190+ MouseArea {

191+ anchors.fill: parent

192+ hoverEnabled: true

193+ property int scrollAreaWidth: width / 3

194+

195+ onMouseXChanged: {

196+ var margins = flickable.width * 0.05;

197+

198+ // do we need to scroll?

199+ if (mouseX < scrollAreaWidth + margins) {

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

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

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

203+ }

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

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

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

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

208+ }

209+ }

210+ }

211+ }

212+}

qml/Stage/WorkspaceSwitcher.qmlnew file+181

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

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 "Spread"

20+import WindowManager 1.0

21+import Unity.Application 0.1

22+

23+UbuntuShape {

24+ id: root

25+

26+ backgroundColor: "#F2111111"

27+ width: screensRow.childrenRect.width + units.gu(4)

28+ opacity: d.shown ? 1 : 0

29+ visible: opacity > 0

30+ Behavior on opacity { UbuntuNumberAnimation {} }

31+

32+ property var screensProxy: Screens.createProxy();

33+ property string background

34+

35+ readonly property alias active: d.active

36+

37+ function showLeft() {

38+ show();

39+ d.decreaseHighlight();

40+ }

41+ function showRight() {

42+ show();

43+ d.increaseHighlight();

44+ }

45+

46+ function show() {

47+ hideTimer.stop();

48+ d.altPressed = true;

49+ d.ctrlPressed = true;

50+ d.active = true;

51+ d.shown = true;

52+ focus = true;

53+

54+ d.highlightedScreenIndex = screensProxy.activeScreen;

55+ var activeScreen = screensProxy.get(screensProxy.activeScreen);

56+ d.highlightedWorkspaceIndex = activeScreen.workspaces.indexOf(activeScreen.currentWorkspace)

57+ }

58+

59+ QtObject {

60+ id: d

61+

62+ property bool active: false

63+ property bool shown: false

64+ property bool altPressed: false

65+ property bool ctrlPressed: false

66+

67+ property int highlightedScreenIndex: -1

68+ property int highlightedWorkspaceIndex: -1

69+

70+ function increaseHighlight() {

71+ var screen = screensProxy.get(highlightedScreenIndex);

72+ highlightedWorkspaceIndex++

73+ if (highlightedWorkspaceIndex >= screen.workspaces.count) {

74+ highlightedScreenIndex = (highlightedScreenIndex + 1) % screensProxy.count;

75+ highlightedWorkspaceIndex = 0;

76+ }

77+ }

78+ function decreaseHighlight() {

79+ highlightedWorkspaceIndex--;

80+ if (highlightedWorkspaceIndex < 0) {

81+ highlightedScreenIndex--;

82+ if (highlightedScreenIndex < 0) {

83+ highlightedScreenIndex = screensProxy.count - 1

84+ }

85+ var screen = screensProxy.get(highlightedScreenIndex);

86+ highlightedWorkspaceIndex = screen.workspaces.count -1;

87+ }

88+ }

89+ }

90+

91+ Timer {

92+ id: hideTimer

93+ interval: 300

94+ onTriggered: d.shown = false;

95+ }

96+

97+ Keys.onPressed: {

98+ hideTimer.restart();

99+ switch (event.key) {

100+ case Qt.Key_Left:

101+ d.decreaseHighlight();

102+ break;

103+ case Qt.Key_Right:

104+ d.increaseHighlight();

105+ break;

106+ }

107+ }

108+ Keys.onReleased: {

109+ switch (event.key) {

110+ case Qt.Key_Alt:

111+ d.altPressed = false;

112+ break;

113+ case Qt.Key_Control:

114+ d.ctrlPressed = false;

115+ break;

116+ }

117+

118+ if (!d.altPressed && !d.ctrlPressed) {

119+ print("starting hidetimer")

120+ d.active = false;

121+ hideTimer.start();

122+ focus = false;

123+ screensProxy.get(d.highlightedScreenIndex).workspaces.get(d.highlightedWorkspaceIndex).activate();

124+ }

125+ }

126+

127+ Row {

128+ id: screensRow

129+ anchors {

130+ top: parent.top; topMargin: units.gu(2)

131+ left: parent.left; leftMargin: units.gu(2)

132+ }

133+ spacing: units.gu(2)

134+

135+ Repeater {

136+ model: screensProxy

137+

138+ delegate: Item {

139+ height: root.height - units.gu(4)

140+ width: workspaces.width

141+

142+ UbuntuShape {

143+ id: header

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

145+ height: units.gu(4)

146+ backgroundColor: "white"

147+

148+ Label {

149+ anchors { left: parent.left; top: parent.top; right: parent.right; margins: units.gu(1) }

150+ text: model.screen.name

151+ color: UbuntuColors.ash

152+ }

153+ }

154+

155+ Workspaces {

156+ id: workspaces

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

158+ width: {

159+ var width = 0;

160+ if (screensProxy.count == 1) {

161+ width = Math.min(implicitWidth, root.width - units.gu(8));

162+ } else {

163+ width = Math.min(implicitWidth, model.screen.active ? root.width - units.gu(48) : units.gu(40))

164+ }

165+ return Math.max(workspaces.minimumWidth, width);

166+ }

167+

168+ Behavior on width { UbuntuNumberAnimation {} }

169+ anchors.bottom: parent.bottom

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

171+ anchors.horizontalCenter: parent.horizontalCenter

172+ screen: model.screen

173+ background: root.background

174+ selectedIndex: d.highlightedScreenIndex == index ? d.highlightedWorkspaceIndex : -1

175+

176+ workspaceModel: model.screen.workspaces

177+ }

178+ }

179+ }

180+ }

181+}

qml/Stage/graphics/multi-monitor_drop-here.pngnew file

Binary file not shown.

qml/Stage/graphics/multi-monitor_leave.pngnew file

Binary file not shown.

qml/qmldirnew file+1

@@ -0,0 +1 @@

1+singleton ShellNotifier 0.1 ShellNotifier.qml

src/ApplicationArguments.cpp+11−2

@@ -16,7 +16,16 @@

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+11−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,11 @@ 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+ UnityApplication.cpp

33− ShellApplication.cpp

34− ShellView.cpp

35 UnityCommandLineParser.cpp

34 UnityCommandLineParser.cpp

36 UnixSignalHandler.cpp

35 UnixSignalHandler.cpp

37 DebuggingController.cpp

36 DebuggingController.cpp

37+ WindowManagementPolicy.cpp

38 ${QML_FILES} # This is to make qml and image files appear in the IDE's project tree

39)

40

@@ -49,7 +49,14 @@ qt5_use_modules(${SHELL_APP} DBus Gui Qml Quick Test)

49if (NOT "${ANDROID_PROPERTIES_INCLUDE_DIRS}" STREQUAL "")

50 set_target_properties(${SHELL_APP} PROPERTIES INCLUDE_DIRECTORIES ${ANDROID_PROPERTIES_INCLUDE_DIRS})

51endif()

52−target_link_libraries(${SHELL_APP} ${ANDROID_PROPERTIES_LDFLAGS} ${GSETTINGS_QT_LDFLAGS} UbuntuGestures connectivity-qt1 unity8-private)

52+target_link_libraries(${SHELL_APP}

53+ ${ANDROID_PROPERTIES_LDFLAGS}

54+ ${GSETTINGS_QT_LDFLAGS}

55+ ${QTMIRSERVER_LDFLAGS}

56+ UbuntuGestures

57+ connectivity-qt1

58+ unity8-private

59+)

53

60

54if (ENABLE_TOUCH_EMULATION)

61if (ENABLE_TOUCH_EMULATION)

55 target_link_libraries(${SHELL_APP} ${MOUSETOUCHADAPTOR_LIBS_LDFLAGS})

62 target_link_libraries(${SHELL_APP} ${MOUSETOUCHADAPTOR_LIBS_LDFLAGS})

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+147

@@ -0,0 +1,147 @@

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

34+#include <paths.h>

35+#include "CachingNetworkManagerFactory.h"

36+#include "UnityCommandLineParser.h"

37+#include "DebuggingController.h"

38+#include "WindowManagementPolicy.h"

39+

40+#include <QDebug>

41+

42+

43+

44+UnityApplication::UnityApplication(int & argc, char ** argv)

45+ : qtmir::MirServerApplication(argc, argv, { qtmir::SetWindowManagementPolicy<WindowManagementPolicy>() })

46+ , m_qmlArgs(this)

47+{

48+ setApplicationName(QStringLiteral("unity8"));

49+ setOrganizationName(QStringLiteral("Canonical"));

50+

51+ setupQmlEngine();

52+

53+ if (m_qmlArgs.deviceName().isEmpty()) {

54+ char buffer[200];

55+ property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);

56+ m_qmlArgs.setDeviceName(QString(buffer));

57+ }

58+

59+ // The testability driver is only loaded by QApplication but not by QGuiApplication.

60+ // However, QApplication depends on QWidget which would add some unneeded overhead => Let's load the testability driver on our own.

61+ if (m_qmlArgs.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {

62+ QLibrary testLib(QStringLiteral("qttestability"));

63+ if (testLib.load()) {

64+ typedef void (*TasInitialize)(void);

65+ TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");

66+ if (initFunction) {

67+ initFunction();

68+ } else {

69+ qCritical("Library qttestability resolve failed!");

70+ }

71+ } else {

72+ qCritical("Library qttestability load failed!");

73+ }

74+ }

75+

76+ bindtextdomain("unity8", translationDirectory().toUtf8().data());

77+ textdomain("unity8");

78+

79+ QScopedPointer<QGSettings> gSettings(new QGSettings("com.canonical.Unity8"));

80+ gSettings->reset(QStringLiteral("alwaysShowOsk"));

81+

82+

83+ QByteArray pxpguEnv = qgetenv("GRID_UNIT_PX");

84+ bool ok;

85+ int pxpgu = pxpguEnv.toInt(&ok);

86+ if (!ok) {

87+ pxpgu = 8;

88+ }

89+ m_qmlEngine->rootContext()->setContextProperty("internalGu", pxpgu);

90+ m_qmlEngine->rootContext()->setContextProperty(QStringLiteral("applicationArguments"), &m_qmlArgs);

91+ m_qmlEngine->rootContext()->setContextProperty("DebuggingController", new DebuggingController(this));

92+

93+ auto component(new QQmlComponent(m_qmlEngine, m_qmlArgs.qmlfie()));

94+ component->create();

95+ if (component->status() == QQmlComponent::Error) {

96+ m_qmlEngine->rootContext()->setContextProperty(QStringLiteral("errorString"), component->errorString());

97+ auto errorComponent(new QQmlComponent(m_qmlEngine,

98+ QUrl::fromLocalFile(::qmlDirectory() + "/ErrorApplication.qml")));

99+ errorComponent->create();

100+ qDebug() << errorComponent->errorString();

101+ return;

102+ }

103+

104+ #ifdef UNITY8_ENABLE_TOUCH_EMULATION

105+ // You will need this if you want to interact with touch-only components using a mouse

106+ // Needed only when manually testing on a desktop.

107+ if (m_qmlArgs.hasMouseToTouch()) {

108+ m_mouseTouchAdaptor = MouseTouchAdaptor::instance();

109+ }

110+ #endif

111+

112+ if (m_qmlArgs.mode().compare("greeter") == 0) {

113+ if (!QProcess::startDetached("initctl emit --no-wait unity8-greeter-started")) {

114+ qDebug() << "Unable to send unity8-greeter-started event to Upstart";

115+ }

116+ }

117+}

118+

119+UnityApplication::~UnityApplication()

120+{

121+ destroyResources();

122+}

123+

124+void UnityApplication::destroyResources()

125+{

126+ #ifdef UNITY8_ENABLE_TOUCH_EMULATION

127+ delete m_mouseTouchAdaptor;

128+ m_mouseTouchAdaptor = nullptr;

129+ #endif

130+

131+ delete m_qmlEngine;

132+ m_qmlEngine = nullptr;

133+}

134+

135+void UnityApplication::setupQmlEngine()

136+{

137+ m_qmlEngine = new QQmlEngine(this);

138+

139+ m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));

140+

141+ prependImportPaths(m_qmlEngine, ::overrideImportPaths());

142+ appendImportPaths(m_qmlEngine, ::fallbackImportPaths());

143+

144+ m_qmlEngine->setNetworkAccessManagerFactory(new CachingNetworkManagerFactory);

145+

146+ QObject::connect(m_qmlEngine, &QQmlEngine::quit, this, &QGuiApplication::quit);

147+}

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, qtmir::WindowManagementPolicyPrivate &dd)

20+ : qtmir::WindowManagementPolicy(tools, dd)

21+ , m_dummyWorkspace(this->tools.create_workspace())

22+{

23+ wmPolicyInterface = this;

24+

25+ // we must always have a active workspace.

26+ m_activeWorkspace = m_dummyWorkspace;

27+}

28+

29+void WindowManagementPolicy::advise_new_window(miral::WindowInfo const& window_info)

30+{

31+ qtmir::WindowManagementPolicy::advise_new_window(window_info);

32+

33+ auto const parent = window_info.parent();

34+

35+ auto activeWorkspace = m_activeWorkspace.lock();

36+ if (!parent && activeWorkspace) {

37+ tools.add_tree_to_workspace(window_info.window(), activeWorkspace);

38+ }

39+}

40+

41+std::shared_ptr<miral::Workspace> WindowManagementPolicy::createWorkspace()

42+{

43+ auto workspace = tools.create_workspace();

44+ m_workspaces.insert(workspace);

45+

46+ if (m_activeWorkspace.lock() == m_dummyWorkspace) {

47+ tools.move_workspace_content_to_workspace(workspace, m_dummyWorkspace);

48+ m_activeWorkspace = workspace;

49+ }

50+ return workspace;

51+}

52+

53+void WindowManagementPolicy::releaseWorkspace(const std::shared_ptr<miral::Workspace> &workspace)

54+{

55+ auto iter = m_workspaces.find(workspace);

56+ if (iter != m_workspaces.end()) m_workspaces.erase(iter);

57+

58+ if (m_workspaces.size() == 0) {

59+ m_activeWorkspace = m_dummyWorkspace;

60+ tools.move_workspace_content_to_workspace(m_dummyWorkspace, workspace);

61+ }

62+}

63+

64+void WindowManagementPolicy::setActiveWorkspace(const std::shared_ptr<miral::Workspace> &workspace)

65+{

66+ if (m_activeWorkspace.lock() == workspace)

67+ return;

68+ m_activeWorkspace = workspace ? workspace : m_dummyWorkspace;

69+}

src/WindowManagementPolicy.hnew file+47

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef UNITY_WINDOWMANAGEMENTPOLICY_H

18+#define UNITY_WINDOWMANAGEMENTPOLICY_H

19+

20+#include <qtmir/windowmanagementpolicy.h>

21+#include "wmpolicyinterface.h"

22+

23+#include <unordered_set>

24+

25+class Q_DECL_EXPORT WindowManagementPolicy : public qtmir::WindowManagementPolicy,

26+ public WMPolicyInterface

27+{

28+public:

29+ WindowManagementPolicy(const miral::WindowManagerTools &tools, qtmir::WindowManagementPolicyPrivate& dd);

30+

31+ void advise_new_window(miral::WindowInfo const& window_info) override;

32+

33+ // From WMPolicyInterface

34+ std::shared_ptr<miral::Workspace> createWorkspace() override;

35+

36+ void releaseWorkspace(const std::shared_ptr<miral::Workspace> &workspace) override;

37+

38+ void setActiveWorkspace(const std::shared_ptr<miral::Workspace> &workspace) override;

39+

40+private:

41+ std::weak_ptr<miral::Workspace> m_activeWorkspace;

42+

43+ std::unordered_set<std::shared_ptr<miral::Workspace>> m_workspaces;

44+ const std::shared_ptr<miral::Workspace> m_dummyWorkspace;

45+};

46+

47+#endif // UNITY_WINDOWMANAGEMENTPOLICY_H

src/libunity8-private/CMakeLists.txt+1

@@ -8,6 +8,7 @@ set(lib${LIB_NAME}_SRCS

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/MirSurfaceItem.cpp+26−7

@@ -189,11 +189,13 @@ void MirSurfaceItem::createQmlContentItem()

189 m_qmlItem = qobject_cast<QQuickItem*>(m_qmlContentComponent->create());

190 m_qmlItem->setParentItem(this);

191

192− m_qmlItem->setWidth(m_surfaceWidth);

192+ if (m_fillMode == FillMode::Stretch && width() != 0 && height() != 0) {

193− m_qmlItem->setHeight(m_surfaceHeight);

193+ m_qmlItem->setSize(QSize(this->width(), this->height()));

194−

194+ } else {

195+ m_qmlItem->setSize(m_qmlSurface->size());

196+ }

195− setImplicitWidth(m_qmlItem->implicitWidth());

197+ setImplicitWidth(m_qmlItem->width());

196− setImplicitHeight(m_qmlItem->implicitHeight());

198+ setImplicitHeight(m_qmlItem->height());

197

199

198 {

200 {

199 QQmlProperty screenshotSource(m_qmlItem, "screenshotSource");

201 QQmlProperty screenshotSource(m_qmlItem, "screenshotSource");

@@ -308,6 +310,16 @@ void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

308 connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);

310 connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);

309 connect(m_qmlSurface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);

311 connect(m_qmlSurface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);

310 connect(m_qmlSurface, &MirSurface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);

312 connect(m_qmlSurface, &MirSurface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);

313+ connect(m_qmlSurface, &MirSurface::sizeChanged, this, [this] () {

314+ setImplicitSize(m_qmlSurface->width(), m_qmlSurface->height());

315+ if (m_fillMode == FillMode::Stretch) {

316+ m_qmlItem->setSize(QSize(this->width(), this->height()));

317+ } else {

318+ m_qmlItem->setSize(m_qmlSurface->size());

319+ }

320+ });

321+ m_surfaceWidth = surface->size().width();

322+ m_surfaceHeight = surface->size().height();

311

323

312 QUrl qmlComponentFilePath;

324 QUrl qmlComponentFilePath;

313 if (!m_qmlSurface->qmlFilePath().isEmpty()) {

325 if (!m_qmlSurface->qmlFilePath().isEmpty()) {

@@ -321,6 +333,7 @@ void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

321 switch (m_qmlContentComponent->status()) {

333 switch (m_qmlContentComponent->status()) {

322 case QQmlComponent::Ready:

334 case QQmlComponent::Ready:

323 createQmlContentItem();

335 createQmlContentItem();

336+ qDebug() << "content created" << m_surfaceWidth << implicitWidth() << width();

324 break;

337 break;

325 case QQmlComponent::Loading:

338 case QQmlComponent::Loading:

326 connect(m_qmlContentComponent, &QQmlComponent::statusChanged,

339 connect(m_qmlContentComponent, &QQmlComponent::statusChanged,

@@ -399,9 +412,15 @@ void MirSurfaceItem::updateSurfaceSize()

399 if (m_qmlSurface && m_surfaceWidth > 0 && m_surfaceHeight > 0) {

412 if (m_qmlSurface && m_surfaceWidth > 0 && m_surfaceHeight > 0) {

400 m_qmlSurface->resize(m_surfaceWidth, m_surfaceHeight);

413 m_qmlSurface->resize(m_surfaceWidth, m_surfaceHeight);

401 if (m_qmlItem) {

414 if (m_qmlItem) {

415+ if (m_fillMode == FillMode::Stretch) {

416+ m_qmlItem->setWidth(width());

417+ m_qmlItem->setHeight(height());

418+ } else {

402− m_qmlItem->setWidth(m_surfaceWidth);

419+ m_qmlItem->setWidth(m_surfaceWidth);

403− m_qmlItem->setHeight(m_surfaceHeight);

420+ m_qmlItem->setHeight(m_surfaceHeight);

421+ }

404 }

422 }

423+ qDebug() << this << "setting implicitsize" << m_surfaceWidth << m_surfaceHeight;

405 setImplicitSize(m_surfaceWidth, m_surfaceHeight);

424 setImplicitSize(m_surfaceWidth, m_surfaceHeight);

406 }

425 }

407}

426}

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/Application/resources/MirSurfaceItem.qml−3

@@ -20,9 +20,6 @@ Rectangle {

20 id: root

21 color: "pink"

22

23− implicitWidth: width

24− implicitHeight: height

25−

26 property alias screenshotSource: screenshotImage.source

23 property alias screenshotSource: screenshotImage.source

27 property int orientationAngle

24 property int orientationAngle

28

25

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+217

@@ -0,0 +1,217 @@

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#include "MockScreens.h"

18+#include "ScreenWindow.h"

19+

20+// qtmirserver

21+#include <qtmir/screen.h>

22+

23+#include <QGuiApplication>

24+#include <QWindow>

25+#include <QWeakPointer>

26+

27+namespace {

28+

29+QWeakPointer<MockScreens> m_screens;

30+

31+class MockScreen : public qtmir::Screen

32+{

33+ Q_OBJECT

34+ Q_PROPERTY(QString outputTypeName READ outputTypeName NOTIFY outputTypeNameChanged)

35+public:

36+ MockScreen()

37+ {

38+ m_sizes.append(new qtmir::ScreenMode(50, QSize(800,568)));

39+ m_sizes.append(new qtmir::ScreenMode(60, QSize(1280,1024)));

40+ m_sizes.append(new qtmir::ScreenMode(60, QSize(1440,900)));

41+ m_sizes.append(new qtmir::ScreenMode(60, QSize(1920,1080)));

42+ m_physicalSize = QSize(800,568);

43+ }

44+ ~MockScreen() {

45+ qDeleteAll(m_sizes);

46+ m_sizes.clear();

47+ }

48+

49+ void connectToWindow(QWindow* w)

50+ {

51+ if (m_connectedWindow == w) return;

52+

53+ if (m_connectedWindow) {

54+ disconnect(m_connectedWindow.data());

55+ }

56+

57+ m_connectedWindow = w;

58+

59+ if (w) {

60+ connect(w, &ScreenWindow::heightChanged, this, [this](int height) {

61+ if (height == 0 || height == m_sizes.first()->size.rheight()) {

62+ return;

63+ }

64+ m_sizes.first()->size.rheight() = height;

65+ Q_EMIT availableModesChanged();

66+

67+ });

68+ connect(w, &ScreenWindow::widthChanged, this, [this](int width) {

69+ if (width == 0 || width == m_sizes.first()->size.rwidth()) {

70+ return;

71+ }

72+ m_sizes.first()->size.rwidth() = width;

73+ Q_EMIT availableModesChanged();

74+ });

75+

76+ Q_EMIT availableModesChanged();

77+ }

78+ }

79+

80+ qtmir::OutputId outputId() const override { return m_id; }

81+ bool used() const override { return m_used; }

82+ QString name() const override { return m_name; }

83+ float scale() const override { return m_scale; }

84+ QSizeF physicalSize() const override { return m_physicalSize; }

85+ qtmir::FormFactor formFactor() const override { return m_formFactor; }

86+ qtmir::OutputTypes outputType() const override { return m_outputType; }

87+ QString outputTypeName() const { return QStringLiteral("Internal"); }

88+ MirPowerMode powerMode() const override { return m_powerMode; }

89+ Qt::ScreenOrientation orientation() const override { return m_orientation; }

90+ QPoint position() const override { return m_position; }

91+ uint currentModeIndex() const override { return m_currentModeIndex; }

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

93+

94+ QQmlListProperty<qtmir::ScreenMode> availableModes() override {

95+ return QQmlListProperty<qtmir::ScreenMode>(this, m_sizes);

96+ }

97+

98+ void setActive(bool active) override {

99+ if (m_active != active) {

100+ m_active = active;

101+ Q_EMIT activeChanged(m_active);

102+ }

103+ }

104+

105+ QScreen* qscreen() const override {

106+ if (qGuiApp->topLevelWindows().count() > 0) {

107+ return qGuiApp->topLevelWindows()[0]->screen();

108+ }

109+ return qGuiApp->primaryScreen();

110+ }

111+

112+ qtmir::ScreenConfiguration *beginConfiguration() const override {

113+ auto config = new qtmir::ScreenConfiguration;

114+ config->valid = true;

115+ config->id = m_id;

116+ config->used = m_used;

117+ config->topLeft = m_position;

118+ config->currentModeIndex = m_currentModeIndex;

119+ config->powerMode = m_powerMode;

120+ config->scale = m_scale;

121+ config->formFactor = m_formFactor;

122+ return config;

123+ }

124+

125+ bool applyConfiguration(qtmir::ScreenConfiguration *configuration) override {

126+ m_used = configuration->used;

127+ m_position = configuration->topLeft;

128+ m_currentModeIndex = configuration->currentModeIndex;

129+ m_powerMode = configuration->powerMode;

130+ m_scale = configuration->scale;

131+ m_formFactor = configuration->formFactor;

132+ return true;

133+ }

134+

135+Q_SIGNALS:

136+ void outputTypeNameChanged();

137+

138+public:

139+ qtmir::OutputId m_id{0};

140+ bool m_active{false};

141+ bool m_used{true};

142+ QString m_name;

143+ qtmir::OutputTypes m_outputType{qtmir::Unknown};

144+ MirPowerMode m_powerMode{mir_power_mode_on};

145+ Qt::ScreenOrientation m_orientation{Qt::PrimaryOrientation};

146+ float m_scale{1.0};

147+ qtmir::FormFactor m_formFactor{qtmir::FormFactorMonitor};

148+ QPoint m_position;

149+ uint m_currentModeIndex{0};

150+ QList<qtmir::ScreenMode*> m_sizes;

151+ QSizeF m_physicalSize;

152+

153+ QPointer<QWindow> m_connectedWindow;

154+};

155+}

156+

157+MockScreens::MockScreens()

158+{

159+ bool ok = false;

160+ int screenCount = qEnvironmentVariableIntValue("UNITY_MOCK_SCREEN_COUNT", &ok);

161+ if (!ok) screenCount = 1;

162+ QPoint lastPoint(0,0);

163+ for (int i = 0; i < screenCount; ++i) {

164+ auto screen = new MockScreen();

165+ screen->m_id = qtmir::OutputId{i};

166+ screen->m_active = i == 0;

167+ screen->m_name = QString("Monitor %1").arg(i);

168+ screen->m_position = QPoint(lastPoint.x(), lastPoint.y());

169+ screen->m_currentModeIndex = 0;

170+ m_mocks.append(screen);

171+

172+ lastPoint.rx() += screen->m_sizes[screen->m_currentModeIndex]->size.width();

173+ }

174+}

175+

176+MockScreens::~MockScreens()

177+{

178+ qDeleteAll(m_mocks);

179+ m_mocks.clear();

180+}

181+

182+QVector<qtmir::Screen *> MockScreens::screens() const

183+{

184+ return m_mocks;

185+}

186+

187+qtmir::Screen *MockScreens::activeScreen() const

188+{

189+ Q_FOREACH(auto screen, m_mocks) {

190+ if (screen->isActive()) return screen;

191+ }

192+ return nullptr;

193+}

194+

195+QSharedPointer<MockScreens> MockScreens::instance()

196+{

197+ if (!m_screens) {

198+ QSharedPointer<MockScreens> screens(new MockScreens());

199+ m_screens = screens.toWeakRef();

200+ return screens;

201+ } else {

202+ return m_screens.lock();

203+ }

204+}

205+

206+void MockScreens::connectWindow(ScreenWindow *w)

207+{

208+ ConcreteScreen* screen = w->screenWrapper();

209+ if (!screen) return;

210+

211+ auto mockScreen = qobject_cast<MockScreen*>(screen->wrapped());

212+ if (mockScreen) {

213+ mockScreen->connectToWindow(w);

214+ }

215+}

216+

217+#include "MockScreens.moc"

tests/mocks/WindowManager/MockScreens.hnew file+54

@@ -0,0 +1,54 @@

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef MOCK_SCREENS_H

18+#define MOCK_SCREENS_H

19+

20+#include <QAbstractListModel>

21+#include <QSharedPointer>

22+

23+#include <qtmir/screens.h>

24+

25+namespace qtmir

26+{

27+class Screens;

28+}

29+

30+class 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+88

@@ -0,0 +1,88 @@

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+ qmlRegisterSingletonType<WindowManagerObjects>(uri, 1, 0, "WindowManagerObjects", objectsSingleton);

65+

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

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

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

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

70+

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

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

73+

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

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

76+

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

78+}

79+

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

81+{

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

83+

84+ // Make sure we've initialized the wm policy.

85+ WindowManagementPolicy::instance();

86+ // Create Screens

87+ new ConcreteScreens(MockScreens::instance(), new ScreensConfiguration());

88+}

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+10−44

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

@@ -247,13 +245,12 @@ Rectangle {

247 function test_showSplashUntilAppFullyInit_data() {

245 function test_showSplashUntilAppFullyInit_data() {

248 return [

246 return [

249 {tag: "state=Running then create surface", swapInitOrder: false},

247 {tag: "state=Running then create surface", swapInitOrder: false},

250−

251 {tag: "create surface then state=Running", swapInitOrder: true},

248 {tag: "create surface then state=Running", swapInitOrder: true},

252 ]

249 ]

253 }

250 }

254

251

255 function test_showSplashUntilAppFullyInit() {

252 function test_showSplashUntilAppFullyInit() {

256− verify(stateGroup.state === "splashScreen");

253+ verify(stateGroup.state === "splash");

257

254

258 if (data.swapInitOrder) {

255 if (data.swapInitOrder) {

259 surfaceCheckbox.checked = true;

256 surfaceCheckbox.checked = true;

@@ -261,7 +258,7 @@ Rectangle {

261 setApplicationState(appRunning);

258 setApplicationState(appRunning);

262 }

259 }

263

260

264− verify(stateGroup.state === "splashScreen");

261+ verify(stateGroup.state === "splash");

265

262

266 if (data.swapInitOrder) {

263 if (data.swapInitOrder) {

267 setApplicationState(appRunning);

264 setApplicationState(appRunning);

@@ -286,27 +283,8 @@ Rectangle {

286 waitUntilTransitionsEnd(stateGroup);

283 waitUntilTransitionsEnd(stateGroup);

287 }

284 }

288

285

289− function test_killedAppShowsScreenshot() {

290− surfaceCheckbox.checked = true;

291− setApplicationState(appRunning);

292− tryCompare(stateGroup, "state", "surface");

293−

294− setApplicationState(appSuspended);

295−

296− verify(stateGroup.state === "surface");

297− verify(fakeApplication.surface !== null);

298−

299− // kill it!

300− surfaceCheckbox.checked = false;

301− setApplicationState(appStopped);

302−

303− tryCompare(stateGroup, "state", "screenshot");

304− tryCompare(fakeApplication.surfaceList, "count", 0);

305− }

306−

307 function test_restartApp() {

286 function test_restartApp() {

308− var screenshotImage = findChild(applicationWindow, "screenshotImage");

287+ tryCompare(stateGroup, "state", "splash");

309−

310 surfaceCheckbox.checked = true;

288 surfaceCheckbox.checked = true;

311 setApplicationState(appRunning);

289 setApplicationState(appRunning);

312 tryCompare(stateGroup, "state", "surface");

290 tryCompare(stateGroup, "state", "surface");

@@ -318,26 +296,23 @@ Rectangle {

318 surfaceCheckbox.checked = false;

296 surfaceCheckbox.checked = false;

319 setApplicationState(appStopped);

297 setApplicationState(appStopped);

320

298

321− tryCompare(stateGroup, "state", "screenshot");

322 waitUntilTransitionsEnd(stateGroup);

299 waitUntilTransitionsEnd(stateGroup);

323− tryCompare(applicationWindow, "surface", null);

300+ tryCompare(stateGroup, "state", "surface");

324

301

325 // and restart it

302 // and restart it

326 setApplicationState(appStarting);

303 setApplicationState(appStarting);

327

304

328 waitUntilTransitionsEnd(stateGroup);

305 waitUntilTransitionsEnd(stateGroup);

329− verify(stateGroup.state === "screenshot");

306+ verify(stateGroup.state === "surface");

330− verify(applicationWindow.surface === null);

331

307

332 setApplicationState(appRunning);

308 setApplicationState(appRunning);

333

309

334 waitUntilTransitionsEnd(stateGroup);

310 waitUntilTransitionsEnd(stateGroup);

335− verify(stateGroup.state === "screenshot");

311+ verify(stateGroup.state === "surface");

336

312

337 surfaceCheckbox.checked = true;

313 surfaceCheckbox.checked = true;

338

314

339 tryCompare(stateGroup, "state", "surface");

315 tryCompare(stateGroup, "state", "surface");

340− tryCompare(screenshotImage, "status", Image.Null);

341 }

316 }

342

317

343 function test_appCrashed() {

318 function test_appCrashed() {

@@ -345,13 +320,15 @@ Rectangle {

345 setApplicationState(appRunning);

320 setApplicationState(appRunning);

346 tryCompare(stateGroup, "state", "surface");

321 tryCompare(stateGroup, "state", "surface");

347 waitUntilTransitionsEnd(stateGroup);

322 waitUntilTransitionsEnd(stateGroup);

323+ var surface = applicationWindow.surface;

348

324

349 // oh, it crashed...

325 // oh, it crashed...

350 surfaceCheckbox.checked = false;

326 surfaceCheckbox.checked = false;

351 setApplicationState(appStopped);

327 setApplicationState(appStopped);

352

328

329+ waitUntilTransitionsEnd(stateGroup);

353− tryCompare(stateGroup, "state", "screenshot");

330+ tryCompare(stateGroup, "state", "surface");

354− tryCompare(applicationWindow, "surface", null);

331+ tryCompare(applicationWindow, "surface", surface);

355 }

332 }

356

333

357 function test_keepSurfaceWhileInvisible() {

334 function test_keepSurfaceWhileInvisible() {

@@ -395,17 +372,6 @@ Rectangle {

395 verify(surfaceItem.touchReleaseCount === 1);

372 verify(surfaceItem.touchReleaseCount === 1);

396 }

373 }

397

374

398− function test_showNothingOnSuddenSurfaceLoss() {

399− surfaceCheckbox.checked = true;

400− setApplicationState(appRunning);

401− tryCompare(stateGroup, "state", "surface");

402− waitUntilTransitionsEnd(stateGroup);

403−

404− applicationWindow.surface = null;

405−

406− tryCompare(stateGroup, "state", "void");

407− }

408−

409 function test_surfaceActiveFocusFollowsAppWindowInterative() {

375 function test_surfaceActiveFocusFollowsAppWindowInterative() {

410 applicationWindow.interactive = false;

376 applicationWindow.interactive = false;

411 applicationWindow.interactive = true;

377 applicationWindow.interactive = 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−13

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

@@ -562,8 +558,6 @@ Item {

562 var gmailDelegate = startApplication("gmail-webapp");

558 var gmailDelegate = startApplication("gmail-webapp");

563 verify(gmailDelegate);

559 verify(gmailDelegate);

564

560

565− wait(2000)

566−

567 var gmailMaximizeButton = findChild(gmailDelegate, "maximizeWindowButton");

561 var gmailMaximizeButton = findChild(gmailDelegate, "maximizeWindowButton");

568 verify(gmailMaximizeButton);

562 verify(gmailMaximizeButton);

569 mouseClick(gmailMaximizeButton);

563 mouseClick(gmailMaximizeButton);

@@ -638,19 +632,19 @@ Item {

638 maximizeDelegate(facebookAppDelegate);

632 maximizeDelegate(facebookAppDelegate);

639

633

640 // verify the drop shadow is still not visible

634 // verify the drop shadow is still not visible

641− verify(PanelState.dropShadow == false);

635+ verify(panelState.dropShadow == false);

642

636

643 // start a foreground app, not maximized

637 // start a foreground app, not maximized

644 var dialerAppDelegate = startApplication("dialer-app");

638 var dialerAppDelegate = startApplication("dialer-app");

645

639

646 // verify the drop shadow becomes visible

640 // verify the drop shadow becomes visible

647− tryCompareFunction(function() { return PanelState.dropShadow; }, true);

641+ tryCompareFunction(function() { return panelState.dropShadow; }, true);

648

642

649 // close the maximized app

643 // close the maximized app

650 ApplicationManager.stopApplication("facebook-webapp");

644 ApplicationManager.stopApplication("facebook-webapp");

651

645

652 // verify the drop shadow is gone

646 // verify the drop shadow is gone

653− tryCompare(PanelState, "dropShadow", false);

647+ tryCompare(panelState, "dropShadow", false);

654 }

648 }

655

649

656 function test_threeFingerTapShowsWindowControls_data() {

650 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+50−49

@@ -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,22 @@ Rectangle {

138 name: "TabletStage"

139 when: windowShown

140

141− readonly property alias topSurfaceList: stage.topLevelSurfaceList

142 property Item sideStage: stage ? findChild(stage, "sideStage") : null

141 property Item sideStage: stage ? findChild(stage, "sideStage") : null

143

142

144 function init() {

143 function init() {

145 stageSaver.clear();

144 stageSaver.clear();

146

145

146+ print("blllaaaaaaaaa")

147 ApplicationManager.startApplication("unity8-dash");

148− tryCompare(topSurfaceList, "count", 1);

148+ tryCompare(topLevelSurfaceList, "count", 1);

149+ print("have", topLevelSurfaceList.count, "surfaces")

149− compare(topSurfaceList.applicationAt(0).appId, "unity8-dash");

150+ compare(topLevelSurfaceList.applicationAt(0).appId, "unity8-dash");

150

151

151 // this is very strange, but sometimes the test starts without

152 // this is very strange, but sometimes the test starts without

152 // Stage components having finished loading themselves

153 // Stage components having finished loading themselves

153 var appWindow = null

154 var appWindow = null

154 while (!appWindow) {

155 while (!appWindow) {

155− appWindow = findAppWindowForSurfaceId(topSurfaceList.idAt(0));

156+ appWindow = findAppWindowForSurfaceId(topLevelSurfaceList.idAt(0));

156 if (!appWindow) {

157 if (!appWindow) {

157 console.log("didn't find unity8-dash appWindow in Stage. Trying again...");

158 console.log("didn't find unity8-dash appWindow in Stage. Trying again...");

158 wait(50);

159 wait(50);

@@ -164,9 +165,11 @@ Rectangle {

164 tryCompare(appRepeater, "count", 1);

165 tryCompare(appRepeater, "count", 1);

165 tryCompare(appRepeater.itemAt(0), "x", 0);

166 tryCompare(appRepeater.itemAt(0), "x", 0);

166

167

167− waitUntilAppSurfaceShowsUp(topSurfaceList.idAt(0));

168+ waitUntilAppSurfaceShowsUp(topLevelSurfaceList.idAt(0));

168 sideStage.hideNow()

169 sideStage.hideNow()

169 tryCompare(sideStage, "x", stage.width)

170 tryCompare(sideStage, "x", stage.width)

171+ print("still have", topLevelSurfaceList.count, "surfaces")

172+

170 }

173 }

171

174

172 function cleanup() {

175 function cleanup() {

@@ -228,7 +231,7 @@ Rectangle {

228 tryCompare(stage, "state", "spread");

231 tryCompare(stage, "state", "spread");

229 }

232 }

230

233

231− function swipeSurfaceUpwards(surfaceId) {

234+ function swipeSurfaceDownwards(surfaceId) {

232 var appWindow = findAppWindowForSurfaceId(surfaceId);

235 var appWindow = findAppWindowForSurfaceId(surfaceId);

233 verify(appWindow);

236 verify(appWindow);

234

237

@@ -236,7 +239,7 @@ Rectangle {

236 // to not be covered by other surfaces when they're all being shown in the spread

239 // to not be covered by other surfaces when they're all being shown in the spread

237 touchFlick(appWindow,

240 touchFlick(appWindow,

238 appWindow.width * 0.1, appWindow.height / 2,

241 appWindow.width * 0.1, appWindow.height / 2,

239− appWindow.width * 0.1, -appWindow.height / 2);

242+ appWindow.width * 0.1, appWindow.height * 1.5);

240 }

243 }

241

244

242 function dragToSideStage(surfaceId) {

245 function dragToSideStage(surfaceId) {

@@ -279,7 +282,7 @@ Rectangle {

279 function test_tappingSwitchesFocusBetweenStages() {

282 function test_tappingSwitchesFocusBetweenStages() {

280 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

283 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

281

284

282− var webbrowserSurfaceId = topSurfaceList.nextId;

285+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

283 webbrowserCheckBox.checked = true;

286 webbrowserCheckBox.checked = true;

284 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

287 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

285 var webbrowserDelegate = findChild(stage, "appDelegate_" + webbrowserSurfaceId);

288 var webbrowserDelegate = findChild(stage, "appDelegate_" + webbrowserSurfaceId);

@@ -290,7 +293,7 @@ Rectangle {

290

293

291 tryCompare(webbrowserWindow.surface, "activeFocus", true);

294 tryCompare(webbrowserWindow.surface, "activeFocus", true);

292

295

293− var dialerSurfaceId = topSurfaceList.nextId;

296+ var dialerSurfaceId = topLevelSurfaceList.nextId;

294 dialerCheckBox.checked = true;

297 dialerCheckBox.checked = true;

295 waitUntilAppSurfaceShowsUp(dialerSurfaceId);

298 waitUntilAppSurfaceShowsUp(dialerSurfaceId);

296

299

@@ -322,7 +325,7 @@ Rectangle {

322 function test_closeAppInSideStage() {

325 function test_closeAppInSideStage() {

323 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

326 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

324

327

325− var dialerSurfaceId = topSurfaceList.nextId;

328+ var dialerSurfaceId = topLevelSurfaceList.nextId;

326 dialerCheckBox.checked = true;

329 dialerCheckBox.checked = true;

327 waitUntilAppSurfaceShowsUp(dialerSurfaceId);

330 waitUntilAppSurfaceShowsUp(dialerSurfaceId);

328

331

@@ -334,7 +337,7 @@ Rectangle {

334 compare(appDelegate.stage, ApplicationInfoInterface.SideStage);

337 compare(appDelegate.stage, ApplicationInfoInterface.SideStage);

335 tryCompare(dragArea, "closeable", true);

338 tryCompare(dragArea, "closeable", true);

336

339

337− swipeSurfaceUpwards(dialerSurfaceId);

340+ swipeSurfaceDownwards(dialerSurfaceId);

338

341

339 // Check that dialer-app has been closed

342 // Check that dialer-app has been closed

340

343

@@ -345,10 +348,12 @@ Rectangle {

345 tryCompareFunction(function() {

348 tryCompareFunction(function() {

346 return ApplicationManager.findApplication(dialerCheckBox.appId);

349 return ApplicationManager.findApplication(dialerCheckBox.appId);

347 }, null);

350 }, null);

351+

352+ stage.closeSpread();

348 }

353 }

349

354

350 function test_suspendsAndResumesAppsInMainStage() {

355 function test_suspendsAndResumesAppsInMainStage() {

351− var webbrowserSurfaceId = topSurfaceList.nextId;

356+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

352 webbrowserCheckBox.checked = true;

357 webbrowserCheckBox.checked = true;

353 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

358 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

354 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

359 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

@@ -357,7 +362,7 @@ Rectangle {

357

362

358 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

363 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

359

364

360− var gallerySurfaceId = topSurfaceList.nextId;

365+ var gallerySurfaceId = topLevelSurfaceList.nextId;

361 galleryCheckBox.checked = true;

366 galleryCheckBox.checked = true;

362 waitUntilAppSurfaceShowsUp(gallerySurfaceId);

367 waitUntilAppSurfaceShowsUp(gallerySurfaceId);

363 var galleryApp = ApplicationManager.findApplication(galleryCheckBox.appId);

368 var galleryApp = ApplicationManager.findApplication(galleryCheckBox.appId);

@@ -388,7 +393,7 @@ Rectangle {

388 // launch two main stage apps

393 // launch two main stage apps

389 // gallery will be on foreground and webbrowser on background

394 // gallery will be on foreground and webbrowser on background

390

395

391− var webbrowserSurfaceId = topSurfaceList.nextId;

396+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

392 webbrowserCheckBox.checked = true;

397 webbrowserCheckBox.checked = true;

393 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

398 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

394 var webbrowserDelegate = findChild(stage, "appDelegate_" + webbrowserSurfaceId);

399 var webbrowserDelegate = findChild(stage, "appDelegate_" + webbrowserSurfaceId);

@@ -396,7 +401,7 @@ Rectangle {

396 compare(webbrowserDelegate.stage, ApplicationInfoInterface.MainStage);

401 compare(webbrowserDelegate.stage, ApplicationInfoInterface.MainStage);

397 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

402 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

398

403

399− var gallerySurfaceId = topSurfaceList.nextId;

404+ var gallerySurfaceId = topLevelSurfaceList.nextId;

400 galleryCheckBox.checked = true;

405 galleryCheckBox.checked = true;

401 waitUntilAppSurfaceShowsUp(gallerySurfaceId);

406 waitUntilAppSurfaceShowsUp(gallerySurfaceId);

402 var galleryApp = ApplicationManager.findApplication(galleryCheckBox.appId);

407 var galleryApp = ApplicationManager.findApplication(galleryCheckBox.appId);

@@ -408,14 +413,14 @@ Rectangle {

408 // then launch two side stage apps

413 // then launch two side stage apps

409 // facebook will be on foreground and dialer on background

414 // facebook will be on foreground and dialer on background

410

415

411− var dialerSurfaceId = topSurfaceList.nextId;

416+ var dialerSurfaceId = topLevelSurfaceList.nextId;

412 dialerCheckBox.checked = true;

417 dialerCheckBox.checked = true;

413 waitUntilAppSurfaceShowsUp(dialerSurfaceId);

418 waitUntilAppSurfaceShowsUp(dialerSurfaceId);

414 var dialerApp = ApplicationManager.findApplication(dialerCheckBox.appId);

419 var dialerApp = ApplicationManager.findApplication(dialerCheckBox.appId);

415 var dialerDelegate = findChild(stage, "appDelegate_" + dialerSurfaceId);

420 var dialerDelegate = findChild(stage, "appDelegate_" + dialerSurfaceId);

416 compare(dialerDelegate.stage, ApplicationInfoInterface.SideStage);

421 compare(dialerDelegate.stage, ApplicationInfoInterface.SideStage);

417

422

418− var facebookSurfaceId = topSurfaceList.nextId;

423+ var facebookSurfaceId = topLevelSurfaceList.nextId;

419 facebookCheckBox.checked = true;

424 facebookCheckBox.checked = true;

420 waitUntilAppSurfaceShowsUp(facebookSurfaceId);

425 waitUntilAppSurfaceShowsUp(facebookSurfaceId);

421 var facebookApp = ApplicationManager.findApplication(facebookCheckBox.appId);

426 var facebookApp = ApplicationManager.findApplication(facebookCheckBox.appId);

@@ -450,14 +455,14 @@ Rectangle {

450 function test_foregroundAppsAreSuspendedWhenStageIsSuspended() {

455 function test_foregroundAppsAreSuspendedWhenStageIsSuspended() {

451 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

456 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

452

457

453− var webbrowserSurfaceId = topSurfaceList.nextId;

458+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

454 webbrowserCheckBox.checked = true;

459 webbrowserCheckBox.checked = true;

455 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

460 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

456 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

461 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

457 var webbrowserDelegate = findChild(stage, "appDelegate_" + webbrowserSurfaceId);

462 var webbrowserDelegate = findChild(stage, "appDelegate_" + webbrowserSurfaceId);

458 compare(webbrowserDelegate.stage, ApplicationInfoInterface.MainStage);

463 compare(webbrowserDelegate.stage, ApplicationInfoInterface.MainStage);

459

464

460− var dialerSurfaceId = topSurfaceList.nextId;

465+ var dialerSurfaceId = topLevelSurfaceList.nextId;

461 dialerCheckBox.checked = true;

466 dialerCheckBox.checked = true;

462 waitUntilAppSurfaceShowsUp(dialerSurfaceId);

467 waitUntilAppSurfaceShowsUp(dialerSurfaceId);

463 var dialerApp = ApplicationManager.findApplication(dialerCheckBox.appId);

468 var dialerApp = ApplicationManager.findApplication(dialerCheckBox.appId);

@@ -531,7 +536,7 @@ Rectangle {

531 tryCompare(stagesPriv, "mainStageAppId", "unity8-dash");

536 tryCompare(stagesPriv, "mainStageAppId", "unity8-dash");

532 tryCompare(stagesPriv, "sideStageAppId", "");

537 tryCompare(stagesPriv, "sideStageAppId", "");

533

538

534− var appSurfaceId = topSurfaceList.nextId;

539+ var appSurfaceId = topLevelSurfaceList.nextId;

535 var app = ApplicationManager.startApplication(data.appId);

540 var app = ApplicationManager.startApplication(data.appId);

536 waitUntilAppSurfaceShowsUp(appSurfaceId);

541 waitUntilAppSurfaceShowsUp(appSurfaceId);

537

542

@@ -555,7 +560,7 @@ Rectangle {

555 tryCompare(stagesPriv, "mainStageAppId", "unity8-dash");

560 tryCompare(stagesPriv, "mainStageAppId", "unity8-dash");

556 tryCompare(stagesPriv, "sideStageAppId", "");

561 tryCompare(stagesPriv, "sideStageAppId", "");

557

562

558− var webbrowserSurfaceId = topSurfaceList.nextId;

563+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

559 webbrowserCheckBox.checked = true;

564 webbrowserCheckBox.checked = true;

560 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

565 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

561

566

@@ -580,7 +585,7 @@ Rectangle {

580 tryCompare(stagesPriv, "mainStageAppId", "unity8-dash");

585 tryCompare(stagesPriv, "mainStageAppId", "unity8-dash");

581 tryCompare(stagesPriv, "sideStageAppId", "");

586 tryCompare(stagesPriv, "sideStageAppId", "");

582

587

583− var webbrowserSurfaceId = topSurfaceList.nextId;

588+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

584 webbrowserCheckBox.checked = true;

589 webbrowserCheckBox.checked = true;

585 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

590 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

586

591

@@ -598,7 +603,7 @@ Rectangle {

598 function test_loadSideStageByDraggingFromMainStage() {

603 function test_loadSideStageByDraggingFromMainStage() {

599 sideStage.showNow();

604 sideStage.showNow();

600 print("sidestage now shown. launching browser")

605 print("sidestage now shown. launching browser")

601− var webbrowserSurfaceId = topSurfaceList.nextId;

606+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

602 webbrowserCheckBox.checked = true;

607 webbrowserCheckBox.checked = true;

603 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

608 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

604

609

@@ -619,7 +624,7 @@ Rectangle {

619 tryCompareFunction(function() {

624 tryCompareFunction(function() {

620 return WindowStateStorage.getStage(webbrowserCheckBox.appId, ApplicationInfoInterface.MainStage) === ApplicationInfoInterface.SideStage

625 return WindowStateStorage.getStage(webbrowserCheckBox.appId, ApplicationInfoInterface.MainStage) === ApplicationInfoInterface.SideStage

621 }, true);

626 }, true);

622− var webbrowserSurfaceId = topSurfaceList.nextId;

627+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

623 webbrowserCheckBox.checked = true;

628 webbrowserCheckBox.checked = true;

624 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

629 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

625

630

@@ -635,7 +640,7 @@ Rectangle {

635

640

636 /*

641 /*

637 1- Suspended app gets killed behind the scenes, causing its surface to go zombie.

642 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,

643+ 2- Surface gets screenshotted and removed. Its slot in the topLevelSurfaceList remains,

639 though (so ApplicationWindow can display the screenshot in its place).

644 though (so ApplicationWindow can display the screenshot in its place).

640 3- User taps on the screenshot of the long-gone surface.

645 3- User taps on the screenshot of the long-gone surface.

641

646

@@ -643,11 +648,11 @@ Rectangle {

643 Application gets relaunched. Its new surface will seamlessly replace the screenshot.

648 Application gets relaunched. Its new surface will seamlessly replace the screenshot.

644 */

649 */

645 function test_selectSuspendedAppWithoutSurface() {

650 function test_selectSuspendedAppWithoutSurface() {

646− compare(topSurfaceList.applicationAt(0).appId, "unity8-dash");

651+ compare(topLevelSurfaceList.applicationAt(0).appId, "unity8-dash");

647− var dashSurfaceId = topSurfaceList.idAt(0);

652+ var dashSurfaceId = topLevelSurfaceList.idAt(0);

648− var dashWindow = topSurfaceList.windowAt(0);

653+ var dashWindow = topLevelSurfaceList.windowAt(0);

649

654

650− var webbrowserSurfaceId = topSurfaceList.nextId;

655+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

651 webbrowserCheckBox.checked = true;

656 webbrowserCheckBox.checked = true;

652 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

657 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

653 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

658 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

@@ -662,24 +667,20 @@ Rectangle {

662 // simulate the suspended app being killed by the out-of-memory daemon

667 // simulate the suspended app being killed by the out-of-memory daemon

663 webbrowserApp.surfaceList.get(0).setLive(false);

668 webbrowserApp.surfaceList.get(0).setLive(false);

664

669

665− // wait until the surface is gone

666− tryCompare(webbrowserApp.surfaceList, "count", 0);

667− compare(topSurfaceList.surfaceAt(topSurfaceList.indexForId(webbrowserSurfaceId)), null);

668−

669 switchToSurface(webbrowserSurfaceId);

670 switchToSurface(webbrowserSurfaceId);

670

671

671 // webbrowser should have been brought to front

672 // webbrowser should have been brought to front

672− tryCompareFunction(function(){return topSurfaceList.idAt(0);}, webbrowserSurfaceId);

673+ tryCompareFunction(function(){return topLevelSurfaceList.idAt(0);}, webbrowserSurfaceId);

673

674

674 // and it should eventually get a new surface and get resumed

675 // and it should eventually get a new surface and get resumed

675− tryCompareFunction(function(){return topSurfaceList.surfaceAt(0) !== null;}, true);

676+ tryCompareFunction(function(){return topLevelSurfaceList.surfaceAt(0) !== null;}, true);

676− compare(topSurfaceList.count, 2); // still two top-level items

677+ compare(topLevelSurfaceList.count, 2); // still two top-level items

677 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

678 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

678 compare(webbrowserApp.surfaceList.count, 1);

679 compare(webbrowserApp.surfaceList.count, 1);

679 }

680 }

680

681

681 function test_draggingSurfaceKeepsSurfaceFocus() {

682 function test_draggingSurfaceKeepsSurfaceFocus() {

682− var webbrowserSurfaceId = topSurfaceList.nextId;

683+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

683 webbrowserCheckBox.checked = true;

684 webbrowserCheckBox.checked = true;

684 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

685 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

685

686

@@ -697,8 +698,8 @@ Rectangle {

697

698

698 function test_dashDoesNotDragToSidestage() {

699 function test_dashDoesNotDragToSidestage() {

699 sideStage.showNow();

700 sideStage.showNow();

700− compare(topSurfaceList.applicationAt(0).appId, "unity8-dash");

701+ compare(topLevelSurfaceList.applicationAt(0).appId, "unity8-dash");

701− var dashSurfaceId = topSurfaceList.idAt(0);

702+ var dashSurfaceId = topLevelSurfaceList.idAt(0);

702

703

703 var appDelegate = findChild(stage, "appDelegate_" + dashSurfaceId);

704 var appDelegate = findChild(stage, "appDelegate_" + dashSurfaceId);

704 verify(appDelegate);

705 verify(appDelegate);

@@ -720,7 +721,7 @@ Rectangle {

720

721

721 function test_switchRestoreStageOnRotation() {

722 function test_switchRestoreStageOnRotation() {

722 WindowStateStorage.saveStage(webbrowserCheckBox.appId, ApplicationInfoInterface.SideStage)

723 WindowStateStorage.saveStage(webbrowserCheckBox.appId, ApplicationInfoInterface.SideStage)

723− var webbrowserSurfaceId = topSurfaceList.nextId;

724+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

724 webbrowserCheckBox.checked = true;

725 webbrowserCheckBox.checked = true;

725 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

726 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

726

727

@@ -739,7 +740,7 @@ Rectangle {

739 }

740 }

740

741

741 function test_restoreSavedStageOnCloseReopen() {

742 function test_restoreSavedStageOnCloseReopen() {

742− var webbrowserSurfaceId = topSurfaceList.nextId;

743+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

743 webbrowserCheckBox.checked = true;

744 webbrowserCheckBox.checked = true;

744 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

745 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

745

746

@@ -757,7 +758,7 @@ Rectangle {

757 // back to landscape

758 // back to landscape

758 stage.shellOrientation = Qt.LandscapeOrientation;

759 stage.shellOrientation = Qt.LandscapeOrientation;

759

760

760− webbrowserSurfaceId = topSurfaceList.nextId;

761+ webbrowserSurfaceId = topLevelSurfaceList.nextId;

761 webbrowserCheckBox.checked = true;

762 webbrowserCheckBox.checked = true;

762 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

763 waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

763

764

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+41−29

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

@@ -262,6 +265,7 @@ Rectangle {

262 anchors { left: parent.left; right: parent.right }

265 anchors { left: parent.left; right: parent.right }

263 activeFocusOnPress: false

266 activeFocusOnPress: false

264 model: ["phone", "tablet", "desktop"]

267 model: ["phone", "tablet", "desktop"]

268+ selectedIndex: 2

265 onSelectedIndexChanged: {

269 onSelectedIndexChanged: {

266 shellLoader.state = model[selectedIndex];

270 shellLoader.state = model[selectedIndex];

267 }

271 }

@@ -275,6 +279,7 @@ Rectangle {

275 anchors { left: parent.left; right: parent.right }

279 anchors { left: parent.left; right: parent.right }

276 activeFocusOnPress: false

280 activeFocusOnPress: false

277 model: ["phone", "tablet", "desktop"]

281 model: ["phone", "tablet", "desktop"]

282+ selectedIndex: 0

278 }

283 }

279 MouseTouchEmulationCheckbox {

284 MouseTouchEmulationCheckbox {

280 id: mouseEmulation

285 id: mouseEmulation

@@ -560,6 +565,7 @@ Rectangle {

560 when: windowShown

565 when: windowShown

561

566

562 property Item shell: shellLoader.status === Loader.Ready ? shellLoader.item : null

567 property Item shell: shellLoader.status === Loader.Ready ? shellLoader.item : null

568+ topLevelSurfaceList: shell ? shell.topLevelSurfaceList : null

563

569

564 function init() {

570 function init() {

565 if (shellLoader.active) {

571 if (shellLoader.active) {

@@ -598,7 +604,6 @@ Rectangle {

598 waitForGreeterToStabilize();

604 waitForGreeterToStabilize();

599

605

600 // from StageTestCase

606 // from StageTestCase

601− topLevelSurfaceList = findInvisibleChild(shell, "topLevelSurfaceList");

602 verify(topLevelSurfaceList);

607 verify(topLevelSurfaceList);

603 stage = findChild(shell, "stage");

608 stage = findChild(shell, "stage");

604

609

@@ -678,9 +683,7 @@ Rectangle {

678 }

683 }

679

684

680 function ensureInputMethodSurface() {

685 function ensureInputMethodSurface() {

681− var surfaceManager = findInvisibleChild(shell, "surfaceManager");

682− verify(surfaceManager);

683− surfaceManager.createInputMethodSurface();

686+ SurfaceManager.createInputMethodSurface();

684

687

685 tryCompareFunction(function() { return root.topLevelSurfaceList.inputMethodSurface !== null }, true);

688 tryCompareFunction(function() { return root.topLevelSurfaceList.inputMethodSurface !== null }, true);

686 }

689 }

@@ -1709,9 +1712,9 @@ Rectangle {

1709 var spreadDelegate2 = appRepeater.itemAt(2);

1712 var spreadDelegate2 = appRepeater.itemAt(2);

1710 var closeMouseArea = findChild(spreadDelegate2, "closeMouseArea");

1713 var closeMouseArea = findChild(spreadDelegate2, "closeMouseArea");

1711

1714

1712− // Move the mosue over tile 2 and verify the close button becomes visible

1715+ // Move the mouse over tile 2 and verify the close button becomes visible

1713 var x = 0;

1716 var x = 0;

1714− var y = shell.height * .5;

1717+ var y = shell.height * .6;

1715 mouseMove(shell, x, y)

1718 mouseMove(shell, x, y)

1716 while (spreadItem.highlightedIndex !== 2 && x <= 4000) {

1719 while (spreadItem.highlightedIndex !== 2 && x <= 4000) {

1717 x+=10;

1720 x+=10;

@@ -1760,7 +1763,7 @@ Rectangle {

1760

1763

1761 // Move the mouse over tile 2 and verify the highlight becomes visible

1764 // Move the mouse over tile 2 and verify the highlight becomes visible

1762 var x = 0;

1765 var x = 0;

1763− var y = shell.height * (data.tileInfo ? .9 : 0.5)

1766+ var y = shell.height * (data.tileInfo ? .9 : 0.7)

1764 mouseMove(shell, x, y)

1767 mouseMove(shell, x, y)

1765 while (spreadItem.highlightedIndex !== 2 && x <= 4000) {

1768 while (spreadItem.highlightedIndex !== 2 && x <= 4000) {

1766 x+=10;

1769 x+=10;

@@ -1782,6 +1785,15 @@ Rectangle {

1782 function test_progressiveAutoScrolling() {

1785 function test_progressiveAutoScrolling() {

1783 loadDesktopShellWithApps()

1786 loadDesktopShellWithApps()

1784

1787

1788+ // load some more apps

1789+ ApplicationManager.startApplication("twitter-webapp")

1790+ ApplicationManager.startApplication("ubuntu-weather-app")

1791+ ApplicationManager.startApplication("notes-app")

1792+ for (var i = 0; i < topLevelSurfaceList.count; ++i) {

1793+ waitUntilAppWindowIsFullyLoaded(topLevelSurfaceList.idAt(i));

1794+ }

1795+

1796+

1785 var appRepeater = findInvisibleChild(shell, "appRepeater");

1797 var appRepeater = findInvisibleChild(shell, "appRepeater");

1786 verify(appRepeater !== null);

1798 verify(appRepeater !== null);

1787

1799

@@ -1794,7 +1806,7 @@ Rectangle {

1794

1806

1795 // Move the mouse to the right and make sure it scrolls the Flickable

1807 // Move the mouse to the right and make sure it scrolls the Flickable

1796 var x = 0;

1808 var x = 0;

1797− var y = shell.height * .5

1809+ var y = shell.height * .7

1798 mouseMove(shell, x, y)

1810 mouseMove(shell, x, y)

1799 while (x <= shell.width) {

1811 while (x <= shell.width) {

1800 x+=10;

1812 x+=10;

@@ -1885,21 +1897,21 @@ Rectangle {

1885 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

1897 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

1886

1898

1887 tryCompare(appDelegate, "state", "normal");

1899 tryCompare(appDelegate, "state", "normal");

1888− tryCompare(PanelState, "decorationsVisible", false)

1900+ tryCompare(panelState, "decorationsVisible", false)

1889

1901

1890 mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);

1902 mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);

1891 tryCompare(appDelegate, "state", "maximized");

1903 tryCompare(appDelegate, "state", "maximized");

1892− tryCompare(PanelState, "decorationsVisible", true)

1904+ tryCompare(panelState, "decorationsVisible", true)

1893

1905

1894 ApplicationManager.stopApplication(application.appId);

1906 ApplicationManager.stopApplication(application.appId);

1895− tryCompare(PanelState, "decorationsVisible", false)

1907+ tryCompare(panelState, "decorationsVisible", false)

1896

1908

1897 // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

1909 // 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.

1910 // They won't be gone until those surface items are destroyed.

1899 tryCompareFunction(function() { return application.surfaceList.count }, 0);

1911 tryCompareFunction(function() { return application.surfaceList.count }, 0);

1900

1912

1901 ApplicationManager.startApplication(application.appId);

1913 ApplicationManager.startApplication(application.appId);

1902− tryCompare(PanelState, "decorationsVisible", true)

1914+ tryCompare(panelState, "decorationsVisible", true)

1903 }

1915 }

1904

1916

1905 function test_newAppHasValidGeometry() {

1917 function test_newAppHasValidGeometry() {

@@ -1956,7 +1968,7 @@ Rectangle {

1956 mousePress(appDelegate, appDelegate.width / 2, units.gu(1))

1968 mousePress(appDelegate, appDelegate.width / 2, units.gu(1))

1957 mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))

1969 mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))

1958

1970

1959− compare(appDelegate.y >= PanelState.panelHeight, true);

1971+ compare(appDelegate.y >= panelState.panelHeight, true);

1960 }

1972 }

1961

1973

1962 function test_cantResizeWindowUnderPanel() {

1974 function test_cantResizeWindowUnderPanel() {

@@ -1984,7 +1996,7 @@ Rectangle {

1984 mouseMove(decoration, decoration.width/2, -units.gu(100));

1996 mouseMove(decoration, decoration.width/2, -units.gu(100));

1985

1997

1986 // verify we don't go past the panel

1998 // verify we don't go past the panel

1987− compare(appDelegate.y >= PanelState.panelHeight, true);

1999+ compare(appDelegate.y >= panelState.panelHeight, true);

1988 }

2000 }

1989

2001

1990 function test_restoreWindowStateFixesIfUnderPanel() {

2002 function test_restoreWindowStateFixesIfUnderPanel() {

@@ -2008,7 +2020,7 @@ Rectangle {

2008 tryCompareFunction(function () { return topLevelSurfaceList.applicationAt(0).appId; }, application.appId);

2020 tryCompareFunction(function () { return topLevelSurfaceList.applicationAt(0).appId; }, application.appId);

2009

2021

2010 appDelegate = appRepeater.itemAt(0);

2022 appDelegate = appRepeater.itemAt(0);

2011− compare(appDelegate.y >= PanelState.panelHeight, true);

2023+ compare(appDelegate.y >= panelState.panelHeight, true);

2012 }

2024 }

2013

2025

2014 function test_lifecyclePolicyForNonTouchApp_data() {

2026 function test_lifecyclePolicyForNonTouchApp_data() {

@@ -2671,9 +2683,9 @@ Rectangle {

2671

2683

2672 function test_oskDisplacesWindow_data() {

2684 function test_oskDisplacesWindow_data() {

2673 return [

2685 return [

2674− {tag: "no need to displace", windowHeight: units.gu(10), windowY: units.gu(5), targetDisplacement: units.gu(5), oskEnabled: true},

2686+ {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},

2687+ {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},

2688+ {tag: "osk not on this screen", windowHeight: units.gu(40), windowY: units.gu(10), targetDisplacement: function() { return units.gu(10); }, oskEnabled: false},

2677 ]

2689 ]

2678 }

2690 }

2679

2691

@@ -2695,11 +2707,11 @@ Rectangle {

2695 dashAppDelegate.windowedY = data.windowY;

2707 dashAppDelegate.windowedY = data.windowY;

2696 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2708 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2697 var initialY = dashAppDelegate.y;

2709 var initialY = dashAppDelegate.y;

2698− print("intial", initialY, "panel", PanelState.panelHeight);

2710+ print("intial", initialY, "panel", panelState.panelHeight);

2699− verify(initialY > PanelState.panelHeight);

2711+ verify(initialY > panelState.panelHeight);

2700

2712

2701 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, root.height / 2, root.width, root.height / 2));

2713 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, root.height / 2, root.width, root.height / 2));

2702− tryCompare(dashAppDelegate, "y", data.targetDisplacement);

2714+ tryCompare(dashAppDelegate, "y", data.targetDisplacement());

2703

2715

2704 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2716 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2705 tryCompare(dashAppDelegate, "y", initialY);

2717 tryCompare(dashAppDelegate, "y", initialY);

@@ -3132,7 +3144,7 @@ Rectangle {

3132 // double click the panel

3144 // double click the panel

3133 var panel = findChild(shell, "panel");

3145 var panel = findChild(shell, "panel");

3134 verify(panel);

3146 verify(panel);

3135− mouseDoubleClickSequence(panel, panel.width/2, PanelState.panelHeight/2, Qt.LeftButton, Qt.NoModifier, 300);

3147+ mouseDoubleClickSequence(panel, panel.width/2, panelState.panelHeight/2, Qt.LeftButton, Qt.NoModifier, 300);

3136 tryCompare(appDelegate, "state", "restored");

3148 tryCompare(appDelegate, "state", "restored");

3137 }

3149 }

3138

3150

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}