xenial...dcb2e88 · unity8

CMakeLists.txt+6−2

since splitsnapshots

unifiedsplit

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

70find_package(Qt5Concurrent 5.6 REQUIRED)

71find_package(Qt5Sql 5.6 REQUIRED)

72

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

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

74+pkg_check_modules(QTMIRSERVER REQUIRED qtmirserver>=0.6.0)

74pkg_check_modules(GEONAMES REQUIRED geonames>=0.2)

75pkg_check_modules(GEONAMES REQUIRED geonames>=0.2)

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

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

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

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

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

79pkg_check_modules(GD3 REQUIRED gnome-desktop-3.0)

80pkg_check_modules(GD3 REQUIRED gnome-desktop-3.0)

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

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

81pkg_check_modules(UBUNTUGESTURES REQUIRED UbuntuGestures)

82pkg_check_modules(UBUNTUGESTURES REQUIRED UbuntuGestures)

83+pkg_check_modules(MIRAL REQUIRED miral)

82

84

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

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

84find_path(UBUNTUGESTUREPRIV

86find_path(UBUNTUGESTUREPRIV

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

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

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

114endif()

116endif()

115

117

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

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

119+

120+set (CMAKE_CXX_STANDARD 14)

117

121

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

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

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

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

debian/control+9−3

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

31 libqmenumodel-dev (>= 0.2.11),

32 libqt5svg5-dev,

33 libqt5xmlpatterns5-dev,

34+ libqtmirserver-dev (>= 0.6.0),

34 libsystemsettings-dev,

35 libsystemsettings-dev,

35 libubuntu-app-launch3-dev,

36 libubuntu-app-launch3-dev,

36 libubuntu-download-manager-common-dev,

37 libubuntu-download-manager-common-dev,

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

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

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

39 libudev-dev,

40 libudev-dev,

40 libudm-common-dev,

41 libudm-common-dev,

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

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

42 libusermetricsoutput1-dev,

43 libusermetricsoutput1-dev,

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

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

44 libx11-dev[!arm64 !armhf],

45 libx11-dev[!arm64 !armhf],

45 libxcb1-dev[!arm64 !armhf],

46 libxcb1-dev[!arm64 !armhf],

46 libxi-dev[!arm64 !armhf],

47 libxi-dev[!arm64 !armhf],

47# End of X11 libs

48# End of X11 libs

49+ mirtest-dev,

48 pkg-config,

50 pkg-config,

49 python3-all:any,

51 python3-all:any,

50 python3-setuptools,

52 python3-setuptools,

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

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

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

71 ttf-ubuntu-font-family,

73 ttf-ubuntu-font-family,

72 xvfb,

74 xvfb,

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

76+ libboost-filesystem-dev,

77+ libboost-system-dev,

73Standards-Version: 3.9.4

78Standards-Version: 3.9.4

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

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

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

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

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

131 qml-module-ubuntu-web,

136 qml-module-ubuntu-web,

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

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

133 qtdeclarative5-ubuntu-telephony0.1,

138 qtdeclarative5-ubuntu-telephony0.1,

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

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

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

135 unity-launcher-impl-10,

141 unity-launcher-impl-10,

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

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

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

162 qttranslations5-l10n,

168 qttranslations5-l10n,

163 ubuntu-thumbnailer-impl-0,

169 ubuntu-thumbnailer-impl-0,

164 ubuntu-wallpapers,

170 ubuntu-wallpapers,

165− unity-application-impl-26,

171+ unity-application-impl-27,

166 unity-notifications-impl-3,

172 unity-notifications-impl-3,

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

173 unity-plugin-scopes | unity-scopes-impl,

168 unity-scopes-impl-12,

174 unity-scopes-impl-12,

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

212 ${misc:Depends},

218 ${misc:Depends},

213 ${shlibs:Depends},

219 ${shlibs:Depends},

214Provides: unity-application-impl,

220Provides: unity-application-impl,

215− unity-application-impl-26,

221+ unity-application-impl-27,

216 unity8-fake-env,

222 unity8-fake-env,

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

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

218 unity8-fake-env,

224 unity8-fake-env,

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/UInput/plugin.cpp+7−1

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

19

20#include <QtQml/qqml.h>

21

22+

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

24+{

25+ return new UInput;

26+}

27+

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

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

23{

29{

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

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

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

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

26}

32}

plugins/Unity/CMakeLists.txt+1

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

1add_subdirectory(ApplicationMenu)

2add_subdirectory(Connectivity)

3+add_subdirectory(Debug)

3add_subdirectory(Indicators)

4add_subdirectory(Indicators)

4add_subdirectory(Launcher)

5add_subdirectory(Launcher)

5add_subdirectory(Session)

6add_subdirectory(Session)

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

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

1+include_directories(

2+ ${CMAKE_CURRENT_SOURCE_DIR}

3+ ${CMAKE_CURRENT_BINARY_DIR}

4+)

5+

6+include_directories(

7+ SYSTEM

8+ ${Qt5Gui_PRIVATE_INCLUDE_DIRS}

9+ ${Qt5Quick_PRIVATE_INCLUDE_DIRS}

10+ ${GIO_INCLUDE_DIRS}

11+)

12+

13+set(QMLPLUGIN_SRC

14+ consolelog.cpp

15+ plugin.cpp

16+ )

17+

18+add_library(Debug-qml SHARED

19+ ${QMLPLUGIN_SRC}

20+ )

21+

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

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

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

25+# files directly in targets.

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

27+

28+qt5_use_modules(Debug-qml Qml Quick Concurrent)

29+

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

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

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU Lesser General Public License for more details.

12+ *

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

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

15+*/

16+

17+#include "consolelog.h"

18+

19+#include <unistd.h>

20+#include <stdio.h>

21+#include <thread>

22+#include <iostream>

23+#include <sys/ioctl.h>

24+

25+#include <functional>

26+

27+namespace

28+{

29+

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

31+{

32+ int ret = -1;

33+ bool fd_blocked = false;

34+ do

35+ {

36+ ret = fn();

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

38+ if (fd_blocked)

39+ QThread::msleep(10);

40+ }

41+ while (ret < 0);

42+ return ret;

43+}

44+

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

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

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

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

49+

50+}

51+

52+LogRedirector::LogRedirector()

53+ : m_ref(0)

54+ , m_stop(false)

55+{

56+ setObjectName("ConsoleLog");

57+

58+ // make stdout & stderr streams unbuffered

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

60+ // before capture and after capture

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

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

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

64+}

65+

66+void LogRedirector::run()

67+{

68+ PIPE_WAIT(m_pipe);

69+

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

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

72+

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

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

75+ CLOSE_WAIT(m_pipe[WRITE]);

76+

77+ while(true) {

78+ {

79+ QMutexLocker lock(&m_mutex);

80+ if (m_stop) break;

81+ }

82+ checkLog();

83+ QThread::msleep(50);

84+ }

85+

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

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

88+

89+ CLOSE_WAIT(oldStdOut);

90+ CLOSE_WAIT(oldStdErr);

91+ CLOSE_WAIT(m_pipe[READ]);

92+}

93+

94+

95+void LogRedirector::checkLog()

96+{

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

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

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

100+ int count = 0;

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

102+ if (count <= 0) return;

103+

104+ std::string captured;

105+ std::string buf;

106+ const int bufSize = 1024;

107+ buf.resize(bufSize);

108+ int bytesRead = 0;

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

110+ while(bytesRead == bufSize)

111+ {

112+ captured += buf;

113+ bytesRead = 0;

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

115+ }

116+ if (bytesRead > 0)

117+ {

118+ buf.resize(bytesRead);

119+ captured += buf;

120+ }

121+

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

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

124+ }

125+}

126+

127+LogRedirector *LogRedirector::instance()

128+{

129+ static LogRedirector* log = nullptr;

130+ if (!log) {

131+ log = new LogRedirector();

132+ }

133+ return log;

134+}

135+

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

137+{

138+ QMutexLocker lock(&m_mutex);

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

140+

141+ m_ref++;

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

143+ m_stop = false;

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

145+ }

146+}

147+

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

149+{

150+ QMutexLocker lock(&m_mutex);

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

152+

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

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

155+ m_stop = true;

156+ lock.unlock();

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

158+ }

159+}

160+

161+ConsoleLog::ConsoleLog(QObject *parent)

162+ : QObject(parent)

163+ , m_enabled(false)

164+ , m_maxLines(60)

165+{

166+ auto updateEnabled = [this]() {

167+ if (m_enabled) {

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

169+ } else {

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

171+ }

172+ };

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

174+}

175+

176+ConsoleLog::~ConsoleLog()

177+{

178+ if (m_enabled) {

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

180+ }

181+}

182+

183+void ConsoleLog::setEnabled(bool enabled)

184+{

185+ if (m_enabled == enabled) {

186+ return;

187+ }

188+

189+ m_enabled = enabled;

190+ Q_EMIT enabledChanged();

191+}

192+

193+QString ConsoleLog::out() const

194+{

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

196+}

197+

198+void ConsoleLog::setMaxLines(int maxLines)

199+{

200+ if (m_maxLines == maxLines) {

201+ return;

202+ }

203+

204+ m_maxLines = maxLines;

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

206+ m_out.removeLast();

207+ }

208+ Q_EMIT outChanged();

209+ Q_EMIT maxLinesChanged();

210+}

211+

212+void ConsoleLog::logged(QString captured)

213+{

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

215+ li << m_out;

216+ m_out = li;

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

218+ m_out.removeLast();

219+ }

220+ Q_EMIT outChanged();

221+}

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

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU Lesser General Public License for more details.

12+ *

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

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

15+*/

16+

17+#ifndef CONSOLELOG_H

18+#define CONSOLELOG_H

19+

20+#include <QThread>

21+#include <QMutex>

22+#include <QSet>

23+

24+class ConsoleLog;

25+

26+class LogRedirector : public QThread

27+{

28+ Q_OBJECT

29+public:

30+ static LogRedirector *instance();

31+

32+ void add(ConsoleLog* logger);

33+ void remove(ConsoleLog* logger);

34+

35+private Q_SLOTS:

36+ void checkLog();

37+

38+Q_SIGNALS:

39+ void log(QString log);

40+

41+private:

42+ LogRedirector();

43+ void run() Q_DECL_OVERRIDE;

44+

45+ QMutex m_mutex;

46+ int m_pipe[2];

47+ int m_ref;

48+ bool m_stop;

49+

50+ enum PIPES { READ, WRITE };

51+};

52+

53+class ConsoleLog : public QObject

54+{

55+ Q_OBJECT

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

57+ Q_PROPERTY(QString out READ out NOTIFY outChanged)

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

59+public:

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

61+ ~ConsoleLog();

62+

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

64+ void setEnabled(bool enabled);

65+

66+ QString out() const;

67+

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

69+ void setMaxLines(int maxLines);

70+

71+public Q_SLOTS:

72+ void logged(QString captured);

73+

74+Q_SIGNALS:

75+ void enabledChanged();

76+ void outChanged();

77+ void maxLinesChanged();

78+

79+private:

80+ void updateEnabled();

81+

82+ QStringList m_out;

83+ bool m_enabled;

84+ int m_maxLines;

85+};

86+

87+#endif // CONSOLELOG_H

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

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+// Qt

18+#include <QtQml/qqml.h>

19+

20+// self

21+#include "plugin.h"

22+

23+// local

24+#include "consolelog.h"

25+

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

27+{

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

29+

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

31+}

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

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

1/*

3 *

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

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

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

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

15 */

16

17−#ifndef UNITY_SHELL_VIEW_H

17+#ifndef UNITYDEBUG_PLUGIN_H

18−#define UNITY_SHELL_VIEW_H

18+#define UNITYDEBUG_PLUGIN_H

19

20−#include <QQuickView>

20+#include <QtQml/QQmlEngine>

21+#include <QtQml/QQmlExtensionPlugin>

21

22

22−class ShellView : public QQuickView

23+class UnityDebugPlugin : public QQmlExtensionPlugin

23{

24{

24 Q_OBJECT

25 Q_OBJECT

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

25

27

26public:

28public:

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

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

28−

29−private Q_SLOTS:

30− void onWidthChanged(int);

31− void onHeightChanged(int);

32};

30};

33

31

34−#endif // UNITY_SHELL_VIEW_H

32+#endif

plugins/Unity/Debug/qmldirnew file+3

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

1+module Unity.Debug

2+plugin Debug-qml

3+typeinfo Debug.qmltypes

plugins/WindowManager/CMakeLists.txt+24−2

@@ -1,16 +1,38 @@

1+include_directories(

2+ SYSTEM

3+ ${QTMIRSERVER_INCLUDE_DIRS}

4+)

5+

6+include_directories(

7+ ${CMAKE_CURRENT_SOURCE_DIR}

8+ ${libunity8-private_SOURCE_DIR}

9+)

10+

1set(WINDOWMANAGER_SRC

11set(WINDOWMANAGER_SRC

2 TopLevelWindowModel.cpp

12 TopLevelWindowModel.cpp

3 Window.cpp

13 Window.cpp

4 WindowManagerPlugin.cpp

14 WindowManagerPlugin.cpp

15+ Screen.cpp

16+ ScreenAttached.cpp

17+ Screens.cpp

18+ ScreenWindow.cpp

19+ Workspace.cpp

20+ WorkspaceManager.cpp

21+ WorkspaceModel.cpp

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

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

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

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

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

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

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

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

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

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

10− )

27+)

11

28

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

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

13

30

31+target_link_libraries(windowmanager-qml

32+ ${QTMIRSERVER_LDFLAGS}

33+ unity8-private

34+)

35+

14qt5_use_modules(windowmanager-qml Qml Quick Gui)

36qt5_use_modules(windowmanager-qml Qml Quick Gui)

15

37

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

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

plugins/WindowManager/Screen.cppnew file+294

@@ -0,0 +1,294 @@

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#include "Screen.h"

18+#include "Screens.h"

19+#include "WorkspaceManager.h"

20+#include "Workspace.h"

21+

22+ScreenInterface::ScreenInterface(QObject *parent)

23+ : QObject(parent)

24+{

25+}

26+

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

28+{

29+ m_wrapped = screen;

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

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

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

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

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

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

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

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

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

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

40+}

41+

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

43+{

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

45+ return m_wrapped->outputId();

46+}

47+

48+bool ScreenInterface::used() const

49+{

50+ if (!m_wrapped) return false;

51+ return m_wrapped->used();

52+}

53+

54+QString ScreenInterface::name() const

55+{

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

57+ return m_wrapped->name();

58+}

59+

60+float ScreenInterface::scale() const

61+{

62+ if (!m_wrapped) return 1.0;

63+ return m_wrapped->scale();

64+}

65+

66+QSizeF ScreenInterface::physicalSize() const

67+{

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

69+ return m_wrapped->physicalSize();

70+}

71+

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

73+{

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

75+ return m_wrapped->formFactor();

76+}

77+

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

79+{

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

81+ return m_wrapped->outputType();

82+}

83+

84+MirPowerMode ScreenInterface::powerMode() const

85+{

86+ if (!m_wrapped) return mir_power_mode_on;

87+ return m_wrapped->powerMode();

88+}

89+

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

91+{

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

93+ return m_wrapped->orientation();

94+}

95+

96+QPoint ScreenInterface::position() const

97+{

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

99+ return m_wrapped->position();

100+}

101+

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

103+{

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

105+ return m_wrapped->availableModes();

106+}

107+

108+uint ScreenInterface::currentModeIndex() const

109+{

110+ if (!m_wrapped) return -1;

111+ return m_wrapped->currentModeIndex();

112+}

113+

114+bool ScreenInterface::isActive() const

115+{

116+ if (!m_wrapped) return false;

117+ return m_wrapped->isActive();

118+}

119+

120+void ScreenInterface::activate()

121+{

122+ setActive(true);

123+}

124+

125+void ScreenInterface::setActive(bool active)

126+{

127+ if (!m_wrapped) return;

128+ m_wrapped->setActive(active);

129+}

130+

131+QScreen *ScreenInterface::qscreen() const

132+{

133+ if (!m_wrapped) return nullptr;

134+ return m_wrapped->qscreen();

135+}

136+

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

138+{

139+ if (!m_wrapped) return nullptr;

140+ return m_wrapped->beginConfiguration();

141+}

142+

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

144+{

145+ if (!m_wrapped) return false;

146+ return m_wrapped->applyConfiguration(configuration);

147+}

148+

149+QString ScreenInterface::outputTypeName() const

150+{

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

152+ case qtmir::Unknown:

153+ return tr("Unknown");

154+ case qtmir::VGA:

155+ return tr("VGA");

156+ case qtmir::DVII:

157+ case qtmir::DVID:

158+ case qtmir::DVIA:

159+ return tr("DVI");

160+ case qtmir::Composite:

161+ return tr("Composite");

162+ case qtmir::SVideo:

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

164+ case qtmir::LVDS:

165+ case qtmir::NinePinDIN:

166+ case qtmir::EDP:

167+ return tr("Internal");

168+ case qtmir::Component:

169+ return tr("Component");

170+ case qtmir::DisplayPort:

171+ return tr("DisplayPort");

172+ case qtmir::HDMIA:

173+ case qtmir::HDMIB:

174+ return tr("HDMI");

175+ case qtmir::TV:

176+ return tr("TV");

177+ }

178+ return QString();

179+}

180+

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

182+{

183+ if (!proxy) return;

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

185+}

186+

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

188+ : m_workspaces(new WorkspaceModel)

189+{

190+ connectToScreen(wrapped);

191+

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

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

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

195+ if (active) {

196+ setCurrentWorkspace(workspace);

197+ activate();

198+ }

199+ });

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

201+ activate();

202+ setCurrentWorkspace(workspace);

203+ }

204+ if (!m_currentWorspace) {

205+ setCurrentWorkspace(workspace);

206+ }

207+ });

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

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

210+ if (workspace == m_currentWorspace) {

211+ resetCurrentWorkspace();

212+ }

213+ });

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

215+ if (active && m_currentWorspace) {

216+ m_currentWorspace->activate();

217+ }

218+ });

219+

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

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

222+}

223+

224+void Screen::resetCurrentWorkspace()

225+{

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

227+ if (m_currentWorspace != newCurrent) {

228+ m_currentWorspace = newCurrent;

229+ Q_EMIT currentWorkspaceChanged(newCurrent);

230+ }

231+}

232+

233+

234+WorkspaceModel *Screen::workspaces() const

235+{

236+ return m_workspaces.data();

237+}

238+

239+Workspace *Screen::currentWorkspace() const

240+{

241+ return m_currentWorspace.data();

242+}

243+

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

245+{

246+ if (m_currentWorspace != workspace) {

247+ m_currentWorspace = workspace;

248+ Q_EMIT currentWorkspaceChanged(workspace);

249+ }

250+}

251+

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

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

254+ , m_original(screen)

255+{

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

257+

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

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

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

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

262+ if (m_currentWorspace != p) {

263+ m_currentWorspace = p;

264+ Q_EMIT currentWorkspaceChanged(p);

265+ }

266+ }

267+ }

268+ };

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

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

271+}

272+

273+WorkspaceModel *ScreenProxy::workspaces() const

274+{

275+ return m_workspaces.data();

276+}

277+

278+Workspace *ScreenProxy::currentWorkspace() const

279+{

280+ return m_currentWorspace.data();

281+}

282+

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

284+{

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

286+ if (p) {

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

288+ }

289+}

290+

291+void ScreenProxy::addWorkspace()

292+{

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

294+}

plugins/WindowManager/Screen.hnew file+133

@@ -0,0 +1,133 @@

1+#ifndef SCREEN_H

2+#define SCREEN_H

3+

4+#include <qtmir/screen.h>

5+#include <QScopedPointer>

6+#include <QPointer>

7+

8+#include "WorkspaceModel.h"

9+

10+class ScreenProxy;

11+class ScreenAttached;

12+

13+class ScreenInterface: public QObject

14+{

15+ Q_OBJECT

16+

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

18+

19+ Q_PROPERTY(bool used READ used NOTIFY usedChanged)

20+ Q_PROPERTY(QString name READ name NOTIFY nameChanged)

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

22+ Q_PROPERTY(float scale READ scale NOTIFY scaleChanged)

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

24+ Q_PROPERTY(MirPowerMode powerMode READ powerMode NOTIFY powerModeChanged)

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

26+ Q_PROPERTY(QPoint position READ position NOTIFY positionChanged)

27+ Q_PROPERTY(uint currentModeIndex READ currentModeIndex NOTIFY currentModeIndexChanged)

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

29+ Q_PROPERTY(QSizeF physicalSize READ physicalSize NOTIFY physicalSizeChanged)

30+ Q_PROPERTY(QString outputTypeName READ outputTypeName NOTIFY outputTypeChanged)

31+

32+ Q_PROPERTY(WorkspaceModel* workspaces READ workspaces CONSTANT)

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

34+public:

35+ // From qtmir::Screen

36+ qtmir::OutputId outputId() const;

37+ bool used() const;

38+ QString name() const;

39+ float scale() const;

40+ QSizeF physicalSize() const;

41+ qtmir::FormFactor formFactor() const;

42+ qtmir::OutputTypes outputType() const;

43+ MirPowerMode powerMode() const;

44+ Qt::ScreenOrientation orientation() const;

45+ QPoint position() const;

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

47+ uint currentModeIndex() const;

48+ bool isActive() const;

49+ void setActive(bool active);

50+ QScreen* qscreen() const;

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

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

53+ QString outputTypeName() const;

54+

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

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

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

58+

59+ void sync(ScreenInterface* proxy);

60+

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

62+

63+public Q_SLOTS:

64+ void activate();

65+

66+Q_SIGNALS:

67+ void usedChanged();

68+ void nameChanged();

69+ void outputTypeChanged();

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+ ScreenInterface(QObject* parent = 0);

83+

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

85+

86+protected:

87+ QPointer<qtmir::Screen> m_wrapped;

88+};

89+

90+

91+class Screen : public ScreenInterface

92+{

93+ Q_OBJECT

94+public:

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

96+

97+ // From qtmir::Screen

98+ WorkspaceModel* workspaces() const override;

99+ Workspace *currentWorkspace() const override;

100+ void setCurrentWorkspace(Workspace* workspace) override;

101+

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

103+

104+protected:

105+ void resetCurrentWorkspace();

106+

107+ const QScopedPointer<WorkspaceModel> m_workspaces;

108+ QPointer<Workspace> m_currentWorspace;

109+};

110+

111+class ScreenProxy : public ScreenInterface

112+{

113+ Q_OBJECT

114+public:

115+ explicit ScreenProxy(ScreenInterface*const screen);

116+

117+ // From qtmir::Screen

118+ WorkspaceModel* workspaces() const override;

119+ Workspace *currentWorkspace() const override;

120+ void setCurrentWorkspace(Workspace* workspace) override;

121+

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

123+

124+public Q_SLOTS:

125+ void addWorkspace();

126+

127+private:

128+ const QScopedPointer<WorkspaceModel> m_workspaces;

129+ const QPointer<ScreenInterface> m_original;

130+ QPointer<Workspace> m_currentWorspace;

131+};

132+

133+#endif // SCREEN_H

plugins/WindowManager/ScreenAttached.cppnew file+149

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#include "ScreenAttached.h"

18+#include "ScreenWindow.h"

19+#include "Screens.h"

20+

21+#include <QQuickItem>

22+#include <QScreen>

23+

24+ScreenAttached::ScreenAttached(QObject *owner)

25+ : ScreenInterface(owner)

26+ , m_window(nullptr)

27+{

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

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

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

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

32+ windowChanged(window);

33+ }

34+}

35+

36+WorkspaceModel *ScreenAttached::workspaces() const

37+{

38+ if (!m_screen) return nullptr;

39+ return m_screen->workspaces();

40+}

41+

42+Workspace *ScreenAttached::currentWorkspace() const

43+{

44+ if (!m_screen) return nullptr;

45+ return m_screen->currentWorkspace();

46+}

47+

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

49+{

50+ if (!m_screen) return;

51+ return m_screen->setCurrentWorkspace(workspace);

52+}

53+

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

55+{

56+ if (m_window) {

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

58+ }

59+

60+ m_window = window;

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

62+

63+ if (screenWindow) {

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

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

66+ } else {

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

68+ if (window) {

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

70+ }

71+ }

72+}

73+

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

75+{

76+ // Find a screen that matches.

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

78+ ScreenInterface* screen{nullptr};

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

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

81+ screen = s;

82+ }

83+ }

84+ screenChanged2(screen);

85+}

86+

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

88+{

89+ if (screen == m_screen) return;

90+

91+ ScreenInterface* oldScreen = m_screen;

92+ m_screen = screen;

93+

94+ if (oldScreen)

95+ oldScreen->disconnect(this);

96+

97+ if (!screen)

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

99+

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

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

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

103+ Q_EMIT usedChanged();

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

105+ Q_EMIT nameChanged();

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

107+ Q_EMIT outputTypeChanged();

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

109+ Q_EMIT scaleChanged();

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

111+ Q_EMIT formFactorChanged();

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

113+ Q_EMIT powerModeChanged();

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

115+ Q_EMIT orientationChanged();

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

117+ Q_EMIT positionChanged();

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

119+ Q_EMIT currentModeIndexChanged();

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

121+ Q_EMIT physicalSizeChanged();

122+

123+ if (oldScreen) {

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

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

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

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

128+ }

129+

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

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

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

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

134+ }

135+

136+ if (newModes != newModes) {

137+ Q_EMIT availableModesChanged();

138+ }

139+ } else {

140+ Q_EMIT availableModesChanged();

141+ }

142+

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

144+}

145+

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

147+{

148+ return new ScreenAttached(owner);

149+}

plugins/WindowManager/ScreenAttached.hnew file+56

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef SCREENATTACHED_H

18+#define SCREENATTACHED_H

19+

20+#include "Screen.h"

21+

22+#include <QQmlEngine>

23+#include <QtQml>

24+

25+class QQuickWindow;

26+

27+class ScreenAttached : public ScreenInterface

28+{

29+ Q_OBJECT

30+public:

31+ ScreenAttached(QObject* owner);

32+

33+ WorkspaceModel* workspaces() const override;

34+ Workspace *currentWorkspace() const override;

35+ void setCurrentWorkspace(Workspace* workspace) override;

36+

37+private Q_SLOTS:

38+ void windowChanged(QQuickWindow*);

39+ void screenChanged(QScreen*);

40+ void screenChanged2(ScreenInterface* screen);

41+

42+private:

43+ QPointer<ScreenInterface> m_screen;

44+ QQuickWindow* m_window;

45+};

46+

47+class WMScreen : public QObject

48+{

49+ Q_OBJECT

50+public:

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

52+};

53+

54+QML_DECLARE_TYPEINFO(WMScreen, QML_HAS_ATTACHED_PROPERTIES)

55+

56+#endif // SCREENATTACHED_H

plugins/WindowManager/ScreenWindow.cppnew file+45

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#include "ScreenWindow.h"

18+#include "Screen.h"

19+

20+// Qt

21+#include <QGuiApplication>

22+#include <QDebug>

23+

24+ScreenWindow::ScreenWindow(QQuickWindow *parent)

25+ : QQuickWindow(parent)

26+{

27+}

28+

29+ScreenWindow::~ScreenWindow()

30+{

31+}

32+

33+Screen *ScreenWindow::screenWrapper() const

34+{

35+ return m_screen.data();

36+}

37+

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

39+{

40+ if (m_screen != screen) {

41+ m_screen = screen;

42+ Q_EMIT screenWrapperChanged(screen);

43+ }

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

45+}

plugins/WindowManager/ScreenWindow.hnew file+49

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef UNITY_SCREENWINDOW_H

18+#define UNITY_SCREENWINDOW_H

19+

20+#include <QQuickWindow>

21+#include <QPointer>

22+

23+#include "Screen.h"

24+

25+class ScreenAdapter;

26+

27+/*

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

29+**/

30+class ScreenWindow : public QQuickWindow

31+{

32+ Q_OBJECT

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

34+ Q_PROPERTY(int winId READ winId CONSTANT)

35+public:

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

37+ ~ScreenWindow();

38+

39+ Screen *screenWrapper() const;

40+ void setScreenWrapper(Screen *screen);

41+

42+Q_SIGNALS:

43+ void screenWrapperChanged(Screen* screen);

44+

45+private:

46+ QPointer<Screen> m_screen;

47+};

48+

49+#endif // UNITY_SCREENWINDOW_H

plugins/WindowManager/Screens.cppnew file+213

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#include "Screens.h"

18+#include "Screen.h"

19+#include "WorkspaceManager.h"

20+

21+// qtmirserver

22+#include <qtmir/screens.h>

23+#include <QGuiApplication>

24+#include <QQmlEngine>

25+

26+// Qt

27+#include <QScreen>

28+#include <QWindow>

29+

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

31+

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

33+ : m_wrapped(model)

34+{

35+ m_self = this;

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

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

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

39+

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

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

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

43+ m_screens.push_back(screenWrapper);

44+ }

45+}

46+

47+Screens::~Screens()

48+{

49+ qDeleteAll(m_screens);

50+ m_screens.clear();

51+}

52+

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

54+ : QAbstractListModel(nullptr)

55+ , m_wrapped(other.m_wrapped)

56+{

57+}

58+

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

60+{

61+ QHash<int, QByteArray> roles;

62+ roles[ScreenRole] = "screen";

63+ return roles;

64+}

65+

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

67+{

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

69+ return QVariant();

70+ }

71+

72+ switch(role) {

73+ case ScreenRole:

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

75+ } // switch

76+

77+ return QVariant();

78+}

79+

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

81+{

82+ return count();

83+}

84+

85+int Screens::count() const

86+{

87+ return m_screens.size();

88+}

89+

90+QVariant Screens::activeScreen() const

91+{

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

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

94+ }

95+ return QVariant();

96+}

97+

98+Screens *Screens::self()

99+{

100+ return Screens::m_self;

101+}

102+

103+ScreensProxy *Screens::createProxy()

104+{

105+ return new ScreensProxy(this);

106+}

107+

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

109+{

110+ if (!proxy) return;

111+

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

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

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

115+ }

116+

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

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

119+}

120+

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

122+{

123+ bool ok = false;

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

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

126+

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

128+ screen->setActive(true);

129+}

130+

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

132+{

133+ Q_FOREACH(auto screenWrapper, m_screens) {

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

135+ }

136+

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

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

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

140+ m_screens.push_back(screenWrapper);

141+ endInsertRows();

142+ Q_EMIT screenAdded(screenWrapper);

143+ Q_EMIT countChanged();

144+}

145+

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

147+{

148+ int index = 0;

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

150+ while(iter.hasNext()) {

151+ auto screenWrapper = iter.next();

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

153+

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

155+ iter.remove();

156+ endRemoveRows();

157+

158+ Q_EMIT screenRemoved(screenWrapper);

159+ Q_EMIT countChanged();

160+

161+ screenWrapper->deleteLater();

162+ break;

163+ }

164+ index++;

165+ }

166+}

167+

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

169+ : Screens(*screens)

170+ , m_original(screens)

171+{

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

173+ Q_FOREACH(auto screen, m_screens) {

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

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

176+ }

177+

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

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

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

181+ m_screens.push_back(screenWrapper);

182+ endInsertRows();

183+ Q_EMIT screenAdded(screenWrapper);

184+ Q_EMIT countChanged();

185+ });

186+

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

188+ int index = 0;

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

190+ while(iter.hasNext()) {

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

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

193+

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

195+ iter.remove();

196+ endRemoveRows();

197+

198+ Q_EMIT screenRemoved(proxy);

199+ Q_EMIT countChanged();

200+

201+ delete proxy;

202+ break;

203+ }

204+ index++;

205+ }

206+ });

207+

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

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

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

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

212+ }

213+}

plugins/WindowManager/Screens.hnew file+93

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef UNITY_SCREENS_H

18+#define UNITY_SCREENS_H

19+

20+#include <QAbstractListModel>

21+#include <QSharedPointer>

22+#include <QPointer>

23+

24+namespace qtmir

25+{

26+class Screen;

27+class Screens;

28+}

29+

30+class ScreenInterface;

31+class ScreensProxy;

32+

33+class Screens : public QAbstractListModel

34+{

35+ Q_OBJECT

36+ Q_PROPERTY(int count READ count NOTIFY countChanged)

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

38+

39+public:

40+ enum ItemRoles {

41+ ScreenRole = Qt::UserRole + 1

42+ };

43+

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

45+ ~Screens();

46+

47+ Q_INVOKABLE ScreensProxy *createProxy();

48+ Q_INVOKABLE void sync(Screens *proxy);

49+

50+ /* QAbstractItemModel */

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

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

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

54+

55+ int count() const;

56+ QVariant activeScreen() const;

57+

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

59+

60+ static Screens *self();

61+

62+public Q_SLOTS:

63+ void activateScreen(const QVariant& index);

64+

65+Q_SIGNALS:

66+ void countChanged();

67+ void activeScreenChanged();

68+

69+ void screenAdded(ScreenInterface* screen);

70+ void screenRemoved(ScreenInterface* screen);

71+

72+private Q_SLOTS:

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

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

75+

76+protected:

77+ Screens(const Screens& other);

78+

79+ QVector<ScreenInterface*> m_screens;

80+ QSharedPointer<qtmir::Screens> m_wrapped;

81+ static Screens* m_self;

82+};

83+

84+class ScreensProxy : public Screens

85+{

86+public:

87+ ScreensProxy(Screens*const screens);

88+

89+private:

90+ const QPointer<Screens> m_original;

91+};

92+

93+#endif // SCREENS_H

plugins/WindowManager/TopLevelWindowModel.cpp+216−52

@@ -24,11 +24,16 @@

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

25

26// Qt

27−#include <QGuiApplication>

28#include <QDebug>

27#include <QDebug>

29

28

30// local

29// local

31#include "Window.h"

30#include "Window.h"

31+#include "Workspace.h"

32+#include "wmpolicyinterface.h"

33+

34+// qtmir

35+#include <qtmir/mirserverapplication.h>

36+#include <qtmir/windowmodelnotifier.h>

32

37

33Q_LOGGING_CATEGORY(TOPLEVELWINDOWMODEL, "toplevelwindowmodel", QtInfoMsg)

38Q_LOGGING_CATEGORY(TOPLEVELWINDOWMODEL, "toplevelwindowmodel", QtInfoMsg)

34

39

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

55 beginResetModel();

60 beginResetModel();

56

61

57 if (m_applicationManager) {

62 if (m_applicationManager) {

58− m_windowModel.clear();

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

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

60 }

64 }

61

65

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

64 if (m_applicationManager) {

68 if (m_applicationManager) {

65 connect(m_applicationManager, &QAbstractItemModel::rowsInserted,

69 connect(m_applicationManager, &QAbstractItemModel::rowsInserted,

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

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

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

72+ return;

73+

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

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

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

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

69− addApplication(application);

76+ addApplication(application);

70− }

77+ }

71− });

78+ });

72

79

73 connect(m_applicationManager, &QAbstractItemModel::rowsAboutToBeRemoved,

80 connect(m_applicationManager, &QAbstractItemModel::rowsAboutToBeRemoved,

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

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

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

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

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

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

77− removeApplication(application);

84+ removeApplication(application);

78− }

79− });

85+ }

80−

86+ });

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

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

83− addApplication(application);

84− }

85 }

87 }

86

88

89+ Q_EMIT applicationManagerChanged(m_applicationManager);

90+ refreshWindows();

91+

87 endResetModel();

92 endResetModel();

88 m_modelState = IdleState;

93 m_modelState = IdleState;

89}

94}

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

96

101

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

102 DEBUG_MSG << "(" << surfaceManager << ")";

98

103

104+ Q_ASSERT(m_modelState == IdleState);

105+ m_modelState = ResettingState;

106+

107+ beginResetModel();

108+

99 if (m_surfaceManager) {

109 if (m_surfaceManager) {

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

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

101 }

111 }

@@ -107,9 +117,44 @@ void TopLevelWindowModel::setSurfaceManager(unityapi::SurfaceManagerInterface *s

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

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

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

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

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

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

120+

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

122+ this, &TopLevelWindowModel::onSurfacesAddedToWorkspace);

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

124+ this, &TopLevelWindowModel::onSurfacesAboutToBeRemovedFromWorkspace);

110 }

125 }

111

126

127+ refreshWindows();

112 Q_EMIT surfaceManagerChanged(m_surfaceManager);

128 Q_EMIT surfaceManagerChanged(m_surfaceManager);

129+

130+ endResetModel();

131+ m_modelState = IdleState;

132+}

133+

134+void TopLevelWindowModel::setWorkspace(Workspace *workspace)

135+{

136+ if (workspace == m_workspace) {

137+ return;

138+ }

139+

140+ DEBUG_MSG << "(" << workspace << ")";

141+

142+ Q_ASSERT(m_modelState == IdleState);

143+ m_modelState = ResettingState;

144+

145+ beginResetModel();

146+

147+ if (m_workspace) {

148+ disconnect(m_workspace, 0, this, 0);

149+ }

150+

151+ m_workspace = workspace;

152+

153+ refreshWindows();

154+ Q_EMIT workspaceChanged(workspace);

155+

156+ endResetModel();

157+ m_modelState = IdleState;

113}

158}

114

159

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

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

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

153 ModelEntry &entry = m_windowModel[i];

198 ModelEntry &entry = m_windowModel[i];

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

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

155 entry.window->setSurface(surface);

200 entry.window->setSurface(surface);

201+ m_allSurfaces.insert(surface);

156 connectSurface(surface);

202 connectSurface(surface);

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

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

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

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

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

180

226

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

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

182 if (surface) {

228 if (surface) {

229+ m_allSurfaces.insert(surface);

183 connectSurface(surface);

230 connectSurface(surface);

184 }

231 }

185

232

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

207

254

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

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

209 if (window->surface()) {

256 if (window->surface()) {

210− // Condense changes to the focused window

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

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

213 if (focused) {

257 if (focused) {

214− Q_ASSERT(m_newlyFocusedWindow == nullptr);

258+ setFocusedWindow(window);

215− m_focusedWindowChanged = true;

259+ m_focusedWindowCleared = false;

216− m_newlyFocusedWindow = window;

217 } else if (m_focusedWindow == window) {

260 } else if (m_focusedWindow == window) {

218− m_focusedWindowChanged = true;

261+ // Condense changes to the focused window

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

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

264+ m_focusedWindowCleared = true;

219 } else {

265 } else {

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

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

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

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

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

313 auto window = m_windowModel[i].window;

359 auto window = m_windowModel[i].window;

314 window->setSurface(nullptr);

360 window->setSurface(nullptr);

315 window->setFocused(false);

361 window->setFocused(false);

362+ m_allSurfaces.remove(surface);

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

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

317 }

364 }

318}

365}

@@ -328,39 +375,103 @@ Window *TopLevelWindowModel::createWindow(unityapi::MirSurfaceInterface *surface

328 return qmlWindow;

375 return qmlWindow;

329}

376}

330

377

378+

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

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

332{

380{

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

381+}

334

382

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

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

385+{

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

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

388+

389+ Q_FOREACH(auto surface, surfaces) {

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

391+

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

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

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

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

337− Window *window = createWindow(surface);

394+ Window *window = createWindow(surface);

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

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

339− window->setSurface(nullptr);

396+ window->setSurface(nullptr);

340− window->deleteLater();

397+ window->deleteLater();

341− });

398+ });

342− } else {

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

344− connectSurface(surface);

345− setInputMethodWindow(createWindow(surface));

346 } else {

399 } else {

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

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

348− if (application) {

401+ connectSurface(surface);

349− prependSurface(surface, application);

402+ setInputMethodWindow(createWindow(surface));

350 } else {

403 } else {

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

405+ if (application) {

406+ prependSurface(surface, application);

407+ } else {

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

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

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

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

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

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

354− Window *promptWindow = createWindow(surface);

411+ Window *promptWindow = createWindow(surface);

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

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

356− promptWindow->setSurface(nullptr);

413+ promptWindow->setSurface(nullptr);

357− promptWindow->deleteLater();

414+ promptWindow->deleteLater();

358− });

415+ });

416+ }

359 }

417 }

360 }

418 }

361 }

419 }

362}

420}

363

421

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

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

424+{

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

426+

427+ int start = -1;

428+ int end = -1;

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

430+ auto surface = *iter;

431+ iter++;

432+

433+ // Do removals in adjacent blocks.

434+ start = end = indexOf(surface);

435+ if (start == -1) {

436+ // probably a child surface

437+ m_allSurfaces.remove(surface);

438+ continue;

439+ }

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

441+ int index = indexOf(*iter);

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

443+ break;

444+ }

445+ end++;

446+ iter++;

447+ }

448+

449+ if (m_modelState == IdleState) {

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

451+ m_modelState = RemovingState;

452+ } else {

453+ Q_ASSERT(m_modelState == ResettingState);

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

455+ }

456+

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

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

459+ window->setSurface(nullptr);

460+ window->setFocused(false);

461+

462+ m_windowModel.removeAt(start);

463+ m_allSurfaces.remove(surface);

464+ }

465+

466+ if (m_modelState == RemovingState) {

467+ endRemoveRows();

468+ Q_EMIT countChanged();

469+ Q_EMIT listChanged();

470+ m_modelState = IdleState;

471+ }

472+ }

473+}

474+

364void TopLevelWindowModel::removeAt(int index)

475void TopLevelWindowModel::removeAt(int index)

365{

476{

366 if (m_modelState == IdleState) {

477 if (m_modelState == IdleState) {

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

372 }

483 }

373

484

374 auto window = m_windowModel[index].window;

485 auto window = m_windowModel[index].window;

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

375

487

376 window->setSurface(nullptr);

488 window->setSurface(nullptr);

377 window->setFocused(false);

489 window->setFocused(false);

378

490

379 m_windowModel.removeAt(index);

491 m_windowModel.removeAt(index);

492+ m_allSurfaces.remove(surface);

380

493

381 if (m_modelState == RemovingState) {

494 if (m_modelState == RemovingState) {

382 endRemoveRows();

495 endRemoveRows();

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

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

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

389 if (m_focusedWindow == window) {

502 if (m_focusedWindow == window) {

390 setFocusedWindow(nullptr);

503 setFocusedWindow(nullptr);

504+ m_focusedWindowCleared = false;

391 }

505 }

392 delete window;

506 delete window;

393

507

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

656

770

657void TopLevelWindowModel::onModificationsEnded()

771void TopLevelWindowModel::onModificationsEnded()

658{

772{

659− if (m_focusedWindowChanged) {

773+ if (m_focusedWindowCleared) {

660− setFocusedWindow(m_newlyFocusedWindow);

774+ setFocusedWindow(nullptr);

661 }

775 }

662 // reset

776 // reset

663− m_focusedWindowChanged = false;

777+ m_focusedWindowCleared = false;

664− m_newlyFocusedWindow = nullptr;

665}

778}

666

779

667void TopLevelWindowModel::activateTopMostWindowWithoutId(int forbiddenId)

780void TopLevelWindowModel::activateTopMostWindowWithoutId(int forbiddenId)

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

675 }

788 }

676 }

789 }

677}

790}

791+

792+void TopLevelWindowModel::refreshWindows()

793+{

794+ DEBUG_MSG << "()";

795+ clear();

796+

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

798+

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

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

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

802+ Window *window = createWindow(surface);

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

804+ window->setSurface(nullptr);

805+ window->deleteLater();

806+ });

807+ } else {

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

809+ setInputMethodWindow(createWindow(surface));

810+ } else {

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

812+ if (application) {

813+ prependSurface(surface, application);

814+ } else {

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

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

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

818+ Window *promptWindow = createWindow(surface);

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

820+ promptWindow->setSurface(nullptr);

821+ promptWindow->deleteLater();

822+ });

823+ }

824+ }

825+ }

826+ });

827+}

828+

829+void TopLevelWindowModel::clear()

830+{

831+ DEBUG_MSG << "()";

832+

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

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

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

836+ delete entry.window;

837+ }

838+ m_allSurfaces.clear();

839+ setFocusedWindow(nullptr);

840+ m_focusedWindowCleared = false;

841+}

plugins/WindowManager/TopLevelWindowModel.h+25−2

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

20#include <QAbstractListModel>

21#include <QLoggingCategory>

22

23+#include <memory>

24+

23Q_DECLARE_LOGGING_CATEGORY(TOPLEVELWINDOWMODEL)

25Q_DECLARE_LOGGING_CATEGORY(TOPLEVELWINDOWMODEL)

24

26

25class Window;

27class Window;

28+class Workspace;

29+

30+namespace miral { class Workspace; }

26

31

27namespace unity {

32namespace unity {

28 namespace shell {

33 namespace shell {

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

70 */

75 */

71 Q_PROPERTY(Window* focusedWindow READ focusedWindow NOTIFY focusedWindowChanged)

76 Q_PROPERTY(Window* focusedWindow READ focusedWindow NOTIFY focusedWindowChanged)

72

77

78+ Q_PROPERTY(Workspace* workspace

79+ READ workspace

80+ WRITE setWorkspace

81+ NOTIFY workspaceChanged)

82+

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

83 Q_PROPERTY(unity::shell::application::SurfaceManagerInterface* surfaceManager

74 READ surfaceManager

84 READ surfaceManager

75 WRITE setSurfaceManager

85 WRITE setSurfaceManager

@@ -111,6 +121,9 @@ public:

111

121

112 // Own API

122 // Own API

113

123

124+ Workspace* workspace() const { return m_workspace; }

125+ void setWorkspace(Workspace* workspace);

126+

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

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

115 Window* focusedWindow() const;

128 Window* focusedWindow() const;

116

129

@@ -178,8 +191,14 @@ Q_SIGNALS:

178

191

179 void nextIdChanged();

192 void nextIdChanged();

180

193

194+ void workspaceChanged(Workspace*);

195+

181private Q_SLOTS:

196private Q_SLOTS:

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

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

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

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

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

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

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

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

184

203

185 void onModificationsStarted();

204 void onModificationsStarted();

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

219 void activateEmptyWindow(Window *window);

238 void activateEmptyWindow(Window *window);

220

239

221 void activateTopMostWindowWithoutId(int forbiddenId);

240 void activateTopMostWindowWithoutId(int forbiddenId);

241+ void refreshWindows();

242+ void clear();

222

243

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

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

224

245

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

235 QVector<ModelEntry> m_windowModel;

256 QVector<ModelEntry> m_windowModel;

236 Window* m_inputMethodWindow{nullptr};

257 Window* m_inputMethodWindow{nullptr};

237 Window* m_focusedWindow{nullptr};

258 Window* m_focusedWindow{nullptr};

259+ Workspace* m_workspace{nullptr};

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

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

238

262

239 int m_nextId{1};

263 int m_nextId{1};

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

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

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

255 ModelState m_modelState{IdleState};

279 ModelState m_modelState{IdleState};

256

280

257 // Valid between modificationsStarted and modificationsEnded

281 // Valid between modificationsStarted and modificationsEnded

258− bool m_focusedWindowChanged{false};

282+ bool m_focusedWindowCleared{false};

259− Window *m_newlyFocusedWindow{nullptr};

260};

283};

261

284

262#endif // TOPLEVELWINDOWMODEL_H

285#endif // TOPLEVELWINDOWMODEL_H

plugins/WindowManager/WindowManagerPlugin.cpp+36−1

@@ -16,16 +16,51 @@

16

17#include "WindowManagerPlugin.h"

18

19+#include "Screen.h"

20+#include "ScreenAttached.h"

21+#include "Screens.h"

22+#include "ScreenWindow.h"

19#include "TopLevelWindowModel.h"

23#include "TopLevelWindowModel.h"

20#include "Window.h"

24#include "Window.h"

25+#include "WorkspaceManager.h"

26+#include "Workspace.h"

27+#include "WorkspaceModel.h"

21

28

22#include <QtQml>

29#include <QtQml>

30+#include <qtmir/qtmir.h>

31+

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

33+

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

35+{

36+ Q_UNUSED(engine)

37+ Q_UNUSED(scriptEngine)

38+ return WorkspaceManager::instance();

39+}

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

41+ Q_UNUSED(engine);

42+ Q_UNUSED(scriptEngine);

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

44+}

23

45

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

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

25{

47{

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

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

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

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

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

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

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

27

54

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

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

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

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

29

58

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

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

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

61+

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

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

64+

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

31}

66}

plugins/WindowManager/Workspace.cppnew file+141

@@ -0,0 +1,141 @@

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#include "Workspace.h"

18+#include "WorkspaceModel.h"

19+#include "WorkspaceManager.h"

20+#include "TopLevelWindowModel.h"

21+

22+#include "wmpolicyinterface.h"

23+

24+int nextWorkspace = 0;

25+

26+Workspace::Workspace(QObject *parent)

27+ : QObject(parent)

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

29+ , m_model(nullptr)

30+ , m_active(false)

31+{

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

33+

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

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

36+ if (newActive != m_active) {

37+ m_active = newActive;

38+ Q_EMIT activeChanged(m_active);

39+

40+ if (m_active) {

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

42+ }

43+ }

44+ });

45+}

46+

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

48+ : QObject(nullptr)

49+ , m_workspace(other.m_workspace)

50+ , m_model(nullptr)

51+ , m_active(other.m_active)

52+{

53+ setObjectName(other.objectName());

54+

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

56+ m_active = active;

57+ Q_EMIT activeChanged(m_active);

58+ });

59+}

60+

61+Workspace::~Workspace()

62+{

63+ if (m_model) {

64+ m_model->remove(this);

65+ }

66+}

67+

68+void Workspace::activate()

69+{

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

71+}

72+

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

74+{

75+ if (m_model == model) return;

76+

77+ if (m_model) {

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

79+ m_model->remove(this);

80+ }

81+

82+ m_model = model;

83+

84+ if (model) {

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

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

87+ index = vIndex.toInt();

88+ }

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

90+

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

92+ m_model = nullptr;

93+ Q_EMIT unassigned();

94+ });

95+ Q_EMIT assigned();

96+ } else {

97+ Q_EMIT unassigned();

98+ }

99+}

100+

101+void Workspace::unassign()

102+{

103+ assign(nullptr);

104+}

105+

106+void Workspace::release()

107+{

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

109+ deleteLater();

110+}

111+

112+bool Workspace::isAssigned() const

113+{

114+ return m_model != nullptr;

115+}

116+

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

118+ : Workspace(*workspace)

119+ , m_original(workspace)

120+{

121+}

122+

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

124+{

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

126+}

127+

128+void WorkspaceProxy::unassign()

129+{

130+ Workspace::unassign();

131+}

132+

133+bool WorkspaceProxy::isActive() const

134+{

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

136+}

137+

138+void WorkspaceProxy::activate()

139+{

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

141+}

plugins/WindowManager/Workspace.hnew file+98

@@ -0,0 +1,98 @@

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef WINDOWMANAGER_WORKSPACE_H

18+#define WINDOWMANAGER_WORKSPACE_H

19+

20+#include <QObject>

21+#include <QVariant>

22+#include <QPointer>

23+

24+#include <memory>

25+#include <functional>

26+

27+class WorkspaceModel;

28+class TopLevelWindowModel;

29+

30+namespace miral { class Workspace; }

31+

32+namespace unity {

33+ namespace shell {

34+ namespace application {

35+ class MirSurfaceInterface;

36+ }

37+ }

38+}

39+

40+class Workspace : public QObject

41+{

42+ Q_OBJECT

43+ Q_PROPERTY(bool active READ isActive NOTIFY activeChanged)

44+public:

45+ ~Workspace();

46+

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

48+ virtual void unassign();

49+ void release();

50+

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

52+ bool isAssigned() const;

53+

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

55+

56+

57+public Q_SLOTS:

58+ virtual void activate();

59+

60+Q_SIGNALS:

61+ void assigned();

62+ void unassigned();

63+

64+ void activeChanged(bool);

65+

66+protected:

67+ Workspace(QObject *parent = 0);

68+ Workspace(Workspace const& other);

69+

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

71+ WorkspaceModel* m_model;

72+ bool m_active;

73+

74+ friend class WorkspaceManager;

75+};

76+

77+class WorkspaceProxy : public Workspace

78+{

79+ Q_OBJECT

80+public:

81+ WorkspaceProxy(Workspace*const workspace);

82+

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

84+

85+ bool isActive() const override;

86+

87+ void activate() override;

88+

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

90+

91+public Q_SLOTS:

92+ void unassign() override;

93+

94+private:

95+ const QPointer<Workspace> m_original;

96+};

97+

98+#endif // WINDOWMANAGER_WORKSPACE_H

plugins/WindowManager/WorkspaceManager.cppnew file+141

@@ -0,0 +1,141 @@

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 <unity/shell/application/SurfaceManagerInterface.h>

21+

22+// Qt

23+#include <QGuiApplication>

24+#include <QScreen>

25+#include <QQmlEngine>

26+

27+WorkspaceManager *WorkspaceManager::instance()

28+{

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

30+ return workspaceManager;

31+}

32+

33+WorkspaceManager::WorkspaceManager()

34+ : m_activeWorkspace(nullptr)

35+ , m_surfaceManager(nullptr)

36+{

37+}

38+

39+Workspace *WorkspaceManager::createWorkspace()

40+{

41+ auto workspace = new Workspace(this);

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

43+ m_allWorkspaces.insert(workspace);

44+ m_floatingWorkspaces.append(workspace);

45+

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

47+ m_floatingWorkspaces.removeOne(workspace);

48+ Q_EMIT floatingWorkspacesChanged();

49+ });

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

51+ m_floatingWorkspaces.append(workspace);

52+ Q_EMIT floatingWorkspacesChanged();

53+ });

54+

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

56+ setActiveWorkspace(nullptr);

57+ Q_EMIT activeWorkspaceChanged();

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

59+ setActiveWorkspace(workspace);

60+ }

61+

62+ return workspace;

63+}

64+

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

66+{

67+ if (!workspace) return;

68+

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

70+ workspace->unassign();

71+ }

72+ m_floatingWorkspaces.removeOne(workspace);

73+ m_allWorkspaces.remove(workspace);

74+ Q_EMIT floatingWorkspacesChanged();

75+

76+ if (m_activeWorkspace == workspace) {

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

78+ // just choose anything.

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

80+ }

81+ if (m_activeWorkspace) {

82+ moveWorkspaceContentToWorkspace(workspace, m_activeWorkspace);

83+ }

84+

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

86+ workspace->release();

87+}

88+

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

90+{

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

92+}

93+

94+void WorkspaceManager::destroyFloatingWorkspaces()

95+{

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

97+ Q_FOREACH(auto workspace, dpCpy) {

98+ destroyWorkspace(workspace);

99+ }

100+}

101+

102+void WorkspaceManager::setSurfaceManager(unity::shell::application::SurfaceManagerInterface *surfaceManager)

103+{

104+ if (m_surfaceManager == surfaceManager) return;

105+

106+ m_surfaceManager = surfaceManager;

107+ Q_EMIT surfaceManagerChanged();

108+}

109+

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

111+{

112+ if (m_surfaceManager) {

113+ m_surfaceManager->moveSurfaceToWorkspace(surface, workspace->workspace());

114+ }

115+}

116+

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

118+{

119+ if (m_surfaceManager) {

120+ m_surfaceManager->moveWorkspaceContentToWorkspace(from->workspace(), to->workspace());

121+ }

122+}

123+

124+Workspace *WorkspaceManager::activeWorkspace() const

125+{

126+ return m_activeWorkspace;

127+}

128+

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

130+{

131+ if (workspace != m_activeWorkspace) {

132+ m_activeWorkspace = workspace;

133+ Q_EMIT activeWorkspaceChanged();

134+ }

135+}

136+

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

138+{

139+ if (!workspace) return;

140+ workspace->activate();

141+}

plugins/WindowManager/WorkspaceManager.hnew file+81

@@ -0,0 +1,81 @@

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef WORKSPACEMANAGER_H

18+#define WORKSPACEMANAGER_H

19+

20+#include "WorkspaceModel.h"

21+#include <QQmlListProperty>

22+

23+class Workspace;

24+class ScreensProxy;

25+

26+namespace unity {

27+ namespace shell {

28+ namespace application {

29+ class MirSurfaceInterface;

30+ class SurfaceManagerInterface;

31+ }

32+ }

33+}

34+

35+class WorkspaceManager : public QObject

36+{

37+ Q_OBJECT

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

39+

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

41+ READ surfaceManager

42+ WRITE setSurfaceManager

43+ NOTIFY surfaceManagerChanged)

44+

45+public:

46+ static WorkspaceManager* instance();

47+

48+ Workspace* activeWorkspace() const;

49+ void setActiveWorkspace(Workspace* workspace);

50+

51+ Workspace* createWorkspace();

52+ void destroyWorkspace(Workspace* workspace);

53+

54+ QQmlListProperty<Workspace> floatingWorkspaces();

55+ void destroyFloatingWorkspaces();

56+

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

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

59+

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

61+ Workspace* workspace);

62+

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

64+

65+Q_SIGNALS:

66+ void activeWorkspaceChanged();

67+ void floatingWorkspacesChanged();

68+ void surfaceManagerChanged();

69+

70+private:

71+ WorkspaceManager();

72+

73+ void setActiveWorkspace2(Workspace* workspace);

74+

75+ QSet<Workspace*> m_allWorkspaces;

76+ QList<Workspace*> m_floatingWorkspaces;

77+ Workspace* m_activeWorkspace;

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

79+};

80+

81+#endif // WORKSPACEMANAGER_H

plugins/WindowManager/WorkspaceModel.cppnew file+220

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#include "WorkspaceModel.h"

18+#include "WorkspaceManager.h"

19+#include "Workspace.h"

20+

21+#include <QQmlEngine>

22+

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

24+

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

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

27+

28+WorkspaceModel::WorkspaceModel(QObject *parent)

29+ : QAbstractListModel(parent)

30+{

31+}

32+

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

34+{

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

36+}

37+

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

39+{

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

41+

42+ m_workspaces.insert(index, workspace);

43+

44+ endInsertRows();

45+

46+ Q_EMIT workspaceInserted(index, workspace);

47+ Q_EMIT countChanged();

48+}

49+

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

51+{

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

53+ if (index < 0) return;

54+

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

56+

57+ m_workspaces.removeAt(index);

58+

59+ endRemoveRows();

60+

61+ Q_EMIT workspaceRemoved(workspace);

62+ Q_EMIT countChanged();

63+}

64+

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

66+{

67+ if (from == to) return;

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

69+

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

71+ QModelIndex parent;

72+

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

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

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

76+ m_workspaces.insert(to, window);

77+#else

78+ m_workspaces.move(from, to);

79+#endif

80+ endMoveRows();

81+

82+ Q_EMIT workspaceMoved(from, to);

83+ }

84+}

85+

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

87+{

88+ return m_workspaces.indexOf(workspace);

89+}

90+

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

92+{

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

94+ return m_workspaces.at(index);

95+}

96+

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

98+{

99+ return m_workspaces.count();

100+}

101+

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

103+{

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

105+ return QVariant();

106+

107+ if (role == WorkspaceRole) {

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

109+ return QVariant::fromValue(workspace);

110+ } else {

111+ return QVariant();

112+ }

113+}

114+

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

116+{

117+ if (!proxy) return;

118+ m_syncing = proxy;

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

120+

121+ // check for removals

122+ int removedIndexWhichWasActive = -1;

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

124+ Q_FOREACH(auto workspace, dpCpy) {

125+

126+ bool found = false;

127+ Q_FOREACH(auto p, proxyList) {

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

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

130+ found = true;

131+ break;

132+ }

133+ }

134+ if (!found) {

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

136+ removedIndexWhichWasActive = indexOf(workspace);

137+ }

138+ workspace->unassign();

139+ }

140+ }

141+

142+ // existing

143+ QSet<Workspace*> newWorkspaces;

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

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

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

147+

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

149+

150+ if (oldIndex < 0) {

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

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

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

154+ }

155+ newWorkspaces.insert(workspace);

156+ }

157+

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

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

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

161+ workspace->assign(this);

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

163+ }

164+

165+ if (removedIndexWhichWasActive != -1) {

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

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

168+

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

170+ }

171+ m_syncing = nullptr;

172+}

173+

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

175+{

176+ return m_syncing == m;

177+}

178+

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

180+ : m_original(model)

181+{

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

183+ auto proxy = new WorkspaceProxy(workspace);

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

185+ proxy->assign(this);

186+ }

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

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

189+

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

191+ });

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

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

194+

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

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

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

198+ if (w == removed) {

199+ remove(workspaceProxy);

200+ break;

201+ }

202+ }

203+ });

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

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

206+

207+ move(from, to);

208+ });

209+}

210+

211+WorkspaceModelProxy::~WorkspaceModelProxy()

212+{

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

214+ m_workspaces.clear();

215+}

216+

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

218+{

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

220+}

plugins/WindowManager/WorkspaceModel.hnew file+91

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef WORKSPACEMODEL_H

18+#define WORKSPACEMODEL_H

19+

20+#include <QAbstractListModel>

21+#include <QLoggingCategory>

22+#include <QPointer>

23+

24+Q_DECLARE_LOGGING_CATEGORY(WORKSPACES)

25+

26+class Workspace;

27+class WorkspaceModelProxy;

28+

29+class WorkspaceModel : public QAbstractListModel

30+{

31+ Q_OBJECT

32+ Q_PROPERTY(int count READ rowCount NOTIFY countChanged)

33+public:

34+ /**

35+ * @brief The Roles supported by the model

36+ *

37+ * WorkspaceRole - A workspace.

38+ */

39+ enum Roles {

40+ WorkspaceRole = Qt::UserRole

41+ };

42+

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

44+

45+ void append(Workspace *workspace);

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

47+ void remove(Workspace* workspace);

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

49+

50+ int indexOf(Workspace *workspace) const;

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

52+

53+ // From QAbstractItemModel

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

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

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

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

58+ return roleNames;

59+ }

60+

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

62+

63+ void sync(WorkspaceModel* proxy);

64+ bool isSyncingWith(WorkspaceModel*);

65+

66+Q_SIGNALS:

67+ void countChanged();

68+

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

70+ void workspaceRemoved(Workspace *workspace);

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

72+

73+protected:

74+ QVector<Workspace*> m_workspaces;

75+ WorkspaceModel* m_syncing;

76+};

77+

78+class WorkspaceModelProxy : public WorkspaceModel

79+{

80+ Q_OBJECT

81+public:

82+ WorkspaceModelProxy(WorkspaceModel*const model);

83+ ~WorkspaceModelProxy();

84+

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

86+

87+protected:

88+ const QPointer<WorkspaceModel> m_original;

89+};

90+

91+#endif // WORKSPACEMODEL_H

qml/CMakeLists.txt+1−1

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

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

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

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

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

25import Unity.Session 0.1

26

27import "." 0.1

28+import ".." 0.1

28import "../Components"

29import "../Components"

29

30

30Showable {

31Showable {

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

227 if (forcedUnlock && shown) {

228 if (forcedUnlock && shown) {

228 hideView();

229 hideView();

229 if (hideNow) {

230 if (hideNow) {

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

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

231 }

232 }

233 }

234 }

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

375 onEmergencyCall: root.emergencyCall()

376 onEmergencyCall: root.emergencyCall()

376 onRequiredChanged: {

377 onRequiredChanged: {

377 if (!loader.item.required) {

378 if (!loader.item.required) {

378− root.hide();

379+ ShellNotifier.greeter.hide(false);

379 }

380 }

381 }

382 }

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

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

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

499 }

500 }

500

501

502+ Connections {

503+ target: ShellNotifier.greeter

504+ onHide: {

505+ if (now) {

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

507+ } else {

508+ root.hide();

509+ }

510+ }

511+ }

512+

513+ Binding {

514+ target: ShellNotifier.greeter

515+ property: "shown"

516+ value: root.shown

517+ }

518+

501 Connections {

519 Connections {

502 target: DBusUnitySessionService

520 target: DBusUnitySessionService

503 onLockRequested: root.forceShow()

521 onLockRequested: root.forceShow()

504 onUnlocked: {

522 onUnlocked: {

505 root.forcedUnlock = true;

523 root.forcedUnlock = true;

506− root.hideNow();

524+ ShellNotifier.greeter.hide(true);

507 }

525 }

508 }

526 }

509

527

qml/Greeter/SecondaryGreeter.qmlnew file+75

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+import QtQuick 2.4

18+import Ubuntu.Components 1.3

19+

20+import "../Components"

21+import ".." 0.1

22+

23+Showable {

24+ id: root

25+

26+ readonly property bool active: required || hasLockedApp

27+

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

29+ readonly property bool locked: false

30+ readonly property bool waiting: false

31+ readonly property bool fullyShown: shown

32+

33+ property string lockedApp: ""

34+

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

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

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

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

39+

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

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

42+

43+ shown: ShellNotifier.greeter.shown

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

45+ visible: opacity != 0

46+

47+ Rectangle {

48+ anchors.fill: parent

49+ color: UbuntuColors.purple

50+ }

51+

52+ MouseArea {

53+ anchors.fill: parent

54+ acceptedButtons: Qt.AllButtons

55+ onWheel: wheel.accepted = true

56+ }

57+

58+ Connections {

59+ target: ShellNotifier.greeter

60+ onHide: {

61+ if (now) {

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

63+ } else {

64+ root.hide();

65+ }

66+ }

67+ onShownChanged: {

68+ if (ShellNotifier.greeter.shown) {

69+ root.show();

70+ } else {

71+ root.hide();

72+ }

73+ }

74+ }

75+}

qml/OrientedShell.qml+6−9

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

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

264

261

265 Shell {

262 Shell {

266 id: shell

263 id: shell

267− objectName: "shell"

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

268 width: root.width

265 width: root.width

269 height: root.height

266 height: root.height

270 orientation: root.angleToOrientation(orientationAngle)

267 orientation: root.angleToOrientation(orientationAngle)

qml/Panel/Panel.qml+15−14

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

47 property bool hasKeyboard: false

48

49 property string mode: "staged"

50+ property PanelState panelState

50

51

51 MouseArea {

52 MouseArea {

52 id: backMouseEater

53 id: backMouseEater

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

63 }

64 }

64

65

65 Binding {

66 Binding {

66− target: PanelState

67+ target: panelState

67 property: "panelHeight"

68 property: "panelHeight"

68 value: minimizedPanelHeight

69 value: minimizedPanelHeight

69 }

70 }

70

71

71 RegisteredApplicationMenuModel {

72 RegisteredApplicationMenuModel {

72 id: registeredMenuModel

73 id: registeredMenuModel

73− persistentSurfaceId: PanelState.focusedPersistentSurfaceId

74+ persistentSurfaceId: panelState.focusedPersistentSurfaceId

74 }

75 }

75

76

76 QtObject {

77 QtObject {

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

81 !indicators.shown &&

82 !indicators.shown &&

82 (decorationMouseArea.containsMouse || menuBarLoader.menusRequested)

83 (decorationMouseArea.containsMouse || menuBarLoader.menusRequested)

83

84

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

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

85− PanelState.decorationsAlwaysVisible

86+ panelState.decorationsAlwaysVisible

86

87

87 property bool showPointerMenu: revealControls &&

88 property bool showPointerMenu: revealControls &&

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

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

89

90

90 property bool enablePointerMenu: revealControls &&

91 property bool enablePointerMenu: revealControls &&

91 applicationMenus.available &&

92 applicationMenus.available &&

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

137 fill: panelAreaBackground

138 fill: panelAreaBackground

138 bottomMargin: -units.gu(1)

139 bottomMargin: -units.gu(1)

139 }

140 }

140− visible: PanelState.dropShadow

141+ visible: panelState.dropShadow

141 source: "graphics/rectangular_dropshadow.sci"

142 source: "graphics/rectangular_dropshadow.sci"

142 }

143 }

143

144

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

190 visible: opacity != 0

191 visible: opacity != 0

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

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

192

193

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

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

194 windowIsMaximized: true

195 windowIsMaximized: true

195− onCloseClicked: PanelState.closeClicked()

196+ onCloseClicked: panelState.closeClicked()

196− onMinimizeClicked: PanelState.minimizeClicked()

197+ onMinimizeClicked: panelState.minimizeClicked()

197− onMaximizeClicked: PanelState.restoreClicked()

198+ onMaximizeClicked: panelState.restoreClicked()

198− closeButtonShown: PanelState.closeButtonShown

199+ closeButtonShown: panelState.closeButtonShown

199 }

200 }

200

201

201 Loader {

202 Loader {

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

217 anchors.left: parent.left

218 anchors.left: parent.left

218 anchors.margins: units.gu(1)

219 anchors.margins: units.gu(1)

219 height: menuBarLoader.height

220 height: menuBarLoader.height

220− enableKeyFilter: valid && PanelState.decorationsVisible

221+ enableKeyFilter: valid && panelState.decorationsVisible

221 unityMenuModel: __applicationMenus.model

222 unityMenuModel: __applicationMenus.model

222

223

223 Connections {

224 Connections {

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

230 onShownChanged: bar.dismiss();

231 onShownChanged: bar.dismiss();

231 }

232 }

232

233

233− onDoubleClicked: PanelState.restoreClicked()

234+ onDoubleClicked: panelState.restoreClicked()

234 }

235 }

236 }

237 }

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

267 }

268 }

268

269

269 showRowTitle: !expanded

270 showRowTitle: !expanded

270− rowTitle: PanelState.title

271+ rowTitle: panelState.title

271 rowItemDelegate: ActionItem {

272 rowItemDelegate: ActionItem {

272 id: actionItem

273 id: actionItem

273 property int ownIndex: index

274 property int ownIndex: index

qml/Shell.qml+50−12

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

1−/*

1+/*

3 *

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

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

38import "Stage"

39import "Tutorial"

40import "Wizard"

41+import "Components/PanelState"

41import Unity.Notifications 1.0 as NotificationBackend

42import Unity.Notifications 1.0 as NotificationBackend

42import Unity.Session 0.1

43import Unity.Session 0.1

43import Unity.DashCommunicator 0.1

44import Unity.DashCommunicator 0.1

44import Unity.Indicators 0.1 as Indicators

45import Unity.Indicators 0.1 as Indicators

45import Cursor 1.1

46import Cursor 1.1

46import WindowManager 1.0

47import WindowManager 1.0

48+import Unity.Debug 0.1 as Debug

47

49

48

50

49StyledItem {

51StyledItem {

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

186 if (ApplicationManager.findApplication(appId)) {

188 if (ApplicationManager.findApplication(appId)) {

187 ApplicationManager.requestFocusApplication(appId);

189 ApplicationManager.requestFocusApplication(appId);

188 } else {

190 } else {

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

189 ApplicationManager.startApplication(appId);

192 ApplicationManager.startApplication(appId);

190 }

193 }

191 }

194 }

@@ -260,21 +263,23 @@ StyledItem {

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

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

261 }

264 }

262

265

266+ PanelState {

267+ id: panelState

268+ objectName: "panelState"

269+ }

270+

263 Item {

271 Item {

264 id: stages

272 id: stages

265 objectName: "stages"

273 objectName: "stages"

266 width: parent.width

274 width: parent.width

267 height: parent.height

275 height: parent.height

268

276

269− SurfaceManager {

270− id: surfaceMan

271− objectName: "surfaceManager"

272− }

273 TopLevelWindowModel {

277 TopLevelWindowModel {

274 id: topLevelSurfaceList

278 id: topLevelSurfaceList

275 objectName: "topLevelSurfaceList"

279 objectName: "topLevelSurfaceList"

276 applicationManager: ApplicationManager // it's a singleton

280 applicationManager: ApplicationManager // it's a singleton

277− surfaceManager: surfaceMan

281+ surfaceManager: SurfaceManager

282+ workspace: screenWindow.screen.currentWorkspace

278 }

283 }

279

284

280 Stage {

285 Stage {

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

316 altTabPressed: physicalKeysMapper.altTabPressed

321 altTabPressed: physicalKeysMapper.altTabPressed

317 oskEnabled: shell.oskEnabled

322 oskEnabled: shell.oskEnabled

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

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

324+ panelState: panelState

319

325

320 onSpreadShownChanged: {

326 onSpreadShownChanged: {

321 panel.indicators.hide();

327 panel.indicators.hide();

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

370 objectName: "greeterLoader"

376 objectName: "greeterLoader"

371 anchors.fill: parent

377 anchors.fill: parent

372 anchors.topMargin: panel.panelHeight

378 anchors.topMargin: panel.panelHeight

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

379+ sourceComponent: {

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

381+ if (screenWindow.primary) return integratedGreeter;

382+ return secondaryGreeter;

383+ }

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

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

385+ }

375 onLoaded: {

386 onLoaded: {

376 item.objectName = "greeter"

387 item.objectName = "greeter"

377 }

388 }

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

421 }

432 }

422 }

433 }

423

434

435+ Component {

436+ id: secondaryGreeter

437+ SecondaryGreeter {

438+ hides: [launcher, panel.indicators]

439+ }

440+ }

441+

424 Timer {

442 Timer {

425 // See powerConnection for why this is useful

443 // See powerConnection for why this is useful

426 id: showGreeterDelayed

444 id: showGreeterDelayed

@@ -535,6 +553,7 @@ StyledItem {

535 || greeter.hasLockedApp

553 || greeter.hasLockedApp

536 greeterShown: greeter && greeter.shown

554 greeterShown: greeter && greeter.shown

537 hasKeyboard: shell.hasKeyboard

555 hasKeyboard: shell.hasKeyboard

556+ panelState: panelState

538 }

557 }

539

558

540 Launcher {

559 Launcher {

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

774

793

775 Cursor {

794 Cursor {

776 id: cursor

795 id: cursor

777− objectName: "cursor"

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

778− visible: shell.hasMouse

797+

779 z: itemGrabber.z + 1

798 z: itemGrabber.z + 1

799+ opacity: 0

780 topBoundaryOffset: panel.panelHeight

800 topBoundaryOffset: panel.panelHeight

781−

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

782− confiningItem: stage.itemConfiningMouseCursor

802+ visible: enabled

783

803

784 property bool mouseNeverMoved: true

804 property bool mouseNeverMoved: true

785 Binding {

805 Binding {

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

791 when: cursor.mouseNeverMoved && cursor.visible

811 when: cursor.mouseNeverMoved && cursor.visible

792 }

812 }

793

813

814+ confiningItem: stage.itemConfiningMouseCursor

815+

794 height: units.gu(3)

816 height: units.gu(3)

795

817

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

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

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

877 }

899 }

878 }

900 }

879 }

901 }

902+

903+ Loader {

904+ z: shutdownFadeOutRectangle.z + 1

905+ active: DebuggingController.logOverlay

906+

907+ sourceComponent: Text {

908+ width: shell.width

909+ height: shell.height

910+

911+ text: consoleLog.out

912+ Debug.ConsoleLog {

913+ id: consoleLog

914+ enabled: true

915+ }

916+ }

917+ }

880}

918}

qml/ShellApplication.qmlnew file+55

@@ -0,0 +1,55 @@

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 workspaceManagerSurfaceManagerBinding: Binding {

51+ target: WorkspaceManager

52+ property: "surfaceManager"

53+ value: SurfaceManager

54+ }

55+}

qml/ShellNotifier.qmlnew file+30

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+/*

18+ Shared signals & properties on multi-window desktop

19+ */

20+

21+pragma Singleton

22+import QtQuick 2.4

23+

24+QtObject {

25+ property var greeter: QtObject {

26+ signal hide(bool now)

27+

28+ property bool shown: true

29+ }

30+}

qml/ShellScreen.qmlnew file+64

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

1+/*

3+*

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

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

6+* the Free Software Foundation; version 3.

7+*

8+* This program is distributed in the hope that it will be useful,

9+* but WITHOUT ANY WARRANTY; without even the implied warranty of

10+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+* GNU General Public License for more details.

12+*

13+* You should have received a copy of the GNU General Public License

14+* along with this program. If not, see <http://www.gnu.org/licenses/>.

15+*/

16+

17+import QtQuick 2.4

18+import Ubuntu.Components 1.3

19+import WindowManager 1.0

20+import Cursor 1.1

21+import "Components"

22+

23+ScreenWindow {

24+ id: screenWindow

25+

26+ color: "black"

27+ title: "Unity8 Shell"

28+ property bool primary: false

29+

30+ DeviceConfiguration {

31+ id: deviceConfiguration

32+ name: applicationArguments.deviceName

33+ }

34+

35+ Loader {

36+ id: loader

37+ width: screenWindow.width

38+ height: screenWindow.height

39+

40+ sourceComponent: {

41+ if (Screens.count > 1 && primary && deviceConfiguration.category !== "desktop") {

42+ return disabledScreenComponent;

43+ }

44+ return shellComponent;

45+ }

46+ }

47+

48+ Component {

49+ id: shellComponent

50+ OrientedShell {

51+ implicitWidth: screenWindow.width

52+ implicitHeight: screenWindow.height

53+

54+ deviceConfiguration {

55+ name: Screens.count > 1 ? "desktop" : applicationArguments.deviceName

56+ }

57+ }

58+ }

59+

60+ Component {

61+ id: disabledScreenComponent

62+ DisabledScreenNotice {}

63+ }

64+}

qml/Stage/DecoratedWindow.qml+3−1

@@ -72,6 +72,8 @@ FocusScope {

72

73 readonly property Item clientAreaItem: applicationWindow

74

75+ property PanelState panelState

76+

75 signal closeClicked()

77 signal closeClicked()

76 signal maximizeClicked()

78 signal maximizeClicked()

77 signal maximizeHorizontallyClicked()

79 signal maximizeHorizontallyClicked()

@@ -231,7 +233,7 @@ FocusScope {

231 enableMenus: {

233 enableMenus: {

232 return active &&

234 return active &&

233 surface &&

235 surface &&

234− (PanelState.focusedPersistentSurfaceId === surface.persistentId && !PanelState.decorationsVisible)

236+ (panelState.focusedPersistentSurfaceId === surface.persistentId && !panelState.decorationsVisible)

235 }

237 }

236 menu: sharedAppModel.model

238 menu: sharedAppModel.model

237

239

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+182

@@ -0,0 +1,182 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Ubuntu.Components.Popups 1.3

4+import WindowManager 1.0

5+import Unity.Application 0.1

6+import ".."

7+

8+Item {

9+ id: root

10+

11+ property string background

12+

13+ property var screensProxy: Screens.createProxy();

14+

15+ signal closeSpread();

16+

17+ Row {

18+ id: row

19+ anchors.bottom: parent.bottom

20+ anchors.horizontalCenter: parent.horizontalCenter

21+ Behavior on anchors.horizontalCenterOffset { NumberAnimation { duration: UbuntuAnimation.SlowDuration } }

22+// anchors.left: parent.left

23+ spacing: units.gu(1)

24+

25+ Repeater {

26+ model: screensProxy

27+

28+ delegate: Item {

29+ height: root.height - units.gu(6)

30+ width: workspaces.width

31+

32+ UbuntuShape {

33+ id: header

34+ anchors { left: parent.left; top: parent.top; right: parent.right }

35+ height: units.gu(7)

36+ backgroundColor: "white"

37+ z: 1

38+

39+ DropArea {

40+ anchors.fill: parent

41+ keys: ["workspace"]

42+

43+ onEntered: {

44+ workspaces.workspaceModel.insert(workspaces.workspaceModel.count, {text: drag.source.text})

45+ drag.source.inDropArea = true;

46+ }

47+

48+ onExited: {

49+ workspaces.workspaceModel.remove(workspaces.workspaceModel.count - 1, 1)

50+ drag.source.inDropArea = false;

51+ }

52+

53+ onDropped: {

54+ drag.source.inDropArea = false;

55+ }

56+ }

57+

58+ Column {

59+ anchors.fill: parent

60+ anchors.margins: units.gu(1)

61+

62+ Label {

63+ text: model.screen.name

64+ color: "black"

65+ }

66+

67+ Label {

68+ text: model.screen.outputTypeName

69+ color: "black"

70+ fontSize: "x-small"

71+ }

72+

73+ Label {

74+ text: screen.availableModes[screen.currentModeIndex].size.width + "x" + screen.availableModes[screen.currentModeIndex].size.height

75+ color: "black"

76+ fontSize: "x-small"

77+ }

78+ }

79+

80+ MouseArea {

81+ anchors.fill: parent

82+

83+ onClicked: {

84+ PopupUtils.open(contextMenu)

85+ }

86+ }

87+

88+ Component {

89+ id: contextMenu

90+ ActionSelectionPopover {

91+ actions: ActionList {

92+ Action {

93+ text: "Add workspace"

94+ onTriggered: {

95+ screen.addWorkspace();

96+ Screens.sync(root.screensProxy)

97+ }

98+ }

99+ }

100+ }

101+ }

102+ }

103+

104+

105+ Workspaces {

106+ id: workspaces

107+ height: parent.height - header.height - units.gu(2)

108+ width: {

109+ if (screensProxy.count == 1) {

110+ return Math.min(implicitWidth, root.width - units.gu(8));

111+ }

112+ return Math.min(implicitWidth, model.screen.active ? root.width - units.gu(48) : units.gu(40))

113+ }

114+

115+ Behavior on width { UbuntuNumberAnimation {} }

116+ anchors.bottom: parent.bottom

117+ anchors.bottomMargin: units.gu(1)

118+ anchors.horizontalCenter: parent.horizontalCenter

119+ screen: model.screen

120+ background: root.background

121+

122+ workspaceModel: model.screen.workspaces

123+

124+ onCommitScreenSetup: Screens.sync(root.screensProxy)

125+ onCloseSpread: root.closeSpread();

126+ }

127+ }

128+ }

129+ }

130+

131+ Rectangle {

132+ anchors { left: parent.left; top: parent.top; bottom: parent.bottom; topMargin: units.gu(6); bottomMargin: units.gu(1) }

133+ width: units.gu(5)

134+ color: "#33000000"

135+ visible: (row.width - root.width + units.gu(10)) / 2 - row.anchors.horizontalCenterOffset > units.gu(5)

136+ MouseArea {

137+ id: leftScrollArea

138+ anchors.fill: parent

139+ hoverEnabled: true

140+ onPressed: mouse.accepted = false;

141+ }

142+ DropArea {

143+ id: leftFakeDropArea

144+ anchors.fill: parent

145+ keys: ["application", "workspace"]

146+ }

147+ }

148+ Rectangle {

149+ anchors { right: parent.right; top: parent.top; bottom: parent.bottom; topMargin: units.gu(6); bottomMargin: units.gu(1) }

150+ width: units.gu(5)

151+ color: "#33000000"

152+ visible: (row.width - root.width + units.gu(10)) / 2 + row.anchors.horizontalCenterOffset > units.gu(5)

153+ MouseArea {

154+ id: rightScrollArea

155+ anchors.fill: parent

156+ hoverEnabled: true

157+ onPressed: mouse.accepted = false;

158+ }

159+ DropArea {

160+ id: rightFakeDropArea

161+ anchors.fill: parent

162+ keys: ["application", "workspace"]

163+ }

164+ }

165+ Timer {

166+ repeat: true

167+ running: leftScrollArea.containsMouse || rightScrollArea.containsMouse || leftFakeDropArea.containsDrag || rightFakeDropArea.containsDrag

168+ interval: UbuntuAnimation.SlowDuration

169+ triggeredOnStart: true

170+ onTriggered: {

171+ var newOffset = row.anchors.horizontalCenterOffset;

172+ var maxOffset = Math.max((row.width - root.width + units.gu(10)) / 2, 0);

173+ if (leftScrollArea.containsMouse || leftFakeDropArea.containsDrag) {

174+ newOffset += units.gu(20)

175+ } else {

176+ newOffset -= units.gu(20)

177+ }

178+ newOffset = Math.max(-maxOffset, Math.min(maxOffset, newOffset));

179+ row.anchors.horizontalCenterOffset = newOffset;

180+ }

181+ }

182+}

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

@@ -51,7 +51,7 @@ Item {

51

52 readonly property real spreadWidth: rightStackXPos - leftStackXPos

53 readonly property real spreadHeight: root.height

54− readonly property real spreadItemHeight: spreadHeight - contentTopMargin - contentBottomMargin

54+ readonly property real spreadItemHeight: spreadHeight - contentMargin * 2

55 readonly property real spreadItemWidth: stackHeight

56

57 readonly property real dynamicLeftRotationAngle: leftRotationAngle * rotationAngleFactor

@@ -91,10 +91,9 @@ Item {

91

92 readonly property real visibleItemCount: (spreadWidth / spreadItemWidth) / (1 - itemOverlap)

93

94− readonly property real spreadTotalWidth: Math.max(2,totalItemCount) * spreadWidth / visibleItemCount

94+ readonly property real spreadTotalWidth: totalItemCount * spreadWidth / visibleItemCount

95−

96− readonly property real centeringOffset: Math.max(spreadWidth - spreadTotalWidth ,0) / (2 * spreadWidth)

97

95

96+ readonly property real centeringOffset: Math.max(spreadWidth - spreadTotalWidth + (leftStackXPos - leftMargin) * 2, 0) / (2 * spreadWidth)

98

97

99 readonly property var curve: BezierCurve {

98 readonly property var curve: BezierCurve {

100 controlPoint2: {'x': 0.19, 'y': 0.00}

99 controlPoint2: {'x': 0.19, 'y': 0.00}

qml/Stage/Spread/SpreadDelegateInputArea.qml+30−11

@@ -85,15 +85,15 @@ Item {

85 }

86

87 // Event eater

88− MouseArea {

88+// MouseArea {

89− anchors.fill: parent

89+// anchors.fill: parent

90− onClicked: root.clicked()

90+// onClicked: root.clicked()

91− onWheel: wheel.accepted = true

91+// onWheel: wheel.accepted = true

92− }

92+// }

93

94 MultiPointTouchArea {

95 anchors.fill: parent

96− mouseEnabled: false

96+// mouseEnabled: false

97 maximumTouchPoints: 1

98 property int offset: 0

99

@@ -104,12 +104,15 @@ Item {

104 ]

105

106 onCanceled: {

107+ print("****************** cancelled")

108+ fakeDragItem.Drag.active = false;

109+ fakeDragItem.surface = null;

107 d.moving = false

110 d.moving = false

108 animation.animate("center");

111 animation.animate("center");

109 }

112 }

110

113

111 onTouchUpdated: {

114 onTouchUpdated: {

112− if (!d.moving) {

115+ if (!d.moving || !tp.pressed) {

113 if (Math.abs(tp.startY - tp.y) > d.threshold) {

116 if (Math.abs(tp.startY - tp.y) > d.threshold) {

114 d.moving = true;

117 d.moving = true;

115 d.dragEvents = []

118 d.dragEvents = []

@@ -119,17 +122,33 @@ Item {

119 }

122 }

120 }

123 }

121

124

122− if (root.closeable) {

125+

123− d.distance = tp.y - tp.startY - offset

126+ var value = tp.y - tp.startY - offset;

127+ if (value < 0) {

128+ var coords = mapToItem(shell, tp.x, tp.y);

129+ fakeDragItem.x = coords.x - units.gu(5)

130+ fakeDragItem.y = coords.y - units.gu(5)

131+ fakeDragItem.Drag.hotSpot.x = units.gu(5)

132+ fakeDragItem.Drag.hotSpot.y = units.gu(5)

133+ fakeDragItem.Drag.active = true;

134+ fakeDragItem.surface = model.window.surface;

135+

124 } else {

136 } else {

125− var value = tp.y - tp.startY - offset;

137+ if (root.closeable) {

138+ d.distance = value

139+ } else {

126− d.distance = Math.sqrt(Math.abs(value)) * (value < 0 ? -1 : 1) * 3

140+ d.distance = Math.sqrt(Math.abs(value)) * (value < 0 ? -1 : 1) * 3

141+ }

127 }

142 }

128

143

129 d.pushDragEvent(tp);

144 d.pushDragEvent(tp);

130 }

145 }

131

146

132 onReleased: {

147 onReleased: {

148+ print("released!")

149+ var result = fakeDragItem.Drag.drop();

150+ fakeDragItem.surface = null;

151+

133 if (!d.moving) {

152 if (!d.moving) {

134 root.clicked()

153 root.clicked()

135 }

154 }

qml/Stage/Spread/WorkspacePreview.qmlnew file+271

@@ -0,0 +1,271 @@

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 string background

13+ property int screenHeight

14+

15+ property real previewScale: previewSpace.height / previewSpace.screenHeight

16+

17+ property bool containsDragLeft: false

18+ property bool containsDragRight: false

19+ property bool isActive: false

20+

21+ Image {

22+ source: previewSpace.background

23+ anchors.fill: parent

24+ sourceSize.width: width

25+ sourceSize.height: height

26+

27+ TopLevelWindowModel {

28+ id: windowModel

29+ applicationManager: ApplicationManager

30+ surfaceManager: SurfaceManager

31+ workspace: model.workspace

32+ }

33+

34+ Repeater {

35+ id: topLevelSurfaceRepeater

36+ model: visible ? windowModel : null

37+ delegate: Rectangle {

38+ width: surfaceItem.width

39+ height: surfaceItem.height + decorationHeight * previewScale

40+ x: model.window.position.x * previewScale

41+ y: (model.window.position.y - decorationHeight) * previewScale

42+ color: "blue"

43+ z: topLevelSurfaceRepeater.count - index

44+

45+ property int decorationHeight: units.gu(3)

46+

47+ WindowDecoration {

48+ width: surfaceItem.implicitWidth

49+ height: parent.decorationHeight

50+ transform: Scale {

51+ origin.x: 0

52+ origin.y: 0

53+ xScale: previewScale

54+ yScale: previewScale

55+ }

56+ title: model.window && model.window.surface ? model.window.surface.name : ""

57+ z: 3

58+ }

59+

60+ MirSurfaceItem {

61+ id: surfaceItem

62+ y: parent.decorationHeight * previewScale

63+ width: implicitWidth * previewScale

64+ height: implicitHeight * previewScale

65+ surfaceWidth: -1

66+ surfaceHeight: -1

67+ onImplicitHeightChanged: print("item", surfaceItem, "height changed", implicitHeight)

68+ surface: model.window.surface

69+ }

70+ }

71+ }

72+

73+ }

74+

75+ Rectangle {

76+ anchors.fill: parent

77+ border.color: UbuntuColors.ash

78+ border.width: units.gu(.5)

79+ color: "transparent"

80+ visible: previewSpace.isActive

81+ }

82+

83+ Rectangle {

84+ anchors.fill: parent

85+ anchors.rightMargin: parent.width / 2

86+ color: "#55000000"

87+ visible: previewSpace.containsDragLeft

88+

89+ Column {

90+ anchors.centerIn: parent

91+ spacing: units.gu(1)

92+ Icon {

93+ source: "../graphics/multi-monitor_drop-here.png"

94+ height: units.gu(4)

95+ width: height

96+ anchors.horizontalCenter: parent.horizontalCenter

97+ }

98+ Label {

99+ text: qsTr("Drop here")

100+ }

101+ }

102+ }

103+

104+ Rectangle {

105+ anchors.fill: parent

106+ anchors.leftMargin: parent.width / 2

107+ color: "#55000000"

108+ visible: previewSpace.containsDragRight

109+

110+ Column {

111+ anchors.centerIn: parent

112+ spacing: units.gu(1)

113+ Icon {

114+ source: "../graphics/multi-monitor_leave.png"

115+ height: units.gu(4)

116+ width: height

117+ anchors.horizontalCenter: parent.horizontalCenter

118+ }

119+ Label {

120+ text: qsTr("Drop and go")

121+ }

122+ }

123+ }

124+}

125+

126+ // Repeater {

127+ // id: topLevelSurfaceRepeater

128+ // model: visible ? topLevelSurfaceList : null

129+ // delegate: Rectangle {

130+ // width: surfaceItem.width

131+ // height: surfaceItem.height + decorationHeight * previewScale

132+ // x: model.window.position.x * previewScale

133+ // y: (model.window.position.y - decorationHeight) * previewScale

134+ // color: "blue"

135+ // z: topLevelSurfaceRepeater.count - index

136+

137+ // property int decorationHeight: units.gu(3)

138+

139+ // WindowDecoration {

140+ // width: surfaceItem.implicitWidth

141+ // height: parent.decorationHeight

142+ // transform: Scale {

143+ // origin.x: 0

144+ // origin.y: 0

145+ // xScale: previewScale

146+ // yScale: previewScale

147+ // }

148+ // title: model.window && model.window.surface ? model.window.surface.name : ""

149+ // z: 3

150+ // }

151+

152+ // MirSurfaceItem {

153+ // id: surfaceItem

154+ // y: parent.decorationHeight * previewScale

155+ // width: implicitWidth * previewScale

156+ // height: implicitHeight * previewScale

157+ // surfaceWidth: -1

158+ // surfaceHeight: -1

159+ // onImplicitHeightChanged: print("item", surfaceItem, "height changed", implicitHeight)

160+ // surface: model.window.surface

161+ // }

162+ // }

163+ // }

164+// }

165+// }

166+

167+

168+// MouseArea {

169+// id: mouseArea

170+// anchors.centerIn: parent

171+// anchors.verticalCenterOffset: header.height / 2

172+// width: units.gu(8)

173+// height: width

174+// hoverEnabled: true

175+// opacity: containsMouse ? 1 : 0

176+

177+// Rectangle {

178+// anchors.fill: parent

179+// color: "#80000000"

180+// radius: height / 2

181+// }

182+

183+// NumberAnimation {

184+// target: canvas

185+// property: "progress"

186+// duration: 2000

187+// running: mouseArea.containsMouse

188+// from: 0

189+// to: 1

190+// }

191+

192+// Canvas {

193+// id: canvas

194+// height: parent.height

195+// width: height

196+// anchors.centerIn: parent

197+

198+// property real progress: 0.5

199+// property int lineWidth: units.dp(4)

200+// onProgressChanged: {

201+// requestPaint();

202+// if (progress == 1) {

203+// Screens.activateScreen(index);

204+// }

205+// }

206+

207+// rotation: -90

208+

209+// onPaint: {

210+// var ctx = canvas.getContext("2d");

211+// ctx.save();

212+// ctx.reset();

213+

214+// ctx.lineWidth = lineWidth;

215+

216+// ctx.strokeStyle = "#3bffffff"

217+// ctx.beginPath();

218+// ctx.arc(canvas.width/2,canvas.height/2, (canvas.height - ctx.lineWidth) / 2, 0, (Math.PI*2),false);

219+// ctx.stroke();

220+// ctx.closePath();

221+

222+// ctx.strokeStyle = "white"

223+// ctx.beginPath();

224+// ctx.arc(canvas.width/2,canvas.height/2, (canvas.height - ctx.lineWidth) / 2, 0, (Math.PI*2*(progress)),false);

225+// ctx.stroke();

226+// ctx.closePath();

227+

228+// ctx.restore();

229+// }

230+// }

231+

232+// Icon {

233+// source: "graphics/multi-monitor_leave.png"

234+// height: units.gu(4)

235+// width: height

236+// anchors.centerIn: parent

237+// }

238+// }

239+// }

240+

241+// FloatingFlickable {

242+// id: flickable

243+// anchors.fill: parent

244+// contentWidth: workspaceRepeater.count * previewSpace.screenWidth * previewScale

245+// property real progress: contentX / contentWidth

246+// onContentXChanged: print("contentX:", contentX, "progress:", progress)

247+// }

248+

249+// MouseArea {

250+// anchors.fill: parent

251+// hoverEnabled: true

252+// property int scrollAreaWidth: width / 3

253+

254+// onMouseXChanged: {

255+// var margins = flickable.width * 0.05;

256+

257+// // do we need to scroll?

258+// if (mouseX < scrollAreaWidth + margins) {

259+// var progress = Math.min(1, (scrollAreaWidth + margins - mouseX) / (scrollAreaWidth - margins));

260+// var contentX = (1 - progress) * (flickable.contentWidth - flickable.width)

261+// flickable.contentX = Math.max(0, Math.min(flickable.contentX, contentX))

262+// }

263+// if (mouseX > flickable.width - scrollAreaWidth) {

264+// var progress = Math.min(1, (mouseX - (flickable.width - scrollAreaWidth)) / (scrollAreaWidth - margins))

265+// var contentX = progress * (flickable.contentWidth - flickable.width)

266+// flickable.contentX = Math.min(flickable.contentWidth - flickable.width, Math.max(flickable.contentX, contentX))

267+// }

268+// }

269+// }

270+// }

271+//}

qml/Stage/Spread/Workspaces.qmlnew file+380

@@ -0,0 +1,380 @@

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+

11+ property QtObject screen: null

12+ property alias workspaceModel: listView.model

13+ property var background // TODO: should be stored in the workspace data

14+

15+ signal commitScreenSetup();

16+ signal closeSpread();

17+

18+ DropArea {

19+ anchors.fill: root

20+

21+ keys: ['workspace']

22+

23+ onEntered: {

24+ listView.updateDropProperties(drag);

25+ drag.source.workspace.assign(workspaceModel, listView.hoveredWorkspaceIndex)

26+ drag.source.inDropArea = true;

27+ }

28+

29+ onPositionChanged: {

30+ listView.updateDropProperties(drag);

31+ if (listView.dropItemIndex == listView.hoveredWorkspaceIndex) return;

32+ listView.model.move(listView.dropItemIndex, index, 1);

33+ listView.dropItemIndex = index;

34+ }

35+

36+ onExited: {

37+ drag.source.workspace.unassign()

38+ listView.dropItemIndex = -1;

39+ listView.hoveredWorkspaceIndex = -1;

40+ drag.source.inDropArea = false;

41+ }

42+

43+ onDropped: {

44+ drop.accept(Qt.MoveAction);

45+ listView.dropItemIndex = -1;

46+ drag.source.inDropArea = false;

47+ }

48+ }

49+ DropArea {

50+ anchors.fill: parent

51+ keys: ["application"]

52+

53+ onPositionChanged: {

54+ listView.progressiveScroll(drag.x)

55+ listView.updateDropProperties(drag)

56+ }

57+ onExited: {

58+ listView.hoveredWorkspaceIndex = -1

59+ }

60+ onDropped: {

61+ var surface = drag.source.surface;

62+ drag.source.surface = null;

63+ var workspace = listView.model.get(listView.hoveredWorkspaceIndex);

64+ WorkspaceManager.moveSurfaceToWorkspace(surface, workspace);

65+ drop.accept(Qt.MoveAction)

66+ if (listView.hoveredHalf == "right") {

67+ workspace.activate();

68+ root.closeSpread();

69+ }

70+ listView.hoveredWorkspaceIndex = -1

71+ }

72+ }

73+

74+ ListView {

75+ id: listView

76+ anchors.fill: parent

77+ anchors.leftMargin: -itemWidth

78+ anchors.rightMargin: -itemWidth

79+ boundsBehavior: Flickable.StopAtBounds

80+

81+ orientation: ListView.Horizontal

82+ spacing: units.gu(1)

83+ leftMargin: itemWidth

84+ rightMargin: itemWidth

85+

86+ property var screenSize: screen.availableModes[screen.currentModeIndex].size

87+ property int itemWidth: height * screenSize.width / screenSize.height

88+ property int foldingAreaWidth: units.gu(10)

89+ property real realContentX: contentX - originX + leftMargin

90+ property int dropItemIndex: -1

91+ property int hoveredWorkspaceIndex: -1

92+ property string hoveredHalf: "" // left or right

93+

94+ function getDropIndex(drag) {

95+ var coords = mapToItem(listView.contentItem, drag.x, drag.y)

96+ var index = Math.floor((drag.x + listView.realContentX) / (listView.itemWidth + listView.spacing));

97+ if (index < 0) index = 0;

98+ var upperLimit = dropItemIndex == -1 ? listView.count : listView.count - 1

99+ if (index > upperLimit) index = upperLimit;

100+ return index;

101+ }

102+

103+ function updateDropProperties(drag) {

104+ var coords = mapToItem(listView.contentItem, drag.x, drag.y)

105+ var index = Math.floor(drag.x + listView.realContentX) / (listView.itemWidth + listView.spacing);

106+ if (index < 0) {

107+ listView.hoveredWorkspaceIndex = -1;

108+ listView.hoveredHalf = "";

109+ return;

110+ }

111+

112+ var upperLimit = dropItemIndex == -1 ? listView.count : listView.count - 1

113+ if (index > upperLimit) index = upperLimit;

114+ listView.hoveredWorkspaceIndex = index;

115+ print("updating drag:", (drag.x + listView.realContentX) % (listView.itemWidth + listView.spacing))

116+ var pixelsInTile = (drag.x + listView.realContentX) % (listView.itemWidth + listView.spacing);

117+ listView.hoveredHalf = (pixelsInTile / listView.itemWidth) < .5 ? "left" : "right";

118+ }

119+

120+ function progressiveScroll(mouseX) {

121+ var progress = Math.max(0, Math.min(1, (mouseX - listView.foldingAreaWidth) / (width - listView.leftMargin * 2 - listView.foldingAreaWidth * 2)))

122+ listView.contentX = listView.originX + (listView.contentWidth - listView.width + listView.leftMargin + listView.rightMargin) * progress - listView.leftMargin

123+ }

124+

125+ displaced: Transition { UbuntuNumberAnimation { properties: "x" } }

126+

127+ delegate: Item {

128+ id: workspaceDelegate

129+ objectName: "delegate" + index

130+ height: parent.height

131+ width: listView.itemWidth

132+ Behavior on width { UbuntuNumberAnimation {} }

133+ visible: listView.dropItemIndex !== index

134+

135+ property int itemX: -listView.realContentX + index * (listView.itemWidth + listView.spacing)

136+ property int distanceFromLeft: itemX //- listView.leftMargin

137+ property int distanceFromRight: listView.width - listView.leftMargin - listView.rightMargin - itemX - listView.itemWidth

138+

139+ property int maxAngle: 40

140+

141+ property int itemAngle: {

142+ if (index == 0) {

143+ if (distanceFromLeft < 0) {

144+ var progress = (distanceFromLeft + listView.foldingAreaWidth) / listView.foldingAreaWidth

145+ return MathUtils.linearAnimation(1, -1, 0, maxAngle, Math.max(-1, Math.min(1, progress)));

146+ }

147+ return 0

148+ }

149+ if (index == listView.count - 1) {

150+ if (distanceFromRight < 0) {

151+ var progress = (distanceFromRight + listView.foldingAreaWidth) / listView.foldingAreaWidth

152+ return MathUtils.linearAnimation(1, -1, 0, -maxAngle, Math.max(-1, Math.min(1, progress)));

153+ }

154+ return 0

155+ }

156+

157+ if (distanceFromLeft < listView.foldingAreaWidth) {

158+ // itemX : 10gu = p : 100

159+ var progress = distanceFromLeft / listView.foldingAreaWidth

160+ return MathUtils.linearAnimation(1, -1, 0, maxAngle, Math.max(-1, Math.min(1, progress)));

161+ }

162+ if (distanceFromRight < listView.foldingAreaWidth) {

163+ var progress = distanceFromRight / listView.foldingAreaWidth

164+ return MathUtils.linearAnimation(1, -1, 0, -maxAngle, Math.max(-1, Math.min(1, progress)));

165+ }

166+ return 0

167+ }

168+

169+ property int itemOffset: {

170+ var rotationOffset = (1 - Math.cos(itemAngle * Math.PI / 360)) * listView.itemWidth

171+ if (index == 0) {

172+ if (distanceFromLeft < 0) {

173+ return -distanceFromLeft - rotationOffset

174+ }

175+ return 0

176+ }

177+ if (index == listView.count - 1) {

178+ if (distanceFromRight < 0) {

179+ return distanceFromRight + rotationOffset

180+ }

181+ return 0

182+ }

183+

184+ if (itemX < -listView.foldingAreaWidth) {

185+ return -itemX - rotationOffset

186+ }

187+ if (distanceFromLeft < listView.foldingAreaWidth) {

188+ return (listView.foldingAreaWidth - distanceFromLeft) / 2 - rotationOffset

189+ }

190+

191+ if (distanceFromRight < -listView.foldingAreaWidth) {

192+ return distanceFromRight + rotationOffset

193+ }

194+

195+ if (distanceFromRight < listView.foldingAreaWidth) {

196+ return -(listView.foldingAreaWidth - distanceFromRight) / 2 + rotationOffset

197+ }

198+

199+ return 0

200+ }

201+

202+// onItemXChanged: if (index == 1) print("x", itemX, listView.contentX)

203+

204+ z: itemOffset < 0 ? itemOffset : -itemOffset

205+ transform: [

206+ Rotation {

207+ angle: itemAngle

208+ axis { x: 0; y: 1; z: 0 }

209+ origin { x: itemAngle < 0 ? listView.itemWidth : 0; y: height / 2 }

210+ },

211+ Translate {

212+ x: itemOffset

213+ }

214+ ]

215+

216+ WorkspacePreview {

217+ height: listView.height

218+ width: listView.itemWidth

219+ background: root.background

220+ screenHeight: screen.availableModes[screen.currentModeIndex].size.height

221+ containsDragLeft: listView.hoveredWorkspaceIndex == index && listView.hoveredHalf == "left"

222+ containsDragRight: listView.hoveredWorkspaceIndex == index && listView.hoveredHalf == "right"

223+ isActive: model.workspace.active

224+ }

225+ MouseArea {

226+ anchors.fill: parent

227+ onClicked: {

228+ model.workspace.activate();

229+ }

230+ onDoubleClicked: {

231+ model.workspace.activate();

232+ root.closeSpread();

233+ }

234+ }

235+

236+ MouseArea {

237+ id: closeMouseArea

238+ objectName: "closeMouseArea"

239+ anchors { left: parent.left; top: parent.top; leftMargin: -height / 2; topMargin: -height / 2 }

240+ hoverEnabled: true

241+ height: units.gu(4)

242+ width: height

243+

244+ onClicked: {

245+ model.workspace.unassign();

246+ root.commitScreenSetup();

247+ }

248+ Image {

249+ id: closeImage

250+ source: "../graphics/window-close.svg"

251+ anchors.fill: closeMouseArea

252+ anchors.margins: units.gu(1)

253+ sourceSize.width: width

254+ sourceSize.height: height

255+ readonly property var mousePos: hoverMouseArea.mapToItem(workspaceDelegate, hoverMouseArea.mouseX, hoverMouseArea.mouseY)

256+ readonly property bool shown: (hoverMouseArea.containsMouse || parent.containsMouse)

257+ && mousePos.y < workspaceDelegate.width / 4

258+ && mousePos.y > -units.gu(2)

259+ && mousePos.x > -units.gu(2)

260+ && mousePos.x < workspaceDelegate.height / 4

261+ opacity: shown ? 1 : 0

262+ visible: opacity > 0

263+ Behavior on opacity { UbuntuNumberAnimation { duration: UbuntuAnimation.SnapDuration } }

264+

265+ }

266+ }

267+ }

268+

269+ MouseArea {

270+ id: hoverMouseArea

271+ anchors.fill: parent

272+ hoverEnabled: true

273+ propagateComposedEvents: true

274+ anchors.leftMargin: listView.leftMargin

275+ anchors.rightMargin: listView.rightMargin

276+

277+ property int draggedIndex: -1

278+

279+ property int startX: 0

280+ property int startY: 0

281+

282+ onMouseXChanged: {

283+ if (!pressed || dragging) {

284+ listView.progressiveScroll(mouseX)

285+ }

286+ }

287+ onMouseYChanged: {

288+ if (Math.abs(mouseY - startY) > units.gu(3)) {

289+ drag.axis = Drag.XAndYAxis;

290+ }

291+ }

292+

293+ onReleased: {

294+ var result = fakeDragItem.Drag.drop();

295+// if (result == Qt.IgnoreAction) {

296+// WorkspaceManager.destroyWorkspace(fakeDragItem.workspace);

297+// }

298+ root.commitScreenSetup();

299+ drag.target = null;

300+ }

301+

302+ property bool dragging: drag.active

303+ onDraggingChanged: {

304+ if (drag.active) {

305+ print("drai", draggedIndex)

306+ var ws = listView.model.get(draggedIndex);

307+ print("ws:", ws)

308+ ws.unassign();

309+// listView.model.remove(draggedIndex, 1)

310+ }

311+ }

312+

313+ onPressed: {

314+ startX = mouseX;

315+ startY = mouseY;

316+ if (listView.model.count < 2) return;

317+

318+ var coords = mapToItem(listView.contentItem, mouseX, mouseY)

319+ draggedIndex = listView.indexAt(coords.x, coords.y)

320+ var clickedItem = listView.itemAt(coords.x, coords.y)

321+

322+ var itemCoords = clickedItem.mapToItem(listView, -listView.leftMargin, 0);

323+ fakeDragItem.x = itemCoords.x

324+ fakeDragItem.y = itemCoords.y

325+ fakeDragItem.workspace = listView.model.get(draggedIndex)

326+

327+ var mouseCoordsInItem = mapToItem(clickedItem, mouseX, mouseY);

328+ fakeDragItem.Drag.hotSpot.x = mouseCoordsInItem.x

329+ fakeDragItem.Drag.hotSpot.y = mouseCoordsInItem.y

330+

331+ drag.axis = Drag.YAxis;

332+ drag.target = fakeDragItem;

333+ }

334+

335+ WorkspacePreview {

336+ id: fakeDragItem

337+ height: listView.height

338+ width: listView.itemWidth

339+ background: root.background

340+ screenHeight: screen.availableModes[screen.currentModeIndex].size.height

341+ visible: Drag.active

342+

343+ Drag.active: hoverMouseArea.drag.active

344+ Drag.keys: ['workspace']

345+

346+ property var workspace

347+ property bool inDropArea: false

348+

349+ Rectangle {

350+ anchors.fill: parent

351+ color: "#33000000"

352+ opacity: parent.inDropArea ? 0 : 1

353+ Behavior on opacity { UbuntuNumberAnimation { } }

354+ Rectangle {

355+ anchors.centerIn: parent

356+ width: units.gu(6)

357+ height: units.gu(6)

358+ radius: width / 2

359+ color: "#aa000000"

360+ }

361+

362+ Icon {

363+ height: units.gu(3)

364+ width: height

365+ anchors.centerIn: parent

366+ name: "edit-delete"

367+ color: "white"

368+ }

369+ }

370+

371+ states: [

372+ State {

373+ when: fakeDragItem.Drag.active

374+ ParentChange { target: fakeDragItem; parent: shell }

375+ }

376+ ]

377+ }

378+ }

379+ }

380+}

qml/Stage/Stage.qml+145−105

@@ -47,6 +47,7 @@ FocusScope {

47 property bool oskEnabled: false

48 property rect inputMethodRect

49 property real rightEdgePushProgress: 0

50+ property PanelState panelState

50

51

51 // Configuration

52 // Configuration

52 property string mode: "staged"

53 property string mode: "staged"

@@ -349,23 +350,23 @@ FocusScope {

349 readonly property real virtualKeyboardHeight: root.inputMethodRect.height

350 readonly property real virtualKeyboardHeight: root.inputMethodRect.height

350 }

351 }

351

352

352− Component.onCompleted: priv.updateMainAndSideStageIndexes();

353+ Component.onCompleted: {priv.updateMainAndSideStageIndexes(); print("size", root.width, root.height)}

353

354

354 Connections {

355 Connections {

355− target: PanelState

356+ target: panelState

356 onCloseClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.close(); } }

357 onCloseClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.close(); } }

357 onMinimizeClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.requestMinimize(); } }

358 onMinimizeClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.requestMinimize(); } }

358 onRestoreClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.requestRestore(); } }

359 onRestoreClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.requestRestore(); } }

359 }

360 }

360

361

361 Binding {

362 Binding {

362− target: PanelState

363+ target: panelState

363 property: "decorationsVisible"

364 property: "decorationsVisible"

364 value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.maximized // FIXME for Locally integrated menus

365 value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.maximized // FIXME for Locally integrated menus

365 }

366 }

366

367

367 Binding {

368 Binding {

368− target: PanelState

369+ target: panelState

369 property: "title"

370 property: "title"

370 value: {

371 value: {

371 if (priv.focusedAppDelegate !== null) {

372 if (priv.focusedAppDelegate !== null) {

@@ -380,7 +381,7 @@ FocusScope {

380 }

381 }

381

382

382 Binding {

383 Binding {

383− target: PanelState

384+ target: panelState

384 property: "focusedPersistentSurfaceId"

385 property: "focusedPersistentSurfaceId"

385 value: {

386 value: {

386 if (priv.focusedAppDelegate !== null) {

387 if (priv.focusedAppDelegate !== null) {

@@ -394,21 +395,21 @@ FocusScope {

394 }

395 }

395

396

396 Binding {

397 Binding {

397− target: PanelState

398+ target: panelState

398 property: "dropShadow"

399 property: "dropShadow"

399 value: priv.focusedAppDelegate && !priv.focusedAppDelegate.maximized && priv.foregroundMaximizedAppDelegate !== null && mode == "windowed"

400 value: priv.focusedAppDelegate && !priv.focusedAppDelegate.maximized && priv.foregroundMaximizedAppDelegate !== null && mode == "windowed"

400 }

401 }

401

402

402 Binding {

403 Binding {

403− target: PanelState

404+ target: panelState

404 property: "closeButtonShown"

405 property: "closeButtonShown"

405 value: priv.focusedAppDelegate && priv.focusedAppDelegate.maximized && !priv.focusedAppDelegate.isDash

406 value: priv.focusedAppDelegate && priv.focusedAppDelegate.maximized && !priv.focusedAppDelegate.isDash

406 }

407 }

407

408

408 Component.onDestruction: {

409 Component.onDestruction: {

409− PanelState.title = "";

410+ panelState.title = "";

410− PanelState.decorationsVisible = false;

411+ panelState.decorationsVisible = false;

411− PanelState.dropShadow = false;

412+ panelState.dropShadow = false;

412 }

413 }

413

414

414 Instantiator {

415 Instantiator {

@@ -454,6 +455,7 @@ FocusScope {

454 PropertyChanges { target: cancelSpreadMouseArea; enabled: true }

455 PropertyChanges { target: cancelSpreadMouseArea; enabled: true }

455 PropertyChanges { target: blurLayer; visible: true; blurRadius: 32; brightness: .65; opacity: 1 }

456 PropertyChanges { target: blurLayer; visible: true; blurRadius: 32; brightness: .65; opacity: 1 }

456 PropertyChanges { target: wallpaper; visible: false }

457 PropertyChanges { target: wallpaper; visible: false }

458+ PropertyChanges { target: screensAndWorkspaces; opacity: 1 }

457 },

459 },

458 State {

460 State {

459 name: "stagedRightEdge"; when: root.spreadEnabled && (rightEdgeDragArea.dragging || rightEdgePushProgress > 0) && root.mode == "staged"

461 name: "stagedRightEdge"; when: root.spreadEnabled && (rightEdgeDragArea.dragging || rightEdgePushProgress > 0) && root.mode == "staged"

@@ -502,10 +504,13 @@ FocusScope {

502 from: "stagedRightEdge,sideStagedRightEdge,windowedRightEdge"; to: "spread"

504 from: "stagedRightEdge,sideStagedRightEdge,windowedRightEdge"; to: "spread"

503 PropertyAction { target: spreadItem; property: "highlightedIndex"; value: -1 }

505 PropertyAction { target: spreadItem; property: "highlightedIndex"; value: -1 }

504 PropertyAnimation { target: blurLayer; properties: "brightness,blurRadius"; duration: priv.animationDuration }

506 PropertyAnimation { target: blurLayer; properties: "brightness,blurRadius"; duration: priv.animationDuration }

507+ UbuntuNumberAnimation { target: screensAndWorkspaces; property: "opacity"; duration: priv.animationDuration }

505 },

508 },

506 Transition {

509 Transition {

507 to: "spread"

510 to: "spread"

508 PropertyAction { target: spreadItem; property: "highlightedIndex"; value: appRepeater.count > 1 ? 1 : 0 }

511 PropertyAction { target: spreadItem; property: "highlightedIndex"; value: appRepeater.count > 1 ? 1 : 0 }

512+ PropertyAction { target: floatingFlickable; property: "contentX"; value: 0 }

513+ UbuntuNumberAnimation { target: screensAndWorkspaces; property: "opacity"; duration: priv.animationDuration }

509 },

514 },

510 Transition {

515 Transition {

511 from: "spread"

516 from: "spread"

@@ -563,10 +568,21 @@ FocusScope {

563 visible: false

568 visible: false

564 }

569 }

565

570

571+ ScreensAndWorkspaces {

572+ id: screensAndWorkspaces

573+ anchors { left: parent.left; top: parent.top; right: parent.right; leftMargin: root.leftMargin }

574+ height: Math.max(units.gu(35), parent.height * .4)

575+ background: root.background

576+ opacity: 0

577+ visible: opacity > 0

578+

579+ onCloseSpread: priv.goneToSpread = false;

580+ }

581+

566 Spread {

582 Spread {

567 id: spreadItem

583 id: spreadItem

568 objectName: "spreadItem"

584 objectName: "spreadItem"

569− anchors.fill: appContainer

585+ anchors { left: parent.left; bottom: parent.bottom; right: parent.right; top: screensAndWorkspaces.bottom }

570 leftMargin: root.leftMargin

586 leftMargin: root.leftMargin

571 model: root.topLevelSurfaceList

587 model: root.topLevelSurfaceList

572 spreadFlickable: floatingFlickable

588 spreadFlickable: floatingFlickable

@@ -575,6 +591,83 @@ FocusScope {

575 onLeaveSpread: {

591 onLeaveSpread: {

576 priv.goneToSpread = false;

592 priv.goneToSpread = false;

577 }

593 }

594+

595+ FloatingFlickable {

596+ id: floatingFlickable

597+ objectName: "spreadFlickable"

598+ anchors.fill: parent

599+ enabled: false

600+ contentWidth: spreadItem.spreadTotalWidth

601+

602+ function snap(toIndex) {

603+ var delegate = appRepeater.itemAt(toIndex)

604+ var targetContentX = floatingFlickable.contentWidth / spreadItem.totalItemCount * toIndex;

605+ if (targetContentX - floatingFlickable.contentX > spreadItem.rightStackXPos - (spreadItem.spreadItemWidth / 2)) {

606+ var offset = (spreadItem.rightStackXPos - (spreadItem.spreadItemWidth / 2)) - (targetContentX - floatingFlickable.contentX)

607+ snapAnimation.to = floatingFlickable.contentX - offset;

608+ snapAnimation.start();

609+ } else if (targetContentX - floatingFlickable.contentX < spreadItem.leftStackXPos + units.gu(1)) {

610+ var offset = (spreadItem.leftStackXPos + units.gu(1)) - (targetContentX - floatingFlickable.contentX);

611+ snapAnimation.to = floatingFlickable.contentX - offset;

612+ snapAnimation.start();

613+ }

614+ }

615+ UbuntuNumberAnimation {id: snapAnimation; target: floatingFlickable; property: "contentX"}

616+ }

617+

618+ MouseArea {

619+ id: hoverMouseArea

620+ objectName: "hoverMouseArea"

621+ anchors.fill: parent

622+ propagateComposedEvents: true

623+ hoverEnabled: true

624+ enabled: false

625+ visible: enabled

626+

627+ property int scrollAreaWidth: width / 3

628+ property bool progressiveScrollingEnabled: false

629+

630+ onPressed: mouse.accepted = false

631+

632+ onMouseXChanged: {

633+ mouse.accepted = false

634+

635+ if (hoverMouseArea.pressed) {

636+ return;

637+ }

638+

639+ // Find the hovered item and mark it active

640+ for (var i = appRepeater.count - 1; i >= 0; i--) {

641+ var appDelegate = appRepeater.itemAt(i);

642+ var mapped = mapToItem(appDelegate, hoverMouseArea.mouseX, hoverMouseArea.mouseY)

643+ var itemUnder = appDelegate.childAt(mapped.x, mapped.y);

644+ if (itemUnder && (itemUnder.objectName === "dragArea" || itemUnder.objectName === "windowInfoItem" || itemUnder.objectName == "closeMouseArea")) {

645+ spreadItem.highlightedIndex = i;

646+ break;

647+ }

648+ }

649+

650+ if (floatingFlickable.contentWidth > floatingFlickable.width) {

651+ var margins = floatingFlickable.width * 0.05;

652+

653+ if (!progressiveScrollingEnabled && mouseX < floatingFlickable.width - scrollAreaWidth) {

654+ progressiveScrollingEnabled = true

655+ }

656+

657+ // do we need to scroll?

658+ if (mouseX < scrollAreaWidth + margins) {

659+ var progress = Math.min(1, (scrollAreaWidth + margins - mouseX) / (scrollAreaWidth - margins));

660+ var contentX = (1 - progress) * (floatingFlickable.contentWidth - floatingFlickable.width)

661+ floatingFlickable.contentX = Math.max(0, Math.min(floatingFlickable.contentX, contentX))

662+ }

663+ if (mouseX > floatingFlickable.width - scrollAreaWidth && progressiveScrollingEnabled) {

664+ var progress = Math.min(1, (mouseX - (floatingFlickable.width - scrollAreaWidth)) / (scrollAreaWidth - margins))

665+ var contentX = progress * (floatingFlickable.contentWidth - floatingFlickable.width)

666+ floatingFlickable.contentX = Math.min(floatingFlickable.contentWidth - floatingFlickable.width, Math.max(floatingFlickable.contentX, contentX))

667+ }

668+ }

669+ }

670+ }

578 }

671 }

579

672

580 Connections {

673 Connections {

@@ -669,10 +762,28 @@ FocusScope {

669 }

762 }

670 }

763 }

671

764

765+ MirSurfaceItem {

766+ id: fakeDragItem

767+ property real previewScale: .5

768+ height: (screensAndWorkspaces.height - units.gu(8)) / 2

769+ // w : h = iw : ih

770+ width: implicitWidth * height / implicitHeight

771+ surfaceWidth: -1

772+ surfaceHeight: -1

773+ opacity: surface != null ? 1 : 0

774+ Behavior on opacity { UbuntuNumberAnimation {} }

775+ visible: opacity > 0

776+

777+ Drag.active: surface != null

778+ Drag.keys: ["application"]

779+

780+ z: 1000

781+ }

782+

672 Item {

783 Item {

673 id: boundariesForWindowPlacement

784 id: boundariesForWindowPlacement

674 anchors.fill: parent

785 anchors.fill: parent

675− anchors.topMargin: PanelState.panelHeight

786+ anchors.topMargin: panelState.panelHeight

676 visible: false

787 visible: false

677 }

788 }

678

789

@@ -704,6 +815,9 @@ FocusScope {

704 }

815 }

705 z: normalZ

816 z: normalZ

706

817

818+ opacity: fakeDragItem.surface == model.window.surface && fakeDragItem.Drag.active ? 0 : 1

819+ Behavior on opacity { UbuntuNumberAnimation {} }

820+

707 // Normally we want x/y where the surface thinks it is. Width/height of our delegate will

821 // Normally we want x/y where the surface thinks it is. Width/height of our delegate will

708 // match what the actual surface size is.

822 // match what the actual surface size is.

709 // Don't write to those, they will be set by states

823 // Don't write to those, they will be set by states

@@ -765,7 +879,7 @@ FocusScope {

765 target: appDelegate

879 target: appDelegate

766 property: "y"

880 property: "y"

767 value: appDelegate.requestedY -

881 value: appDelegate.requestedY -

768− Math.min(appDelegate.requestedY - PanelState.panelHeight,

882+ Math.min(appDelegate.requestedY - panelState.panelHeight,

769 Math.max(0, priv.virtualKeyboardHeight - (appContainer.height - (appDelegate.requestedY + appDelegate.height))))

883 Math.max(0, priv.virtualKeyboardHeight - (appContainer.height - (appDelegate.requestedY + appDelegate.height))))

770 when: root.oskEnabled && appDelegate.focus && (appDelegate.state == "normal" || appDelegate.state == "restored")

884 when: root.oskEnabled && appDelegate.focus && (appDelegate.state == "normal" || appDelegate.state == "restored")

771 && root.inputMethodRect.height > 0

885 && root.inputMethodRect.height > 0

@@ -876,7 +990,6 @@ FocusScope {

876 function claimFocus() {

990 function claimFocus() {

877 if (root.state == "spread") {

991 if (root.state == "spread") {

878 spreadItem.highlightedIndex = index

992 spreadItem.highlightedIndex = index

879− priv.goneToSpread = false;

880 }

993 }

881 if (root.mode == "stagedWithSideStage") {

994 if (root.mode == "stagedWithSideStage") {

882 if (appDelegate.stage == ApplicationInfoInterface.SideStage && !sideStage.shown) {

995 if (appDelegate.stage == ApplicationInfoInterface.SideStage && !sideStage.shown) {

@@ -1163,7 +1276,7 @@ FocusScope {

1163 progress: 0

1276 progress: 0

1164 targetHeight: spreadItem.stackHeight

1277 targetHeight: spreadItem.stackHeight

1165 targetX: spreadMaths.targetX

1278 targetX: spreadMaths.targetX

1166− startY: appDelegate.fullscreen ? 0 : PanelState.panelHeight

1279+ startY: appDelegate.fullscreen ? 0 : panelState.panelHeight

1167 targetY: spreadMaths.targetY

1280 targetY: spreadMaths.targetY

1168 targetAngle: spreadMaths.targetAngle

1281 targetAngle: spreadMaths.targetAngle

1169 targetScale: spreadMaths.targetScale

1282 targetScale: spreadMaths.targetScale

@@ -1284,9 +1397,9 @@ FocusScope {

1284 PropertyChanges {

1397 PropertyChanges {

1285 target: appDelegate

1398 target: appDelegate

1286 x: stageMaths.itemX

1399 x: stageMaths.itemX

1287− y: appDelegate.fullscreen ? 0 : PanelState.panelHeight

1400+ y: appDelegate.fullscreen ? 0 : panelState.panelHeight

1288 requestedWidth: appContainer.width

1401 requestedWidth: appContainer.width

1289− requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - PanelState.panelHeight

1402+ requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - panelState.panelHeight

1290 visuallyMaximized: true

1403 visuallyMaximized: true

1291 visible: appDelegate.x < root.width

1404 visible: appDelegate.x < root.width

1292 }

1405 }

@@ -1312,10 +1425,10 @@ FocusScope {

1312 PropertyChanges {

1425 PropertyChanges {

1313 target: appDelegate

1426 target: appDelegate

1314 x: stageMaths.itemX

1427 x: stageMaths.itemX

1315− y: appDelegate.fullscreen ? 0 : PanelState.panelHeight

1428+ y: appDelegate.fullscreen ? 0 : panelState.panelHeight

1316 z: stageMaths.itemZ

1429 z: stageMaths.itemZ

1317 requestedWidth: stageMaths.itemWidth

1430 requestedWidth: stageMaths.itemWidth

1318− requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - PanelState.panelHeight

1431+ requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - panelState.panelHeight

1319 visuallyMaximized: true

1432 visuallyMaximized: true

1320 visible: appDelegate.x < root.width

1433 visible: appDelegate.x < root.width

1321 }

1434 }

@@ -1380,9 +1493,9 @@ FocusScope {

1380 PropertyChanges {

1493 PropertyChanges {

1381 target: appDelegate

1494 target: appDelegate

1382 windowedX: root.leftMargin

1495 windowedX: root.leftMargin

1383− windowedY: PanelState.panelHeight

1496+ windowedY: panelState.panelHeight

1384 windowedWidth: (appContainer.width - root.leftMargin)/2

1497 windowedWidth: (appContainer.width - root.leftMargin)/2

1385− windowedHeight: appContainer.height - PanelState.panelHeight

1498+ windowedHeight: appContainer.height - panelState.panelHeight

1386 }

1499 }

1387 },

1500 },

1388 State {

1501 State {

@@ -1399,9 +1512,9 @@ FocusScope {

1399 PropertyChanges {

1512 PropertyChanges {

1400 target: appDelegate

1513 target: appDelegate

1401 windowedX: root.leftMargin

1514 windowedX: root.leftMargin

1402− windowedY: PanelState.panelHeight

1515+ windowedY: panelState.panelHeight

1403 windowedWidth: (appContainer.width - root.leftMargin)/2

1516 windowedWidth: (appContainer.width - root.leftMargin)/2

1404− windowedHeight: (appContainer.height - PanelState.panelHeight)/2

1517+ windowedHeight: (appContainer.height - panelState.panelHeight)/2

1405 }

1518 }

1406 },

1519 },

1407 State {

1520 State {

@@ -1418,7 +1531,7 @@ FocusScope {

1418 PropertyChanges {

1531 PropertyChanges {

1419 target: appDelegate

1532 target: appDelegate

1420 windowedX: root.leftMargin

1533 windowedX: root.leftMargin

1421− windowedY: (appContainer.height + PanelState.panelHeight)/2

1534+ windowedY: (appContainer.height + panelState.panelHeight)/2

1422 windowedWidth: (appContainer.width - root.leftMargin)/2

1535 windowedWidth: (appContainer.width - root.leftMargin)/2

1423 windowedHeight: appContainer.height/2

1536 windowedHeight: appContainer.height/2

1424 }

1537 }

@@ -1440,8 +1553,8 @@ FocusScope {

1440 State {

1553 State {

1441 name: "maximizedVertically"; when: appDelegate.maximizedVertically && !appDelegate.minimized

1554 name: "maximizedVertically"; when: appDelegate.maximizedVertically && !appDelegate.minimized

1442 extend: "normal"

1555 extend: "normal"

1443− PropertyChanges { target: appDelegate; windowedX: windowedX; windowedY: PanelState.panelHeight;

1556+ PropertyChanges { target: appDelegate; windowedX: windowedX; windowedY: panelState.panelHeight;

1444− windowedWidth: windowedWidth; windowedHeight: appContainer.height - PanelState.panelHeight }

1557+ windowedWidth: windowedWidth; windowedHeight: appContainer.height - panelState.panelHeight }

1445 },

1558 },

1446 State {

1559 State {

1447 name: "minimized"; when: appDelegate.minimized

1560 name: "minimized"; when: appDelegate.minimized

@@ -1554,7 +1667,7 @@ FocusScope {

1554 ]

1667 ]

1555

1668

1556 Binding {

1669 Binding {

1557− target: PanelState

1670+ target: panelState

1558 property: "decorationsAlwaysVisible"

1671 property: "decorationsAlwaysVisible"

1559 value: appDelegate && appDelegate.maximized && touchControls.overlayShown

1672 value: appDelegate && appDelegate.maximized && touchControls.overlayShown

1560 }

1673 }

@@ -1730,12 +1843,15 @@ FocusScope {

1730 objectName: "closeMouseArea"

1843 objectName: "closeMouseArea"

1731 anchors { left: parent.left; top: parent.top; leftMargin: -height / 2; topMargin: -height / 2 + spreadMaths.closeIconOffset }

1844 anchors { left: parent.left; top: parent.top; leftMargin: -height / 2; topMargin: -height / 2 + spreadMaths.closeIconOffset }

1732 readonly property var mousePos: hoverMouseArea.mapToItem(appDelegate, hoverMouseArea.mouseX, hoverMouseArea.mouseY)

1845 readonly property var mousePos: hoverMouseArea.mapToItem(appDelegate, hoverMouseArea.mouseX, hoverMouseArea.mouseY)

1733− visible: !appDelegate.isDash && dragArea.distance == 0

1846+ readonly property bool shown: !appDelegate.isDash && dragArea.distance == 0

1734 && index == spreadItem.highlightedIndex

1847 && index == spreadItem.highlightedIndex

1735 && mousePos.y < (decoratedWindow.height / 3)

1848 && mousePos.y < (decoratedWindow.height / 3)

1736 && mousePos.y > -units.gu(4)

1849 && mousePos.y > -units.gu(4)

1737 && mousePos.x > -units.gu(4)

1850 && mousePos.x > -units.gu(4)

1738 && mousePos.x < (decoratedWindow.width * 2 / 3)

1851 && mousePos.x < (decoratedWindow.width * 2 / 3)

1852+ opacity: shown ? 1 : 0

1853+ visible: opacity > 0

1854+ Behavior on opacity { UbuntuNumberAnimation { duration: UbuntuAnimation.SnapDuration } }

1739 height: units.gu(6)

1855 height: units.gu(6)

1740 width: height

1856 width: height

1741

1857

@@ -1797,83 +1913,7 @@ FocusScope {

1797 leftMargin: root.leftMargin

1913 leftMargin: root.leftMargin

1798 appContainerWidth: appContainer.width

1914 appContainerWidth: appContainer.width

1799 appContainerHeight: appContainer.height

1915 appContainerHeight: appContainer.height

1800− }

1916+ panelState: root.panelState

1801−

1802− MouseArea {

1803− id: hoverMouseArea

1804− objectName: "hoverMouseArea"

1805− anchors.fill: appContainer

1806− propagateComposedEvents: true

1807− hoverEnabled: true

1808− enabled: false

1809− visible: enabled

1810−

1811− property int scrollAreaWidth: width / 3

1812− property bool progressiveScrollingEnabled: false

1813−

1814− onMouseXChanged: {

1815− mouse.accepted = false

1816−

1817− if (hoverMouseArea.pressed) {

1818− return;

1819− }

1820−

1821− // Find the hovered item and mark it active

1822− for (var i = appRepeater.count - 1; i >= 0; i--) {

1823− var appDelegate = appRepeater.itemAt(i);

1824− var mapped = mapToItem(appDelegate, hoverMouseArea.mouseX, hoverMouseArea.mouseY)

1825− var itemUnder = appDelegate.childAt(mapped.x, mapped.y);

1826− if (itemUnder && (itemUnder.objectName === "dragArea" || itemUnder.objectName === "windowInfoItem" || itemUnder.objectName == "closeMouseArea")) {

1827− spreadItem.highlightedIndex = i;

1828− break;

1829− }

1830− }

1831−

1832− if (floatingFlickable.contentWidth > floatingFlickable.width) {

1833− var margins = floatingFlickable.width * 0.05;

1834−

1835− if (!progressiveScrollingEnabled && mouseX < floatingFlickable.width - scrollAreaWidth) {

1836− progressiveScrollingEnabled = true

1837− }

1838−

1839− // do we need to scroll?

1840− if (mouseX < scrollAreaWidth + margins) {

1841− var progress = Math.min(1, (scrollAreaWidth + margins - mouseX) / (scrollAreaWidth - margins));

1842− var contentX = (1 - progress) * (floatingFlickable.contentWidth - floatingFlickable.width)

1843− floatingFlickable.contentX = Math.max(0, Math.min(floatingFlickable.contentX, contentX))

1844− }

1845− if (mouseX > floatingFlickable.width - scrollAreaWidth && progressiveScrollingEnabled) {

1846− var progress = Math.min(1, (mouseX - (floatingFlickable.width - scrollAreaWidth)) / (scrollAreaWidth - margins))

1847− var contentX = progress * (floatingFlickable.contentWidth - floatingFlickable.width)

1848− floatingFlickable.contentX = Math.min(floatingFlickable.contentWidth - floatingFlickable.width, Math.max(floatingFlickable.contentX, contentX))

1849− }

1850− }

1851− }

1852−

1853− onPressed: mouse.accepted = false

1854− }

1855−

1856− FloatingFlickable {

1857− id: floatingFlickable

1858− objectName: "spreadFlickable"

1859− anchors.fill: appContainer

1860− enabled: false

1861− contentWidth: spreadItem.spreadTotalWidth

1862−

1863− function snap(toIndex) {

1864− var delegate = appRepeater.itemAt(toIndex)

1865− var targetContentX = floatingFlickable.contentWidth / spreadItem.totalItemCount * toIndex;

1866− if (targetContentX - floatingFlickable.contentX > spreadItem.rightStackXPos - (spreadItem.spreadItemWidth / 2)) {

1867− var offset = (spreadItem.rightStackXPos - (spreadItem.spreadItemWidth / 2)) - (targetContentX - floatingFlickable.contentX)

1868− snapAnimation.to = Math.max(0, floatingFlickable.contentX - offset);

1869− snapAnimation.start();

1870− } else if (targetContentX - floatingFlickable.contentX < spreadItem.leftStackXPos + units.gu(1)) {

1871− var offset = (spreadItem.leftStackXPos + units.gu(1)) - (targetContentX - floatingFlickable.contentX);

1872− snapAnimation.to = Math.max(0, floatingFlickable.contentX - offset);

1873− snapAnimation.start();

1874− }

1875− }

1876− UbuntuNumberAnimation {id: snapAnimation; target: floatingFlickable; property: "contentX"}

1877 }

1917 }

1878

1918

1879 PropertyAnimation {

1919 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/WorkspacePreview.qmlnew file+212

@@ -0,0 +1,212 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Unity.Screens 0.1

4+import Unity.Application 0.1

5+import "../Components"

6+

7+UbuntuShape {

8+ id: previewSpace

9+

10+ // Set the height. this preview will then automatically adjust the width, keeping aspect ratio of the screen

11+ width: model.geometry.width * previewScale * 4

12+ color: "white"

13+ property string background

14+

15+ property int screenWidth: model.geometry.width

16+ property int screenHeight: model.geometry.height

17+ property real previewScale: (previewSpace.height - header.height) / previewSpace.screenHeight

18+

19+ Item {

20+ id: header

21+ anchors { left: parent.left; top: parent.top; right: parent.right }

22+ height: units.gu(7)

23+

24+ Column {

25+ anchors.fill: parent

26+ anchors.margins: units.gu(1)

27+

28+ Label {

29+ text: model.name

30+ color: "black"

31+ }

32+

33+ Label {

34+ text: model.outputType === Screens.LVDS ? "Built-in" : "Clone"

35+ color: "black"

36+ fontSize: "x-small"

37+ }

38+

39+ Label {

40+ text: model.geometry.width + "x" + model.geometry.height

41+ color: "black"

42+ fontSize: "x-small"

43+ }

44+ }

45+ }

46+

47+

48+ Rectangle {

49+ anchors.fill: parent

50+ anchors.topMargin: header.height

51+ color: "blue"

52+

53+ Repeater {

54+ id: workspaceRepeater

55+ model: 15

56+

57+ delegate: Item {

58+ x: index * previewSpace.screenWidth * previewScale

59+ height: previewSpace.screenHeight * previewScale

60+ width: previewSpace.screenWidth * previewScale

61+ clip: true

62+

63+ Wallpaper {

64+ source: previewSpace.background

65+ anchors.fill: parent

66+

67+ // Repeater {

68+ // id: topLevelSurfaceRepeater

69+ // model: visible ? topLevelSurfaceList : null

70+ // delegate: Rectangle {

71+ // width: surfaceItem.width

72+ // height: surfaceItem.height + decorationHeight * previewScale

73+ // x: model.window.position.x * previewScale

74+ // y: (model.window.position.y - decorationHeight) * previewScale

75+ // color: "blue"

76+ // z: topLevelSurfaceRepeater.count - index

77+

78+ // property int decorationHeight: units.gu(3)

79+

80+ // WindowDecoration {

81+ // width: surfaceItem.implicitWidth

82+ // height: parent.decorationHeight

83+ // transform: Scale {

84+ // origin.x: 0

85+ // origin.y: 0

86+ // xScale: previewScale

87+ // yScale: previewScale

88+ // }

89+ // title: model.window && model.window.surface ? model.window.surface.name : ""

90+ // z: 3

91+ // }

92+

93+ // MirSurfaceItem {

94+ // id: surfaceItem

95+ // y: parent.decorationHeight * previewScale

96+ // width: implicitWidth * previewScale

97+ // height: implicitHeight * previewScale

98+ // surfaceWidth: -1

99+ // surfaceHeight: -1

100+ // onImplicitHeightChanged: print("item", surfaceItem, "height changed", implicitHeight)

101+ // surface: model.window.surface

102+ // }

103+ // }

104+ // }

105+ }

106+ }

107+

108+

109+// MouseArea {

110+// id: mouseArea

111+// anchors.centerIn: parent

112+// anchors.verticalCenterOffset: header.height / 2

113+// width: units.gu(8)

114+// height: width

115+// hoverEnabled: true

116+// opacity: containsMouse ? 1 : 0

117+

118+// Rectangle {

119+// anchors.fill: parent

120+// color: "#80000000"

121+// radius: height / 2

122+// }

123+

124+// NumberAnimation {

125+// target: canvas

126+// property: "progress"

127+// duration: 2000

128+// running: mouseArea.containsMouse

129+// from: 0

130+// to: 1

131+// }

132+

133+// Canvas {

134+// id: canvas

135+// height: parent.height

136+// width: height

137+// anchors.centerIn: parent

138+

139+// property real progress: 0.5

140+// property int lineWidth: units.dp(4)

141+// onProgressChanged: {

142+// requestPaint();

143+// if (progress == 1) {

144+// Screens.activateScreen(index);

145+// }

146+// }

147+

148+// rotation: -90

149+

150+// onPaint: {

151+// var ctx = canvas.getContext("2d");

152+// ctx.save();

153+// ctx.reset();

154+

155+// ctx.lineWidth = lineWidth;

156+

157+// ctx.strokeStyle = "#3bffffff"

158+// ctx.beginPath();

159+// ctx.arc(canvas.width/2,canvas.height/2, (canvas.height - ctx.lineWidth) / 2, 0, (Math.PI*2),false);

160+// ctx.stroke();

161+// ctx.closePath();

162+

163+// ctx.strokeStyle = "white"

164+// ctx.beginPath();

165+// ctx.arc(canvas.width/2,canvas.height/2, (canvas.height - ctx.lineWidth) / 2, 0, (Math.PI*2*(progress)),false);

166+// ctx.stroke();

167+// ctx.closePath();

168+

169+// ctx.restore();

170+// }

171+// }

172+

173+// Icon {

174+// source: "graphics/multi-monitor_leave.png"

175+// height: units.gu(4)

176+// width: height

177+// anchors.centerIn: parent

178+// }

179+// }

180+ }

181+

182+ FloatingFlickable {

183+ id: flickable

184+ anchors.fill: parent

185+ contentWidth: workspaceRepeater.count * previewSpace.screenWidth * previewScale

186+ property real progress: contentX / contentWidth

187+ onContentXChanged: print("contentX:", contentX, "progress:", progress)

188+ }

189+

190+ MouseArea {

191+ anchors.fill: parent

192+ hoverEnabled: true

193+ property int scrollAreaWidth: width / 3

194+

195+ onMouseXChanged: {

196+ var margins = flickable.width * 0.05;

197+

198+ // do we need to scroll?

199+ if (mouseX < scrollAreaWidth + margins) {

200+ var progress = Math.min(1, (scrollAreaWidth + margins - mouseX) / (scrollAreaWidth - margins));

201+ var contentX = (1 - progress) * (flickable.contentWidth - flickable.width)

202+ flickable.contentX = Math.max(0, Math.min(flickable.contentX, contentX))

203+ }

204+ if (mouseX > flickable.width - scrollAreaWidth) {

205+ var progress = Math.min(1, (mouseX - (flickable.width - scrollAreaWidth)) / (scrollAreaWidth - margins))

206+ var contentX = progress * (flickable.contentWidth - flickable.width)

207+ flickable.contentX = Math.min(flickable.contentWidth - flickable.width, Math.max(flickable.contentX, contentX))

208+ }

209+ }

210+ }

211+ }

212+}

qml/Stage/graphics/multi-monitor_drop-here.pngnew file

Binary file not shown.

qml/Stage/graphics/multi-monitor_leave.pngnew file

Binary file not shown.

qml/qmldirnew file+1

@@ -0,0 +1 @@

1+singleton ShellNotifier 0.1 ShellNotifier.qml

src/ApplicationArguments.cpp+11−2

@@ -16,7 +16,16 @@

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+10−4

@@ -7,6 +7,7 @@ include_directories(

7 ${Qt5Gui_PRIVATE_INCLUDE_DIRS}

8 ${Qt5Quick_PRIVATE_INCLUDE_DIRS}

9 ${CONNECTIVITY_INCLUDE_DIRS}

10+ ${QTMIRSERVER_INCLUDE_DIRS}

10)

11)

11

12

12include_directories(

13include_directories(

@@ -27,12 +28,11 @@ set(SOURCE_FILES

27 ApplicationArguments.cpp

28 ApplicationArguments.cpp

28 main.cpp

29 main.cpp

29 CachingNetworkManagerFactory.cpp

30 CachingNetworkManagerFactory.cpp

30− SecondaryWindow.cpp

31+ UnityApplication.cpp

31− ShellApplication.cpp

32− ShellView.cpp

33 UnityCommandLineParser.cpp

32 UnityCommandLineParser.cpp

34 UnixSignalHandler.cpp

33 UnixSignalHandler.cpp

35 DebuggingController.cpp

34 DebuggingController.cpp

35+ WindowManagementPolicy.cpp

36 ${QML_FILES} # This is to make qml and image files appear in the IDE's project tree

37)

38

@@ -47,7 +47,13 @@ qt5_use_modules(${SHELL_APP} DBus Gui Qml Quick Test)

47if (NOT "${ANDROID_PROPERTIES_INCLUDE_DIRS}" STREQUAL "")

48 set_target_properties(${SHELL_APP} PROPERTIES INCLUDE_DIRECTORIES ${ANDROID_PROPERTIES_INCLUDE_DIRS})

49endif()

50−target_link_libraries(${SHELL_APP} ${ANDROID_PROPERTIES_LDFLAGS} UbuntuGestures connectivity-qt1 unity8-private)

50+target_link_libraries(${SHELL_APP}

51+ ${ANDROID_PROPERTIES_LDFLAGS}

52+ ${QTMIRSERVER_LDFLAGS}

53+ UbuntuGestures

54+ connectivity-qt1

55+ unity8-private

56+)

51

57

52if (ENABLE_TOUCH_EMULATION)

58if (ENABLE_TOUCH_EMULATION)

53 target_link_libraries(${SHELL_APP} ${MOUSETOUCHADAPTOR_LIBS_LDFLAGS})

59 target_link_libraries(${SHELL_APP} ${MOUSETOUCHADAPTOR_LIBS_LDFLAGS})

src/DebuggingController.cpp+12−1

@@ -49,7 +49,8 @@ public:

49};

50

51DebuggingController::DebuggingController(QObject *parent):

52− UnityDBusObject(QStringLiteral("/com/canonical/Unity8/Debugging"), QStringLiteral("com.canonical.Unity8"), true, parent)

52+ UnityDBusObject(QStringLiteral("/com/canonical/Unity8/Debugging"), QStringLiteral("com.canonical.Unity8"), true, parent),

53+ m_logOverlay(false)

53{

54{

54}

55}

55

56

@@ -90,3 +91,13 @@ void DebuggingController::SetLoggingFilterRules(const QString &filterRules)

90{

91{

91 QLoggingCategory::setFilterRules(filterRules);

92 QLoggingCategory::setFilterRules(filterRules);

92}

93}

94+

95+void DebuggingController::SetLogOverlay(bool logOverlay)

96+{

97+ if (logOverlay == m_logOverlay) {

98+ return;

99+ }

100+

101+ m_logOverlay = logOverlay;

102+ Q_EMIT logOverlayChanged(m_logOverlay);

103+}

src/DebuggingController.h+14

@@ -32,10 +32,14 @@ class DebuggingController: public UnityDBusObject

32 Q_OBJECT

33 Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity8.Debugging")

34

35+ Q_PROPERTY(bool logOverlay READ logOverlay NOTIFY logOverlayChanged)

36+

35public:

37public:

36 DebuggingController(QObject *parent = nullptr);

38 DebuggingController(QObject *parent = nullptr);

37 ~DebuggingController() = default;

39 ~DebuggingController() = default;

38

40

41+ bool logOverlay() const { return m_logOverlay; }

42+

39public Q_SLOTS:

43public Q_SLOTS:

40 /**

44 /**

41 * Set the QSG_VISUALIZE mode. This follows the vlues supported by Qt in

45 * Set the QSG_VISUALIZE mode. This follows the vlues supported by Qt in

@@ -53,5 +57,15 @@ public Q_SLOTS:

53 */

57 */

54 Q_SCRIPTABLE void SetLoggingFilterRules(const QString &filterRules);

58 Q_SCRIPTABLE void SetLoggingFilterRules(const QString &filterRules);

55

59

60+ /**

61+ * Enable/Disable the shell console log overlay

62+ */

63+ Q_SCRIPTABLE void SetLogOverlay(bool logOverlay);

64+

65+Q_SIGNALS:

66+ void logOverlayChanged(bool logOverlay);

67+

68+private:

69+ bool m_logOverlay;

56};

70};

57#endif // DEBUGGINGCONTROLLER_H

71#endif // DEBUGGINGCONTROLLER_H

src/SecondaryWindow.cppdeleted−40

@@ -1,40 +0,0 @@

1−/*

3− *

4− * This program is free software; you can redistribute it and/or modify

5− * it under the terms of the GNU General Public License as published by

6− * the Free Software Foundation; version 3.

7− *

8− * This program is distributed in the hope that it will be useful,

9− * but WITHOUT ANY WARRANTY; without even the implied warranty of

10− * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11− * GNU General Public License for more details.

12− *

13− * You should have received a copy of the GNU General Public License

14− * along with this program. If not, see <http://www.gnu.org/licenses/>.

15− */

16−

17−#include "SecondaryWindow.h"

18−

19−// local

20−#include <paths.h>

21−

22−#include <QQmlContext>

23−

24−SecondaryWindow::SecondaryWindow(QQmlEngine *engine)

25− : QQuickView(engine, nullptr)

26−{

27− QByteArray pxpguEnv = qgetenv("GRID_UNIT_PX");

28− bool ok;

29− int pxpgu = pxpguEnv.toInt(&ok);

30− if (!ok) {

31− pxpgu = 8;

32− }

33− engine->rootContext()->setContextProperty(QStringLiteral("internalGu"), pxpgu);

34− setResizeMode(QQuickView::SizeRootObjectToView);

35− setColor("black");

36− setTitle(QStringLiteral("Unity8 Shell - Secondary Screen"));

37−

38− QUrl source(::qmlDirectory() + "/DisabledScreenNotice.qml");

39− setSource(source);

40−}

src/ShellApplication.cppdeleted−216

@@ -1,216 +0,0 @@

1−/*

3− *

4− * This program is free software; you can redistribute it and/or modify

5− * it under the terms of the GNU General Public License as published by

6− * the Free Software Foundation; version 3.

7− *

8− * This program is distributed in the hope that it will be useful,

9− * but WITHOUT ANY WARRANTY; without even the implied warranty of

10− * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11− * GNU General Public License for more details.

12− *

13− * You should have received a copy of the GNU General Public License

14− * along with this program. If not, see <http://www.gnu.org/licenses/>.

15− */

16−

17−#include "ShellApplication.h"

18−

19−// Qt

20−#include <QLibrary>

21−#include <QProcess>

22−#include <QScreen>

23−

24−#include <libintl.h>

25−

26−// libandroid-properties

27−#include <hybris/properties/properties.h>

28−

29−// local

30−#include <paths.h>

31−#include "CachingNetworkManagerFactory.h"

32−#include "UnityCommandLineParser.h"

33−#include "DebuggingController.h"

34−

35−ShellApplication::ShellApplication(int & argc, char ** argv, bool isMirServer)

36− : QGuiApplication(argc, argv)

37−{

38− setApplicationName(QStringLiteral("unity8"));

39− setOrganizationName(QStringLiteral("Canonical"));

40−

41− connect(this, &QGuiApplication::screenAdded, this, &ShellApplication::onScreenAdded);

42−

43− setupQmlEngine(isMirServer);

44−

45− UnityCommandLineParser parser(*this);

46−

47− if (!parser.deviceName().isEmpty()) {

48− m_deviceName = parser.deviceName();

49− } else {

50− char buffer[200];

51− property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);

52− m_deviceName = QString(buffer);

53− }

54− m_qmlArgs.setDeviceName(m_deviceName);

55−

56− m_qmlArgs.setMode(parser.mode());

57−

58− // The testability driver is only loaded by QApplication but not by QGuiApplication.

59− // However, QApplication depends on QWidget which would add some unneeded overhead => Let's load the testability driver on our own.

60− if (parser.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {

61− QLibrary testLib(QStringLiteral("qttestability"));

62− if (testLib.load()) {

63− typedef void (*TasInitialize)(void);

64− TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");

65− if (initFunction) {

66− initFunction();

67− } else {

68− qCritical("Library qttestability resolve failed!");

69− }

70− } else {

71− qCritical("Library qttestability load failed!");

72− }

73− }

74−

75− bindtextdomain("unity8", translationDirectory().toUtf8().data());

76− textdomain("unity8");

77−

78− m_shellView = new ShellView(m_qmlEngine, &m_qmlArgs);

79−

80− if (parser.windowGeometry().isValid()) {

81− m_shellView->setWidth(parser.windowGeometry().width());

82− m_shellView->setHeight(parser.windowGeometry().height());

83− }

84−

85− if (parser.hasFrameless()) {

86− m_shellView->setFlags(Qt::FramelessWindowHint);

87− }

88−

89−

90− #ifdef UNITY8_ENABLE_TOUCH_EMULATION

91− // You will need this if you want to interact with touch-only components using a mouse

92− // Needed only when manually testing on a desktop.

93− if (parser.hasMouseToTouch()) {

94− m_mouseTouchAdaptor = MouseTouchAdaptor::instance();

95− }

96− #endif

97−

98− new DebuggingController(this);

99−

100− // Some hard-coded policy for now.

101− // NB: We don't support more than two screens at the moment

102− //

103− // TODO: Support an arbitrary number of screens and different policies

104− // (eg cloned desktop, several desktops, etc)

105− if (isMirServer && screens().count() == 2) {

106− m_shellView->setScreen(screens().at(1));

107− m_qmlArgs.setDeviceName(QStringLiteral("desktop"));

108−

109− m_secondaryWindow = new SecondaryWindow(m_qmlEngine);

110− m_secondaryWindow->setScreen(screens().at(0));

111− // QWindow::showFullScreen() also calls QWindow::requestActivate() and we don't want that!

112− m_secondaryWindow->setWindowState(Qt::WindowFullScreen);

113− m_secondaryWindow->setVisible(true);

114− }

115−

116− if (parser.mode().compare("greeter") == 0) {

117− QSize primaryScreenSize = this->primaryScreen()->size();

118− m_shellView->setHeight(primaryScreenSize.height());

119− m_shellView->setWidth(primaryScreenSize.width());

120− m_shellView->show();

121− m_shellView->requestActivate();

122− if (!QProcess::startDetached("initctl emit --no-wait unity8-greeter-started")) {

123− qDebug() << "Unable to send unity8-greeter-started event to Upstart";

124− }

125− } else if (isMirServer || parser.hasFullscreen()) {

126− m_shellView->showFullScreen();

127− } else {

128− m_shellView->show();

129− }

130−}

131−

132−ShellApplication::~ShellApplication()

133−{

134− destroyResources();

135−}

136−

137−void ShellApplication::destroyResources()

138−{

139− // Deletion order is important. Don't use QScopedPointers and the like

140− // Otherwise the process will hang on shutdown (bug somewhere I guess).

141− delete m_shellView;

142− m_shellView = nullptr;

143−

144− delete m_secondaryWindow;

145− m_secondaryWindow = nullptr;

146−

147− #ifdef UNITY8_ENABLE_TOUCH_EMULATION

148− delete m_mouseTouchAdaptor;

149− m_mouseTouchAdaptor = nullptr;

150− #endif

151−

152− delete m_qmlEngine;

153− m_qmlEngine = nullptr;

154−}

155−

156−void ShellApplication::setupQmlEngine(bool isMirServer)

157−{

158− m_qmlEngine = new QQmlEngine(this);

159−

160− m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));

161−

162− prependImportPaths(m_qmlEngine, ::overrideImportPaths());

163− if (!isMirServer) {

164− prependImportPaths(m_qmlEngine, ::nonMirImportPaths());

165− }

166− appendImportPaths(m_qmlEngine, ::fallbackImportPaths());

167−

168− m_qmlEngine->setNetworkAccessManagerFactory(new CachingNetworkManagerFactory);

169−

170− QObject::connect(m_qmlEngine, &QQmlEngine::quit, this, &QGuiApplication::quit);

171−}

172−

173−void ShellApplication::onScreenAdded(QScreen * /*screen*/)

174−{

175− // TODO: Support an arbitrary number of screens and different policies

176− // (eg cloned desktop, several desktops, etc)

177− if (screens().count() == 2) {

178− m_shellView->setScreen(screens().at(1));

179− m_qmlArgs.setDeviceName(QStringLiteral("desktop"));

180− // Changing the QScreen where a QWindow is drawn makes it also lose focus (besides having

181− // its backing QPlatformWindow recreated). So lets refocus it.

182− m_shellView->requestActivate();

183− // QWindow::destroy() is called when it changes between screens. We have to manually make it visible again

184− // <dandrader> This bug is supposedly fixed in Qt 5.5.1, although I can still reproduce it there. :-/

185− m_shellView->setVisible(true);

186−

187− m_secondaryWindow = new SecondaryWindow(m_qmlEngine);

188− m_secondaryWindow->setScreen(screens().at(0));

189−

190− // QWindow::showFullScreen() also calls QWindow::requestActivate() and we don't want that!

191− m_secondaryWindow->setWindowState(Qt::WindowFullScreen);

192− m_secondaryWindow->setVisible(true);

193− }

194−}

195−

196−void ShellApplication::onScreenAboutToBeRemoved(QScreen *screen)

197−{

198− // TODO: Support an arbitrary number of screens and different policies

199− // (eg cloned desktop, several desktops, etc)

200− if (screen == m_shellView->screen()) {

201− const QList<QScreen *> allScreens = screens();

202− Q_ASSERT(allScreens.count() > 1);

203− Q_ASSERT(allScreens.at(0) != screen);

204− Q_ASSERT(m_secondaryWindow);

205− delete m_secondaryWindow;

206− m_secondaryWindow = nullptr;

207− m_shellView->setScreen(allScreens.first());

208− m_qmlArgs.setDeviceName(m_deviceName);

209− // Changing the QScreen where a QWindow is drawn makes it also lose focus (besides having

210− // its backing QPlatformWindow recreated). So lets refocus it.

211− m_shellView->requestActivate();

212− // QWindow::destroy() is called when it changes between screens. We have to manually make it visible again

213− // <dandrader> This bug is supposedly fixed in Qt 5.5.1, although I can still reproduce it there. :-/

214− m_shellView->setVisible(true);

215− }

216−}

src/ShellView.cppdeleted−85

@@ -1,85 +0,0 @@

1−/*

3− *

4− * This program is free software; you can redistribute it and/or modify

5− * it under the terms of the GNU General Public License as published by

6− * the Free Software Foundation; version 3.

7− *

8− * This program is distributed in the hope that it will be useful,

9− * but WITHOUT ANY WARRANTY; without even the implied warranty of

10− * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11− * GNU General Public License for more details.

12− *

13− * You should have received a copy of the GNU General Public License

14− * along with this program. If not, see <http://www.gnu.org/licenses/>.

15− */

16−

17−#include "ShellView.h"

18−

19−// Qt

20−#include <QQmlContext>

21−#include <QQuickItem>

22−#include <QtQuick/private/qquickitem_p.h>

23−#include <QtQuick/private/qquickrectangle_p.h>

24−#include <QtQuick/private/qquicktext_p.h>

25−

26−// local

27−#include <paths.h>

28−

29−ShellView::ShellView(QQmlEngine *engine, QObject *qmlArgs)

30− : QQuickView(engine, nullptr)

31−{

32− setResizeMode(QQuickView::SizeRootObjectToView);

33− setColor("black");

34− setTitle(QStringLiteral("Unity8"));

35−

36− rootContext()->setContextProperty(QStringLiteral("applicationArguments"), qmlArgs);

37−

38− connect(this, &QQuickView::statusChanged, this, [this] {

39− if (status() == QQuickView::Error) {

40− QQuickRectangle *rect = new QQuickRectangle(contentItem());

41− rect->setColor(Qt::white);

42− QQuickItemPrivate::get(rect)->anchors()->setFill(contentItem());

43−

44− QString errorsString;

45− for(const QQmlError &e: errors()) {

46− errorsString += e.toString() + "\n";

47− }

48− QQuickText *text = new QQuickText(rect);

49− text->setColor(Qt::black);

50− text->setWrapMode(QQuickText::Wrap);

51− text->setText(QString("There was an error loading Unity8:\n%1").arg(errorsString));

52− QQuickItemPrivate::get(text)->anchors()->setFill(rect);

53− }

54− }

55− );

56−

57− QUrl source(::qmlDirectory() + "/OrientedShell.qml");

58− setSource(source);

59−

60− connect(this, &QWindow::widthChanged, this, &ShellView::onWidthChanged);

61− connect(this, &QWindow::heightChanged, this, &ShellView::onHeightChanged);

62−}

63−

64−void ShellView::onWidthChanged(int w)

65−{

66− // For good measure in case SizeRootObjectToView doesn't fulfill its promise.

67− //

68− // There's at least one situation that's know to leave the root object with an outdated size.

69− // (really looks like Qt bug)

70− // Happens when starting unity8 with an external monitor already connected.

71− // The QResizeEvent we get still has the size of the first screen and since the resize move is triggered

72− // from the resize event handler, the root item doesn't get resized.

73− // TODO: Confirm the Qt bug and submit a patch upstream

74− if (rootObject()) {

75− rootObject()->setWidth(w);

76− }

77−}

78−

79−void ShellView::onHeightChanged(int h)

80−{

81− // See comment in ShellView::onWidthChanged()

82− if (rootObject()) {

83− rootObject()->setHeight(h);

84− }

85−}

src/UnityApplication.cppnew file+142

@@ -0,0 +1,142 @@

1+/*

3+ *

4+ * This program is free software; you can redistribute it and/or modify

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

8+ * This program is distributed in the hope that it will be useful,

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+ */

16+

17+#include "UnityApplication.h"

18+

19+// Qt

20+#include <QLibrary>

21+#include <QProcess>

22+#include <QScreen>

23+#include <QQmlContext>

24+#include <QQmlComponent>

25+

26+#include <libintl.h>

27+

28+// libandroid-properties

29+#include <hybris/properties/properties.h>

30+

31+// local

32+#include <paths.h>

33+#include "CachingNetworkManagerFactory.h"

34+#include "UnityCommandLineParser.h"

35+#include "DebuggingController.h"

36+#include "WindowManagementPolicy.h"

37+

38+#include <QDebug>

39+

40+

41+

42+UnityApplication::UnityApplication(int & argc, char ** argv)

43+ : qtmir::MirServerApplication(argc, argv, { qtmir::SetWindowManagementPolicy<WindowManagementPolicy>() })

44+ , m_qmlArgs(this)

45+{

46+ setApplicationName(QStringLiteral("unity8"));

47+ setOrganizationName(QStringLiteral("Canonical"));

48+

49+ setupQmlEngine();

50+

51+ if (m_qmlArgs.deviceName().isEmpty()) {

52+ char buffer[200];

53+ property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);

54+ m_qmlArgs.setDeviceName(QString(buffer));

55+ }

56+

57+ // The testability driver is only loaded by QApplication but not by QGuiApplication.

58+ // However, QApplication depends on QWidget which would add some unneeded overhead => Let's load the testability driver on our own.

59+ if (m_qmlArgs.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {

60+ QLibrary testLib(QStringLiteral("qttestability"));

61+ if (testLib.load()) {

62+ typedef void (*TasInitialize)(void);

63+ TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");

64+ if (initFunction) {

65+ initFunction();

66+ } else {

67+ qCritical("Library qttestability resolve failed!");

68+ }

69+ } else {

70+ qCritical("Library qttestability load failed!");

71+ }

72+ }

73+

74+ bindtextdomain("unity8", translationDirectory().toUtf8().data());

75+ textdomain("unity8");

76+

77+ m_qmlEngine->rootContext()->setContextProperty(QStringLiteral("applicationArguments"), &m_qmlArgs);

78+ m_qmlEngine->rootContext()->setContextProperty("DebuggingController", new DebuggingController(this));

79+

80+ QByteArray pxpguEnv = qgetenv("GRID_UNIT_PX");

81+ bool ok;

82+ int pxpgu = pxpguEnv.toInt(&ok);

83+ if (!ok) {

84+ pxpgu = 8;

85+ }

86+ m_qmlEngine->rootContext()->setContextProperty("internalGu", pxpgu);

87+

88+ auto component(new QQmlComponent(m_qmlEngine, m_qmlArgs.qmlfie()));

89+ component->create();

90+ if (component->status() == QQmlComponent::Error) {

91+ m_qmlEngine->rootContext()->setContextProperty(QStringLiteral("errorString"), component->errorString());

92+ auto errorComponent(new QQmlComponent(m_qmlEngine,

93+ QUrl::fromLocalFile(::qmlDirectory() + "/ErrorApplication.qml")));

94+ errorComponent->create();

95+ qDebug() << errorComponent->errorString();

96+ return;

97+ }

98+

99+ #ifdef UNITY8_ENABLE_TOUCH_EMULATION

100+ // You will need this if you want to interact with touch-only components using a mouse

101+ // Needed only when manually testing on a desktop.

102+ if (m_qmlArgs.hasMouseToTouch()) {

103+ m_mouseTouchAdaptor = MouseTouchAdaptor::instance();

104+ }

105+ #endif

106+

107+ if (m_qmlArgs.mode().compare("greeter") == 0) {

108+ if (!QProcess::startDetached("initctl emit --no-wait unity8-greeter-started")) {

109+ qDebug() << "Unable to send unity8-greeter-started event to Upstart";

110+ }

111+ }

112+}

113+

114+UnityApplication::~UnityApplication()

115+{

116+ destroyResources();

117+}

118+

119+void UnityApplication::destroyResources()

120+{

121+ #ifdef UNITY8_ENABLE_TOUCH_EMULATION

122+ delete m_mouseTouchAdaptor;

123+ m_mouseTouchAdaptor = nullptr;

124+ #endif

125+

126+ delete m_qmlEngine;

127+ m_qmlEngine = nullptr;

128+}

129+

130+void UnityApplication::setupQmlEngine()

131+{

132+ m_qmlEngine = new QQmlEngine(this);

133+

134+ m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));

135+

136+ prependImportPaths(m_qmlEngine, ::overrideImportPaths());

137+ appendImportPaths(m_qmlEngine, ::fallbackImportPaths());

138+

139+ m_qmlEngine->setNetworkAccessManagerFactory(new CachingNetworkManagerFactory);

140+

141+ QObject::connect(m_qmlEngine, &QQmlEngine::quit, this, &QGuiApplication::quit);

142+}

src/ShellApplication.h → src/UnityApplication.hrenamed+9−19

@@ -14,11 +14,11 @@

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+44

@@ -0,0 +1,44 @@

1+/*

3+ *

4+ * This program is free software; you can redistribute it and/or modify

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

8+ * This program is distributed in the hope that it will be useful,

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+ */

16+

17+#ifndef WMPOLICYINTERFACE_H

18+#define WMPOLICYINTERFACE_H

19+

20+#include <memory>

21+#include <functional>

22+

23+#include <qglobal.h>

24+

25+namespace miral {

26+class Workspace;

27+class Window;

28+}

29+

30+class Q_DECL_EXPORT WMPolicyInterface

31+{

32+public:

33+ static WMPolicyInterface *instance();

34+

35+ virtual std::shared_ptr<miral::Workspace> createWorkspace() = 0;

36+

37+ virtual void releaseWorkspace(const std::shared_ptr<miral::Workspace> &workspace) = 0;

38+

39+ virtual void setActiveWorkspace(const std::shared_ptr<miral::Workspace>& workspace) = 0;

40+};

41+

42+extern Q_DECL_EXPORT WMPolicyInterface* wmPolicyInterface;

43+

44+#endif // WMPOLICYINTERFACE_H

src/main.cpp+4−8

@@ -15,9 +15,10 @@

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/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+27−4

@@ -189,9 +189,15 @@ void MirSurfaceItem::createQmlContentItem()

189 m_qmlItem = qobject_cast<QQuickItem*>(m_qmlContentComponent->create());

190 m_qmlItem->setParentItem(this);

191

192+ if (m_fillMode == FillMode::Stretch && width() != 0 && height() != 0) {

193+ m_qmlItem->setWidth(width());

194+ m_qmlItem->setHeight(height());

195+ } else {

192− m_qmlItem->setWidth(m_surfaceWidth);

196+ m_qmlItem->setWidth(m_surfaceWidth);

193− m_qmlItem->setHeight(m_surfaceHeight);

197+ m_qmlItem->setHeight(m_surfaceHeight);

198+ }

194

199

200+ qDebug() << "set size to" << m_surfaceWidth;

195 setImplicitWidth(m_qmlItem->implicitWidth());

201 setImplicitWidth(m_qmlItem->implicitWidth());

196 setImplicitHeight(m_qmlItem->implicitHeight());

202 setImplicitHeight(m_qmlItem->implicitHeight());

197

203

@@ -308,6 +314,16 @@ void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

308 connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);

314 connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);

309 connect(m_qmlSurface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);

315 connect(m_qmlSurface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);

310 connect(m_qmlSurface, &MirSurface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);

316 connect(m_qmlSurface, &MirSurface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);

317+ connect(m_qmlSurface, &MirSurface::sizeChanged, this, [this] () {

318+ if (m_fillMode == FillMode::Stretch) {

319+ m_qmlItem->setSize(QSize(this->width(), this->height()));

320+ } else {

321+ m_qmlItem->setSize(m_qmlSurface->size());

322+ }

323+ setImplicitSize(m_qmlSurface->width(), m_qmlSurface->height());

324+ });

325+ m_surfaceWidth = surface->size().width();

326+ m_surfaceHeight = surface->size().height();

311

327

312 QUrl qmlComponentFilePath;

328 QUrl qmlComponentFilePath;

313 if (!m_qmlSurface->qmlFilePath().isEmpty()) {

329 if (!m_qmlSurface->qmlFilePath().isEmpty()) {

@@ -321,6 +337,7 @@ void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

321 switch (m_qmlContentComponent->status()) {

337 switch (m_qmlContentComponent->status()) {

322 case QQmlComponent::Ready:

338 case QQmlComponent::Ready:

323 createQmlContentItem();

339 createQmlContentItem();

340+ qDebug() << "content created" << m_surfaceWidth << implicitWidth() << width();

324 break;

341 break;

325 case QQmlComponent::Loading:

342 case QQmlComponent::Loading:

326 connect(m_qmlContentComponent, &QQmlComponent::statusChanged,

343 connect(m_qmlContentComponent, &QQmlComponent::statusChanged,

@@ -399,9 +416,15 @@ void MirSurfaceItem::updateSurfaceSize()

399 if (m_qmlSurface && m_surfaceWidth > 0 && m_surfaceHeight > 0) {

416 if (m_qmlSurface && m_surfaceWidth > 0 && m_surfaceHeight > 0) {

400 m_qmlSurface->resize(m_surfaceWidth, m_surfaceHeight);

417 m_qmlSurface->resize(m_surfaceWidth, m_surfaceHeight);

401 if (m_qmlItem) {

418 if (m_qmlItem) {

419+ if (m_fillMode == FillMode::Stretch) {

420+ m_qmlItem->setWidth(width());

421+ m_qmlItem->setHeight(height());

422+ } else {

402− m_qmlItem->setWidth(m_surfaceWidth);

423+ m_qmlItem->setWidth(m_surfaceWidth);

403− m_qmlItem->setHeight(m_surfaceHeight);

424+ m_qmlItem->setHeight(m_surfaceHeight);

425+ }

404 }

426 }

427+ qDebug() << this << "setting implicitsize" << m_surfaceWidth << m_surfaceHeight;

405 setImplicitSize(m_surfaceWidth, m_surfaceHeight);

428 setImplicitSize(m_surfaceWidth, m_surfaceHeight);

406 }

429 }

407}

430}

tests/mocks/Unity/Application/SurfaceManager.cpp+93−2

@@ -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,6 +52,21 @@ 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()

@@ -58,6 +81,36 @@ SurfaceManager::~SurfaceManager()

58 m_instance = nullptr;

81 m_instance = nullptr;

59}

82}

60

83

84+MirSurfaceInterface *SurfaceManager::surfaceFor(const miral::Window& window) const

85+{

86+ auto iter = m_windowToSurface.find({window});

87+ if (iter != m_windowToSurface.end()) {

88+ return *iter;

89+ }

90+ return nullptr;

91+}

92+

93+QVector<MirSurfaceInterface*> SurfaceManager::surfacesFor(const std::vector<miral::Window> &windows) const

94+{

95+ QVector<unityapi::MirSurfaceInterface*> surfaces;

96+ for (size_t i = 0; i < windows.size(); i++) {

97+ auto mirSurface = surfaceFor(windows[i]);

98+ if (mirSurface) {

99+ surfaces.push_back(mirSurface);

100+ }

101+ }

102+ return surfaces;

103+}

104+

105+miral::Window SurfaceManager::windowFor(MirSurfaceInterface *surface) const

106+{

107+ auto iter = m_surfaceToWindow.find(surface);

108+ if (iter != m_surfaceToWindow.end()) {

109+ return iter->window;

110+ }

111+ return miral::Window();

112+}

113+

61MirSurface *SurfaceManager::createSurface(const QString& name,

114MirSurface *SurfaceManager::createSurface(const QString& name,

62 Mir::Type type,

115 Mir::Type type,

63 Mir::State state,

116 Mir::State state,

@@ -75,7 +128,12 @@ MirSurface *SurfaceManager::createSurface(const QString& name,

75

128

76void SurfaceManager::registerSurface(MirSurface *surface)

129void SurfaceManager::registerSurface(MirSurface *surface)

77{

130{

131+ auto fakeSurface = std::make_shared<mir::test::doubles::StubSurface>();

132+ WindowWrapper window{miral::Window(nullptr, fakeSurface), fakeSurface};

133+

78 m_surfaces.prepend(surface);

134 m_surfaces.prepend(surface);

135+ m_windowToSurface.insert(window, surface);

136+ m_surfaceToWindow.insert(surface, window);

79

137

80 if (!surface->parentSurface()) {

138 if (!surface->parentSurface()) {

81 surface->setMinimumWidth(m_newSurfaceMinimumWidth);

139 surface->setMinimumWidth(m_newSurfaceMinimumWidth);

@@ -92,6 +150,8 @@ void SurfaceManager::registerSurface(MirSurface *surface)

92

150

93 const QString persistentId = surface->persistentId();

151 const QString persistentId = surface->persistentId();

94 connect(surface, &QObject::destroyed, this, [=]() {

152 connect(surface, &QObject::destroyed, this, [=]() {

153+ WindowWrapper key = m_surfaceToWindow.take(surface);

154+ m_windowToSurface.remove(key);

95 this->onSurfaceDestroyed(surface, persistentId);

155 this->onSurfaceDestroyed(surface, persistentId);

96 });

156 });

97

157

@@ -99,7 +159,12 @@ void SurfaceManager::registerSurface(MirSurface *surface)

99

159

100void SurfaceManager::notifySurfaceCreated(unityapi::MirSurfaceInterface *surface)

160void SurfaceManager::notifySurfaceCreated(unityapi::MirSurfaceInterface *surface)

101{

161{

162+ if (Q_UNLIKELY(!m_surfaceToWindow.contains(surface))) {

102− Q_EMIT surfaceCreated(surface);

163+ Q_EMIT surfaceCreated(surface);

164+ return;

165+ }

166+

167+ WindowManagementPolicy::instance()->addWindow(m_surfaceToWindow[surface].window);

103}

168}

104

169

105void SurfaceManager::setNewSurfaceMinimumWidth(int value)

170void SurfaceManager::setNewSurfaceMinimumWidth(int value)

@@ -209,6 +274,32 @@ void SurfaceManager::activate(unityapi::MirSurfaceInterface *apiSurface)

209 DEBUG_MSG("("<<surface<<") ended");

274 DEBUG_MSG("("<<surface<<") ended");

210}

275}

211

276

277+void SurfaceManager::forEachSurfaceInWorkspace(const std::shared_ptr<miral::Workspace> &workspace,

278+ const std::function<void(unity::shell::application::MirSurfaceInterface*)> &callback)

279+{

280+ WindowManagementPolicy::instance()->forEachWindowInWorkspace(workspace, [&](const miral::Window &window) {

281+ auto surface = surfaceFor(window);

282+ if (surface) {

283+ callback(surface);

284+ }

285+ });

286+}

287+

288+void SurfaceManager::moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface* surface,

289+ const std::shared_ptr<miral::Workspace> &workspace)

290+{

291+ auto window = windowFor(surface);

292+ if (window) {

293+ WindowManagementPolicy::instance()->moveWindowToWorkspace(window, workspace);

294+ }

295+}

296+

297+void SurfaceManager::moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to,

298+ const std::shared_ptr<miral::Workspace> &from)

299+{

300+ WindowManagementPolicy::instance()->moveWorkspaceContentToWorkspace(to, from);

301+}

302+

212void SurfaceManager::onStateRequested(MirSurface *surface, Mir::State state)

303void SurfaceManager::onStateRequested(MirSurface *surface, Mir::State state)

213{

304{

214 DEBUG_MSG("("<<surface<<","<<state<<") started");

305 DEBUG_MSG("("<<surface<<","<<state<<") started");

tests/mocks/Unity/Application/SurfaceManager.h+21

@@ -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,

@@ -95,6 +110,9 @@ private:

95 void doRaise(unity::shell::application::MirSurfaceInterface *surface);

110 void doRaise(unity::shell::application::MirSurfaceInterface *surface);

96 void focusFirstAvailableSurface();

111 void focusFirstAvailableSurface();

97 void registerSurface(MirSurface *surface);

112 void registerSurface(MirSurface *surface);

113+ unity::shell::application::MirSurfaceInterface* surfaceFor(const miral::Window &window) const;

114+ QVector<unity::shell::application::MirSurfaceInterface*> surfacesFor(const std::vector<miral::Window> &windows) const;

115+ miral::Window windowFor(unity::shell::application::MirSurfaceInterface* surface) const;

98

116

99 static SurfaceManager *m_instance;

117 static SurfaceManager *m_instance;

100

118

@@ -110,6 +128,9 @@ private:

110

128

111 QList<MirSurface*> m_surfaces;

129 QList<MirSurface*> m_surfaces;

112

130

131+ QHash<WindowWrapper, unity::shell::application::MirSurfaceInterface*> m_windowToSurface;

132+ QHash<unity::shell::application::MirSurfaceInterface*, WindowWrapper> m_surfaceToWindow;

133+

113 VirtualKeyboard *m_virtualKeyboard{nullptr};

134 VirtualKeyboard *m_virtualKeyboard{nullptr};

114};

135};

115

136

tests/mocks/Unity/Application/plugin.cpp+7−1

@@ -38,6 +38,12 @@ QObject* mirSingleton(QQmlEngine*, QJSEngine*)

38{

39 return new MirMock;

40}

41+

42+QObject* surfaceManagerSingleton(QQmlEngine*, QJSEngine*)

43+{

44+ return new SurfaceManager;

45+}

46+

41} // anonymous namespace

47} // anonymous namespace

42

48

43void FakeUnityApplicationQmlPlugin::registerTypes(const char *uri)

49void FakeUnityApplicationQmlPlugin::registerTypes(const char *uri)

@@ -59,7 +65,7 @@ void FakeUnityApplicationQmlPlugin::registerTypes(const char *uri)

59

65

60 qmlRegisterSingletonType<ApplicationManager>(uri, 0, 1, "ApplicationManager", applicationManagerSingleton);

66 qmlRegisterSingletonType<ApplicationManager>(uri, 0, 1, "ApplicationManager", applicationManagerSingleton);

61 qmlRegisterSingletonType<MirMock>(uri, 0, 1, "Mir", mirSingleton);

67 qmlRegisterSingletonType<MirMock>(uri, 0, 1, "Mir", mirSingleton);

62− qmlRegisterType<SurfaceManager>(uri, 0, 1, "SurfaceManager");

68+ qmlRegisterSingletonType<SurfaceManager>(uri, 0, 1, "SurfaceManager", surfaceManagerSingleton);

63}

69}

64

70

65void FakeUnityApplicationQmlPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

71void FakeUnityApplicationQmlPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

tests/mocks/Unity/CMakeLists.txt−1

@@ -6,7 +6,6 @@ add_subdirectory(InputInfo)

6add_subdirectory(Launcher)

7add_subdirectory(Notifications)

8add_subdirectory(DashCommunicator)

9−add_subdirectory(Screens)

10add_subdirectory(Platform)

9add_subdirectory(Platform)

11

10

12pkg_search_module(GOBJECT gobject-2.0 REQUIRED)

11pkg_search_module(GOBJECT gobject-2.0 REQUIRED)

tests/mocks/Unity/InputInfo/InputWindow.qmlnew file+68

@@ -0,0 +1,68 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Unity.InputInfo 0.1

4+

5+Rectangle {

6+ id: rect

7+ color: "white"

8+ width: parent.width

9+ height: parent.height

10+

11+ Action {

12+ id: mouseAction

13+ text: checked ? "Remove Mouse" : "Add Mouse"

14+ onTriggered: {

15+ if (checked) {

16+ console.log("ADD")

17+ MockInputDeviceBackend.addMockDevice("/mouse0", InputInfo.Mouse);

18+ } else {

19+ console.log("REMOVE")

20+ MockInputDeviceBackend.removeDevice("/mouse0");

21+ }

22+ }

23+ iconName: "input-mouse-symbolic"

24+ checkable: true

25+ checked: false

26+ }

27+

28+ Action {

29+ id: kbAction

30+ text: checked ? "Remove Keyboard" : "Add Keyboard"

31+ onTriggered: {

32+ if (checked) {

33+ MockInputDeviceBackend.addMockDevice("/kbd0", InputInfo.Keyboard);

34+ } else {

35+ MockInputDeviceBackend.removeDevice("/kbd0");

36+ }

37+ }

38+ iconName: "input-keyboard-symbolic"

39+ checkable: true

40+ checked: false

41+ }

42+

43+ Column {

44+ anchors {

45+ fill: parent

46+ margins: units.gu(1)

47+ }

48+ spacing: units.gu(1)

49+

50+ Button {

51+ anchors {

52+ left: parent.left

53+ right: parent.right

54+ }

55+ action: mouseAction

56+ color: mouseAction.checked ? UbuntuColors.red : UbuntuColors.green

57+ }

58+

59+ Button {

60+ anchors {

61+ left: parent.left

62+ right: parent.right

63+ }

64+ action: kbAction

65+ color: kbAction.checked ? UbuntuColors.red : UbuntuColors.green

66+ }

67+ }

68+}

tests/mocks/Unity/InputInfo/mockcontroller.cpp+24−2

@@ -18,10 +18,32 @@

18

19#include "qinputdeviceinfo_mock_p.h"

20

21+#include <QQuickView>

22+#include <QQmlComponent>

23+#include <QQuickItem>

24+#include <paths.h>

25+

21−MockController::MockController(QObject *parent):

26+MockController::MockController(QQmlEngine *engine)

22− QObject(parent)

23{

27{

28+ QQmlComponent component(engine);

29+ component.setData("import QtQuick 2.4; import Unity.InputInfo 0.1; InputWindow { }", ::qmlDirectory());

30+ QObject *myObject = component.create();

31+ QQuickItem *item = qobject_cast<QQuickItem*>(myObject);

32+ if (item) {

33+ auto window = new QQuickView();

34+ window->setTitle("Input");

35+ item->setParentItem(window->contentItem());

36+ window->setResizeMode(QQuickView::SizeRootObjectToView);

37+ window->setWidth(200);

38+ window->setHeight(100);

39+ window->show();

40+ }

41+}

24

42

43+MockController *MockController::instance(QQmlEngine *engine)

44+{

45+ static MockController* controller = new MockController(engine);

46+ return controller;

25}

47}

26

48

27QInputDevice *MockController::addMockDevice(const QString &devicePath, QInputDevice::InputType type)

49QInputDevice *MockController::addMockDevice(const QString &devicePath, QInputDevice::InputType type)

tests/mocks/Unity/InputInfo/mockcontroller.h+5−1

@@ -20,13 +20,17 @@

20#include <QObject>

21#include "qinputinfo.h"

22

23+class QQmlEngine;

24+

23class MockController: public QObject

25class MockController: public QObject

24{

26{

25 Q_OBJECT

27 Q_OBJECT

26public:

28public:

27− MockController(QObject *parent = 0);

29+ MockController(QQmlEngine *engine);

28 ~MockController() = default;

30 ~MockController() = default;

29

31

32+ static MockController *instance(QQmlEngine *engine);

33+

30 Q_INVOKABLE QInputDevice* addMockDevice(const QString &devicePath, QInputDevice::InputType type);

34 Q_INVOKABLE QInputDevice* addMockDevice(const QString &devicePath, QInputDevice::InputType type);

31 Q_INVOKABLE void removeDevice(const QString &devicePath);

35 Q_INVOKABLE void removeDevice(const QString &devicePath);

32};

36};

tests/mocks/Unity/InputInfo/plugin.cpp+1−2

@@ -26,9 +26,8 @@

26

27static QObject *backendProvider(QQmlEngine *engine, QJSEngine *scriptEngine)

28{

29− Q_UNUSED(engine)

30 Q_UNUSED(scriptEngine)

29 Q_UNUSED(scriptEngine)

31− return new MockController(engine);

30+ return MockController::instance(engine);

32}

31}

33

32

34void InputInfoPlugin::registerTypes(const char *uri)

33void InputInfoPlugin::registerTypes(const char *uri)

tests/mocks/Unity/InputInfo/qmldir+2

@@ -1,2 +1,4 @@

1module Unity.InputInfo

2plugin MockInputInfo

3+

4+InputWindow 0.1 InputWindow.qml

tests/mocks/Unity/Screens/CMakeLists.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+51

@@ -0,0 +1,51 @@

1+include_directories(

2+ SYSTEM

3+ ${QTMIRSERVER_INCLUDE_DIRS}

4+)

5+

6+include_directories(

7+ ${CMAKE_CURRENT_SOURCE_DIR}

8+ ${CMAKE_CURRENT_BINARY_DIR}

9+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager

10+ ${libunity8-private_SOURCE_DIR}

11+)

12+

13+add_library(mockwindowmanagmentpolicy SHARED

14+ WindowManagementPolicy.cpp

15+)

16+target_link_libraries(mockwindowmanagmentpolicy

17+ ${MIRAL_LDFLAGS}

18+ unity8-private

19+)

20+qt5_use_modules(mockwindowmanagmentpolicy Core)

21+

22+set(WINDOWMANAGER_SRC

23+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Screen.cpp

24+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/ScreenAttached.cpp

25+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Screens.cpp

26+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/ScreenWindow.cpp

27+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/TopLevelWindowModel.cpp

28+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Window.cpp

29+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/WorkspaceManager.cpp

30+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/WorkspaceModel.cpp

31+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Workspace.cpp

32+ MockScreens.cpp

33+ MockScreenWindow.cpp

34+ WindowManagerPlugin.cpp

35+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h

36+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h

37+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h

38+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceListInterface.h

39+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/SurfaceManagerInterface.h

40+)

41+

42+add_library(MockWindowManager-qml SHARED ${WINDOWMANAGER_SRC})

43+

44+target_link_libraries(MockWindowManager-qml

45+ ${QTMIRSERVER_LDFLAGS}

46+ mockwindowmanagmentpolicy

47+)

48+

49+qt5_use_modules(MockWindowManager-qml Qml Quick Gui)

50+

51+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+213

@@ -0,0 +1,213 @@

1+/*

3+ *

4+ * This program is free software: you can redistribute it and/or modify it under

5+ * the terms of the GNU Lesser General Public License version 3, as published by

6+ * the Free Software Foundation.

7+ *

8+ * This program is distributed in the hope that it will be useful, but WITHOUT

9+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,

10+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

11+ * Lesser General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU Lesser General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+ */

16+

17+#include "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(640,480)));

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+ m_sizes.takeFirst()->deleteLater();

56+ }

57+

58+ m_connectedWindow = w;

59+

60+ if (w) {

61+ connect(w, &ScreenWindow::heightChanged, this, [this](int height) {

62+ m_sizes.first()->size.rheight() = height;

63+ Q_EMIT availableModesChanged();

64+

65+ });

66+ connect(w, &ScreenWindow::widthChanged, this, [this](int width) {

67+ m_sizes.first()->size.rwidth() = width;

68+ Q_EMIT availableModesChanged();

69+ });

70+

71+ m_sizes.push_front(new qtmir::ScreenMode(50, w->size()));

72+ Q_EMIT availableModesChanged();

73+ }

74+ }

75+

76+ qtmir::OutputId outputId() const override { return m_id; }

77+ bool used() const override { return m_used; }

78+ QString name() const override { return m_name; }

79+ float scale() const override { return m_scale; }

80+ QSizeF physicalSize() const override { return m_physicalSize; }

81+ qtmir::FormFactor formFactor() const override { return m_formFactor; }

82+ qtmir::OutputTypes outputType() const override { return m_outputType; }

83+ QString outputTypeName() const { return QStringLiteral("Internal"); }

84+ MirPowerMode powerMode() const override { return m_powerMode; }

85+ Qt::ScreenOrientation orientation() const override { return m_orientation; }

86+ QPoint position() const override { return m_position; }

87+ uint currentModeIndex() const override { return m_currentModeIndex; }

88+ bool isActive() const override { return m_active; }

89+

90+ QQmlListProperty<qtmir::ScreenMode> availableModes() override {

91+ return QQmlListProperty<qtmir::ScreenMode>(this, m_sizes);

92+ }

93+

94+ void setActive(bool active) override {

95+ if (m_active != active) {

96+ m_active = active;

97+ Q_EMIT activeChanged(m_active);

98+ }

99+ }

100+

101+ QScreen* qscreen() const override {

102+ if (qGuiApp->topLevelWindows().count() > 0) {

103+ return qGuiApp->topLevelWindows()[0]->screen();

104+ }

105+ return qGuiApp->primaryScreen();

106+ }

107+

108+ qtmir::ScreenConfiguration *beginConfiguration() const override {

109+ auto config = new qtmir::ScreenConfiguration;

110+ config->valid = true;

111+ config->id = m_id;

112+ config->used = m_used;

113+ config->topLeft = m_position;

114+ config->currentModeIndex = m_currentModeIndex;

115+ config->powerMode = m_powerMode;

116+ config->scale = m_scale;

117+ config->formFactor = m_formFactor;

118+ return config;

119+ }

120+

121+ bool applyConfiguration(qtmir::ScreenConfiguration *configuration) override {

122+ m_used = configuration->used;

123+ m_position = configuration->topLeft;

124+ m_currentModeIndex = configuration->currentModeIndex;

125+ m_powerMode = configuration->powerMode;

126+ m_scale = configuration->scale;

127+ m_formFactor = configuration->formFactor;

128+ return true;

129+ }

130+

131+Q_SIGNALS:

132+ void outputTypeNameChanged();

133+

134+public:

135+ qtmir::OutputId m_id{0};

136+ bool m_active{false};

137+ bool m_used{true};

138+ QString m_name;

139+ qtmir::OutputTypes m_outputType{qtmir::Unknown};

140+ MirPowerMode m_powerMode{mir_power_mode_on};

141+ Qt::ScreenOrientation m_orientation{Qt::PrimaryOrientation};

142+ float m_scale{1.0};

143+ qtmir::FormFactor m_formFactor{qtmir::FormFactorMonitor};

144+ QPoint m_position;

145+ uint m_currentModeIndex{0};

146+ QList<qtmir::ScreenMode*> m_sizes;

147+ QSizeF m_physicalSize;

148+

149+ QPointer<QWindow> m_connectedWindow;

150+};

151+}

152+

153+MockScreens::MockScreens()

154+{

155+ bool ok = false;

156+ int screenCount = qEnvironmentVariableIntValue("UNITY_MOCK_SCREEN_COUNT", &ok);

157+ if (!ok) screenCount = 1;

158+ QPoint lastPoint(0,0);

159+ for (int i = 0; i < screenCount; ++i) {

160+ auto screen = new MockScreen();

161+ screen->m_id = qtmir::OutputId{i};

162+ screen->m_active = i == 0;

163+ screen->m_name = QString("Monitor %1").arg(i);

164+ screen->m_position = QPoint(lastPoint.x(), lastPoint.y());

165+ screen->m_currentModeIndex = 3;

166+ m_mocks.append(screen);

167+

168+ lastPoint.rx() += screen->m_sizes[screen->m_currentModeIndex]->size.width();

169+ }

170+}

171+

172+MockScreens::~MockScreens()

173+{

174+ qDeleteAll(m_mocks);

175+ m_mocks.clear();

176+}

177+

178+QVector<qtmir::Screen *> MockScreens::screens() const

179+{

180+ return m_mocks;

181+}

182+

183+qtmir::Screen *MockScreens::activeScreen() const

184+{

185+ Q_FOREACH(auto screen, m_mocks) {

186+ if (screen->isActive()) return screen;

187+ }

188+ return nullptr;

189+}

190+

191+QSharedPointer<MockScreens> MockScreens::instance()

192+{

193+ if (!m_screens) {

194+ QSharedPointer<MockScreens> screens(new MockScreens());

195+ m_screens = screens.toWeakRef();

196+ return screens;

197+ } else {

198+ return m_screens.lock();

199+ }

200+}

201+

202+void MockScreens::connectWindow(ScreenWindow *w)

203+{

204+ Screen* screen = w->screenWrapper();

205+ if (!screen) return;

206+

207+ auto mockScreen = qobject_cast<MockScreen*>(screen->wrapped());

208+ if (mockScreen) {

209+ mockScreen->connectToWindow(w);

210+ }

211+}

212+

213+#include "MockScreens.moc"

tests/mocks/WindowManager/MockScreens.hnew file+54

@@ -0,0 +1,54 @@

1+/*

3+ *

4+ * This program is free software: you can redistribute it and/or modify it under

5+ * the terms of the GNU Lesser General Public License version 3, as published by

6+ * the Free Software Foundation.

7+ *

8+ * This program is distributed in the hope that it will be useful, but WITHOUT

9+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,

10+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

11+ * Lesser General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU Lesser General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+ */

16+

17+#ifndef MOCK_SCREENS_H

18+#define MOCK_SCREENS_H

19+

20+#include <QAbstractListModel>

21+#include <QSharedPointer>

22+

23+#include <qtmir/screens.h>

24+

25+namespace qtmir

26+{

27+class Screens;

28+}

29+

30+class Screen;

31+class ScreenWindow;

32+

33+class MockScreens : public qtmir::Screens

34+{

35+ Q_OBJECT

36+public:

37+ MockScreens();

38+ ~MockScreens();

39+

40+ QVector<qtmir::Screen*> screens() const override;

41+

42+ qtmir::Screen *activeScreen() const override;

43+

44+ static QSharedPointer<MockScreens> instance();

45+

46+public Q_SLOTS:

47+ void connectWindow(ScreenWindow *w);

48+

49+private:

50+ QVector<qtmir::Screen*> m_mocks;

51+};

52+

53+

54+#endif // MOCK_SCREENS_H

tests/mocks/WindowManager/WindowManagementPolicy.cppnew file+114

@@ -0,0 +1,114 @@

1+/*

3+ *

4+ * This program is free software; you can redistribute it and/or modify

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

8+ * This program is distributed in the hope that it will be useful,

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+ */

16+

17+#include "WindowManagementPolicy.h"

18+

19+#include <QDebug>

20+

21+WindowManagementPolicy::WindowManagementPolicy()

22+ : m_dummyWorkspace(std::shared_ptr<miral::Workspace>())

23+{

24+ wmPolicyInterface = this;

25+ m_activeWorkspace = m_dummyWorkspace;

26+}

27+

28+WindowManagementPolicy *WindowManagementPolicy::instance()

29+{

30+ static WindowManagementPolicy* wmPolicy(new WindowManagementPolicy);

31+ return wmPolicy;

32+}

33+

34+std::shared_ptr<miral::Workspace> WindowManagementPolicy::createWorkspace()

35+{

36+ auto workspace = std::make_shared<miral::Workspace>();

37+ m_workspaces.insert(workspace);

38+

39+ if (m_activeWorkspace.lock() == m_dummyWorkspace) {

40+ moveWorkspaceContentToWorkspace(workspace, m_dummyWorkspace);

41+ m_activeWorkspace = workspace;

42+ }

43+ return workspace;

44+}

45+

46+void WindowManagementPolicy::releaseWorkspace(const std::shared_ptr<miral::Workspace> &workspace)

47+{

48+ auto iter = m_workspaces.find(workspace);

49+ if (iter != m_workspaces.end()) m_workspaces.erase(iter);

50+

51+ if (m_workspaces.size() == 0) {

52+ m_activeWorkspace = m_dummyWorkspace;

53+ moveWorkspaceContentToWorkspace(m_dummyWorkspace, workspace);

54+ }

55+}

56+

57+void WindowManagementPolicy::setActiveWorkspace(const std::shared_ptr<miral::Workspace> &workspace)

58+{

59+ if (m_activeWorkspace.lock() == workspace)

60+ return;

61+ m_activeWorkspace = workspace ? workspace : m_dummyWorkspace;

62+}

63+

64+void WindowManagementPolicy::addWindow(const miral::Window &window)

65+{

66+ Q_EMIT windowAdded(window);

67+

68+ auto activeWorkspace = m_activeWorkspace.lock();

69+ if (activeWorkspace) {

70+ m_windows.insert(activeWorkspace, window);

71+

72+ Q_EMIT windowsAddedToWorkspace(activeWorkspace, {window});

73+ }

74+}

75+

76+void WindowManagementPolicy::forEachWindowInWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::function<void(const miral::Window &)> &callback)

77+{

78+ WorkspaceWindows::iterator i = m_windows.find(workspace);

79+ while (i != m_windows.end() && i.key() == workspace) {

80+ callback(i.value());

81+ ++i;

82+ }

83+}

84+

85+void WindowManagementPolicy::moveWindowToWorkspace(const miral::Window &window, const std::shared_ptr<miral::Workspace> &workspace)

86+{

87+ auto from = m_windows.key(window);

88+ if (from) {

89+ auto iter = m_windows.find(from, window);

90+ Q_EMIT windowsAboutToBeRemovedFromWorkspace(from, { window });

91+ m_windows.erase(iter);

92+ }

93+

94+ m_windows.insert(workspace, window);

95+ Q_EMIT windowsAddedToWorkspace(workspace, { window });

96+}

97+

98+void WindowManagementPolicy::moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to, const std::shared_ptr<miral::Workspace> &from)

99+{

100+ std::vector<miral::Window> windows;

101+

102+ WorkspaceWindows::iterator i = m_windows.find(from);

103+ while (i != m_windows.end() && i.key() == from) {

104+ windows.push_back(i.value());

105+ ++i;

106+ }

107+ Q_EMIT windowsAboutToBeRemovedFromWorkspace(from, windows);

108+ m_windows.remove(from);

109+

110+ Q_FOREACH(miral::Window window, windows) {

111+ m_windows.insert(to, window);

112+ }

113+ Q_EMIT windowsAddedToWorkspace(to, windows);

114+}

tests/mocks/WindowManager/WindowManagementPolicy.hnew file+73

@@ -0,0 +1,73 @@

1+/*

3+ *

4+ * This program is free software; you can redistribute it and/or modify

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

8+ * This program is distributed in the hope that it will be useful,

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+ */

16+

17+#ifndef MOCKWINDOMANAGEMENTPOLICY_H

18+#define MOCKWINDOMANAGEMENTPOLICY_H

19+

20+#include "wmpolicyinterface.h"

21+

22+#include <QObject>

23+#include <QMultiMap>

24+#include <QVector>

25+

26+#include <miral/window.h>

27+#include <memory>

28+#include <unordered_set>

29+

30+namespace miral {

31+class Workspace {};

32+}

33+

34+// A Fake window management policy for the mock.

35+class Q_DECL_EXPORT WindowManagementPolicy : public QObject,

36+ public WMPolicyInterface

37+{

38+ Q_OBJECT

39+public:

40+ WindowManagementPolicy();

41+

42+ // for use in mocks

43+ static WindowManagementPolicy *instance();

44+

45+ // From WMPolicyInterface

46+ std::shared_ptr<miral::Workspace> createWorkspace() override;

47+ void releaseWorkspace(const std::shared_ptr<miral::Workspace>& workspace) override;

48+ void setActiveWorkspace(const std::shared_ptr<miral::Workspace>& workspace) override;

49+

50+ void addWindow(const miral::Window& window);

51+

52+ void forEachWindowInWorkspace(std::shared_ptr<miral::Workspace> const& workspace,

53+ std::function<void(miral::Window const&)> const& callback);

54+

55+ void moveWindowToWorkspace(const miral::Window &window, const std::shared_ptr<miral::Workspace> &workspace);

56+

57+ void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace>& to,

58+ const std::shared_ptr<miral::Workspace>& from);

59+

60+Q_SIGNALS:

61+ void windowAdded(const miral::Window& window);

62+ void windowsAddedToWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows);

63+ void windowsAboutToBeRemovedFromWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows);

64+

65+private:

66+ std::weak_ptr<miral::Workspace> m_activeWorkspace;

67+ std::shared_ptr<miral::Workspace> m_dummyWorkspace;

68+ std::unordered_set<std::shared_ptr<miral::Workspace>> m_workspaces;

69+

70+ typedef QMultiMap<std::shared_ptr<miral::Workspace>, miral::Window> WorkspaceWindows;

71+ WorkspaceWindows m_windows;

72+};

73+#endif // UNITY_WINDOWMANAGEMENTPOLICY_H

tests/mocks/WindowManager/WindowManagerPlugin.cppnew file+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+#include "WindowManagerPlugin.h"

18+

19+#include "MockScreens.h"

20+#include "MockScreenWindow.h"

21+#include "Screen.h"

22+#include "ScreenAttached.h"

23+#include "Screens.h"

24+#include "TopLevelWindowModel.h"

25+#include "Window.h"

26+#include "WorkspaceManager.h"

27+#include "Workspace.h"

28+#include "WorkspaceModel.h"

29+#include "WindowManagementPolicy.h"

30+

31+#include <QtQml>

32+

33+static const QString notInstantiatable = QStringLiteral("Not instantiatable");

34+

35+static QObject *workspace_manager(QQmlEngine *engine, QJSEngine *scriptEngine)

36+{

37+ Q_UNUSED(engine)

38+ Q_UNUSED(scriptEngine)

39+ return WorkspaceManager::instance();

40+}

41+QObject* screensSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {

42+ Q_UNUSED(engine);

43+ Q_UNUSED(scriptEngine);

44+ return new Screens(MockScreens::instance());

45+}

46+

47+void WindowManagerPlugin::registerTypes(const char *uri)

48+{

49+ qmlRegisterType<TopLevelWindowModel>(uri, 1, 0, "TopLevelWindowModel");

50+ qmlRegisterSingletonType<WorkspaceManager>(uri, 1, 0, "WorkspaceManager", workspace_manager);

51+ qmlRegisterUncreatableType<WorkspaceModel>(uri, 1, 0, "WorkspaceModel", notInstantiatable);

52+ qmlRegisterSingletonType<Screens>(uri, 1, 0, "Screens", screensSingleton);

53+ qmlRegisterUncreatableType<qtmir::ScreenMode>(uri, 1, 0, "ScreenMode", notInstantiatable);

54+ qmlRegisterUncreatableType<Workspace>(uri, 1, 0, "Workspace", notInstantiatable);

55+

56+ qRegisterMetaType<Screen*>("Screen*");

57+ qRegisterMetaType<ScreensProxy*>("ScreensProxy*");

58+ qRegisterMetaType<Workspace*>("Workspace*");

59+

60+ qRegisterMetaType<Window*>("Window*");

61+ qRegisterMetaType<QAbstractListModel*>("QAbstractListModel*");

62+

63+ qmlRegisterType<MockScreenWindow>(uri, 1, 0, "ScreenWindow");

64+ qmlRegisterRevision<QWindow,1>(uri, 1, 0);

65+

66+ qmlRegisterUncreatableType<WMScreen>(uri, 1, 0, "WMScreen", notInstantiatable);

67+}

68+

69+void WindowManagerPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

70+{

71+ QQmlExtensionPlugin::initializeEngine(engine, uri);

72+

73+ // Make sure we've initialized the wm policy.

74+ WindowManagementPolicy::instance();

75+}

tests/mocks/WindowManager/WindowManagerPlugin.hnew file+33

@@ -0,0 +1,33 @@

1+/*

3+ *

4+ * This program is free software; you can redistribute it and/or modify

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

8+ * This program is distributed in the hope that it will be useful,

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+ */

16+

17+#ifndef WINDOWMANAGER_PLUGIN_H

18+#define WINDOWMANAGER_PLUGIN_H

19+

20+#include <QtQml/QQmlEngine>

21+#include <QtQml/QQmlExtensionPlugin>

22+

23+class WindowManagerPlugin : public QQmlExtensionPlugin

24+{

25+ Q_OBJECT

26+ Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")

27+

28+public:

29+ void registerTypes(const char *uri) override;

30+ void initializeEngine(QQmlEngine *engine, const char *uri) override;

31+};

32+

33+#endif // WINDOWMANAGER_PLUGIN_H

tests/mocks/WindowManager/qmldirnew file+2

@@ -0,0 +1,2 @@

1+module WindowManager

2+plugin MockWindowManager-qml

tests/qmltests/ApplicationMenuDataLoader.qml+1−4

@@ -22,11 +22,8 @@ import Unity.Indicators 0.1 as Indicators

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

tests/qmltests/ApplicationMenus/tst_MenuBar.qml−2

@@ -42,10 +42,8 @@ Item {

42 value: false

43 }

44

45− SurfaceManager { id: sMgr }

46 ApplicationMenuDataLoader {

45 ApplicationMenuDataLoader {

47 id: appMenuData

46 id: appMenuData

48− surfaceManager: sMgr

49 }

47 }

50

48

51 Rectangle {

49 Rectangle {

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+14−14

@@ -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: {

@@ -148,7 +148,7 @@ PanelTest {

148 Layout.fillWidth: true

149 CheckBox {

150 id: windowControlsCB

151− onClicked: PanelState.decorationsVisible = checked

151+ onClicked: panelState.decorationsVisible = checked

152 }

153 Label {

154 text: "Show window decorations"

@@ -159,7 +159,7 @@ PanelTest {

159 RowLayout {

160 Layout.fillWidth: true

161 CheckBox {

162− onClicked: PanelState.title = checked ? "Fake window title" : ""

162+ onClicked: panelState.title = checked ? "Fake window title" : ""

163 }

164 Label {

165 text: "Show fake window title"

@@ -245,7 +245,7 @@ PanelTest {

245

246 SignalSpy {

247 id: windowControlButtonsSpy

248− target: PanelState

248+ target: panelState

249 signalName: "closeClicked"

250 }

251

@@ -255,8 +255,8 @@ PanelTest {

255 panel.fullscreenMode = false;

256 callManager.foregroundCall = null;

257

258− PanelState.title = "";

258+ panelState.title = "";

259− PanelState.decorationsVisible = false;

259+ panelState.decorationsVisible = false;

260

261 // Wait for the indicators to get into position.

262 // (switches between normal and fullscreen modes are animated)

@@ -448,7 +448,7 @@ PanelTest {

448 }

449

450 function test_hint(data) {

451− PanelState.title = "Fake Title"

451+ panelState.title = "Fake Title"

452 panel.fullscreenMode = data.fullscreen;

453 callManager.foregroundCall = data.call;

454

@@ -490,7 +490,7 @@ PanelTest {

490 // menus, first by running the hint animation, then after dragging down will

491 // expose more of the panel. Releasing the touch will complete the show.

492 function test_drag_applicationMenu_down_shows_menu(data) {

493− PanelState.title = "Fake Title";

493+ panelState.title = "Fake Title";

494 panel.fullscreenMode = data.fullscreen;

495 callManager.foregroundCall = data.call;

496

@@ -581,7 +581,7 @@ PanelTest {

581 }

582

583 function test_darkenedAreaEatsAllApplicationMenuEvents() {

584− PanelState.title = "Fake Title"

584+ panelState.title = "Fake Title"

585

586 // The center of the area not covered by the indicators menu

587 // Ie, the visible darkened area behind the menu

@@ -702,7 +702,7 @@ PanelTest {

702 var windowControlArea = findChild(panel, "windowControlArea");

703 verify(windowControlArea, "Window control area should have been created in windowed mode")

704

705− PanelState.decorationsVisible = true;

705+ panelState.decorationsVisible = true;

706 // click in very topleft corner and verify the close button got clicked too

707 mouseMove(panel, 0, 0);

708 mouseClick(panel, 0, 0, undefined /*button*/, undefined /*modifiers*/, 100 /*short delay*/);

@@ -765,7 +765,7 @@ PanelTest {

765 }

766

767 function test_stagedApplicationMenuBarShowOnMouseHover() {

768− PanelState.title = "Fake Title";

768+ panelState.title = "Fake Title";

769 panel.mode = "staged";

770 mouseEmulation.checked = false;

771

@@ -783,7 +783,7 @@ PanelTest {

783 }

784

785 function test_windowedApplicationMenuShowOnMouseHoverWhenDecorationsShown() {

786− PanelState.title = "Fake Title";

786+ panelState.title = "Fake Title";

787 panel.mode = "windowed";

788 mouseEmulation.checked = false;

789

@@ -799,7 +799,7 @@ PanelTest {

799 tryCompare(appTitle, "visible", true, undefined, "App title should still be visible on mouse hover when panel decorations are not visible");

800 tryCompare(appMenuBar, "visible", false, undefined, "App menu bar should be visible on mouse hover when panel decorations are not visible");

801

802− PanelState.decorationsVisible = true;

802+ panelState.decorationsVisible = true;

803

804 tryCompare(appTitle, "visible", false, undefined, "App title should still be visible on mouse hover when panel decorations are visible");

805 tryCompare(appMenuBar, "visible", true, undefined, "App menu bar should be visible on mouse hover when panel decorations not visible");

tests/qmltests/Stage/tst_ApplicationWindow.qml−2

@@ -37,8 +37,6 @@ Rectangle {

37 }

38 property QtObject fakeApplication: null

39

40− SurfaceManager{}

41−

42 Loader {

40 Loader {

43 id: applicationWindowLoader

41 id: applicationWindowLoader

44 focus: true

42 focus: true

tests/qmltests/Stage/tst_DecoratedWindow.qml+5−3

@@ -46,10 +46,12 @@ Rectangle {

46 value: false

47 }

48

49− SurfaceManager { id: sMgr }

50 ApplicationMenuDataLoader {

49 ApplicationMenuDataLoader {

51 id: appMenuData

50 id: appMenuData

52− surfaceManager: sMgr

51+ }

52+

53+ PanelState {

54+ id: panelState

53 }

55 }

54

56

55 Item {

57 Item {

@@ -99,7 +101,7 @@ Rectangle {

99 surface: fakeApplication && fakeApplication.surfaceList.count > 0 ? fakeApplication.surfaceList.get(0) : null

101 surface: fakeApplication && fakeApplication.surfaceList.count > 0 ? fakeApplication.surfaceList.get(0) : null

100

102

101 Binding {

103 Binding {

102− target: PanelState

104+ target: panelState

103 property: "focusedPersistentSurfaceId"

105 property: "focusedPersistentSurfaceId"

104 value: decoratedWindow.surface ? decoratedWindow.surface.persistentId : "x"

106 value: decoratedWindow.surface ? decoratedWindow.surface.persistentId : "x"

105 }

107 }

tests/qmltests/Stage/tst_DesktopStage.qml+9−6

@@ -44,6 +44,10 @@ Item {

44 value: false

45 }

46

47+ PanelState {

48+ id: panelState

49+ }

50+

47 Component.onCompleted: {

51 Component.onCompleted: {

48 ApplicationMenusLimits.screenWidth = Qt.binding( function() { return stageLoader.width; } );

52 ApplicationMenusLimits.screenWidth = Qt.binding( function() { return stageLoader.width; } );

49 ApplicationMenusLimits.screenHeight = Qt.binding( function() { return stageLoader.height; } );

53 ApplicationMenusLimits.screenHeight = Qt.binding( function() { return stageLoader.height; } );

@@ -63,16 +67,14 @@ Item {

63 }

67 }

64 }

68 }

65

69

66− SurfaceManager { id: sMgr }

67 ApplicationMenuDataLoader {

70 ApplicationMenuDataLoader {

68 id: appMenuData

71 id: appMenuData

69− surfaceManager: sMgr

70 }

72 }

71

73

72 TopLevelWindowModel {

74 TopLevelWindowModel {

73 id: topSurfaceList

75 id: topSurfaceList

74 applicationManager: ApplicationManager

76 applicationManager: ApplicationManager

75− surfaceManager: sMgr

77+ surfaceManager: SurfaceManager

76 }

78 }

77

79

78 Loader {

80 Loader {

@@ -102,6 +104,7 @@ Item {

102 topLevelSurfaceList: topSurfaceList

104 topLevelSurfaceList: topSurfaceList

103 interactive: true

105 interactive: true

104 mode: "windowed"

106 mode: "windowed"

107+ panelState: panelState

105 }

108 }

106 }

109 }

107 }

110 }

@@ -631,19 +634,19 @@ Item {

631 maximizeDelegate(facebookAppDelegate);

634 maximizeDelegate(facebookAppDelegate);

632

635

633 // verify the drop shadow is still not visible

636 // verify the drop shadow is still not visible

634− verify(PanelState.dropShadow == false);

637+ verify(panelState.dropShadow == false);

635

638

636 // start a foreground app, not maximized

639 // start a foreground app, not maximized

637 var dialerAppDelegate = startApplication("dialer-app");

640 var dialerAppDelegate = startApplication("dialer-app");

638

641

639 // verify the drop shadow becomes visible

642 // verify the drop shadow becomes visible

640− tryCompareFunction(function() { return PanelState.dropShadow; }, true);

643+ tryCompareFunction(function() { return panelState.dropShadow; }, true);

641

644

642 // close the maximized app

645 // close the maximized app

643 ApplicationManager.stopApplication("facebook-webapp");

646 ApplicationManager.stopApplication("facebook-webapp");

644

647

645 // verify the drop shadow is gone

648 // verify the drop shadow is gone

646− tryCompare(PanelState, "dropShadow", false);

649+ tryCompare(panelState, "dropShadow", false);

647 }

650 }

648

651

649 function test_threeFingerTapShowsWindowControls_data() {

652 function test_threeFingerTapShowsWindowControls_data() {

tests/qmltests/Stage/tst_PhoneStage.qml+1−3

@@ -31,10 +31,8 @@ Item {

31

32 property var greeter: { fullyShown: true }

33

34− SurfaceManager { id: sMgr }

35 ApplicationMenuDataLoader {

34 ApplicationMenuDataLoader {

36 id: appMenuData

35 id: appMenuData

37− surfaceManager: sMgr

38 }

36 }

39

37

40 Stage {

38 Stage {

@@ -50,7 +48,7 @@ Item {

50 topLevelSurfaceList: TopLevelWindowModel {

48 topLevelSurfaceList: TopLevelWindowModel {

51 id: topLevelSurfaceList

49 id: topLevelSurfaceList

52 applicationManager: ApplicationManager

50 applicationManager: ApplicationManager

53− surfaceManager: sMgr

51+ surfaceManager: SurfaceManager

54 }

52 }

55 Component.onCompleted: {

53 Component.onCompleted: {

56 ApplicationManager.startApplication("unity8-dash");

54 ApplicationManager.startApplication("unity8-dash");

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+1−3

@@ -35,10 +35,8 @@ Rectangle {

35

36 property var greeter: { fullyShown: true }

37

38− SurfaceManager { id: sMgr }

39 ApplicationMenuDataLoader {

38 ApplicationMenuDataLoader {

40 id: appMenuData

39 id: appMenuData

41− surfaceManager: sMgr

42 }

40 }

43

41

44 Stage {

42 Stage {

@@ -59,7 +57,7 @@ Rectangle {

59 topLevelSurfaceList: TopLevelWindowModel {

57 topLevelSurfaceList: TopLevelWindowModel {

60 id: topLevelSurfaceList

58 id: topLevelSurfaceList

61 applicationManager: ApplicationManager

59 applicationManager: ApplicationManager

62− surfaceManager: sMgr

60+ surfaceManager: SurfaceManager

63 }

61 }

64 Component.onCompleted: {

62 Component.onCompleted: {

65 ApplicationManager.startApplication("unity8-dash");

63 ApplicationManager.startApplication("unity8-dash");

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+1−3

@@ -327,9 +327,7 @@ Rectangle {

327 }

328

329 function ensureInputMethodSurface() {

330− var surfaceManager = findInvisibleChild(shell, "surfaceManager");

331− verify(surfaceManager);

332− surfaceManager.createInputMethodSurface();

330+ SurfaceManager.createInputMethodSurface();

333

331

334 tryCompareFunction(function() { return topLevelSurfaceList.inputMethodSurface !== null }, true);

332 tryCompareFunction(function() { return topLevelSurfaceList.inputMethodSurface !== null }, true);

335 }

333 }

tests/qmltests/tst_OrientedShell.qml+19−5

@@ -30,7 +30,6 @@ import Utils 0.1

30

31import "../../qml"

32import "../../qml/Components"

33−import "../../qml/Components/PanelState"

34import "Stage"

33import "Stage"

35

34

36Rectangle {

35Rectangle {

@@ -82,6 +81,12 @@ Rectangle {

82 deviceFilter: InputInfo.Keyboard

81 deviceFilter: InputInfo.Keyboard

83 }

82 }

84

83

84+ QtObject {

85+ id: _screenWindow

86+ property bool primary: true

87+ }

88+ property alias screenWindow: _screenWindow

89+

85 property int physicalOrientation0

90 property int physicalOrientation0

86 property int physicalOrientation90

91 property int physicalOrientation90

87 property int physicalOrientation180

92 property int physicalOrientation180

@@ -446,6 +451,15 @@ Rectangle {

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

448 property QtObject topLevelSurfaceList

453 property QtObject topLevelSurfaceList

454+ property var panelState: undefined

455+

456+ onOrientedShellChanged: {

457+ if (orientedShell) {

458+ panelState = findInvisibleChild(orientedShell, "panelState");

459+ } else {

460+ panelState = undefined;

461+ }

462+ }

449

463

450 SignalSpy { id: signalSpy }

464 SignalSpy { id: signalSpy }

451 SignalSpy { id: signalSpy2 }

465 SignalSpy { id: signalSpy2 }

@@ -1512,13 +1526,13 @@ Rectangle {

1512 print("exptectedAngle", expectedAngle, point.x, point.y)

1526 print("exptectedAngle", expectedAngle, point.x, point.y)

1513 switch (expectedAngle) {

1527 switch (expectedAngle) {

1514 case 0:

1528 case 0:

1515− return point.x === 0 && point.y === PanelState.panelHeight;

1529+ return point.x === 0 && point.y === panelState.panelHeight;

1516 case 90:

1530 case 90:

1517− return point.x === orientedShell.width - PanelState.panelHeight && point.y === 0;

1531+ return point.x === orientedShell.width - panelState.panelHeight && point.y === 0;

1518 case 180:

1532 case 180:

1519− return point.x === orientedShell.width && point.y === orientedShell.height - PanelState.panelHeight;

1533+ return point.x === orientedShell.width && point.y === orientedShell.height - panelState.panelHeight;

1520 default: // 270

1534 default: // 270

1521− return point.x === PanelState.panelHeight && point.y === orientedShell.height;

1535+ return point.x === panelState.panelHeight && point.y === orientedShell.height;

1522 }

1536 }

1523 }

1537 }

1524

1538

tests/qmltests/tst_Shell.qml+22−15

@@ -61,14 +61,21 @@ Rectangle {

61 onShellChanged: {

62 if (shell) {

63 topLevelSurfaceList = testCase.findInvisibleChild(shell, "topLevelSurfaceList");

64− appMenuData.surfaceManager = testCase.findInvisibleChild(shell, "surfaceManager");

64+ panelState = testCase.findInvisibleChild(shell, "panelState");

65 } else {

66 topLevelSurfaceList = null;

67− appMenuData.surfaceManager = null;

67+ panelState = undefined;

68 }

69 }

70

71 property var topLevelSurfaceList: null

72+ property var panelState: undefined

73+

74+ QtObject {

75+ id: _screenWindow

76+ property bool primary: true

77+ }

78+ property alias screenWindow: _screenWindow

72

79

73 Item {

80 Item {

74 id: shellContainer

81 id: shellContainer

@@ -262,6 +269,7 @@ Rectangle {

262 anchors { left: parent.left; right: parent.right }

269 anchors { left: parent.left; right: parent.right }

263 activeFocusOnPress: false

270 activeFocusOnPress: false

264 model: ["phone", "tablet", "desktop"]

271 model: ["phone", "tablet", "desktop"]

272+ selectedIndex: 2

265 onSelectedIndexChanged: {

273 onSelectedIndexChanged: {

266 shellLoader.state = model[selectedIndex];

274 shellLoader.state = model[selectedIndex];

267 }

275 }

@@ -275,6 +283,7 @@ Rectangle {

275 anchors { left: parent.left; right: parent.right }

283 anchors { left: parent.left; right: parent.right }

276 activeFocusOnPress: false

284 activeFocusOnPress: false

277 model: ["phone", "tablet", "desktop"]

285 model: ["phone", "tablet", "desktop"]

286+ selectedIndex: 2

278 }

287 }

279 MouseTouchEmulationCheckbox {

288 MouseTouchEmulationCheckbox {

280 id: mouseEmulation

289 id: mouseEmulation

@@ -678,9 +687,7 @@ Rectangle {

678 }

687 }

679

688

680 function ensureInputMethodSurface() {

689 function ensureInputMethodSurface() {

681− var surfaceManager = findInvisibleChild(shell, "surfaceManager");

682− verify(surfaceManager);

683− surfaceManager.createInputMethodSurface();

690+ SurfaceManager.createInputMethodSurface();

684

691

685 tryCompareFunction(function() { return root.topLevelSurfaceList.inputMethodSurface !== null }, true);

692 tryCompareFunction(function() { return root.topLevelSurfaceList.inputMethodSurface !== null }, true);

686 }

693 }

@@ -1866,21 +1873,21 @@ Rectangle {

1866 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

1873 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

1867

1874

1868 tryCompare(appDelegate, "state", "normal");

1875 tryCompare(appDelegate, "state", "normal");

1869− tryCompare(PanelState, "decorationsVisible", false)

1876+ tryCompare(panelState, "decorationsVisible", false)

1870

1877

1871 mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);

1878 mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);

1872 tryCompare(appDelegate, "state", "maximized");

1879 tryCompare(appDelegate, "state", "maximized");

1873− tryCompare(PanelState, "decorationsVisible", true)

1880+ tryCompare(panelState, "decorationsVisible", true)

1874

1881

1875 ApplicationManager.stopApplication(application.appId);

1882 ApplicationManager.stopApplication(application.appId);

1876− tryCompare(PanelState, "decorationsVisible", false)

1883+ tryCompare(panelState, "decorationsVisible", false)

1877

1884

1878 // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

1885 // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

1879 // They won't be gone until those surface items are destroyed.

1886 // They won't be gone until those surface items are destroyed.

1880 tryCompareFunction(function() { return application.surfaceList.count }, 0);

1887 tryCompareFunction(function() { return application.surfaceList.count }, 0);

1881

1888

1882 ApplicationManager.startApplication(application.appId);

1889 ApplicationManager.startApplication(application.appId);

1883− tryCompare(PanelState, "decorationsVisible", true)

1890+ tryCompare(panelState, "decorationsVisible", true)

1884 }

1891 }

1885

1892

1886 function test_newAppHasValidGeometry() {

1893 function test_newAppHasValidGeometry() {

@@ -1937,7 +1944,7 @@ Rectangle {

1937 mousePress(appDelegate, appDelegate.width / 2, units.gu(1))

1944 mousePress(appDelegate, appDelegate.width / 2, units.gu(1))

1938 mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))

1945 mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))

1939

1946

1940− compare(appDelegate.y >= PanelState.panelHeight, true);

1947+ compare(appDelegate.y >= panelState.panelHeight, true);

1941 }

1948 }

1942

1949

1943 function test_cantResizeWindowUnderPanel() {

1950 function test_cantResizeWindowUnderPanel() {

@@ -1965,7 +1972,7 @@ Rectangle {

1965 mouseMove(decoration, decoration.width/2, -units.gu(100));

1972 mouseMove(decoration, decoration.width/2, -units.gu(100));

1966

1973

1967 // verify we don't go past the panel

1974 // verify we don't go past the panel

1968− compare(appDelegate.y >= PanelState.panelHeight, true);

1975+ compare(appDelegate.y >= panelState.panelHeight, true);

1969 }

1976 }

1970

1977

1971 function test_restoreWindowStateFixesIfUnderPanel() {

1978 function test_restoreWindowStateFixesIfUnderPanel() {

@@ -1989,7 +1996,7 @@ Rectangle {

1989 tryCompareFunction(function () { return topLevelSurfaceList.applicationAt(0).appId; }, application.appId);

1996 tryCompareFunction(function () { return topLevelSurfaceList.applicationAt(0).appId; }, application.appId);

1990

1997

1991 appDelegate = appRepeater.itemAt(0);

1998 appDelegate = appRepeater.itemAt(0);

1992− compare(appDelegate.y >= PanelState.panelHeight, true);

1999+ compare(appDelegate.y >= panelState.panelHeight, true);

1993 }

2000 }

1994

2001

1995 function test_lifecyclePolicyForNonTouchApp_data() {

2002 function test_lifecyclePolicyForNonTouchApp_data() {

@@ -2636,7 +2643,7 @@ Rectangle {

2636 function test_oskDisplacesWindow_data() {

2643 function test_oskDisplacesWindow_data() {

2637 return [

2644 return [

2638 {tag: "no need to displace", windowHeight: units.gu(10), windowY: units.gu(5), targetDisplacement: units.gu(5), oskEnabled: true},

2645 {tag: "no need to displace", windowHeight: units.gu(10), windowY: units.gu(5), targetDisplacement: units.gu(5), oskEnabled: true},

2639− {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: PanelState.panelHeight, oskEnabled: true},

2646+ {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: panelState.panelHeight, oskEnabled: true},

2640 {tag: "osk not on this screen", windowHeight: units.gu(40), windowY: units.gu(10), targetDisplacement: units.gu(10), oskEnabled: false},

2647 {tag: "osk not on this screen", windowHeight: units.gu(40), windowY: units.gu(10), targetDisplacement: units.gu(10), oskEnabled: false},

2641 ]

2648 ]

2642 }

2649 }

@@ -2659,8 +2666,8 @@ Rectangle {

2659 dashAppDelegate.windowedY = data.windowY;

2666 dashAppDelegate.windowedY = data.windowY;

2660 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2667 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2661 var initialY = dashAppDelegate.y;

2668 var initialY = dashAppDelegate.y;

2662− print("intial", initialY, "panel", PanelState.panelHeight);

2669+ print("intial", initialY, "panel", panelState.panelHeight);

2663− verify(initialY > PanelState.panelHeight);

2670+ verify(initialY > panelState.panelHeight);

2664

2671

2665 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, root.height / 2, root.width, root.height / 2));

2672 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, root.height / 2, root.width, root.height / 2));

2666 tryCompare(dashAppDelegate, "y", data.targetDisplacement);

2673 tryCompare(dashAppDelegate, "y", data.targetDisplacement);

tests/qmltests/tst_ShellApplication.qmlnew file+162

@@ -0,0 +1,162 @@

1+/*

3+ *

4+ * This program is free software; you can redistribute it and/or modify

5+ * it under the terms of the GNU General Public License as published by

6+ * the Free Software Foundation; version 3.

7+ *

8+ * This program is distributed in the hope that it will be useful,

9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11+ * GNU General Public License for more details.

12+ *

13+ * You should have received a copy of the GNU General Public License

14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.

15+ */

16+

17+import QtQuick 2.4

18+import Ubuntu.Components 1.3

19+import LightDM.FullLightDM 0.1 as LightDM

20+import LightDMController 0.1

21+import Unity.Application 0.1

22+import Unity.Test 0.1

23+

24+import "../../qml"

25+import "../../qml/Components"

26+import "Stage"

27+

28+Rectangle {

29+ id: root

30+ color: "grey"

31+ width: units.gu(100)

32+ height: units.gu(71)

33+

34+ QtObject {

35+ id: args

36+ property bool hasFullscreen: false

37+ property bool hasFrameless: false

38+ property bool hasGeometry: true

39+ property size windowGeometry: Qt.size(root.width, root.height)

40+ property string deviceName: "desktop"

41+ property string mode: "full-greeter"

42+ }

43+ property alias applicationArguments: args

44+

45+ Component.onCompleted: {

46+ // must set the mock mode before loading the Shell

47+ LightDMController.userMode = "single";

48+ }

49+

50+ Flickable {

51+ id: controls

52+ contentHeight: controlRect.height

53+

54+ anchors.top: root.top

55+ anchors.bottom: root.bottom

56+ anchors.right: root.right

57+ width: units.gu(30)

58+

59+ Rectangle {

60+ id: controlRect

61+ anchors { left: parent.left; right: parent.right }

62+ color: "darkgrey"

63+ height: childrenRect.height + units.gu(2)

64+

65+ Column {

66+ anchors { left: parent.left; right: parent.right; top: parent.top; margins: units.gu(1) }

67+ spacing: units.gu(1)

68+

69+ Flow {

70+ spacing: units.gu(1)

71+ anchors { left: parent.left; right: parent.right }

72+

73+ Button {

74+ text: "Show Greeter"

75+ activeFocusOnPress: false

76+ onClicked: {

77+ LightDM.Greeter.showGreeter();

78+ }

79+ }

80+ Button {

81+ text: "Hide Greeter"

82+ activeFocusOnPress: false

83+ onClicked: {

84+ LightDM.Greeter.hideGreeter()

85+ }

86+ }

87+ }

88+

89+ MouseTouchEmulationCheckbox {

90+ id: mouseEmulation

91+ checked: true

92+ }

93+

94+ Row {

95+ anchors { left: parent.left; right: parent.right }

96+ CheckBox {

97+ id: autohideLauncherCheckbox

98+ onCheckedChanged: {

99+ GSettingsController.setAutohideLauncher(checked)

100+ }

101+ }

102+ Label {

103+ text: "Autohide launcher"

104+ }

105+ }

106+

107+ Label { text: "Applications"; font.bold: true }

108+

109+ Button {

110+ text: "Start all apps"

111+ width: parent.width

112+ activeFocusOnPress: false

113+ onClicked: {

114+ for (var i = 0; i < ApplicationManager.availableApplications.length; i++) {

115+ var appId = ApplicationManager.availableApplications[i];

116+ ApplicationManager.startApplication(appId)

117+ }

118+ }

119+ }

120+

121+ Repeater {

122+ id: appCheckBoxRepeater

123+ model: ApplicationManager.availableApplications

124+ ApplicationCheckBox {

125+ appId: modelData

126+ }

127+ }

128+

129+ Label {

130+ text: "Fingerprint"

131+ }

132+ Row {

133+ Button {

134+ text: "Success"

135+ onClicked: {

136+ var biometryd = testCase.findInvisibleChild(shellContainer, "biometryd");

137+ var uid = 0;

138+ for (var i = 0; i < LightDM.Users.count; i++) {

139+ if (LightDM.Users.data(i, LightDM.UserRoles.NameRole) == AccountsService.user) {

140+ uid = LightDM.Users.data(i, LightDM.UserRoles.UidRole);

141+ break;

142+ }

143+ }

144+ biometryd.operation.mockSuccess(uid);

145+ }

146+ }

147+

148+ Button {

149+ text: "Failure"

150+ onClicked: {

151+ var biometryd = testCase.findInvisibleChild(shellContainer, "biometryd");

152+ biometryd.operation.mockFailure("error");

153+ }

154+ }

155+ }

156+ }

157+ }

158+ }

159+

160+ ShellApplication {

161+ }

162+}

tests/uqmlscene/main.cpp+2

@@ -479,6 +479,8 @@ int main(int argc, char ** argv)

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));