xenial...17872af · unity8

CMakeLists.txt+5−2

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

7070find_package(Qt5Concurrent 5.6 REQUIRED)

7171find_package(Qt5Sql 5.6 REQUIRED)

7272

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

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

74+pkg_check_modules(QTMIRSERVER REQUIRED qtmirserver>=0.6.0)

7475pkg_check_modules(GEONAMES REQUIRED geonames>=0.2)

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

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

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

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

114115endif()

115116

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

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

118+

119+set (CMAKE_CXX_STANDARD 14)

117120

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

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

debian/control+5−3

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

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

3939 libudev-dev,

4040 libudm-common-dev,

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

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

4242 libusermetricsoutput1-dev,

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

4444 libx11-dev[!arm64 !armhf],

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

6868 qtdeclarative5-private-dev (>= 5.6),

6969 qtdeclarative5-ubuntu-content1,

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

71+ qtmir-dev (>= 0.6.0),

7172 ttf-ubuntu-font-family,

7273 xvfb,

7374Standards-Version: 3.9.4

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

131132 qml-module-ubuntu-web,

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

133134 qtdeclarative5-ubuntu-telephony0.1,

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

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

135137 unity-launcher-impl-10,

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

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

162164 qttranslations5-l10n,

163165 ubuntu-thumbnailer-impl-0,

164166 ubuntu-wallpapers,

165− unity-application-impl-26,

167+ unity-application-impl-27,

166168 unity-notifications-impl-3,

167169 unity-plugin-scopes | unity-scopes-impl,

168170 unity-scopes-impl-12,

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

212214 ${misc:Depends},

213215 ${shlibs:Depends},

214216Provides: unity-application-impl,

215− unity-application-impl-26,

217+ unity-application-impl-27,

216218 unity8-fake-env,

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

218220 unity8-fake-env,

debian/unity8.install+4

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

1616usr/share/unity8/DeviceConfiguration.qml

1717usr/share/unity8/OrientedShell.qml

1818usr/share/unity8/DisabledScreenNotice.qml

19+usr/share/unity8/qmldir

1920usr/share/unity8/Shell.qml

21+usr/share/unity8/ShellApplication.qml

22+usr/share/unity8/ShellNotifier.qml

23+usr/share/unity8/ShellScreen.qml

2024usr/share/unity8/Stage

2125usr/share/unity8/Tutorial

2226usr/share/unity8/Wizard

plugins/Cursor/CMakeLists.txt+1

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

1515 CursorImageInfo.cpp

1616 CursorImageProvider.cpp

1717 MousePointer.cpp

18+ InputDispatcherFilter.cpp

1819 # We need to run moc on this header

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

2021 )

plugins/Cursor/InputDispatcherFilter.cppnew file+175

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#include "InputDispatcherFilter.h"

18+#include "MousePointer.h"

19+

20+#include <QEvent>

21+#include <QGuiApplication>

22+#include <QQuickWindow>

23+#include <QScreen>

24+#include <QtMath>

25+#include <qpa/qplatformnativeinterface.h>

26+#include <qpa/qplatformscreen.h>

27+

28+InputDispatcherFilter *InputDispatcherFilter::instance()

29+{

30+ static InputDispatcherFilter filter;

31+ return &filter;

32+}

33+

34+InputDispatcherFilter::InputDispatcherFilter(QObject *parent)

35+ : QObject(parent)

36+ , m_pushing(false)

37+{

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

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

40+ if (m_inputDispatcher) {

41+ m_inputDispatcher->installEventFilter(this);

42+ }

43+}

44+

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

46+{

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

48+ m_pointers.insert(pointer);

49+}

50+

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

52+{

53+ m_pointers.remove(pointer);

54+}

55+

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

57+{

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

59+

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

61+ case QEvent::MouseMove:

62+ case QEvent::MouseButtonPress:

63+ case QEvent::MouseButtonRelease:

64+ {

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

66+ auto pointer = currentPointer();

67+ if (!pointer) return true;

68+

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

70+

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

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

73+

74+ // Adjust the position

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

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

77+

78+ QScreen* currentScreen = screenAt(newPos);

79+ if (currentScreen) {

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

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

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

83+

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

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

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

87+ m_pushing = true;

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

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

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

91+ m_pushing = true;

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

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

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

95+ m_pushing = true;

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

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

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

99+ m_pushing = true;

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

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

102+ m_pushing = true;

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

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

105+ m_pushing = true;

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

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

108+ m_pushing = true;

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

110+ if (m_pushing) {

111+ Q_EMIT pushStopped(currentScreen);

112+ m_pushing = false;

113+ }

114+ }

115+ }

116+

117+ // Send the event

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

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

120+ o->event(&eCopy);

121+ return true;

122+ }

123+ default:

124+ break;

125+ }

126+ return false;

127+}

128+

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

130+{

131+ QPointF adjusted = pt + movement;

132+

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

134+ if (screen) {

135+ return adjusted;

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

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

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

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

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

141+ } else {

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

143+

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

145+ Q_FOREACH(QScreen* screen, screens) {

146+ Q_FOREACH(MousePointer* pointer, m_pointers) {

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

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

149+ }

150+ }

151+ }

152+ }

153+ return adjusted;

154+}

155+

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

157+{

158+ Q_FOREACH(MousePointer* pointer, m_pointers) {

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

160+

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

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

163+ return screen;

164+ }

165+ return nullptr;

166+}

167+

168+MousePointer *InputDispatcherFilter::currentPointer() const

169+{

170+ Q_FOREACH(MousePointer* pointer, m_pointers) {

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

172+ return pointer;

173+ }

174+ return nullptr;

175+}

plugins/Cursor/InputDispatcherFilter.hnew file+62

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef INPUTDISPATCHERFILTER_H

18+#define INPUTDISPATCHERFILTER_H

19+

20+#include <QObject>

21+#include <QPointF>

22+#include <QSet>

23+

24+class MousePointer;

25+class QScreen;

26+

27+class InputDispatcherFilter : public QObject

28+{

29+ Q_OBJECT

30+public:

31+ static InputDispatcherFilter *instance();

32+

33+ void registerPointer(MousePointer* pointer);

34+ void unregisterPointer(MousePointer* pointer);

35+

36+Q_SIGNALS:

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

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

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

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

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

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

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

44+ void pushStopped(QScreen* screen);

45+

46+protected:

47+ InputDispatcherFilter(QObject* parent = nullptr);

48+

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

50+

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

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

53+

54+ MousePointer* currentPointer() const;

55+

56+private:

57+ QObject* m_inputDispatcher;

58+ QSet<MousePointer*> m_pointers;

59+ bool m_pushing;

60+};

61+

62+#endif // INPUTDISPATCHERFILTER_H

plugins/Cursor/MousePointer.cpp+63−78

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

1616

1717#include "MousePointer.h"

1818#include "CursorImageProvider.h"

19−

20−// Unity API

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

19+#include "InputDispatcherFilter.h"

2220

2321#include <QQuickWindow>

24−#include <QGuiApplication>

25−#include <QtMath>

2622

27−#include <qpa/qwindowsysteminterface.h>

23+// Unity API

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

2825

2926MousePointer::MousePointer(QQuickItem *parent)

3027 : MirMousePointerInterface(parent)

3128 , m_cursorName(QStringLiteral("left_ptr"))

3229 , m_themeName(QStringLiteral("default"))

3330{

34−}

35−

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

37− Qt::KeyboardModifiers modifiers)

38−{

39− if (!parentItem()) {

40− return;

41− }

42−

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

44− Q_EMIT mouseMoved();

45− }

46−

47− m_accumulatedMovement += movement;

48− // don't apply the fractional part

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

50− m_accumulatedMovement -= appliedMovement;

51−

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

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

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

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

56−

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

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

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

60− m_pushing = true;

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

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

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

64− m_pushing = true;

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

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

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

68− m_pushing = true;

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

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

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

72− m_pushing = true;

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

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

75− m_pushing = true;

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

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

78− m_pushing = true;

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

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

81− m_pushing = true;

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

83− if (m_pushing) {

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

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

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

34+ Q_EMIT pushedLeftBoundary(amount, buttons);

35+ }

36+ });

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

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

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

40+ Q_EMIT pushedRightBoundary(amount, buttons);

41+ }

42+ });

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

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

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

46+ Q_EMIT pushedTopBoundary(amount, buttons);

47+ }

48+ });

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

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

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

52+ Q_EMIT pushedTopLeftCorner(amount, buttons);

53+ }

54+ });

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

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

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

58+ Q_EMIT pushedTopRightCorner(amount, buttons);

59+ }

60+ });

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

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

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

64+ Q_EMIT pushedBottomLeftCorner(amount, buttons);

65+ }

66+ });

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

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

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

70+ Q_EMIT pushedBottomRightCorner(amount, buttons);

71+ }

72+ });

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

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

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

8476 Q_EMIT pushStopped();

85− m_pushing = false;

8677 }

87− }

78+ });

8879

89− applyItemConfinement(newX, newY);

90−

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

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

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

81+}

9382

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

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

96− buttons, modifiers);

83+MousePointer::~MousePointer()

84+{

85+ registerScreen(nullptr);

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

9787}

9888

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

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

121111 }

122112}

123113

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

125−{

126− if (!parentItem()) {

127− return;

128− }

129−

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

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

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

133−}

134−

135114int MousePointer::topBoundaryOffset() const

136115{

137116 return m_topBoundaryOffset;

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

182161 if (m_registeredScreen) {

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

184163 if (previousCursor) {

185− previousCursor->setMousePointer(nullptr);

164+ previousCursor->unregisterMousePointer(this);

186165 } else {

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

188167 }

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

193172 if (m_registeredScreen) {

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

195174 if (cursor) {

196− cursor->setMousePointer(this);

175+ cursor->registerMousePointer(this);

197176 } else {

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

199178 }

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

216195 }

217196}

218197

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

199+{

200+ setPosition(position);

201+ Q_EMIT mouseMoved();

202+}

203+

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

220205{

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

plugins/Cursor/MousePointer.h+5−4

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

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

3232public:

3333 MousePointer(QQuickItem *parent = nullptr);

34+ ~MousePointer();

3435

3536 void setCursorName(const QString &qtCursorName) override;

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

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

3839 void setThemeName(const QString &themeName) override;

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

4041

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

43+

4144 void setCustomCursor(const QCursor &) override;

4245

4346 QQuickItem* confiningItem() const;

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

4649 int topBoundaryOffset() const;

4750 void setTopBoundaryOffset(int topBoundaryOffset);

4851

49−public Q_SLOTS:

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

51− Qt::KeyboardModifiers modifiers) override;

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

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

5353

5454Q_SIGNALS:

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

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

7979 QPointer<QScreen> m_registeredScreen;

8080 QString m_cursorName;

8181 QString m_themeName;

82+ bool m_active;

8283

8384 // Accumulated, unapplied, mouse movement.

8485 QPointF m_accumulatedMovement;

plugins/UInput/plugin.cpp+7−1

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

1919

2020#include <QtQml/qqml.h>

2121

22+

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

24+{

25+ return new UInput;

26+}

27+

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

2329{

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

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

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

2632}

plugins/Unity/CMakeLists.txt+1

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

11add_subdirectory(ApplicationMenu)

22add_subdirectory(Connectivity)

3+add_subdirectory(Debug)

34add_subdirectory(Indicators)

45add_subdirectory(Launcher)

56add_subdirectory(Session)

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

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

1+include_directories(

2+ ${CMAKE_CURRENT_SOURCE_DIR}

3+ ${CMAKE_CURRENT_BINARY_DIR}

4+)

5+

6+include_directories(

7+ SYSTEM

8+ ${Qt5Gui_PRIVATE_INCLUDE_DIRS}

9+ ${Qt5Quick_PRIVATE_INCLUDE_DIRS}

10+ ${GIO_INCLUDE_DIRS}

11+)

12+

13+set(QMLPLUGIN_SRC

14+ consolelog.cpp

15+ plugin.cpp

16+ )

17+

18+add_library(Debug-qml SHARED

19+ ${QMLPLUGIN_SRC}

20+ )

21+

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

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

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

25+# files directly in targets.

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

27+

28+qt5_use_modules(Debug-qml Qml Quick Concurrent)

29+

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

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

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

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

12+ *

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

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

15+*/

16+

17+#include "consolelog.h"

18+

19+#include <unistd.h>

20+#include <stdio.h>

21+#include <thread>

22+#include <iostream>

23+#include <sys/ioctl.h>

24+

25+#include <functional>

26+

27+namespace

28+{

29+

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

31+{

32+ int ret = -1;

33+ bool fd_blocked = false;

34+ do

35+ {

36+ ret = fn();

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

38+ if (fd_blocked)

39+ QThread::msleep(10);

40+ }

41+ while (ret < 0);

42+ return ret;

43+}

44+

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

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

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

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

49+

50+}

51+

52+LogRedirector::LogRedirector()

53+ : m_ref(0)

54+ , m_stop(false)

55+{

56+ setObjectName("ConsoleLog");

57+

58+ // make stdout & stderr streams unbuffered

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

60+ // before capture and after capture

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

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

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

64+}

65+

66+void LogRedirector::run()

67+{

68+ PIPE_WAIT(m_pipe);

69+

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

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

72+

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

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

75+ CLOSE_WAIT(m_pipe[WRITE]);

76+

77+ while(true) {

78+ {

79+ QMutexLocker lock(&m_mutex);

80+ if (m_stop) break;

81+ }

82+ checkLog();

83+ QThread::msleep(50);

84+ }

85+

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

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

88+

89+ CLOSE_WAIT(oldStdOut);

90+ CLOSE_WAIT(oldStdErr);

91+ CLOSE_WAIT(m_pipe[READ]);

92+}

93+

94+

95+void LogRedirector::checkLog()

96+{

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

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

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

100+ int count = 0;

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

102+ if (count <= 0) return;

103+

104+ std::string captured;

105+ std::string buf;

106+ const int bufSize = 1024;

107+ buf.resize(bufSize);

108+ int bytesRead = 0;

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

110+ while(bytesRead == bufSize)

111+ {

112+ captured += buf;

113+ bytesRead = 0;

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

115+ }

116+ if (bytesRead > 0)

117+ {

118+ buf.resize(bytesRead);

119+ captured += buf;

120+ }

121+

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

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

124+ }

125+}

126+

127+LogRedirector *LogRedirector::instance()

128+{

129+ static LogRedirector* log = nullptr;

130+ if (!log) {

131+ log = new LogRedirector();

132+ }

133+ return log;

134+}

135+

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

137+{

138+ QMutexLocker lock(&m_mutex);

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

140+

141+ m_ref++;

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

143+ m_stop = false;

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

145+ }

146+}

147+

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

149+{

150+ QMutexLocker lock(&m_mutex);

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

152+

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

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

155+ m_stop = true;

156+ lock.unlock();

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

158+ }

159+}

160+

161+ConsoleLog::ConsoleLog(QObject *parent)

162+ : QObject(parent)

163+ , m_enabled(false)

164+ , m_maxLines(60)

165+{

166+ auto updateEnabled = [this]() {

167+ if (m_enabled) {

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

169+ } else {

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

171+ }

172+ };

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

174+}

175+

176+ConsoleLog::~ConsoleLog()

177+{

178+ if (m_enabled) {

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

180+ }

181+}

182+

183+void ConsoleLog::setEnabled(bool enabled)

184+{

185+ if (m_enabled == enabled) {

186+ return;

187+ }

188+

189+ m_enabled = enabled;

190+ Q_EMIT enabledChanged();

191+}

192+

193+QString ConsoleLog::out() const

194+{

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

196+}

197+

198+void ConsoleLog::setMaxLines(int maxLines)

199+{

200+ if (m_maxLines == maxLines) {

201+ return;

202+ }

203+

204+ m_maxLines = maxLines;

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

206+ m_out.removeLast();

207+ }

208+ Q_EMIT outChanged();

209+ Q_EMIT maxLinesChanged();

210+}

211+

212+void ConsoleLog::logged(QString captured)

213+{

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

215+ li << m_out;

216+ m_out = li;

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

218+ m_out.removeLast();

219+ }

220+ Q_EMIT outChanged();

221+}

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

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

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

12+ *

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

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

15+*/

16+

17+#ifndef CONSOLELOG_H

18+#define CONSOLELOG_H

19+

20+#include <QThread>

21+#include <QMutex>

22+#include <QSet>

23+

24+class ConsoleLog;

25+

26+class LogRedirector : public QThread

27+{

28+ Q_OBJECT

29+public:

30+ static LogRedirector *instance();

31+

32+ void add(ConsoleLog* logger);

33+ void remove(ConsoleLog* logger);

34+

35+private Q_SLOTS:

36+ void checkLog();

37+

38+Q_SIGNALS:

39+ void log(QString log);

40+

41+private:

42+ LogRedirector();

43+ void run() Q_DECL_OVERRIDE;

44+

45+ QMutex m_mutex;

46+ int m_pipe[2];

47+ int m_ref;

48+ bool m_stop;

49+

50+ enum PIPES { READ, WRITE };

51+};

52+

53+class ConsoleLog : public QObject

54+{

55+ Q_OBJECT

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

57+ Q_PROPERTY(QString out READ out NOTIFY outChanged)

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

59+public:

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

61+ ~ConsoleLog();

62+

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

64+ void setEnabled(bool enabled);

65+

66+ QString out() const;

67+

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

69+ void setMaxLines(int maxLines);

70+

71+public Q_SLOTS:

72+ void logged(QString captured);

73+

74+Q_SIGNALS:

75+ void enabledChanged();

76+ void outChanged();

77+ void maxLinesChanged();

78+

79+private:

80+ void updateEnabled();

81+

82+ QStringList m_out;

83+ bool m_enabled;

84+ int m_maxLines;

85+};

86+

87+#endif // CONSOLELOG_H

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

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+// Qt

18+#include <QtQml/qqml.h>

19+

20+// self

21+#include "plugin.h"

22+

23+// local

24+#include "consolelog.h"

25+

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

27+{

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

29+

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

31+}

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

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

11/*

33 *

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

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

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

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

1515 */

1616

17−#ifndef UNITY_SHELL_VIEW_H

18−#define UNITY_SHELL_VIEW_H

17+#ifndef UNITYDEBUG_PLUGIN_H

18+#define UNITYDEBUG_PLUGIN_H

1919

20−#include <QQuickView>

20+#include <QtQml/QQmlEngine>

21+#include <QtQml/QQmlExtensionPlugin>

2122

22−class ShellView : public QQuickView

23+class UnityDebugPlugin : public QQmlExtensionPlugin

2324{

2425 Q_OBJECT

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

2527

2628public:

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

28−

29−private Q_SLOTS:

30− void onWidthChanged(int);

31− void onHeightChanged(int);

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

3230};

3331

34−#endif // UNITY_SHELL_VIEW_H

32+#endif

plugins/Unity/Debug/qmldirnew file+3

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

1+module Unity.Debug

2+plugin Debug-qml

3+typeinfo Debug.qmltypes

plugins/WindowManager/CMakeLists.txt+17−2

@@ -1,16 +1,31 @@

1+include_directories(

2+ SYSTEM

3+ ${QTMIRSERVER_INCLUDE_DIRS}

4+)

5+

16set(WINDOWMANAGER_SRC

27 TopLevelWindowModel.cpp

38 Window.cpp

49 WindowManagerPlugin.cpp

10+ Screens.cpp

11+ Screen.cpp

12+ ScreenWindow.cpp

13+ Workspace.cpp

14+ WorkspaceManager.cpp

15+ WorkspaceModel.cpp

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

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

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

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

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

10− )

21+)

1122

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

1324

25+target_link_libraries(windowmanager-qml

26+ ${QTMIRSERVER_LDFLAGS}

27+)

28+

1429qt5_use_modules(windowmanager-qml Qml Quick Gui)

1530

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

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

plugins/WindowManager/Screen.cppnew file+124

@@ -0,0 +1,124 @@

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

19+#include "WorkspaceManager.h"

20+#include "Workspace.h"

21+

22+Screen::Screen(qtmir::Screen* screen)

23+ : m_wrapped(screen)

24+ , m_workspaces(new WorkspaceModel)

25+{

26+ connect(m_wrapped, &qtmir::Screen::usedChanged, this, &Screen::usedChanged);

27+ connect(m_wrapped, &qtmir::Screen::nameChanged, this, &Screen::nameChanged);

28+ connect(m_wrapped, &qtmir::Screen::outputTypeChanged, this, &Screen::outputTypeChanged);

29+ connect(m_wrapped, &qtmir::Screen::scaleChanged, this, &Screen::scaleChanged);

30+ connect(m_wrapped, &qtmir::Screen::formFactorChanged, this, &Screen::formFactorChanged);

31+ connect(m_wrapped, &qtmir::Screen::physicalSizeChanged, this, &Screen::physicalSizeChanged);

32+ connect(m_wrapped, &qtmir::Screen::positionChanged, this, &Screen::positionChanged);

33+ connect(m_wrapped, &qtmir::Screen::activeChanged, this, &Screen::activeChanged);

34+ connect(m_wrapped, &qtmir::Screen::currentModeIndexChanged, this, &Screen::currentModeIndexChanged);

35+ connect(m_wrapped, &qtmir::Screen::availableModesChanged, this, &Screen::availableModesChanged);

36+

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

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

39+}

40+

41+qtmir::OutputId Screen::outputId() const

42+{

43+ return m_wrapped->outputId();

44+}

45+

46+bool Screen::used() const

47+{

48+ return m_wrapped->used();

49+}

50+

51+QString Screen::name() const

52+{

53+ return m_wrapped->name();

54+}

55+

56+float Screen::scale() const

57+{

58+ return m_wrapped->scale();

59+}

60+

61+QSizeF Screen::physicalSize() const

62+{

63+ return m_wrapped->physicalSize();

64+}

65+

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

67+{

68+ return m_wrapped->formFactor();

69+}

70+

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

72+{

73+ return m_wrapped->outputType();

74+}

75+

76+MirPowerMode Screen::powerMode() const

77+{

78+ return m_wrapped->powerMode();

79+}

80+

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

82+{

83+ return m_wrapped->orientation();

84+}

85+

86+QPoint Screen::position() const

87+{

88+ return m_wrapped->position();

89+}

90+

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

92+{

93+ return m_wrapped->availableModes();

94+}

95+

96+uint Screen::currentModeIndex() const

97+{

98+ return m_wrapped->currentModeIndex();

99+}

100+

101+bool Screen::isActive() const

102+{

103+ return m_wrapped->isActive();

104+}

105+

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

107+{

108+ return m_wrapped->beginConfiguration();

109+}

110+

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

112+{

113+ return m_wrapped->applyConfiguration(configuration);

114+}

115+

116+void Screen::setActive(bool active)

117+{

118+ m_wrapped->setActive(active);

119+}

120+

121+QScreen *Screen::qscreen() const

122+{

123+ return m_wrapped->qscreen();

124+}

plugins/WindowManager/Screen.hnew file+46

@@ -0,0 +1,46 @@

1+#ifndef SCREEN_H

2+#define SCREEN_H

3+

4+#include <qtmir/screen.h>

5+#include <QScopedPointer>

6+

7+class WorkspaceModel;

8+

9+class Screen : public qtmir::Screen

10+{

11+ Q_OBJECT

12+ Q_PROPERTY(WorkspaceModel* workspaces READ workspaces CONSTANT)

13+

14+public:

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

16+

17+ qtmir::OutputId outputId() const override;

18+ bool used() const override;

19+ QString name() const override;

20+ float scale() const override;

21+ QSizeF physicalSize() const override;

22+ qtmir::FormFactor formFactor() const override;

23+ qtmir::OutputTypes outputType() const override;

24+ MirPowerMode powerMode() const override;

25+ Qt::ScreenOrientation orientation() const override;

26+ QPoint position() const override;

27+ QQmlListProperty<qtmir::ScreenMode> availableModes() override;

28+ uint currentModeIndex() const override;

29+ bool isActive() const override;

30+ void setActive(bool active) override;

31+

32+ QScreen* qscreen() const override;

33+

34+ qtmir::ScreenConfiguration *beginConfiguration() const override;

35+ bool applyConfiguration(qtmir::ScreenConfiguration *configuration) override;

36+

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

38+

39+ WorkspaceModel* workspaces() const { return m_workspaces.data(); }

40+

41+private:

42+ qtmir::Screen*const m_wrapped;

43+ const QScopedPointer<WorkspaceModel> m_workspaces;

44+};

45+

46+#endif // SCREEN_H

plugins/WindowManager/ScreenWindow.cppnew file+48

@@ -0,0 +1,48 @@

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+ if (qGuiApp->platformName() != QLatin1String("mirserver")) {

28+ qCritical("Not using 'mirserver' QPA plugin. Using ScreenWindow may produce unknown results.");

29+ }

30+}

31+

32+ScreenWindow::~ScreenWindow()

33+{

34+}

35+

36+Screen *ScreenWindow::screenWrapper() const

37+{

38+ return m_screen.data();

39+}

40+

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

42+{

43+ if (m_screen != screen) {

44+ m_screen = screen;

45+ Q_EMIT screenWrapperChanged();

46+ }

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

48+}

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

44+

45+private:

46+ QPointer<Screen> m_screen;

47+};

48+

49+#endif // UNITY_SCREENWINDOW_H

plugins/WindowManager/Screens.cppnew file+129

@@ -0,0 +1,129 @@

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+

20+// qtmirserver

21+#include <qtmir/qtmir.h>

22+#include <qtmir/screens.h>

23+#include <QGuiApplication>

24+

25+// Qt

26+#include <QScreen>

27+#include <QWindow>

28+

29+Screens::Screens(QObject *parent)

30+ : QAbstractListModel(parent)

31+ , m_wrapped(qtmir::get_screen_model())

32+{

33+ if (qGuiApp->platformName() != QLatin1String("mirserver")) {

34+ qCritical("Not using 'mirserver' QPA plugin. Using qGuiApp may produce unknown results.");

35+ }

36+

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

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

39+ connect(qGuiApp, &QGuiApplication::focusWindowChanged, this, &Screens::activeScreenChanged);

40+

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

42+ m_screenList.push_back(new Screen(screen));

43+ }

44+}

45+

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

47+{

48+ QHash<int, QByteArray> roles;

49+ roles[ScreenRole] = "screen";

50+ return roles;

51+}

52+

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

54+{

55+ if (!index.isValid() || index.row() >= m_screenList.size()) {

56+ return QVariant();

57+ }

58+

59+ switch(role) {

60+ case ScreenRole:

61+ return QVariant::fromValue(m_screenList.at(index.row()));

62+ } // switch

63+

64+ return QVariant();

65+}

66+

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

68+{

69+ return count();

70+}

71+

72+int Screens::count() const

73+{

74+ return m_screenList.size();

75+}

76+

77+QVariant Screens::activeScreen() const

78+{

79+ for (int i = 0; i < m_screenList.count(); i++) {

80+ if (m_screenList[i]->isActive()) return i;

81+ }

82+ return QVariant();

83+}

84+

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

86+{

87+ bool ok = false;

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

89+ if (!ok || index < 0 || m_screenList.count() <= index) return;

90+

91+ auto screen = m_screenList.at(index);

92+ screen->setActive(true);

93+}

94+

95+void Screens::onScreenAdded(qtmir::Screen *screen)

96+{

97+ Q_FOREACH(auto screenWrapper, m_screenList) {

98+ if (screenWrapper->wrapped() == screen) return;

99+ }

100+

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

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

103+ m_screenList.push_back(screenWrapper);

104+ endInsertRows();

105+ Q_EMIT screenAdded(screenWrapper);

106+ Q_EMIT countChanged();

107+}

108+

109+void Screens::onScreenRemoved(qtmir::Screen *screen)

110+{

111+ int index = 0;

112+ QMutableListIterator<Screen*> iter(m_screenList);

113+ while(iter.hasNext()) {

114+ auto screenWrapper = iter.next();

115+ if (screenWrapper->wrapped() == screen) {

116+

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

118+ iter.remove();

119+ endRemoveRows();

120+

121+ Q_EMIT screenRemoved(screenWrapper);

122+ Q_EMIT countChanged();

123+

124+ screenWrapper->deleteLater();

125+ break;

126+ }

127+ index++;

128+ }

129+}

plugins/WindowManager/Screens.hnew file+71

@@ -0,0 +1,71 @@

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+

23+class Screen;

24+namespace qtmir

25+{

26+class Screen;

27+class Screens;

28+}

29+

30+class Screens : public QAbstractListModel

31+{

32+ Q_OBJECT

33+ Q_PROPERTY(int count READ count NOTIFY countChanged)

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

35+

36+public:

37+ enum ItemRoles {

38+ ScreenRole = Qt::UserRole + 1

39+ };

40+

41+ explicit Screens(QObject *parent = 0);

42+ virtual ~Screens() noexcept = default;

43+

44+ /* QAbstractItemModel */

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

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

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

48+

49+ int count() const;

50+ QVariant activeScreen() const;

51+

52+public Q_SLOTS:

53+ void activateScreen(const QVariant& index);

54+

55+Q_SIGNALS:

56+ void countChanged();

57+ void activeScreenChanged();

58+

59+ void screenAdded(Screen* screen);

60+ void screenRemoved(Screen* screen);

61+

62+private Q_SLOTS:

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

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

65+

66+private:

67+ QList<Screen*> m_screenList;

68+ QSharedPointer<qtmir::Screens> m_wrapped;

69+};

70+

71+#endif // SCREENS_H

plugins/WindowManager/WindowManagerPlugin.cpp+27

@@ -16,16 +16,43 @@

1616

1717#include "WindowManagerPlugin.h"

1818

19+#include "Screens.h"

20+#include "Screen.h"

21+#include "ScreenWindow.h"

1922#include "TopLevelWindowModel.h"

2023#include "Window.h"

24+#include "WorkspaceManager.h"

25+#include "Workspace.h"

26+#include "WorkspaceModel.h"

2127

2228#include <QtQml>

2329

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

31+{

32+ Q_UNUSED(engine)

33+ Q_UNUSED(scriptEngine)

34+ return WorkspaceManager::instance();

35+}

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

37+ Q_UNUSED(engine);

38+ Q_UNUSED(scriptEngine);

39+ return new Screens();

40+}

41+

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

2543{

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

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

46+ qmlRegisterUncreatableType<WorkspaceModel>(uri, 1, 0, "WorkspaceModel", "Not a creatable type");

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

48+ qmlRegisterUncreatableType<qtmir::ScreenMode>(uri, 1, 0, "ScreenMode", "ScreenMode is not creatable.");

2749

2850 qRegisterMetaType<Window*>("Window*");

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

2952

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

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

55+

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

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

3158}

plugins/WindowManager/Workspace.cppnew file+63

@@ -0,0 +1,63 @@

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+

20+Workspace::Workspace(QObject *parent)

21+ : QObject(parent)

22+ , m_model(nullptr)

23+{

24+

25+}

26+

27+Workspace::~Workspace()

28+{

29+ unassign();

30+}

31+

32+void Workspace::assign(WorkspaceModel *model)

33+{

34+ bool wasAssinged = false;

35+ if (m_model) {

36+ disconnect(model);

37+ m_model->remove(this);

38+ wasAssinged = true;

39+ }

40+

41+ m_model = model;

42+ if (model) {

43+ model->append(this);

44+

45+ connect(model, &QObject::destroyed, this, [this]() {

46+ m_model = nullptr;

47+ Q_EMIT unassigned();

48+ });

49+ Q_EMIT assigned();

50+ } else if (wasAssinged) {

51+ Q_EMIT unassigned();

52+ }

53+}

54+

55+void Workspace::unassign()

56+{

57+ if (m_model) {

58+ m_model->remove(this);

59+ m_model = nullptr;

60+

61+ Q_EMIT unassigned();

62+ }

63+}

plugins/WindowManager/Workspace.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 WORKSPACE_H

18+#define WORKSPACE_H

19+

20+#include <QObject>

21+

22+class WorkspaceModel;

23+

24+class Workspace : public QObject

25+{

26+ Q_OBJECT

27+public:

28+ explicit Workspace(QObject *parent = 0);

29+ ~Workspace();

30+

31+ Q_INVOKABLE void assign(WorkspaceModel* model);

32+

33+public Q_SLOT:

34+ void unassign();

35+

36+Q_SIGNALS:

37+ void assigned();

38+ void unassigned();

39+

40+private:

41+ WorkspaceModel* m_model;

42+};

43+

44+#endif // WORKSPACE_H

plugins/WindowManager/WorkspaceManager.cppnew file+47

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+#include "WorkspaceManager.h"

18+#include "Workspace.h"

19+

20+// Qt

21+#include <QGuiApplication>

22+#include <QScreen>

23+#include <QQmlEngine>

24+

25+WorkspaceManager *WorkspaceManager::instance()

26+{

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

28+ return workspaceManager;

29+}

30+

31+WorkspaceManager::WorkspaceManager()

32+{

33+}

34+Workspace *WorkspaceManager::createWorkspace()

35+{

36+ auto workspace = new Workspace(this);

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

38+ m_allWorkspaces.append(workspace);

39+ workspace->assign(this);

40+ return workspace;

41+}

42+

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

44+{

45+ workspace->deleteLater();

46+}

47+

plugins/WindowManager/WorkspaceManager.hnew file+41

@@ -0,0 +1,41 @@

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+

22+class Workspace;

23+

24+class WorkspaceManager : public WorkspaceModel

25+{

26+ Q_OBJECT

27+public:

28+ static WorkspaceManager* instance();

29+

30+private:

31+ WorkspaceManager();

32+

33+public Q_SLOTS:

34+ Workspace* createWorkspace();

35+ void destroyWorkspace(Workspace* workspace);

36+

37+private:

38+ QVector<Workspace*> m_allWorkspaces;

39+};

40+

41+#endif // WORKSPACEMANAGER_H

plugins/WindowManager/WorkspaceModel.cppnew file+90

@@ -0,0 +1,90 @@

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

19+

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

21+

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

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

24+

25+WorkspaceModel::WorkspaceModel(QObject *parent)

26+ : QAbstractListModel(parent)

27+{

28+}

29+

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

31+{

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

33+}

34+

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

36+{

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

38+ m_workspaces.append(workspace);

39+ endInsertRows();

40+ Q_EMIT countChanged();

41+}

42+

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

44+{

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

46+ if (index < 0) return;

47+

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

49+ m_workspaces.removeAt(index);

50+ endRemoveRows();

51+ Q_EMIT countChanged();

52+}

53+

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

55+{

56+ if (from == to) return;

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

58+

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

60+ QModelIndex parent;

61+

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

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

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

65+ m_workspaces.insert(to, window);

66+#else

67+ m_workspaces.move(from, to);

68+#endif

69+ endMoveRows();

70+ Q_EMIT countChanged();

71+ }

72+}

73+

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

75+{

76+ return m_workspaces.count();

77+}

78+

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

80+{

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

82+ return QVariant();

83+

84+ if (role == WorkspaceRole) {

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

86+ return QVariant::fromValue(workspace);

87+ } else {

88+ return QVariant();

89+ }

90+}

plugins/WindowManager/WorkspaceModel.hnew file+63

@@ -0,0 +1,63 @@

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+

23+Q_DECLARE_LOGGING_CATEGORY(WORKSPACES)

24+

25+class Workspace;

26+

27+class WorkspaceModel : public QAbstractListModel

28+{

29+ Q_OBJECT

30+ Q_PROPERTY(int count READ rowCount NOTIFY countChanged)

31+public:

32+ /**

33+ * @brief The Roles supported by the model

34+ *

35+ * WorkspaceRole - A workspace.

36+ */

37+ enum Roles {

38+ WorkspaceRole = Qt::UserRole

39+ };

40+

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

42+

43+ void append(Workspace* workspace);

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

45+ void remove(Workspace* workspace);

46+ void move(int from, int to);

47+

48+ // From QAbstractItemModel

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

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

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

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

53+ return roleNames;

54+ }

55+

56+Q_SIGNALS:

57+ void countChanged();

58+

59+protected:

60+ QVector<Workspace*> m_workspaces;

61+};

62+

63+#endif // WORKSPACEMODEL_H

qml/CMakeLists.txt+1−1

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

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

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

22

33install(FILES ${QML_JS_FILES}

44 DESTINATION ${SHELL_APP_DIR}

qml/Components/PanelState/PanelState.qml−1

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

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

1515 */

1616

17−pragma Singleton

1817import QtQuick 2.4

1918

2019QtObject {

qml/Components/PanelState/qmldir+1−1

@@ -1 +1 @@

1−singleton PanelState 1.0 PanelState.qml

1+PanelState 1.0 PanelState.qml

qml/Components/VirtualTouchPad.qml+14−20

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

1818import QtQuick.Layouts 1.1

1919import Ubuntu.Components 1.3

2020import Qt.labs.settings 1.0

21−import Unity.Screens 0.1

21+import WindowManager 1.0

2222import UInput 0.1

2323import "../Components"

2424

2525Item {

2626 id: root

27− property var uinput: UInput {

28− Component.onCompleted: createMouse();

29− Component.onDestruction: removeMouse();

30− }

3127

3228 Component.onCompleted: {

29+ UInput.createMouse();

3330 if (!settings.touchpadTutorialHasRun) {

3431 root.runTutorial()

3532 }

3633 }

34+ Component.onDestruction: UInput.removeMouse()

3735

3836 function runTutorial() {

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

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

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

8684 && clickTimer.running) {

8785 clickTimer.stop();

88− uinput.pressMouse(UInput.ButtonLeft)

86+ UInput.pressMouse(UInput.ButtonLeft)

8987 isDoubleClick = true;

9088 }

9189 isClick = true;

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

104102

105103 onReleased: {

106104 if (isDoubleClick || isDrag) {

107− uinput.releaseMouse(UInput.ButtonLeft)

105+ UInput.releaseMouse(UInput.ButtonLeft)

108106 isDoubleClick = false;

109107 }

110108 if (isClick) {

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

120118 interval: 200

121119 property int button: UInput.ButtonLeft

122120 onTriggered: {

123− uinput.pressMouse(button);

124− uinput.releaseMouse(button);

121+ UInput.pressMouse(button);

122+ UInput.releaseMouse(button);

125123 }

126124 function scheduleClick(button) {

127125 clickTimer.button = button;

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

138136 isDrag = true;

139137 }

140138

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

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

142140 }

143141

144142 function scroll(touchPoints) {

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

166164 dh /= 2;

167165 dv /= 2;

168166

169− uinput.scrollMouse(dh, dv);

167+ UInput.scrollMouse(dh, dv);

170168 }

171169

172170 touchPoints: [

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

189187 objectName: "leftButton"

190188 Layout.fillWidth: true

191189 Layout.fillHeight: true

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

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

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

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

194192 property bool highlight: false

195193 UbuntuShape {

196194 anchors.fill: parent

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

204202 objectName: "rightButton"

205203 Layout.fillWidth: true

206204 Layout.fillHeight: true

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

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

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

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

209207 property bool highlight: false

210208 UbuntuShape {

211209 anchors.fill: parent

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

239237 }

240238 }

241239

242− Screens {

243− id: screens

244− }

245−

246240 InputMethod {

247241 id: inputMethod

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

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

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

250244 objectName: "inputMethod"

251245 anchors.fill: parent

252246 }

qml/DisabledScreenNotice.qml+2−1

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

2828 property var screen: Screen

2929 property var orientationLock: OrientationLock

3030

31+ property alias deviceConfiguration: _deviceConfiguration

3132 DeviceConfiguration {

32− id: deviceConfiguration

33+ id: _deviceConfiguration

3334 name: applicationArguments.deviceName

3435 }

3536

qml/Greeter/Greeter.qml+21−3

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

2525import Unity.Session 0.1

2626

2727import "." 0.1

28+import ".." 0.1

2829import "../Components"

2930

3031Showable {

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

227228 if (forcedUnlock && shown) {

228229 hideView();

229230 if (hideNow) {

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

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

231232 }

232233 }

233234 }

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

375376 onEmergencyCall: root.emergencyCall()

376377 onRequiredChanged: {

377378 if (!loader.item.required) {

378− root.hide();

379+ ShellNotifier.greeter.hide(false);

379380 }

380381 }

381382 }

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

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

499500 }

500501

502+ Connections {

503+ target: ShellNotifier.greeter

504+ onHide: {

505+ if (now) {

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

507+ } else {

508+ root.hide();

509+ }

510+ }

511+ }

512+

513+ Binding {

514+ target: ShellNotifier.greeter

515+ property: "shown"

516+ value: root.shown

517+ }

518+

501519 Connections {

502520 target: DBusUnitySessionService

503521 onLockRequested: root.forceShow()

504522 onUnlocked: {

505523 root.forcedUnlock = true;

506− root.hideNow();

524+ ShellNotifier.greeter.hide(true);

507525 }

508526 }

509527

qml/Greeter/SecondaryGreeter.qmlnew file+75

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation; version 3.

7+ *

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

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

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

11+ * GNU General Public License for more details.

12+ *

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

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

15+ */

16+

17+import QtQuick 2.4

18+import Ubuntu.Components 1.3

19+

20+import "../Components"

21+import ".." 0.1

22+

23+Showable {

24+ id: root

25+

26+ readonly property bool active: required || hasLockedApp

27+

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

29+ readonly property bool locked: false

30+ readonly property bool waiting: false

31+ readonly property bool fullyShown: shown

32+

33+ property string lockedApp: ""

34+

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

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

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

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

39+

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

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

42+

43+ shown: ShellNotifier.greeter.shown

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

45+ visible: opacity != 0

46+

47+ Rectangle {

48+ anchors.fill: parent

49+ color: UbuntuColors.purple

50+ }

51+

52+ MouseArea {

53+ anchors.fill: parent

54+ acceptedButtons: Qt.AllButtons

55+ onWheel: wheel.accepted = true

56+ }

57+

58+ Connections {

59+ target: ShellNotifier.greeter

60+ onHide: {

61+ if (now) {

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

63+ } else {

64+ root.hide();

65+ }

66+ }

67+ onShownChanged: {

68+ if (ShellNotifier.greeter.shown) {

69+ root.show();

70+ } else {

71+ root.hide();

72+ }

73+ }

74+ }

75+}

qml/OrientedShell.qml+8−10

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

1818import QtQuick.Window 2.2

1919import Unity.InputInfo 0.1

2020import Unity.Session 0.1

21−import Unity.Screens 0.1

21+import WindowManager 1.0

2222import Utils 0.1

2323import GSettings 1.0

2424import "Components"

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

3232 implicitWidth: units.gu(40)

3333 implicitHeight: units.gu(71)

3434

35+ property alias deviceConfiguration: _deviceConfiguration

36+ property alias orientations: d.orientations

37+ property alias surfaceManager: shell.surfaceManager

38+

3539 onWidthChanged: calculateUsageMode();

3640

3741 DeviceConfiguration {

38− id: deviceConfiguration

42+ id: _deviceConfiguration

3943 name: applicationArguments.deviceName

4044 }

4145

42− property alias orientations: d.orientations

43−

4446 Item {

4547 id: d

4648

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

157159 return false;

158160 }

159161

160− Screens {

161− id: screens

162− }

163−

164162 property int orientation

165163 onPhysicalOrientationChanged: {

166164 if (!orientationLocked) {

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

258256

259257 Shell {

260258 id: shell

261− objectName: "shell"

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

262260 width: root.width

263261 height: root.height

264262 orientation: root.angleToOrientation(orientationAngle)

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

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

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

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

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

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

276274 forceOSKEnabled

277275

278276 usageScenario: {

qml/Panel/Panel.qml+14−14

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

4747 property bool fullscreenMode: false

4848 property real panelAreaShowProgress: 1.0

4949 property bool greeterShown: false

50−

5150 property string mode: "staged"

51+ property PanelState panelState

5252

5353 MouseArea {

5454 id: backMouseEater

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

6565 }

6666

6767 Binding {

68− target: PanelState

68+ target: panelState

6969 property: "panelHeight"

7070 value: minimizedPanelHeight

7171 }

7272

7373 RegisteredApplicationMenuModel {

7474 id: registeredMenuModel

75− persistentSurfaceId: PanelState.focusedPersistentSurfaceId

75+ persistentSurfaceId: panelState.focusedPersistentSurfaceId

7676 }

7777

7878 QtObject {

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

8383 !indicators.shown &&

8484 (decorationMouseArea.containsMouse || menuBarLoader.menusRequested)

8585

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

87− PanelState.decorationsAlwaysVisible

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

87+ panelState.decorationsAlwaysVisible

8888

8989 property bool showPointerMenu: revealControls &&

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

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

9191

9292 property bool enablePointerMenu: revealControls &&

9393 applicationMenus.available &&

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

139139 fill: panelAreaBackground

140140 bottomMargin: -units.gu(1)

141141 }

142− visible: PanelState.dropShadow

142+ visible: panelState.dropShadow

143143 source: "graphics/rectangular_dropshadow.sci"

144144 }

145145

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

192192 visible: opacity != 0

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

194194

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

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

196196 windowIsMaximized: true

197− onCloseClicked: PanelState.closeClicked()

198− onMinimizeClicked: PanelState.minimizeClicked()

199− onMaximizeClicked: PanelState.restoreClicked()

200− closeButtonShown: PanelState.closeButtonShown

197+ onCloseClicked: panelState.closeClicked()

198+ onMinimizeClicked: panelState.minimizeClicked()

199+ onMaximizeClicked: panelState.restoreClicked()

200+ closeButtonShown: panelState.closeButtonShown

201201 }

202202

203203 Loader {

@@ -219,7 +219,7 @@ Item {

219219 anchors.left: parent.left

220220 anchors.margins: units.gu(1)

221221 height: menuBarLoader.height

222− enableKeyFilter: valid && PanelState.decorationsVisible

222+ enableKeyFilter: valid && panelState.decorationsVisible

223223 unityMenuModel: __applicationMenus.model

224224

225225 Connections {

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

267267 }

268268

269269 showRowTitle: !expanded

270− rowTitle: PanelState.title

270+ rowTitle: panelState.title

271271 rowItemDelegate: ActionItem {

272272 id: actionItem

273273 property int ownIndex: index

qml/Shell.qml+48−12

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

1−/*

1+/*

33 *

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

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

3838import "Stage"

3939import "Tutorial"

4040import "Wizard"

41+import "Components/PanelState"

4142import Unity.Notifications 1.0 as NotificationBackend

4243import Unity.Session 0.1

4344import Unity.DashCommunicator 0.1

4445import Unity.Indicators 0.1 as Indicators

4546import Cursor 1.1

4647import WindowManager 1.0

48+import Unity.Debug 0.1 as Debug

4749

4850

4951StyledItem {

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

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

5355

5456 // to be set from outside

57+ property alias surfaceManager: topLevelSurfaceList.surfaceManager

5558 property int orientationAngle: 0

5659 property int orientation

5760 property Orientations orientations

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

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

260263 }

261264

265+ PanelState {

266+ id: panelState

267+ objectName: "panelState"

268+ }

269+

262270 Item {

263271 id: stages

264272 objectName: "stages"

265273 width: parent.width

266274 height: parent.height

267275

268− SurfaceManager {

269− id: surfaceMan

270− objectName: "surfaceManager"

271− }

272276 TopLevelWindowModel {

273277 id: topLevelSurfaceList

274278 objectName: "topLevelSurfaceList"

275279 applicationManager: ApplicationManager // it's a singleton

276− surfaceManager: surfaceMan

277280 }

278281

279282 Stage {

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

315318 altTabPressed: physicalKeysMapper.altTabPressed

316319 oskEnabled: shell.oskEnabled

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

321+ panelState: panelState

318322

319323 onSpreadShownChanged: {

320324 panel.indicators.hide();

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

369373 objectName: "greeterLoader"

370374 anchors.fill: parent

371375 anchors.topMargin: panel.panelHeight

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

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

376+ sourceComponent: {

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

378+ if (screenWindow.primary) return integratedGreeter;

379+ return secondaryGreeter;

380+ }

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

382+ }

374383 onLoaded: {

375384 item.objectName = "greeter"

376385 }

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

420429 }

421430 }

422431

432+ Component {

433+ id: secondaryGreeter

434+ SecondaryGreeter {

435+ hides: [launcher, panel.indicators]

436+ }

437+ }

438+

423439 Timer {

424440 // See powerConnection for why this is useful

425441 id: showGreeterDelayed

@@ -533,6 +549,7 @@ StyledItem {

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

534550 || greeter.hasLockedApp

535551 greeterShown: greeter && greeter.shown

552+ panelState: panelState

536553 }

537554

538555 Launcher {

@@ -772,12 +789,13 @@ StyledItem {

772789

773790 Cursor {

774791 id: cursor

775− objectName: "cursor"

776− visible: shell.hasMouse

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

793+

777794 z: itemGrabber.z + 1

795+ opacity: 0

778796 topBoundaryOffset: panel.panelHeight

779−

780− confiningItem: stage.itemConfiningMouseCursor

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

798+ visible: enabled

781799

782800 property bool mouseNeverMoved: true

783801 Binding {

@@ -789,6 +807,8 @@ StyledItem {

789807 when: cursor.mouseNeverMoved && cursor.visible

790808 }

791809

810+ confiningItem: stage.itemConfiningMouseCursor

811+

792812 height: units.gu(3)

793813

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

@@ -875,4 +895,20 @@ StyledItem {

875895 }

876896 }

877897 }

898+

899+ Loader {

900+ z: shutdownFadeOutRectangle.z + 1

901+ active: DebuggingController.logOverlay

902+

903+ sourceComponent: Text {

904+ width: shell.width

905+ height: shell.height

906+

907+ text: consoleLog.out

908+ Debug.ConsoleLog {

909+ id: consoleLog

910+ enabled: true

911+ }

912+ }

913+ }

878914}

qml/ShellApplication.qmlnew file+52

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

1+/*

3+*

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

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

6+* the Free Software Foundation; version 3.

7+*

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

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

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

11+* GNU General Public License for more details.

12+*

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

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

15+*/

16+

17+import QtQuick 2.4

18+import QtQuick.Window 2.2

19+import WindowManager 1.0

20+import Unity.Application 0.1

21+

22+Instantiator {

23+ id: root

24+ model: Screens

25+

26+ property QtObject surfaceMan: SurfaceManager {}

27+

28+ ShellScreen {

29+ id: window

30+ objectName: "screen"+index

31+ screen: model.screen

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

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

34+ surfaceManager: surfaceMan

35+

36+ Binding {

37+ when: applicationArguments.hasGeometry

38+ target: window

39+ property: "width"

40+ value: applicationArguments.windowGeometry.width

41+ }

42+ Binding {

43+ when: applicationArguments.hasGeometry

44+ target: window

45+ property: "height"

46+ value: applicationArguments.windowGeometry.height

47+ }

48+

49+ Component.onCompleted: screen.active = primary

50+ primary: index == 0

51+ }

52+}

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

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

11/*

33 *

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

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

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

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

1515 */

1616

17−#ifndef UNITY_SECONDARY_WINDOW_H

18−#define UNITY_SECONDARY_WINDOW_H

19−

20−#include <QQuickView>

17+/*

18+ Shared signals & properties on multi-window desktop

19+ */

2120

22−class SecondaryWindow : public QQuickView

23−{

24− Q_OBJECT

21+pragma Singleton

22+import QtQuick 2.4

2523

26−public:

27− SecondaryWindow(QQmlEngine *engine);

28−};

24+QtObject {

25+ property var greeter: QtObject {

26+ signal hide(bool now)

2927

30−#endif // UNITY_SECONDARY_WINDOW_H

28+ property bool shown: true

29+ }

30+}

qml/ShellScreen.qmlnew file+65

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

1+/*

3+*

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

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

6+* the Free Software Foundation; version 3.

7+*

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

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

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

11+* GNU General Public License for more details.

12+*

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

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

15+*/

16+

17+import QtQuick 2.4

18+import Ubuntu.Components 1.3

19+import 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+ property QtObject surfaceManager: null

30+

31+ DeviceConfiguration {

32+ id: deviceConfiguration

33+ name: applicationArguments.deviceName

34+ }

35+

36+ Loader {

37+ width: screenWindow.width

38+ height: screenWindow.height

39+

40+ sourceComponent: {

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

42+ return disabledScreenComponent;

43+ }

44+ return shellComponent;

45+ }

46+ }

47+

48+ Component {

49+ id: shellComponent

50+ OrientedShell {

51+ implicitWidth: screenWindow.width

52+ implicitHeight: screenWindow.height

53+ surfaceManager: screenWindow.surfaceManager

54+

55+ deviceConfiguration {

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

57+ }

58+ }

59+ }

60+

61+ Component {

62+ id: disabledScreenComponent

63+ DisabledScreenNotice {}

64+ }

65+}

qml/Stage/DecoratedWindow.qml+3−1

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

7272

7373 readonly property Item clientAreaItem: applicationWindow

7474

75+ property PanelState panelState

76+

7577 signal closeClicked()

7678 signal maximizeClicked()

7779 signal maximizeHorizontallyClicked()

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

225227 enableMenus: {

226228 return active &&

227229 surface &&

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

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

229231 }

230232 menu: sharedAppModel.model

231233

qml/Stage/FakeMaximizeDelegate.qml+12−11

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

3535 property int leftMargin

3636 property real appContainerWidth

3737 property real appContainerHeight

38+ property PanelState panelState

3839

3940 readonly property real hintThreshold: 0.1

4041

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

178179 ParallelAnimation {

179180 id: fakeMaximizeAnimation

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

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

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

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

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

184185 }

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

186187 ParallelAnimation {

187188 id: fakeMaximizeLeftAnimation

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

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

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

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

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

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

192193 }

193194

194195 ParallelAnimation {

195196 id: fakeMaximizeRightAnimation

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

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

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

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

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

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

200201 }

201202

202203 ParallelAnimation {

203204 id: fakeMaximizeTopLeftAnimation

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

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

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

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

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

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

208209 }

209210

210211 ParallelAnimation {

211212 id: fakeMaximizeTopRightAnimation

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

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

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

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

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

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

216217 }

217218

218219 ParallelAnimation {

219220 id: fakeMaximizeBottomLeftAnimation

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

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

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

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

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

224225 }

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

226227 ParallelAnimation {

227228 id: fakeMaximizeBottomRightAnimation

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

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

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

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

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

232233 }

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

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

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Ubuntu.Components.Popups 1.3

4+import Unity.Screens 0.1

5+import Unity.Application 0.1

6+import ".."

7+

8+Item {

9+ id: root

10+

11+ property string background

12+

13+ Row {

14+ id: row

15+ anchors.bottom: parent.bottom

16+ anchors.horizontalCenter: parent.horizontalCenter

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

18+// anchors.left: parent.left

19+ spacing: units.gu(1)

20+

21+ Repeater {

22+ model: Screens

23+

24+ delegate: Item {

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

26+ width: workspaces.width

27+ clip: true

28+

29+ UbuntuShape {

30+ id: header

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

32+ height: units.gu(7)

33+ backgroundColor: "white"

34+ z: 1

35+

36+ DropArea {

37+ anchors.fill: parent

38+ keys: ["workspace"]

39+

40+ onEntered: {

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

42+ drag.source.inDropArea = true;

43+ }

44+

45+ onExited: {

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

47+ drag.source.inDropArea = false;

48+ }

49+

50+ onDropped: {

51+ drag.source.inDropArea = false;

52+ }

53+ }

54+

55+ Column {

56+ anchors.fill: parent

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

58+

59+ Label {

60+ text: model.screen.name

61+ color: "black"

62+ }

63+

64+ Label {

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

66+ color: "black"

67+ fontSize: "x-small"

68+ }

69+

70+ Label {

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

72+ color: "black"

73+ fontSize: "x-small"

74+ }

75+ }

76+

77+ MouseArea {

78+ anchors.fill: parent

79+// acceptedButtons: Qt.RightButton

80+

81+

82+ onClicked: {

83+ print("should open popup")

84+ PopupUtils.open(contextMenu)

85+ }

86+ }

87+

88+ Component {

89+ id: contextMenu

90+ ActionSelectionPopover {

91+ actions: ActionList {

92+ Action {

93+ text: "Add workspace"

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

95+ }

96+ }

97+ }

98+ }

99+ }

100+

101+

102+ Workspaces {

103+ id: workspaces

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

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

106+ Behavior on width { UbuntuNumberAnimation {} }

107+ anchors.bottom: parent.bottom

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

109+ anchors.horizontalCenter: parent.horizontalCenter

110+ screen: model.screen

111+ background: root.background

112+

113+ workspaceModel: ListModel {

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

115+ ListElement {text: "1"}

116+ ListElement {text: "2"}

117+ ListElement {text: "3"}

118+ ListElement {text: "4"}

119+ ListElement {text: "5"}

120+ ListElement {text: "6"}

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

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

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

124+ }

125+ }

126+ }

127+ }

128+ }

129+

130+ Rectangle {

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

132+ width: units.gu(5)

133+ color: "#33000000"

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

135+ MouseArea {

136+ id: leftScrollArea

137+ anchors.fill: parent

138+ hoverEnabled: true

139+ onPressed: mouse.accepted = false;

140+ }

141+ DropArea {

142+ id: leftFakeDropArea

143+ anchors.fill: parent

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

145+ }

146+ }

147+ Rectangle {

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

149+ width: units.gu(5)

150+ color: "#33000000"

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

152+ MouseArea {

153+ id: rightScrollArea

154+ anchors.fill: parent

155+ hoverEnabled: true

156+ onPressed: mouse.accepted = false;

157+ }

158+ DropArea {

159+ id: rightFakeDropArea

160+ anchors.fill: parent

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

162+ }

163+ }

164+ Timer {

165+ repeat: true

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

167+ interval: UbuntuAnimation.SlowDuration

168+ triggeredOnStart: true

169+ onTriggered: {

170+ var newOffset = row.anchors.horizontalCenterOffset;

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

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

173+ newOffset += units.gu(20)

174+ } else {

175+ newOffset -= units.gu(20)

176+ }

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

178+ row.anchors.horizontalCenterOffset = newOffset;

179+ }

180+ }

181+}

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

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

2828 property var spreadFlickable

2929

3030 // some config options

31− property real contentMargin: 0.16 * root.height

32− property real contentTopMargin: contentMargin

33− property real contentBottomMargin: 0.35 * contentMargin

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

31+ property real contentMargin: 0.1 * root.height

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

33+ property real contentBottomMargin: contentMargin

34+ property real windowTitleTopMargin: contentMargin - windowTitle.height

3535 property int stackItemCount: 3

3636 property real leftRotationAngle: 22

3737 property real rightRotationAngle: 32

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

5151

5252 readonly property real spreadWidth: rightStackXPos - leftStackXPos

5353 readonly property real spreadHeight: root.height

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

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

5555 readonly property real spreadItemWidth: stackHeight

5656

5757 readonly property real dynamicLeftRotationAngle: leftRotationAngle * rotationAngleFactor

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

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

8585 }

8686

8787 // Event eater

88− MouseArea {

89− anchors.fill: parent

90− onClicked: root.clicked()

91− onWheel: wheel.accepted = true

92− }

88+// MouseArea {

89+// anchors.fill: parent

90+// onClicked: root.clicked()

91+// onWheel: wheel.accepted = true

92+// }

9393

9494 MultiPointTouchArea {

9595 anchors.fill: parent

96− mouseEnabled: false

96+// mouseEnabled: false

9797 maximumTouchPoints: 1

9898 property int offset: 0

9999

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

109109 }

110110

111111 onTouchUpdated: {

112− if (!d.moving) {

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

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

114114 d.moving = true;

115115 d.dragEvents = []

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

119119 }

120120 }

121121

122− if (root.closeable) {

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

122+

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

124+ if (value < 0) {

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

126+ fakeDragItem.x = coords.x - units.gu(5)

127+ fakeDragItem.y = coords.y - units.gu(5)

128+ fakeDragItem.Drag.hotSpot.x = units.gu(5)

129+ fakeDragItem.Drag.hotSpot.y = units.gu(5)

130+ fakeDragItem.Drag.active = true;

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

132+

124133 } else {

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

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

134+ if (root.closeable) {

135+ d.distance = value

136+ } else {

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

138+ }

127139 }

128140

129141 d.pushDragEvent(tp);

130142 }

131143

132144 onReleased: {

145+ print("released!")

146+ fakeDragItem.surface = null;

147+

133148 if (!d.moving) {

134149 root.clicked()

135150 }

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

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

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Unity.Screens 0.1

4+import Unity.Application 0.1

5+import ".."

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

7+

8+Item {

9+ id: previewSpace

10+ clip: true

11+

12+ property string background

13+ property int screenHeight

14+

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

16+

17+ property bool containsDrag: false

18+

19+ Image {

20+ source: previewSpace.background

21+ anchors.fill: parent

22+ sourceSize.width: width

23+ sourceSize.height: height

24+

25+ Repeater {

26+ id: topLevelSurfaceRepeater

27+ model: visible ? topLevelSurfaceList : null

28+ delegate: Rectangle {

29+ width: surfaceItem.width

30+ height: surfaceItem.height + decorationHeight * previewScale

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

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

33+ color: "blue"

34+ z: topLevelSurfaceRepeater.count - index

35+

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

37+

38+ WindowDecoration {

39+ width: surfaceItem.implicitWidth

40+ height: parent.decorationHeight

41+ transform: Scale {

42+ origin.x: 0

43+ origin.y: 0

44+ xScale: previewScale

45+ yScale: previewScale

46+ }

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

48+ z: 3

49+ }

50+

51+ MirSurfaceItem {

52+ id: surfaceItem

53+ y: parent.decorationHeight * previewScale

54+ width: implicitWidth * previewScale

55+ height: implicitHeight * previewScale

56+ surfaceWidth: -1

57+ surfaceHeight: -1

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

59+ surface: model.window.surface

60+ }

61+ }

62+ }

63+

64+ }

65+

66+ Rectangle {

67+ anchors.fill: parent

68+ border.color: UbuntuColors.blue

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

70+ color: "transparent"

71+ visible: previewSpace.containsDrag

72+ }

73+}

74+

75+ // Repeater {

76+ // id: topLevelSurfaceRepeater

77+ // model: visible ? topLevelSurfaceList : null

78+ // delegate: Rectangle {

79+ // width: surfaceItem.width

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

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

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

83+ // color: "blue"

84+ // z: topLevelSurfaceRepeater.count - index

85+

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

87+

88+ // WindowDecoration {

89+ // width: surfaceItem.implicitWidth

90+ // height: parent.decorationHeight

91+ // transform: Scale {

92+ // origin.x: 0

93+ // origin.y: 0

94+ // xScale: previewScale

95+ // yScale: previewScale

96+ // }

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

98+ // z: 3

99+ // }

100+

101+ // MirSurfaceItem {

102+ // id: surfaceItem

103+ // y: parent.decorationHeight * previewScale

104+ // width: implicitWidth * previewScale

105+ // height: implicitHeight * previewScale

106+ // surfaceWidth: -1

107+ // surfaceHeight: -1

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

109+ // surface: model.window.surface

110+ // }

111+ // }

112+ // }

113+// }

114+// }

115+

116+

117+// MouseArea {

118+// id: mouseArea

119+// anchors.centerIn: parent

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

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

122+// height: width

123+// hoverEnabled: true

124+// opacity: containsMouse ? 1 : 0

125+

126+// Rectangle {

127+// anchors.fill: parent

128+// color: "#80000000"

129+// radius: height / 2

130+// }

131+

132+// NumberAnimation {

133+// target: canvas

134+// property: "progress"

135+// duration: 2000

136+// running: mouseArea.containsMouse

137+// from: 0

138+// to: 1

139+// }

140+

141+// Canvas {

142+// id: canvas

143+// height: parent.height

144+// width: height

145+// anchors.centerIn: parent

146+

147+// property real progress: 0.5

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

149+// onProgressChanged: {

150+// requestPaint();

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

152+// Screens.activateScreen(index);

153+// }

154+// }

155+

156+// rotation: -90

157+

158+// onPaint: {

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

160+// ctx.save();

161+// ctx.reset();

162+

163+// ctx.lineWidth = lineWidth;

164+

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

166+// ctx.beginPath();

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

168+// ctx.stroke();

169+// ctx.closePath();

170+

171+// ctx.strokeStyle = "white"

172+// ctx.beginPath();

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

174+// ctx.stroke();

175+// ctx.closePath();

176+

177+// ctx.restore();

178+// }

179+// }

180+

181+// Icon {

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

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

184+// width: height

185+// anchors.centerIn: parent

186+// }

187+// }

188+// }

189+

190+// FloatingFlickable {

191+// id: flickable

192+// anchors.fill: parent

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

194+// property real progress: contentX / contentWidth

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

196+// }

197+

198+// MouseArea {

199+// anchors.fill: parent

200+// hoverEnabled: true

201+// property int scrollAreaWidth: width / 3

202+

203+// onMouseXChanged: {

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

205+

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

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

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

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

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

211+// }

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

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

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

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

216+// }

217+// }

218+// }

219+// }

220+//}

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

@@ -0,0 +1,307 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import "MathUtils.js" as MathUtils

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

5+

6+Item {

7+ id: root

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

9+// color: "blue"

10+

11+ property QtObject screen: null

12+ property alias workspaceModel: listView.model

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

14+

15+ DropArea {

16+ anchors.fill: root

17+

18+ keys: ['workspace']

19+

20+ onEntered: {

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

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

23+ listView.dropItemIndex = index;

24+ drag.source.inDropArea = true;

25+ }

26+

27+ onPositionChanged: {

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

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

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

31+ listView.dropItemIndex = index;

32+ }

33+

34+ onExited: {

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

36+ listView.dropItemIndex = -1;

37+ drag.source.inDropArea = false;

38+ }

39+

40+ onDropped: {

41+ listView.dropItemIndex = -1;

42+ drag.source.inDropArea = false;

43+ }

44+ }

45+ DropArea {

46+ anchors.fill: parent

47+ keys: ["application"]

48+

49+ onPositionChanged: {

50+ listView.progressiveScroll(drag.x)

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

52+ }

53+ onExited: {

54+ listView.hoveredWorkspaceIndex = -1

55+ }

56+ }

57+

58+ ListView {

59+ id: listView

60+ anchors.fill: parent

61+ anchors.leftMargin: -itemWidth

62+ anchors.rightMargin: -itemWidth

63+// interactive: false

64+

65+ orientation: ListView.Horizontal

66+ spacing: units.gu(1)

67+ leftMargin: itemWidth

68+ rightMargin: itemWidth

69+

70+ property int itemWidth: height * 16 / 9

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

72+ property real realContentX: contentX - originX + leftMargin

73+ property int dropItemIndex: -1

74+ property int hoveredWorkspaceIndex: -1

75+

76+ function getDropIndex(drag) {

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

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

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

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

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

82+ return index;

83+ }

84+

85+ function progressiveScroll(mouseX) {

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

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

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

89+ }

90+

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

92+

93+ delegate: Item {

94+ objectName: "delegate" + index

95+ height: parent.height

96+ width: listView.itemWidth

97+ Behavior on width { UbuntuNumberAnimation {} }

98+ visible: listView.dropItemIndex !== index

99+

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

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

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

103+

104+ property int maxAngle: 40

105+

106+ property int itemAngle: {

107+ if (index == 0) {

108+ if (distanceFromLeft < 0) {

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

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

111+ }

112+ return 0

113+ }

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

115+ if (distanceFromRight < 0) {

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

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

118+ }

119+ return 0

120+ }

121+

122+ if (distanceFromLeft < listView.foldingAreaWidth) {

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

124+ var progress = distanceFromLeft / listView.foldingAreaWidth

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

126+ }

127+ if (distanceFromRight < listView.foldingAreaWidth) {

128+ var progress = distanceFromRight / listView.foldingAreaWidth

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

130+ }

131+ return 0

132+ }

133+

134+ property int itemOffset: {

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

136+ if (index == 0) {

137+ if (distanceFromLeft < 0) {

138+ return -distanceFromLeft - rotationOffset

139+ }

140+ return 0

141+ }

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

143+ if (distanceFromRight < 0) {

144+ return distanceFromRight + rotationOffset

145+ }

146+ return 0

147+ }

148+

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

150+ return -itemX - rotationOffset

151+ }

152+ if (distanceFromLeft < listView.foldingAreaWidth) {

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

154+ }

155+

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

157+ return distanceFromRight + rotationOffset

158+ }

159+

160+ if (distanceFromRight < listView.foldingAreaWidth) {

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

162+ }

163+

164+ return 0

165+ }

166+

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

168+

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

170+ transform: [

171+ Rotation {

172+ angle: itemAngle

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

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

175+ },

176+ Translate {

177+ x: itemOffset

178+ }

179+ ]

180+

181+ WorkspacePreview {

182+ height: listView.height

183+ width: listView.itemWidth

184+ background: root.background

185+ screenHeight: root.screen.physicalSize.height

186+ containsDrag: listView.hoveredWorkspaceIndex == index

187+

188+ Label {

189+ anchors.centerIn: parent

190+ text: model.text

191+ color: "red"

192+ fontSize: "large"

193+ }

194+ }

195+ }

196+

197+ MouseArea {

198+ id: mouseArea

199+ anchors.fill: parent

200+ hoverEnabled: true

201+ propagateComposedEvents: true

202+ anchors.leftMargin: listView.leftMargin

203+ anchors.rightMargin: listView.rightMargin

204+

205+ property int draggedIndex: -1

206+

207+ property int startX: 0

208+ property int startY: 0

209+

210+ onMouseXChanged: {

211+ if (!pressed || dragging) {

212+ listView.progressiveScroll(mouseX)

213+ }

214+ }

215+ onMouseYChanged: {

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

217+ drag.axis = Drag.XAndYAxis;

218+ }

219+ }

220+

221+ onReleased: {

222+ fakeDragItem.Drag.drop();

223+ drag.target = null;

224+ }

225+

226+ property bool dragging: drag.active

227+ onDraggingChanged: {

228+ if (drag.active) {

229+ print("drai", draggedIndex)

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

231+ }

232+ }

233+

234+ onPressed: {

235+ startX = mouseX;

236+ startY = mouseY;

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

238+

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

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

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

242+

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

244+ fakeDragItem.x = itemCoords.x

245+ fakeDragItem.y = itemCoords.y

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

247+

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

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

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

251+

252+ drag.axis = Drag.YAxis;

253+ drag.target = fakeDragItem;

254+ }

255+

256+ WorkspacePreview {

257+ id: fakeDragItem

258+ height: listView.height

259+ width: listView.itemWidth

260+ background: root.background

261+ screenHeight: root.screen.physicalSize.height

262+ visible: Drag.active

263+

264+ Drag.active: mouseArea.drag.active

265+ Drag.keys: ['workspace']

266+

267+ property string text

268+ property bool inDropArea: false

269+ Label {

270+ anchors.centerIn: parent

271+ text: parent.text

272+ color: "red"

273+ fontSize: "large"

274+ }

275+

276+ Rectangle {

277+ anchors.fill: parent

278+ color: "#33000000"

279+ opacity: parent.inDropArea ? 0 : 1

280+ Behavior on opacity { UbuntuNumberAnimation { } }

281+ Rectangle {

282+ anchors.centerIn: parent

283+ width: units.gu(6)

284+ height: units.gu(6)

285+ radius: width / 2

286+ color: "#aa000000"

287+ }

288+

289+ Icon {

290+ height: units.gu(3)

291+ width: height

292+ anchors.centerIn: parent

293+ name: "edit-delete"

294+ color: "white"

295+ }

296+ }

297+

298+ states: [

299+ State {

300+ when: fakeDragItem.Drag.active

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

302+ }

303+ ]

304+ }

305+ }

306+ }

307+}

qml/Stage/Stage.qml+138−103

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

4747 property bool oskEnabled: false

4848 property rect inputMethodRect

4949 property real rightEdgePushProgress: 0

50+ property PanelState panelState

5051

5152 // Configuration

5253 property string mode: "staged"

@@ -349,23 +350,23 @@ FocusScope {

349350 readonly property real virtualKeyboardHeight: root.inputMethodRect.height

350351 }

351352

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

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

353354

354355 Connections {

355− target: PanelState

356+ target: panelState

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

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

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

359360 }

360361

361362 Binding {

362− target: PanelState

363+ target: panelState

363364 property: "decorationsVisible"

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

365366 }

366367

367368 Binding {

368− target: PanelState

369+ target: panelState

369370 property: "title"

370371 value: {

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

@@ -380,7 +381,7 @@ FocusScope {

380381 }

381382

382383 Binding {

383− target: PanelState

384+ target: panelState

384385 property: "focusedPersistentSurfaceId"

385386 value: {

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

@@ -394,21 +395,21 @@ FocusScope {

394395 }

395396

396397 Binding {

397− target: PanelState

398+ target: panelState

398399 property: "dropShadow"

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

400401 }

401402

402403 Binding {

403− target: PanelState

404+ target: panelState

404405 property: "closeButtonShown"

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

406407 }

407408

408409 Component.onDestruction: {

409− PanelState.title = "";

410− PanelState.decorationsVisible = false;

411− PanelState.dropShadow = false;

410+ panelState.title = "";

411+ panelState.decorationsVisible = false;

412+ panelState.dropShadow = false;

412413 }

413414

414415 Instantiator {

@@ -454,6 +455,7 @@ FocusScope {

454455 PropertyChanges { target: cancelSpreadMouseArea; enabled: true }

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

456457 PropertyChanges { target: wallpaper; visible: false }

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

457459 },

458460 State {

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

@@ -502,10 +504,13 @@ FocusScope {

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

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

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

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

505508 },

506509 Transition {

507510 to: "spread"

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

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

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

509514 },

510515 Transition {

511516 from: "spread"

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

563568 visible: false

564569 }

565570

571+ ScreensAndWorkspaces {

572+ id: screensAndWorkspaces

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

574+ height: parent.height / 3

575+ background: root.background

576+ opacity: 0

577+ visible: opacity > 0

578+ }

579+

566580 Spread {

567581 id: spreadItem

568582 objectName: "spreadItem"

569− anchors.fill: appContainer

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

570584 leftMargin: root.leftMargin

571585 model: root.topLevelSurfaceList

572586 spreadFlickable: floatingFlickable

@@ -575,6 +589,83 @@ FocusScope {

575589 onLeaveSpread: {

576590 priv.goneToSpread = false;

577591 }

592+

593+ FloatingFlickable {

594+ id: floatingFlickable

595+ objectName: "spreadFlickable"

596+ anchors.fill: parent

597+ enabled: false

598+ contentWidth: spreadItem.spreadTotalWidth

599+

600+ function snap(toIndex) {

601+ var delegate = appRepeater.itemAt(toIndex)

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

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

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

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

606+ snapAnimation.start();

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

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

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

610+ snapAnimation.start();

611+ }

612+ }

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

614+ }

615+

616+ MouseArea {

617+ id: hoverMouseArea

618+ objectName: "hoverMouseArea"

619+ anchors.fill: parent

620+ propagateComposedEvents: true

621+ hoverEnabled: true

622+ enabled: false

623+ visible: enabled

624+

625+ property int scrollAreaWidth: width / 3

626+ property bool progressiveScrollingEnabled: false

627+

628+ onPressed: mouse.accepted = false

629+

630+ onMouseXChanged: {

631+ mouse.accepted = false

632+

633+ if (hoverMouseArea.pressed) {

634+ return;

635+ }

636+

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

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

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

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

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

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

643+ spreadItem.highlightedIndex = i;

644+ break;

645+ }

646+ }

647+

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

649+ var margins = floatingFlickable.width * 0.05;

650+

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

652+ progressiveScrollingEnabled = true

653+ }

654+

655+ // do we need to scroll?

656+ if (mouseX < scrollAreaWidth + margins) {

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

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

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

660+ }

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

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

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

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

665+ }

666+ }

667+ }

668+ }

578669 }

579670

580671 Connections {

@@ -669,10 +760,27 @@ FocusScope {

669760 }

670761 }

671762

763+ MirSurfaceItem {

764+ id: fakeDragItem

765+ property real previewScale: .5

766+ width: implicitWidth * previewScale

767+ height: implicitHeight * previewScale

768+ surfaceWidth: -1

769+ surfaceHeight: -1

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

771+ Behavior on opacity { UbuntuNumberAnimation {} }

772+ visible: opacity > 0

773+

774+ Drag.active: surface != null

775+ Drag.keys: ["application"]

776+

777+ z: 1000

778+ }

779+

672780 Item {

673781 id: boundariesForWindowPlacement

674782 anchors.fill: parent

675− anchors.topMargin: PanelState.panelHeight

783+ anchors.topMargin: panelState.panelHeight

676784 visible: false

677785 }

678786

@@ -704,6 +812,9 @@ FocusScope {

704812 }

705813 z: normalZ

706814

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

816+ Behavior on opacity { UbuntuNumberAnimation {} }

817+

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

708819 // match what the actual surface size is.

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

@@ -764,7 +875,7 @@ FocusScope {

764875 target: appDelegate

765876 property: "y"

766877 value: appDelegate.requestedY -

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

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

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

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

770881 && root.inputMethodRect.height > 0

@@ -1148,7 +1259,7 @@ FocusScope {

11481259 progress: 0

11491260 targetHeight: spreadItem.stackHeight

11501261 targetX: spreadMaths.targetX

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

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

11521263 targetY: spreadMaths.targetY

11531264 targetAngle: spreadMaths.targetAngle

11541265 targetScale: spreadMaths.targetScale

@@ -1267,9 +1378,9 @@ FocusScope {

12671378 PropertyChanges {

12681379 target: appDelegate

12691380 x: stageMaths.itemX

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

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

12711382 requestedWidth: appContainer.width

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

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

12731384 visuallyMaximized: true

12741385 visible: appDelegate.x < root.width

12751386 }

@@ -1295,10 +1406,10 @@ FocusScope {

12951406 PropertyChanges {

12961407 target: appDelegate

12971408 x: stageMaths.itemX

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

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

12991410 z: stageMaths.itemZ

13001411 requestedWidth: stageMaths.itemWidth

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

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

13021413 visuallyMaximized: true

13031414 visible: appDelegate.x < root.width

13041415 }

@@ -1363,9 +1474,9 @@ FocusScope {

13631474 PropertyChanges {

13641475 target: appDelegate

13651476 windowedX: root.leftMargin

1366− windowedY: PanelState.panelHeight

1477+ windowedY: panelState.panelHeight

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

1368− windowedHeight: appContainer.height - PanelState.panelHeight

1479+ windowedHeight: appContainer.height - panelState.panelHeight

13691480 }

13701481 },

13711482 State {

@@ -1382,9 +1493,9 @@ FocusScope {

13821493 PropertyChanges {

13831494 target: appDelegate

13841495 windowedX: root.leftMargin

1385− windowedY: PanelState.panelHeight

1496+ windowedY: panelState.panelHeight

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

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

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

13881499 }

13891500 },

13901501 State {

@@ -1401,7 +1512,7 @@ FocusScope {

14011512 PropertyChanges {

14021513 target: appDelegate

14031514 windowedX: root.leftMargin

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

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

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

14061517 windowedHeight: appContainer.height/2

14071518 }

@@ -1423,8 +1534,8 @@ FocusScope {

14231534 State {

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

14251536 extend: "normal"

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

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

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

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

14281539 },

14291540 State {

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

@@ -1540,7 +1651,7 @@ FocusScope {

15401651 ]

15411652

15421653 Binding {

1543− target: PanelState

1654+ target: panelState

15441655 property: "decorationsAlwaysVisible"

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

15461657 }

@@ -1785,83 +1896,7 @@ FocusScope {

17851896 leftMargin: root.leftMargin

17861897 appContainerWidth: appContainer.width

17871898 appContainerHeight: appContainer.height

1788− }

1789−

1790− MouseArea {

1791− id: hoverMouseArea

1792− objectName: "hoverMouseArea"

1793− anchors.fill: appContainer

1794− propagateComposedEvents: true

1795− hoverEnabled: true

1796− enabled: false

1797− visible: enabled

1798−

1799− property int scrollAreaWidth: width / 3

1800− property bool progressiveScrollingEnabled: false

1801−

1802− onMouseXChanged: {

1803− mouse.accepted = false

1804−

1805− if (hoverMouseArea.pressed) {

1806− return;

1807− }

1808−

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

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

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

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

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

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

1815− spreadItem.highlightedIndex = i;

1816− break;

1817− }

1818− }

1819−

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

1821− var margins = floatingFlickable.width * 0.05;

1822−

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

1824− progressiveScrollingEnabled = true

1825− }

1826−

1827− // do we need to scroll?

1828− if (mouseX < scrollAreaWidth + margins) {

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

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

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

1832− }

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

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

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

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

1837− }

1838− }

1839− }

1840−

1841− onPressed: mouse.accepted = false

1842− }

1843−

1844− FloatingFlickable {

1845− id: floatingFlickable

1846− objectName: "spreadFlickable"

1847− anchors.fill: appContainer

1848− enabled: false

1849− contentWidth: spreadItem.spreadTotalWidth

1850−

1851− function snap(toIndex) {

1852− var delegate = appRepeater.itemAt(toIndex)

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

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

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

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

1857− snapAnimation.start();

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

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

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

1861− snapAnimation.start();

1862− }

1863− }

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

1899+ panelState: root.panelState

18651900 }

18661901

18671902 PropertyAnimation {

qml/Stage/SurfaceContainer.qml+2

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

6666 fillMode: MirSurfaceItem.PadOrCrop

6767 consumesInput: true

6868

69+ onSurfaceChanged: print("surface changed", surface, implicitWidth, implicitHeight)

70+

6971 surfaceWidth: root.requestedWidth

7072 surfaceHeight: root.requestedHeight

7173

qml/Stage/WorkspacePreview.qmlnew file+212

@@ -0,0 +1,212 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Unity.Screens 0.1

4+import Unity.Application 0.1

5+import "../Components"

6+

7+UbuntuShape {

8+ id: previewSpace

9+

10+ // Set the height. this preview will then automatically adjust the width, keeping aspect ratio of the screen

11+ width: model.geometry.width * previewScale * 4

12+ color: "white"

13+ property string background

14+

15+ property int screenWidth: model.geometry.width

16+ property int screenHeight: model.geometry.height

17+ property real previewScale: (previewSpace.height - header.height) / previewSpace.screenHeight

18+

19+ Item {

20+ id: header

21+ anchors { left: parent.left; top: parent.top; right: parent.right }

22+ height: units.gu(7)

23+

24+ Column {

25+ anchors.fill: parent

26+ anchors.margins: units.gu(1)

27+

28+ Label {

29+ text: model.name

30+ color: "black"

31+ }

32+

33+ Label {

34+ text: model.outputType === Screens.LVDS ? "Built-in" : "Clone"

35+ color: "black"

36+ fontSize: "x-small"

37+ }

38+

39+ Label {

40+ text: model.geometry.width + "x" + model.geometry.height

41+ color: "black"

42+ fontSize: "x-small"

43+ }

44+ }

45+ }

46+

47+

48+ Rectangle {

49+ anchors.fill: parent

50+ anchors.topMargin: header.height

51+ color: "blue"

52+

53+ Repeater {

54+ id: workspaceRepeater

55+ model: 15

56+

57+ delegate: Item {

58+ x: index * previewSpace.screenWidth * previewScale

59+ height: previewSpace.screenHeight * previewScale

60+ width: previewSpace.screenWidth * previewScale

61+ clip: true

62+

63+ Wallpaper {

64+ source: previewSpace.background

65+ anchors.fill: parent

66+

67+ // Repeater {

68+ // id: topLevelSurfaceRepeater

69+ // model: visible ? topLevelSurfaceList : null

70+ // delegate: Rectangle {

71+ // width: surfaceItem.width

72+ // height: surfaceItem.height + decorationHeight * previewScale

73+ // x: model.window.position.x * previewScale

74+ // y: (model.window.position.y - decorationHeight) * previewScale

75+ // color: "blue"

76+ // z: topLevelSurfaceRepeater.count - index

77+

78+ // property int decorationHeight: units.gu(3)

79+

80+ // WindowDecoration {

81+ // width: surfaceItem.implicitWidth

82+ // height: parent.decorationHeight

83+ // transform: Scale {

84+ // origin.x: 0

85+ // origin.y: 0

86+ // xScale: previewScale

87+ // yScale: previewScale

88+ // }

89+ // title: model.window && model.window.surface ? model.window.surface.name : ""

90+ // z: 3

91+ // }

92+

93+ // MirSurfaceItem {

94+ // id: surfaceItem

95+ // y: parent.decorationHeight * previewScale

96+ // width: implicitWidth * previewScale

97+ // height: implicitHeight * previewScale

98+ // surfaceWidth: -1

99+ // surfaceHeight: -1

100+ // onImplicitHeightChanged: print("item", surfaceItem, "height changed", implicitHeight)

101+ // surface: model.window.surface

102+ // }

103+ // }

104+ // }

105+ }

106+ }

107+

108+

109+// MouseArea {

110+// id: mouseArea

111+// anchors.centerIn: parent

112+// anchors.verticalCenterOffset: header.height / 2

113+// width: units.gu(8)

114+// height: width

115+// hoverEnabled: true

116+// opacity: containsMouse ? 1 : 0

117+

118+// Rectangle {

119+// anchors.fill: parent

120+// color: "#80000000"

121+// radius: height / 2

122+// }

123+

124+// NumberAnimation {

125+// target: canvas

126+// property: "progress"

127+// duration: 2000

128+// running: mouseArea.containsMouse

129+// from: 0

130+// to: 1

131+// }

132+

133+// Canvas {

134+// id: canvas

135+// height: parent.height

136+// width: height

137+// anchors.centerIn: parent

138+

139+// property real progress: 0.5

140+// property int lineWidth: units.dp(4)

141+// onProgressChanged: {

142+// requestPaint();

143+// if (progress == 1) {

144+// Screens.activateScreen(index);

145+// }

146+// }

147+

148+// rotation: -90

149+

150+// onPaint: {

151+// var ctx = canvas.getContext("2d");

152+// ctx.save();

153+// ctx.reset();

154+

155+// ctx.lineWidth = lineWidth;

156+

157+// ctx.strokeStyle = "#3bffffff"

158+// ctx.beginPath();

159+// ctx.arc(canvas.width/2,canvas.height/2, (canvas.height - ctx.lineWidth) / 2, 0, (Math.PI*2),false);

160+// ctx.stroke();

161+// ctx.closePath();

162+

163+// ctx.strokeStyle = "white"

164+// ctx.beginPath();

165+// ctx.arc(canvas.width/2,canvas.height/2, (canvas.height - ctx.lineWidth) / 2, 0, (Math.PI*2*(progress)),false);

166+// ctx.stroke();

167+// ctx.closePath();

168+

169+// ctx.restore();

170+// }

171+// }

172+

173+// Icon {

174+// source: "graphics/multi-monitor_leave.png"

175+// height: units.gu(4)

176+// width: height

177+// anchors.centerIn: parent

178+// }

179+// }

180+ }

181+

182+ FloatingFlickable {

183+ id: flickable

184+ anchors.fill: parent

185+ contentWidth: workspaceRepeater.count * previewSpace.screenWidth * previewScale

186+ property real progress: contentX / contentWidth

187+ onContentXChanged: print("contentX:", contentX, "progress:", progress)

188+ }

189+

190+ MouseArea {

191+ anchors.fill: parent

192+ hoverEnabled: true

193+ property int scrollAreaWidth: width / 3

194+

195+ onMouseXChanged: {

196+ var margins = flickable.width * 0.05;

197+

198+ // do we need to scroll?

199+ if (mouseX < scrollAreaWidth + margins) {

200+ var progress = Math.min(1, (scrollAreaWidth + margins - mouseX) / (scrollAreaWidth - margins));

201+ var contentX = (1 - progress) * (flickable.contentWidth - flickable.width)

202+ flickable.contentX = Math.max(0, Math.min(flickable.contentX, contentX))

203+ }

204+ if (mouseX > flickable.width - scrollAreaWidth) {

205+ var progress = Math.min(1, (mouseX - (flickable.width - scrollAreaWidth)) / (scrollAreaWidth - margins))

206+ var contentX = progress * (flickable.contentWidth - flickable.width)

207+ flickable.contentX = Math.min(flickable.contentWidth - flickable.width, Math.max(flickable.contentX, contentX))

208+ }

209+ }

210+ }

211+ }

212+}

qml/Stage/graphics/multi-monitor_leave.pngnew file

Binary file not shown.

qml/qmldirnew file+1

@@ -0,0 +1 @@

1+singleton ShellNotifier 0.1 ShellNotifier.qml

src/ApplicationArguments.cpp+11−2

@@ -16,7 +16,16 @@

1616

1717#include "ApplicationArguments.h"

1818

19−ApplicationArguments::ApplicationArguments(QObject *parent)

20− : QObject(parent)

19+ApplicationArguments::ApplicationArguments(QCoreApplication *app)

20+ : QObject(app)

21+ , UnityCommandLineParser(*app)

2122{

2223}

24+

25+void ApplicationArguments::setDeviceName(const QString &deviceName)

26+{

27+ if (deviceName != m_deviceName) {

28+ m_deviceName = deviceName;

29+ Q_EMIT deviceNameChanged(m_deviceName);

30+ }

31+}

src/ApplicationArguments.h+17−15

@@ -23,31 +23,33 @@

2323#include <QSize>

2424#include <QString>

2525

26−class ApplicationArguments : public QObject

26+#include "UnityCommandLineParser.h"

27+

28+class ApplicationArguments : public QObject,

29+ public UnityCommandLineParser

2730{

2831 Q_OBJECT

2932 Q_PROPERTY(QString deviceName READ deviceName NOTIFY deviceNameChanged)

3033 Q_PROPERTY(QString mode READ mode CONSTANT)

34+

35+ Q_PROPERTY(bool hasGeometry READ hasGeometry CONSTANT)

36+ Q_PROPERTY(QSize windowGeometry READ windowGeometry CONSTANT)

37+ Q_PROPERTY(bool hasTestability READ hasTestability CONSTANT)

38+ Q_PROPERTY(bool hasFrameless READ hasFrameless CONSTANT)

39+ Q_PROPERTY(bool hasFullscreen READ hasFullscreen CONSTANT)

40+#ifdef UNITY8_ENABLE_TOUCH_EMULATION

41+ Q_PROPERTY(bool hasMouseToTouch READ hasMouseToTouch CONSTANT)

42+#endif

43+

3144public:

32− ApplicationArguments(QObject *parent = nullptr);

45+ ApplicationArguments(QCoreApplication *app);

3346

34− void setDeviceName(const QString &deviceName) {

35− if (deviceName != m_deviceName) {

36− m_deviceName = deviceName;

37− Q_EMIT deviceNameChanged(m_deviceName);

38− }

39− }

40− QString deviceName() const { return m_deviceName; }

47+ void setDeviceName(const QString &deviceName);

4148

42− void setMode(const QString &mode) { m_mode = mode; }

43− QString mode() const { return m_mode; }

49+ bool hasGeometry() const { return m_windowGeometry.isValid(); }

4450

4551Q_SIGNALS:

4652 void deviceNameChanged(const QString&);

47−

48−private:

49− QString m_deviceName;

50− QString m_mode;

5153};

5254

5355#endif // APPLICATION_ARGUMENTS_H

src/CMakeLists.txt+2−3

@@ -7,6 +7,7 @@ include_directories(

77 ${Qt5Gui_PRIVATE_INCLUDE_DIRS}

88 ${Qt5Quick_PRIVATE_INCLUDE_DIRS}

99 ${CONNECTIVITY_INCLUDE_DIRS}

10+ ${QTMIRSERVER_INCLUDE_DIRS}

1011)

1112

1213include_directories(

@@ -27,9 +28,7 @@ set(SOURCE_FILES

2728 ApplicationArguments.cpp

2829 main.cpp

2930 CachingNetworkManagerFactory.cpp

30− SecondaryWindow.cpp

3131 ShellApplication.cpp

32− ShellView.cpp

3332 UnityCommandLineParser.cpp

3433 UnixSignalHandler.cpp

3534 DebuggingController.cpp

@@ -47,7 +46,7 @@ qt5_use_modules(${SHELL_APP} DBus Gui Qml Quick Test)

4746if (NOT "${ANDROID_PROPERTIES_INCLUDE_DIRS}" STREQUAL "")

4847 set_target_properties(${SHELL_APP} PROPERTIES INCLUDE_DIRECTORIES ${ANDROID_PROPERTIES_INCLUDE_DIRS})

4948endif()

50−target_link_libraries(${SHELL_APP} ${ANDROID_PROPERTIES_LDFLAGS} UbuntuGestures connectivity-qt1 unity8-private)

49+target_link_libraries(${SHELL_APP} ${ANDROID_PROPERTIES_LDFLAGS} UbuntuGestures connectivity-qt1 unity8-private qtmirserver)

5150

5251if (ENABLE_TOUCH_EMULATION)

5352 target_link_libraries(${SHELL_APP} ${MOUSETOUCHADAPTOR_LIBS_LDFLAGS})

src/DebuggingController.cpp+12−1

@@ -49,7 +49,8 @@ public:

4949};

5050

5151DebuggingController::DebuggingController(QObject *parent):

52− UnityDBusObject(QStringLiteral("/com/canonical/Unity8/Debugging"), QStringLiteral("com.canonical.Unity8"), true, parent)

52+ UnityDBusObject(QStringLiteral("/com/canonical/Unity8/Debugging"), QStringLiteral("com.canonical.Unity8"), true, parent),

53+ m_logOverlay(false)

5354{

5455}

5556

@@ -90,3 +91,13 @@ void DebuggingController::SetLoggingFilterRules(const QString &filterRules)

9091{

9192 QLoggingCategory::setFilterRules(filterRules);

9293}

94+

95+void DebuggingController::SetLogOverlay(bool logOverlay)

96+{

97+ if (logOverlay == m_logOverlay) {

98+ return;

99+ }

100+

101+ m_logOverlay = logOverlay;

102+ Q_EMIT logOverlayChanged(m_logOverlay);

103+}

src/DebuggingController.h+14

@@ -32,10 +32,14 @@ class DebuggingController: public UnityDBusObject

3232 Q_OBJECT

3333 Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity8.Debugging")

3434

35+ Q_PROPERTY(bool logOverlay READ logOverlay NOTIFY logOverlayChanged)

36+

3537public:

3638 DebuggingController(QObject *parent = nullptr);

3739 ~DebuggingController() = default;

3840

41+ bool logOverlay() const { return m_logOverlay; }

42+

3943public Q_SLOTS:

4044 /**

4145 * Set the QSG_VISUALIZE mode. This follows the vlues supported by Qt in

@@ -53,5 +57,15 @@ public Q_SLOTS:

5357 */

5458 Q_SCRIPTABLE void SetLoggingFilterRules(const QString &filterRules);

5559

60+ /**

61+ * Enable/Disable the shell console log overlay

62+ */

63+ Q_SCRIPTABLE void SetLogOverlay(bool logOverlay);

64+

65+Q_SIGNALS:

66+ void logOverlayChanged(bool logOverlay);

67+

68+private:

69+ bool m_logOverlay;

5670};

5771#endif // DEBUGGINGCONTROLLER_H

src/SecondaryWindow.cppdeleted−40

@@ -1,40 +0,0 @@

1−/*

3− *

4− * This program is free software; you can redistribute it and/or modify

5− * it under the terms of the GNU General Public License as published by

6− * the Free Software Foundation; version 3.

7− *

8− * This program is distributed in the hope that it will be useful,

9− * but WITHOUT ANY WARRANTY; without even the implied warranty of

10− * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11− * GNU General Public License for more details.

12− *

13− * You should have received a copy of the GNU General Public License

14− * along with this program. If not, see <http://www.gnu.org/licenses/>.

15− */

16−

17−#include "SecondaryWindow.h"

18−

19−// local

20−#include <paths.h>

21−

22−#include <QQmlContext>

23−

24−SecondaryWindow::SecondaryWindow(QQmlEngine *engine)

25− : QQuickView(engine, nullptr)

26−{

27− QByteArray pxpguEnv = qgetenv("GRID_UNIT_PX");

28− bool ok;

29− int pxpgu = pxpguEnv.toInt(&ok);

30− if (!ok) {

31− pxpgu = 8;

32− }

33− engine->rootContext()->setContextProperty(QStringLiteral("internalGu"), pxpgu);

34− setResizeMode(QQuickView::SizeRootObjectToView);

35− setColor("black");

36− setTitle(QStringLiteral("Unity8 Shell - Secondary Screen"));

37−

38− QUrl source(::qmlDirectory() + "/DisabledScreenNotice.qml");

39− setSource(source);

40−}

src/ShellApplication.cpp+46−111

@@ -20,6 +20,7 @@

2020#include <QLibrary>

2121#include <QProcess>

2222#include <QScreen>

23+#include <QQmlContext>

2324

2425#include <libintl.h>

2526

@@ -32,32 +33,49 @@

3233#include "UnityCommandLineParser.h"

3334#include "DebuggingController.h"

3435

35−ShellApplication::ShellApplication(int & argc, char ** argv, bool isMirServer)

36− : QGuiApplication(argc, argv)

36+#include <QDebug>

37+

38+#include <qtmir/windowmanagementpolicy.h>

39+

40+class WindowManagementPolicy : public qtmir::WindowManagementPolicy

41+{

42+public:

43+ WindowManagementPolicy(const miral::WindowManagerTools &tools, qtmir::WindowManagementPolicyPrivate& dd)

44+ : qtmir::WindowManagementPolicy(tools, dd)

45+ {}

46+

47+// virtual void advise_adding_to_workspace(

48+// std::shared_ptr<miral::Workspace> const& workspace,

49+// std::vector<miral::Window> const& windows) override

50+// {

51+// }

52+

53+// virtual void advise_removing_from_workspace(

54+// std::shared_ptr<miral::Workspace> const& workspace,

55+// std::vector<miral::Window> const& windows) override

56+// {

57+// }

58+};

59+

60+

61+ShellApplication::ShellApplication(int & argc, char ** argv)

62+ : qtmir::MirServerApplication(argc, argv, {})

63+ , m_qmlArgs(this)

3764{

3865 setApplicationName(QStringLiteral("unity8"));

3966 setOrganizationName(QStringLiteral("Canonical"));

4067

41− connect(this, &QGuiApplication::screenAdded, this, &ShellApplication::onScreenAdded);

68+ setupQmlEngine();

4269

43− setupQmlEngine(isMirServer);

44−

45− UnityCommandLineParser parser(*this);

46−

47− if (!parser.deviceName().isEmpty()) {

48− m_deviceName = parser.deviceName();

49− } else {

70+ if (m_qmlArgs.deviceName().isEmpty()) {

5071 char buffer[200];

5172 property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);

52− m_deviceName = QString(buffer);

73+ m_qmlArgs.setDeviceName(QString(buffer));

5374 }

54− m_qmlArgs.setDeviceName(m_deviceName);

55−

56− m_qmlArgs.setMode(parser.mode());

5775

5876 // The testability driver is only loaded by QApplication but not by QGuiApplication.

5977 // 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")) {

78+ if (m_qmlArgs.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {

6179 QLibrary testLib(QStringLiteral("qttestability"));

6280 if (testLib.load()) {

6381 typedef void (*TasInitialize)(void);

@@ -75,57 +93,30 @@ ShellApplication::ShellApplication(int & argc, char ** argv, bool isMirServer)

7593 bindtextdomain("unity8", translationDirectory().toUtf8().data());

7694 textdomain("unity8");

7795

78− m_shellView = new ShellView(m_qmlEngine, &m_qmlArgs);

96+ m_qmlEngine->rootContext()->setContextProperty(QStringLiteral("applicationArguments"), &m_qmlArgs);

97+ m_qmlEngine->rootContext()->setContextProperty("DebuggingController", new DebuggingController(this));

7998

80− if (parser.windowGeometry().isValid()) {

81− m_shellView->setWidth(parser.windowGeometry().width());

82− m_shellView->setHeight(parser.windowGeometry().height());

99+ QByteArray pxpguEnv = qgetenv("GRID_UNIT_PX");

100+ bool ok;

101+ int pxpgu = pxpguEnv.toInt(&ok);

102+ if (!ok) {

103+ pxpgu = 8;

83104 }

84−

85− if (parser.hasFrameless()) {

86− m_shellView->setFlags(Qt::FramelessWindowHint);

87− }

88−

105+ m_qmlEngine->rootContext()->setContextProperty("internalGu", pxpgu);

106+ m_qmlEngine->load(::qmlDirectory() + "/ShellApplication.qml");

89107

90108 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

91109 // You will need this if you want to interact with touch-only components using a mouse

92110 // Needed only when manually testing on a desktop.

93− if (parser.hasMouseToTouch()) {

111+ if (m_qmlArgs.hasMouseToTouch()) {

94112 m_mouseTouchAdaptor = MouseTouchAdaptor::instance();

95113 }

96114 #endif

97115

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();

116+ if (m_qmlArgs.mode().compare("greeter") == 0) {

122117 if (!QProcess::startDetached("initctl emit --no-wait unity8-greeter-started")) {

123118 qDebug() << "Unable to send unity8-greeter-started event to Upstart";

124119 }

125− } else if (isMirServer || parser.hasFullscreen()) {

126− m_shellView->showFullScreen();

127− } else {

128− m_shellView->show();

129120 }

130121}

131122

@@ -136,14 +127,6 @@ ShellApplication::~ShellApplication()

136127

137128void ShellApplication::destroyResources()

138129{

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−

147130 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

148131 delete m_mouseTouchAdaptor;

149132 m_mouseTouchAdaptor = nullptr;

@@ -153,64 +136,16 @@ void ShellApplication::destroyResources()

153136 m_qmlEngine = nullptr;

154137}

155138

156−void ShellApplication::setupQmlEngine(bool isMirServer)

139+void ShellApplication::setupQmlEngine()

157140{

158− m_qmlEngine = new QQmlEngine(this);

141+ m_qmlEngine = new QQmlApplicationEngine(this);

159142

160143 m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));

161144

162145 prependImportPaths(m_qmlEngine, ::overrideImportPaths());

163− if (!isMirServer) {

164− prependImportPaths(m_qmlEngine, ::nonMirImportPaths());

165− }

166146 appendImportPaths(m_qmlEngine, ::fallbackImportPaths());

167147

168148 m_qmlEngine->setNetworkAccessManagerFactory(new CachingNetworkManagerFactory);

169149

170150 QObject::connect(m_qmlEngine, &QQmlEngine::quit, this, &QGuiApplication::quit);

171151}

172−

173−void ShellApplication::onScreenAdded(QScreen * /*screen*/)

174−{

175− // TODO: Support an arbitrary number of screens and different policies

176− // (eg cloned desktop, several desktops, etc)

177− if (screens().count() == 2) {

178− m_shellView->setScreen(screens().at(1));

179− m_qmlArgs.setDeviceName(QStringLiteral("desktop"));

180− // Changing the QScreen where a QWindow is drawn makes it also lose focus (besides having

181− // its backing QPlatformWindow recreated). So lets refocus it.

182− m_shellView->requestActivate();

183− // QWindow::destroy() is called when it changes between screens. We have to manually make it visible again

184− // <dandrader> This bug is supposedly fixed in Qt 5.5.1, although I can still reproduce it there. :-/

185− m_shellView->setVisible(true);

186−

187− m_secondaryWindow = new SecondaryWindow(m_qmlEngine);

188− m_secondaryWindow->setScreen(screens().at(0));

189−

190− // QWindow::showFullScreen() also calls QWindow::requestActivate() and we don't want that!

191− m_secondaryWindow->setWindowState(Qt::WindowFullScreen);

192− m_secondaryWindow->setVisible(true);

193− }

194−}

195−

196−void ShellApplication::onScreenAboutToBeRemoved(QScreen *screen)

197−{

198− // TODO: Support an arbitrary number of screens and different policies

199− // (eg cloned desktop, several desktops, etc)

200− if (screen == m_shellView->screen()) {

201− const QList<QScreen *> allScreens = screens();

202− Q_ASSERT(allScreens.count() > 1);

203− Q_ASSERT(allScreens.at(0) != screen);

204− Q_ASSERT(m_secondaryWindow);

205− delete m_secondaryWindow;

206− m_secondaryWindow = nullptr;

207− m_shellView->setScreen(allScreens.first());

208− m_qmlArgs.setDeviceName(m_deviceName);

209− // Changing the QScreen where a QWindow is drawn makes it also lose focus (besides having

210− // its backing QPlatformWindow recreated). So lets refocus it.

211− m_shellView->requestActivate();

212− // QWindow::destroy() is called when it changes between screens. We have to manually make it visible again

213− // <dandrader> This bug is supposedly fixed in Qt 5.5.1, although I can still reproduce it there. :-/

214− m_shellView->setVisible(true);

215− }

216−}

src/ShellApplication.h+6−16

@@ -18,7 +18,7 @@

1818#define SHELLAPPLICATION_H

1919

2020#include <QGuiApplication>

21−#include <QQmlEngine>

21+#include <QQmlApplicationEngine>

2222#include <QQuickView>

2323#include <QScopedPointer>

2424

@@ -28,36 +28,26 @@

2828#include "MouseTouchAdaptor.h"

2929#endif

3030

31−#include "SecondaryWindow.h"

32−#include "ShellView.h"

31+#include <qtmir/mirserverapplication.h>

3332

34−class ShellApplication : public QGuiApplication

33+class ShellApplication : public qtmir::MirServerApplication

3534{

3635 Q_OBJECT

3736public:

38− ShellApplication(int & argc, char ** argv, bool isMirServer);

37+ ShellApplication(int & argc, char ** argv);

3938 virtual ~ShellApplication();

4039

4140 void destroyResources();

42−public Q_SLOTS:

43− // called by qtmir

44− void onScreenAboutToBeRemoved(QScreen *screen);

45−

46−private Q_SLOTS:

47− void onScreenAdded(QScreen*);

4841

4942private:

50− void setupQmlEngine(bool isMirServer);

51− QString m_deviceName;

43+ void setupQmlEngine();

5244 ApplicationArguments m_qmlArgs;

53− ShellView *m_shellView{nullptr};

54− SecondaryWindow *m_secondaryWindow{nullptr};

5545

5646 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

5747 MouseTouchAdaptor *m_mouseTouchAdaptor{nullptr};

5848 #endif

5949

60− QQmlEngine *m_qmlEngine{nullptr};

50+ QQmlApplicationEngine *m_qmlEngine{nullptr};

6151};

6252

6353#endif // SHELLAPPLICATION_H

src/ShellView.cppdeleted−63

@@ -1,63 +0,0 @@

1−/*

3− *

4− * This program is free software; you can redistribute it and/or modify

5− * it under the terms of the GNU General Public License as published by

6− * the Free Software Foundation; version 3.

7− *

8− * This program is distributed in the hope that it will be useful,

9− * but WITHOUT ANY WARRANTY; without even the implied warranty of

10− * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11− * GNU General Public License for more details.

12− *

13− * You should have received a copy of the GNU General Public License

14− * along with this program. If not, see <http://www.gnu.org/licenses/>.

15− */

16−

17−#include "ShellView.h"

18−

19−// Qt

20−#include <QQmlContext>

21−#include <QQuickItem>

22−

23−// local

24−#include <paths.h>

25−

26−ShellView::ShellView(QQmlEngine *engine, QObject *qmlArgs)

27− : QQuickView(engine, nullptr)

28−{

29− setResizeMode(QQuickView::SizeRootObjectToView);

30− setColor("black");

31− setTitle(QStringLiteral("Unity8"));

32−

33− rootContext()->setContextProperty(QStringLiteral("applicationArguments"), qmlArgs);

34−

35− QUrl source(::qmlDirectory() + "/OrientedShell.qml");

36− setSource(source);

37−

38− connect(this, &QWindow::widthChanged, this, &ShellView::onWidthChanged);

39− connect(this, &QWindow::heightChanged, this, &ShellView::onHeightChanged);

40−}

41−

42−void ShellView::onWidthChanged(int w)

43−{

44− // For good measure in case SizeRootObjectToView doesn't fulfill its promise.

45− //

46− // There's at least one situation that's know to leave the root object with an outdated size.

47− // (really looks like Qt bug)

48− // Happens when starting unity8 with an external monitor already connected.

49− // The QResizeEvent we get still has the size of the first screen and since the resize move is triggered

50− // from the resize event handler, the root item doesn't get resized.

51− // TODO: Confirm the Qt bug and submit a patch upstream

52− if (rootObject()) {

53− rootObject()->setWidth(w);

54− }

55−}

56−

57−void ShellView::onHeightChanged(int h)

58−{

59− // See comment in ShellView::onWidthChanged()

60− if (rootObject()) {

61− rootObject()->setHeight(h);

62− }

63−}

src/UnityCommandLineParser.h+1−1

@@ -36,8 +36,8 @@ public:

3636 bool hasFullscreen() const { return m_hasFullscreen; }

3737 QString deviceName() const { return m_deviceName; }

3838 QString mode() const { return m_mode; }

39−private:

4039

40+protected:

4141 int parsePixelsValue(const QString &str);

4242 static float getenvFloat(const char* name, float defaultValue);

4343 void resolveMode(QCommandLineParser &parser, QCommandLineOption &modeOption);

src/main.cpp+1−7

@@ -27,17 +27,11 @@ int main(int argc, const char *argv[])

2727{

2828 qSetMessagePattern("[%{time yyyy-MM-dd:hh:mm:ss.zzz}] %{if-category}%{category}: %{endif}%{message}");

2929

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−

3630 if (enableQmlDebugger(argc, argv)) {

3731 QQmlDebuggingEnabler qQmlEnableDebuggingHelper(true);

3832 }

3933

40− ShellApplication *application = new ShellApplication(argc, (char**)argv, isMirServer);

34+ ShellApplication *application = new ShellApplication(argc, (char**)argv);

4135

4236 UnixSignalHandler signalHandler([]{

4337 QGuiApplication::exit(0);

tests/mocks/CMakeLists.txt+1

@@ -43,6 +43,7 @@ add_subdirectory(SessionBroadcast)

4343add_subdirectory(Ubuntu)

4444add_subdirectory(Unity)

4545add_subdirectory(QtMultimedia)

46+add_subdirectory(WindowManager)

4647add_subdirectory(Wizard)

4748add_subdirectory(Utils)

4849add_subdirectory(UInput)

tests/mocks/Cursor/Cursor.qml+49−2

@@ -15,8 +15,11 @@

1515 */

1616

1717import QtQuick 2.4

18+import UInput 0.1

19+

20+Canvas {

21+ id: root

1822

19−Item {

2023 property int topBoundaryOffset // effectively panel height

2124 property Item confiningItem

2225

@@ -30,5 +33,49 @@ Item {

3033 signal pushStopped()

3134 signal mouseMoved()

3235

33− onMouseMoved: opacity = 1;

36+ width: units.gu(2)

37+ height: units.gu(2)

38+ antialiasing: true

39+

40+ onPaint: {

41+ var ctx = getContext("2d");

42+ ctx.save();

43+ ctx.clearRect(0,0,width, height);

44+ ctx.strokeStyle = "#000000";

45+ ctx.lineWidth = 1

46+ ctx.fillStyle = "#ffffff";

47+ ctx.globalAlpha = 1.0;

48+ ctx.lineJoin = "round";

49+ ctx.beginPath();

50+

51+ // put rectangle in the middle

52+ // draw the rectangle

53+ ctx.moveTo(width/2,height);

54+ ctx.lineTo(width, height/2);

55+ ctx.lineTo(0,0);

56+

57+ ctx.closePath();

58+ ctx.fill();

59+ ctx.stroke();

60+ ctx.restore();

61+ }

62+

63+ Connections {

64+ target: UInput

65+ onMouseMoved: {

66+ var newX = root.x;

67+ newX += dx;

68+ if (newX < 0) newX = 0;

69+ else if (newX >= parent.width) newX = parent.width-1;

70+

71+ var newY = root.y;

72+ newY += dy;

73+ if (newY < 0) newY = 0;

74+ else if (newY >= parent.height) newY = parent.height-1;

75+

76+ root.x = newX;

77+ root.y = newY;

78+ root.mouseMoved();

79+ }

80+ }

3481}

tests/mocks/GSettings.1.0/plugin.cpp+12

@@ -18,6 +18,8 @@

1818#include "fake_gsettings.h"

1919

2020#include <QtQml/qqml.h>

21+#include <QQmlEngine>

22+#include <QQmlContext>

2123

2224static QObject* controllerProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)

2325{

@@ -31,3 +33,13 @@ void FakeGSettingsQmlPlugin::registerTypes(const char *uri)

3133 qmlRegisterUncreatableType<GSettingsSchemaQml>(uri, 1, 0, "GSettingsSchema",

3234 "GSettingsSchema can only be used inside of a GSettings component");

3335}

36+

37+void FakeGSettingsQmlPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

38+{

39+ QQmlExtensionPlugin::initializeEngine(engine, uri);

40+

41+ QString usageType = qgetenv("UNITY_MOCK_DESKTOP");

42+ if (!usageType.isEmpty()) {

43+ GSettingsControllerQml::instance()->setUsageMode("Windowed");

44+ }

45+}

tests/mocks/GSettings.1.0/plugin.h+1

@@ -26,6 +26,7 @@ class FakeGSettingsQmlPlugin : public QQmlExtensionPlugin

2626

2727public:

2828 void registerTypes(const char *uri) override;

29+ void initializeEngine(QQmlEngine *engine, const char *uri) override;

2930};

3031

3132#endif // PLUGIN_H

tests/mocks/UInput/plugin.cpp+6−1

@@ -19,8 +19,13 @@

1919

2020#include <QtQml/qqml.h>

2121

22+QObject* uinputSingleton(QQmlEngine*, QJSEngine*)

23+{

24+ return new MockUInput;

25+}

26+

2227void MockUInputPlugin::registerTypes(const char *uri)

2328{

2429 Q_ASSERT(uri == QLatin1String("UInput"));

25− qmlRegisterType<MockUInput>(uri, 0, 1, "UInput");

30+ qmlRegisterSingletonType<MockUInput>(uri, 0, 1, "UInput", uinputSingleton);

2631}

tests/mocks/Unity/Application/MirSurfaceItem.cpp+27−4

@@ -189,9 +189,15 @@ void MirSurfaceItem::createQmlContentItem()

189189 m_qmlItem = qobject_cast<QQuickItem*>(m_qmlContentComponent->create());

190190 m_qmlItem->setParentItem(this);

191191

192− m_qmlItem->setWidth(m_surfaceWidth);

193− m_qmlItem->setHeight(m_surfaceHeight);

192+ if (m_fillMode == FillMode::Stretch && width() != 0 && height() != 0) {

193+ m_qmlItem->setWidth(width());

194+ m_qmlItem->setHeight(height());

195+ } else {

196+ m_qmlItem->setWidth(m_surfaceWidth);

197+ m_qmlItem->setHeight(m_surfaceHeight);

198+ }

194199

200+ qDebug() << "set size to" << m_surfaceWidth;

195201 setImplicitWidth(m_qmlItem->implicitWidth());

196202 setImplicitHeight(m_qmlItem->implicitHeight());

197203

@@ -308,6 +314,16 @@ void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

308314 connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);

309315 connect(m_qmlSurface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);

310316 connect(m_qmlSurface, &MirSurface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);

317+ connect(m_qmlSurface, &MirSurface::sizeChanged, this, [this] () {

318+ if (m_fillMode == FillMode::Stretch) {

319+ m_qmlItem->setSize(QSize(this->width(), this->height()));

320+ } else {

321+ m_qmlItem->setSize(m_qmlSurface->size());

322+ }

323+ setImplicitSize(m_qmlSurface->width(), m_qmlSurface->height());

324+ });

325+ m_surfaceWidth = surface->size().width();

326+ m_surfaceHeight = surface->size().height();

311327

312328 QUrl qmlComponentFilePath;

313329 if (!m_qmlSurface->qmlFilePath().isEmpty()) {

@@ -321,6 +337,7 @@ void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

321337 switch (m_qmlContentComponent->status()) {

322338 case QQmlComponent::Ready:

323339 createQmlContentItem();

340+ qDebug() << "content created" << m_surfaceWidth << implicitWidth() << width();

324341 break;

325342 case QQmlComponent::Loading:

326343 connect(m_qmlContentComponent, &QQmlComponent::statusChanged,

@@ -399,9 +416,15 @@ void MirSurfaceItem::updateSurfaceSize()

399416 if (m_qmlSurface && m_surfaceWidth > 0 && m_surfaceHeight > 0) {

400417 m_qmlSurface->resize(m_surfaceWidth, m_surfaceHeight);

401418 if (m_qmlItem) {

402− m_qmlItem->setWidth(m_surfaceWidth);

403− m_qmlItem->setHeight(m_surfaceHeight);

419+ if (m_fillMode == FillMode::Stretch) {

420+ m_qmlItem->setWidth(width());

421+ m_qmlItem->setHeight(height());

422+ } else {

423+ m_qmlItem->setWidth(m_surfaceWidth);

424+ m_qmlItem->setHeight(m_surfaceHeight);

425+ }

404426 }

427+ qDebug() << this << "setting implicitsize" << m_surfaceWidth << m_surfaceHeight;

405428 setImplicitSize(m_surfaceWidth, m_surfaceHeight);

406429 }

407430}

tests/mocks/Unity/Application/SurfaceManager.cpp+1−1

@@ -21,7 +21,7 @@

2121

2222#include <paths.h>

2323

24−#define SURFACEMANAGER_DEBUG 0

24+#define SURFACEMANAGER_DEBUG 1

2525

2626#if SURFACEMANAGER_DEBUG

2727#define DEBUG_MSG(params) qDebug().nospace() << "SurfaceManager[" << (void*)this << "]::" << __func__ << params

tests/mocks/Unity/CMakeLists.txt−1

@@ -6,7 +6,6 @@ add_subdirectory(InputInfo)

66add_subdirectory(Launcher)

77add_subdirectory(Notifications)

88add_subdirectory(DashCommunicator)

9−add_subdirectory(Screens)

109add_subdirectory(Platform)

1110

1211pkg_search_module(GOBJECT gobject-2.0 REQUIRED)

tests/mocks/Unity/InputInfo/InputWindow.qmlnew file+68

@@ -0,0 +1,68 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Unity.InputInfo 0.1

4+

5+Rectangle {

6+ id: rect

7+ color: "white"

8+ width: parent.width

9+ height: parent.height

10+

11+ Action {

12+ id: mouseAction

13+ text: checked ? "Remove Mouse" : "Add Mouse"

14+ onTriggered: {

15+ if (checked) {

16+ console.log("ADD")

17+ MockInputDeviceBackend.addMockDevice("/mouse0", InputInfo.Mouse);

18+ } else {

19+ console.log("REMOVE")

20+ MockInputDeviceBackend.removeDevice("/mouse0");

21+ }

22+ }

23+ iconName: "input-mouse-symbolic"

24+ checkable: true

25+ checked: false

26+ }

27+

28+ Action {

29+ id: kbAction

30+ text: checked ? "Remove Keyboard" : "Add Keyboard"

31+ onTriggered: {

32+ if (checked) {

33+ MockInputDeviceBackend.addMockDevice("/kbd0", InputInfo.Keyboard);

34+ } else {

35+ MockInputDeviceBackend.removeDevice("/kbd0");

36+ }

37+ }

38+ iconName: "input-keyboard-symbolic"

39+ checkable: true

40+ checked: false

41+ }

42+

43+ Column {

44+ anchors {

45+ fill: parent

46+ margins: units.gu(1)

47+ }

48+ spacing: units.gu(1)

49+

50+ Button {

51+ anchors {

52+ left: parent.left

53+ right: parent.right

54+ }

55+ action: mouseAction

56+ color: mouseAction.checked ? UbuntuColors.red : UbuntuColors.green

57+ }

58+

59+ Button {

60+ anchors {

61+ left: parent.left

62+ right: parent.right

63+ }

64+ action: kbAction

65+ color: kbAction.checked ? UbuntuColors.red : UbuntuColors.green

66+ }

67+ }

68+}

tests/mocks/Unity/InputInfo/mockcontroller.cpp+24−2

@@ -18,10 +18,32 @@

1818

1919#include "qinputdeviceinfo_mock_p.h"

2020

21−MockController::MockController(QObject *parent):

22− QObject(parent)

21+#include <QQuickView>

22+#include <QQmlComponent>

23+#include <QQuickItem>

24+#include <paths.h>

25+

26+MockController::MockController(QQmlEngine *engine)

2327{

28+ QQmlComponent component(engine);

29+ component.setData("import QtQuick 2.4; import Unity.InputInfo 0.1; InputWindow { }", ::qmlDirectory());

30+ QObject *myObject = component.create();

31+ QQuickItem *item = qobject_cast<QQuickItem*>(myObject);

32+ if (item) {

33+ auto window = new QQuickView();

34+ window->setTitle("Input");

35+ item->setParentItem(window->contentItem());

36+ window->setResizeMode(QQuickView::SizeRootObjectToView);

37+ window->setWidth(200);

38+ window->setHeight(100);

39+ window->show();

40+ }

41+}

2442

43+MockController *MockController::instance(QQmlEngine *engine)

44+{

45+ static MockController* controller = new MockController(engine);

46+ return controller;

2547}

2648

2749QInputDevice *MockController::addMockDevice(const QString &devicePath, QInputDevice::InputType type)

tests/mocks/Unity/InputInfo/mockcontroller.h+5−1

@@ -20,13 +20,17 @@

2020#include <QObject>

2121#include "qinputinfo.h"

2222

23+class QQmlEngine;

24+

2325class MockController: public QObject

2426{

2527 Q_OBJECT

2628public:

27− MockController(QObject *parent = 0);

29+ MockController(QQmlEngine *engine);

2830 ~MockController() = default;

2931

32+ static MockController *instance(QQmlEngine *engine);

33+

3034 Q_INVOKABLE QInputDevice* addMockDevice(const QString &devicePath, QInputDevice::InputType type);

3135 Q_INVOKABLE void removeDevice(const QString &devicePath);

3236};

tests/mocks/Unity/InputInfo/plugin.cpp+1−2

@@ -26,9 +26,8 @@

2626

2727static QObject *backendProvider(QQmlEngine *engine, QJSEngine *scriptEngine)

2828{

29− Q_UNUSED(engine)

3029 Q_UNUSED(scriptEngine)

31− return new MockController(engine);

30+ return MockController::instance(engine);

3231}

3332

3433void InputInfoPlugin::registerTypes(const char *uri)

tests/mocks/Unity/InputInfo/qmldir+2

@@ -1,2 +1,4 @@

11module Unity.InputInfo

22plugin MockInputInfo

3+

4+InputWindow 0.1 InputWindow.qml

tests/mocks/Unity/Screens/CMakeLists.txtdeleted−14

@@ -1,14 +0,0 @@

1−include_directories(

2− ${CMAKE_CURRENT_SOURCE_DIR}

3−)

4−

5−set(MockScreens_SOURCES

6− plugin.cpp

7− screens.cpp

8−)

9−

10−add_library(MockScreensPlugin MODULE ${MockScreens_SOURCES})

11−

12−qt5_use_modules(MockScreensPlugin Gui Qml)

13−

14−add_unity8_mock(Unity.Screens 0.1 Unity/Screens PREFIX mocks TARGETS MockScreensPlugin)

tests/mocks/Unity/Screens/plugin.cppdeleted−29

@@ -1,29 +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 "plugin.h"

18−#include "screens.h"

19−

20−#include <QScreen>

21−

22−void UnityScreensPlugin::registerTypes(const char* uri)

23−{

24− Q_ASSERT(QLatin1String(uri) == QLatin1String("Unity.Screens"));

25−

26− qRegisterMetaType<QScreen*>("QScreen*");

27−

28− qmlRegisterType<Screens>(uri, 0, 1, "Screens");

29−}

tests/mocks/Unity/Screens/plugin.hdeleted−25

@@ -1,25 +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 <QQmlExtensionPlugin>

18−#include <QtQml/qqml.h>

19−

20−class UnityScreensPlugin : public QQmlExtensionPlugin {

21− Q_OBJECT

22− Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface/1.0")

23−public:

24− void registerTypes(const char* uri) override;

25−};

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/WindowManager/CMakeLists.txtnew file+35

@@ -0,0 +1,35 @@

1+include_directories(

2+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager

3+)

4+

5+include_directories(

6+ SYSTEM

7+ ${QTMIRSERVER_INCLUDE_DIRS}

8+)

9+

10+set(WINDOWMANAGER_SRC

11+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/TopLevelWindowModel.cpp

12+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Window.cpp

13+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Workspace.cpp

14+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/WorkspaceManager.cpp

15+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/WorkspaceModel.cpp

16+ WindowManagerPlugin.cpp

17+ Screens.cpp

18+ Screen.cpp

19+ ScreenWindow.cpp

20+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h

21+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h

22+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h

23+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceListInterface.h

24+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/SurfaceManagerInterface.h

25+)

26+

27+add_library(MockWindowManager-qml SHARED ${WINDOWMANAGER_SRC})

28+

29+target_link_libraries(MockWindowManager-qml

30+ ${QTMIRSERVER_LDFLAGS}

31+)

32+

33+qt5_use_modules(MockWindowManager-qml Qml Quick Gui)

34+

35+add_unity8_mock(WindowManager 1.0 WindowManager TARGETS MockWindowManager-qml)

tests/mocks/WindowManager/Screen.cppnew file+65

@@ -0,0 +1,65 @@

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 "WorkspaceModel.h"

19+#include "WorkspaceManager.h"

20+#include "Workspace.h"

21+

22+Screen::Screen()

23+ : m_workspaces(new WorkspaceModel)

24+{

25+ WorkspaceManager::instance()->createWorkspace()->assign(m_workspaces.data());

26+ WorkspaceManager::instance()->createWorkspace()->assign(m_workspaces.data());

27+}

28+

29+QQmlListProperty<qtmir::ScreenMode> Screen::availableModes()

30+{

31+ return QQmlListProperty<qtmir::ScreenMode>(this, m_sizes);

32+}

33+

34+qtmir::ScreenConfiguration *Screen::beginConfiguration() const

35+{

36+ auto config = new qtmir::ScreenConfiguration;

37+ config->valid = true;

38+ config->id = m_id;

39+ config->used = m_used;

40+ config->topLeft = m_position;

41+ config->currentModeIndex = m_currentModeIndex;

42+ config->powerMode = m_powerMode;

43+ config->scale = m_scale;

44+ config->formFactor = m_formFactor;

45+ return config;

46+}

47+

48+bool Screen::applyConfiguration(qtmir::ScreenConfiguration *configuration)

49+{

50+ m_used = configuration->used;

51+ m_position = configuration->topLeft;

52+ m_currentModeIndex = configuration->currentModeIndex;

53+ m_powerMode = configuration->powerMode;

54+ m_scale = configuration->scale;

55+ m_formFactor = configuration->formFactor;

56+

57+// m_orientation = configuration->orientation;

58+ return true;

59+}

60+

61+void Screen::setActive(bool active)

62+{

63+ m_active = active;

64+ Q_EMIT activeChanged(active);

65+}

tests/mocks/WindowManager/Screen.hnew file+56

@@ -0,0 +1,56 @@

1+#ifndef MOCK_SCREEN_H

2+#define MOCK_SCREEN_H

3+

4+#include <qtmir/screen.h>

5+#include <QScopedPointer>

6+

7+class WorkspaceModel;

8+

9+class Screen : public qtmir::Screen

10+{

11+ Q_OBJECT

12+ Q_PROPERTY(WorkspaceModel* workspaces READ workspaces CONSTANT)

13+

14+public:

15+ Screen();

16+

17+ qtmir::OutputId outputId() const override { return m_id; }

18+ bool used() const override { return m_used; }

19+ QString name() const override { return m_name; }

20+ float scale() const override { return m_scale; }

21+ QSizeF physicalSize() const override { return m_physicalSize; }

22+ qtmir::FormFactor formFactor() const override { return m_formFactor; }

23+ qtmir::OutputTypes outputType() const override { return m_outputType; }

24+ MirPowerMode powerMode() const override { return m_powerMode; }

25+ Qt::ScreenOrientation orientation() const override { return m_orientation; }

26+ QPoint position() const override { return m_position; }

27+ QQmlListProperty<qtmir::ScreenMode> availableModes() override;

28+ uint currentModeIndex() const override { return m_currentModeIndex; }

29+ bool isActive() const override { return m_active; }

30+ void setActive(bool active) override;

31+

32+ QScreen* qscreen() const override { return nullptr; }

33+

34+ qtmir::ScreenConfiguration *beginConfiguration() const override;

35+ bool applyConfiguration(qtmir::ScreenConfiguration *configuration) override;

36+

37+ WorkspaceModel* workspaces() const { return m_workspaces.data(); }

38+

39+public:

40+ qtmir::OutputId m_id{0};

41+ bool m_active{false};

42+ bool m_used{true};

43+ QString m_name;

44+ qtmir::OutputTypes m_outputType{qtmir::Unknown};

45+ MirPowerMode m_powerMode{mir_power_mode_on};

46+ Qt::ScreenOrientation m_orientation{Qt::PrimaryOrientation};

47+ float m_scale{1.0};

48+ qtmir::FormFactor m_formFactor{qtmir::FormFactorMonitor};

49+ QPoint m_position;

50+ uint m_currentModeIndex{0};

51+ QList<qtmir::ScreenMode*> m_sizes;

52+ QSizeF m_physicalSize;

53+ const QScopedPointer<WorkspaceModel> m_workspaces;

54+};

55+

56+#endif // MOCK_SCREEN_H

tests/mocks/WindowManager/ScreenWindow.cppnew file+48

@@ -0,0 +1,48 @@

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+ if (qGuiApp->platformName() != QLatin1String("mirserver")) {

28+ qCritical("Not using 'mirserver' QPA plugin. Using ScreenWindow may produce unknown results.");

29+ }

30+}

31+

32+ScreenWindow::~ScreenWindow()

33+{

34+}

35+

36+Screen *ScreenWindow::screenWrapper() const

37+{

38+ return m_screen.data();

39+}

40+

41+void ScreenWindow::setScreenWrapper(Screen *screen)

42+{

43+ if (m_screen != screen) {

44+ m_screen = screen;

45+ Q_EMIT screenWrapperChanged();

46+ }

47+ QQuickWindow::setScreen(screen->qscreen());

48+}

tests/mocks/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();

44+

45+private:

46+ QPointer<Screen> m_screen;

47+};

48+

49+#endif // UNITY_SCREENWINDOW_H

tests/mocks/WindowManager/Screens.cppnew file+101

@@ -0,0 +1,101 @@

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+

20+// qtmirserver

21+#include <qtmir/qtmir.h>

22+#include <qtmir/screens.h>

23+#include <QGuiApplication>

24+

25+// Qt

26+#include <QScreen>

27+#include <QWindow>

28+

29+Screens::Screens(QObject *parent)

30+ : QAbstractListModel(parent)

31+{

32+ bool ok = false;

33+ int screenCount = qEnvironmentVariableIntValue("UNITY_MOCK_SCREEN_COUNT", &ok);

34+ if (!ok) screenCount = 1;

35+ QPoint lastPoint(0,0);

36+ for (int i = 0; i < screenCount; ++i) {

37+ auto screen = new Screen();

38+ screen->m_id = qtmir::OutputId{i};

39+ screen->m_active = i == 0;

40+ screen->m_name = QString("Monitor %1").arg(i);

41+ screen->m_position = QPoint(lastPoint.x(), lastPoint.y());

42+ screen->m_sizes.append(new qtmir::ScreenMode(50, QSize(640,480)));

43+ screen->m_sizes.append(new qtmir::ScreenMode(60, QSize(1280,1024)));

44+ screen->m_sizes.append(new qtmir::ScreenMode(60, QSize(1440,900)));

45+ screen->m_sizes.append(new qtmir::ScreenMode(60, QSize(1920,1080)));

46+ screen->m_currentModeIndex = 3;

47+ screen->m_physicalSize = QSize(800,568);

48+ m_screenList.append(screen);

49+

50+ lastPoint.rx() += screen->m_sizes[screen->m_currentModeIndex]->size.width();

51+ }

52+}

53+

54+QHash<int, QByteArray> Screens::roleNames() const

55+{

56+ QHash<int, QByteArray> roles;

57+ roles[ScreenRole] = "screen";

58+ return roles;

59+}

60+

61+QVariant Screens::data(const QModelIndex &index, int role) const

62+{

63+ if (!index.isValid() || index.row() >= m_screenList.size()) {

64+ return QVariant();

65+ }

66+

67+ switch(role) {

68+ case ScreenRole:

69+ return QVariant::fromValue(m_screenList.at(index.row()));

70+ } // switch

71+

72+ return QVariant();

73+}

74+

75+int Screens::rowCount(const QModelIndex &) const

76+{

77+ return count();

78+}

79+

80+int Screens::count() const

81+{

82+ return m_screenList.size();

83+}

84+

85+QVariant Screens::activeScreen() const

86+{

87+ for (int i = 0; i < m_screenList.count(); i++) {

88+ if (m_screenList[i]->isActive()) return i;

89+ }

90+ return QVariant();

91+}

92+

93+void Screens::activateScreen(const QVariant& vindex)

94+{

95+ bool ok = false;

96+ int index = vindex.toInt(&ok);

97+ if (!ok || index < 0 || m_screenList.count() <= index) return;

98+

99+ auto screen = m_screenList.at(index);

100+ screen->setActive(true);

101+}

tests/mocks/Unity/Screens/screens.h → tests/mocks/WindowManager/Screens.hrenamed+20−37

@@ -1,5 +1,5 @@

11/*

33 *

44 * This program is free software: you can redistribute it and/or modify it under

55 * the terms of the GNU Lesser General Public License version 3, as published by

@@ -14,47 +14,31 @@

1414 * along with this program. If not, see <http://www.gnu.org/licenses/>.

1515 */

1616

17−#ifndef SCREENS_H

18−#define SCREENS_H

17+#ifndef UNITY_SCREENS_H

18+#define UNITY_SCREENS_H

1919

2020#include <QAbstractListModel>

21−#include <QScreen>

21+#include <QSharedPointer>

2222

2323class Screen;

24+namespace qtmir

25+{

26+class Screens;

27+}

2428

2529class Screens : public QAbstractListModel

2630{

2731 Q_OBJECT

28−

2932 Q_PROPERTY(int count READ count NOTIFY countChanged)

33+ Q_PROPERTY(QVariant activeScreen READ activeScreen WRITE activateScreen NOTIFY activeScreenChanged)

3034

3135public:

3236 enum ItemRoles {

33− ScreenRole = Qt::UserRole + 1,

34− OutputTypeRole

37+ ScreenRole = Qt::UserRole + 1

3538 };

3639

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−

5640 explicit Screens(QObject *parent = 0);

57− virtual ~Screens() noexcept;

41+ virtual ~Screens() noexcept = default;

5842

5943 /* QAbstractItemModel */

6044 QHash<int, QByteArray> roleNames() const override;

@@ -62,21 +46,20 @@ public:

6246 int rowCount(const QModelIndex &parent = QModelIndex()) const override;

6347

6448 int count() const;

49+ QVariant activeScreen() const;

50+

51+public Q_SLOTS:

52+ void activateScreen(const QVariant& index);

6553

6654Q_SIGNALS:

6755 void countChanged();

68− void screenAdded(QScreen *screen);

69− void screenRemoved(QScreen *screen);

56+ void activeScreenChanged();

7057

71−private:

72− QList<Screen *> m_screenList;

73−};

58+ void screenAdded(Screen* screen);

59+ void screenRemoved(Screen* screen);

7460

75−class Screen

76−{

77−public:

78− Screens::OutputTypes outputTypes = Screens::Unknown;

79− QScreen *qScreen = nullptr;

61+private:

62+ QList<Screen*> m_screenList;

8063};

8164

8265#endif // SCREENS_H

tests/mocks/WindowManager/WindowManagerPlugin.cppnew file+58

@@ -0,0 +1,58 @@

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 "Screens.h"

20+#include "Screen.h"

21+#include "ScreenWindow.h"

22+#include "TopLevelWindowModel.h"

23+#include "Window.h"

24+#include "WorkspaceManager.h"

25+#include "Workspace.h"

26+#include "WorkspaceModel.h"

27+

28+#include <QtQml>

29+

30+static QObject *workspace_manager(QQmlEngine *engine, QJSEngine *scriptEngine)

31+{

32+ Q_UNUSED(engine)

33+ Q_UNUSED(scriptEngine)

34+ return WorkspaceManager::instance();

35+}

36+QObject* screensSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {

37+ Q_UNUSED(engine);

38+ Q_UNUSED(scriptEngine);

39+ return new Screens();

40+}

41+

42+void WindowManagerPlugin::registerTypes(const char *uri)

43+{

44+ qmlRegisterType<TopLevelWindowModel>(uri, 1, 0, "TopLevelWindowModel");

45+ qmlRegisterSingletonType<WorkspaceManager>(uri, 1, 0, "WorkspaceManager", workspace_manager);

46+ qmlRegisterUncreatableType<WorkspaceModel>(uri, 1, 0, "WorkspaceModel", "Not a creatable type");

47+ qmlRegisterSingletonType<Screens>(uri, 1, 0, "Screens", screensSingleton);

48+ qmlRegisterUncreatableType<qtmir::ScreenMode>(uri, 1, 0, "ScreenMode", "ScreenMode is not creatable.");

49+

50+ qRegisterMetaType<Window*>("Window*");

51+ qRegisterMetaType<Workspace*>("Workspace*");

52+

53+ qRegisterMetaType<QAbstractListModel*>("QAbstractListModel*");

54+ qRegisterMetaType<Screen*>("Screen*");

55+

56+ qmlRegisterType<ScreenWindow>(uri, 1, 0, "ScreenWindow");

57+ qmlRegisterRevision<QWindow,1>(uri, 1, 0);

58+}

tests/mocks/WindowManager/WindowManagerPlugin.hnew file+32

@@ -0,0 +1,32 @@

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+};

31+

32+#endif // WINDOWMANAGER_PLUGIN_H

tests/mocks/WindowManager/qmldirnew file+2

@@ -0,0 +1,2 @@

1+module WindowManager

2+plugin MockWindowManager-qml

tests/qmltests/Components/tst_VirtualTouchPad.qml+2−2

@@ -39,11 +39,11 @@ Rectangle {

3939

4040 SignalSpy {

4141 id: mouseEventSpy1

42− target: touchScreenPad.uinput

42+ target: UInput

4343 }

4444 SignalSpy {

4545 id: mouseEventSpy2

46− target: touchScreenPad.uinput

46+ target: UInput

4747 }

4848

4949 UnityTestCase {

tests/qmltests/Panel/tst_Panel.qml+14−12

@@ -42,6 +42,8 @@ PanelTest {

4242 value: keyboardAttached.checked

4343 }

4444

45+ readonly property alias panelState: panel.panelState

46+

4547 SurfaceManager { id: sMgr }

4648 ApplicationMenuDataLoader {

4749 id: appMenuData

@@ -148,7 +150,7 @@ PanelTest {

148150 Layout.fillWidth: true

149151 CheckBox {

150152 id: windowControlsCB

151− onClicked: PanelState.decorationsVisible = checked

153+ onClicked: panelState.decorationsVisible = checked

152154 }

153155 Label {

154156 text: "Show window decorations"

@@ -159,7 +161,7 @@ PanelTest {

159161 RowLayout {

160162 Layout.fillWidth: true

161163 CheckBox {

162− onClicked: PanelState.title = checked ? "Fake window title" : ""

164+ onClicked: panelState.title = checked ? "Fake window title" : ""

163165 }

164166 Label {

165167 text: "Show fake window title"

@@ -245,7 +247,7 @@ PanelTest {

245247

246248 SignalSpy {

247249 id: windowControlButtonsSpy

248− target: PanelState

250+ target: panelState

249251 signalName: "closeClicked"

250252 }

251253

@@ -255,8 +257,8 @@ PanelTest {

255257 panel.fullscreenMode = false;

256258 callManager.foregroundCall = null;

257259

258− PanelState.title = "";

259− PanelState.decorationsVisible = false;

260+ panelState.title = "";

261+ panelState.decorationsVisible = false;

260262

261263 // Wait for the indicators to get into position.

262264 // (switches between normal and fullscreen modes are animated)

@@ -447,7 +449,7 @@ PanelTest {

447449 }

448450

449451 function test_hint(data) {

450− PanelState.title = "Fake Title"

452+ panelState.title = "Fake Title"

451453 panel.fullscreenMode = data.fullscreen;

452454 callManager.foregroundCall = data.call;

453455

@@ -489,7 +491,7 @@ PanelTest {

489491 // menus, first by running the hint animation, then after dragging down will

490492 // expose more of the panel. Releasing the touch will complete the show.

491493 function test_drag_applicationMenu_down_shows_menu(data) {

492− PanelState.title = "Fake Title";

494+ panelState.title = "Fake Title";

493495 panel.fullscreenMode = data.fullscreen;

494496 callManager.foregroundCall = data.call;

495497

@@ -580,7 +582,7 @@ PanelTest {

580582 }

581583

582584 function test_darkenedAreaEatsAllApplicationMenuEvents() {

583− PanelState.title = "Fake Title"

585+ panelState.title = "Fake Title"

584586

585587 // The center of the area not covered by the indicators menu

586588 // Ie, the visible darkened area behind the menu

@@ -701,7 +703,7 @@ PanelTest {

701703 var windowControlArea = findChild(panel, "windowControlArea");

702704 verify(windowControlArea, "Window control area should have been created in windowed mode")

703705

704− PanelState.decorationsVisible = true;

706+ panelState.decorationsVisible = true;

705707 // click in very topleft corner and verify the close button got clicked too

706708 mouseMove(panel, 0, 0);

707709 mouseClick(panel, 0, 0, undefined /*button*/, undefined /*modifiers*/, 100 /*short delay*/);

@@ -762,7 +764,7 @@ PanelTest {

762764 }

763765

764766 function test_stagedApplicationMenuBarShowOnMouseHover() {

765− PanelState.title = "Fake Title";

767+ panelState.title = "Fake Title";

766768 panel.mode = "staged";

767769 mouseEmulation.checked = false;

768770

@@ -780,7 +782,7 @@ PanelTest {

780782 }

781783

782784 function test_windowedApplicationMenuShowOnMouseHoverWhenDecorationsShown() {

783− PanelState.title = "Fake Title";

785+ panelState.title = "Fake Title";

784786 panel.mode = "windowed";

785787 mouseEmulation.checked = false;

786788

@@ -796,7 +798,7 @@ PanelTest {

796798 tryCompare(appTitle, "visible", true, undefined, "App title should still be visible on mouse hover when panel decorations are not visible");

797799 tryCompare(appMenuBar, "visible", false, undefined, "App menu bar should be visible on mouse hover when panel decorations are not visible");

798800

799− PanelState.decorationsVisible = true;

801+ panelState.decorationsVisible = true;

800802

801803 tryCompare(appTitle, "visible", false, undefined, "App title should still be visible on mouse hover when panel decorations are visible");

802804 tryCompare(appMenuBar, "visible", true, undefined, "App menu bar should be visible on mouse hover when panel decorations not visible");

tests/qmltests/Stage/tst_DecoratedWindow.qml+5−1

@@ -52,6 +52,10 @@ Rectangle {

5252 surfaceManager: sMgr

5353 }

5454

55+ PanelState {

56+ id: panelState

57+ }

58+

5559 Item {

5660 id: fakeShell

5761

@@ -99,7 +103,7 @@ Rectangle {

99103 surface: fakeApplication && fakeApplication.surfaceList.count > 0 ? fakeApplication.surfaceList.get(0) : null

100104

101105 Binding {

102− target: PanelState

106+ target: panelState

103107 property: "focusedPersistentSurfaceId"

104108 value: decoratedWindow.surface ? decoratedWindow.surface.persistentId : "x"

105109 }

tests/qmltests/Stage/tst_DesktopStage.qml+8−3

@@ -44,6 +44,10 @@ Item {

4444 value: false

4545 }

4646

47+ PanelState {

48+ id: panelState

49+ }

50+

4751 Component.onCompleted: {

4852 ApplicationMenusLimits.screenWidth = Qt.binding( function() { return stageLoader.width; } );

4953 ApplicationMenusLimits.screenHeight = Qt.binding( function() { return stageLoader.height; } );

@@ -102,6 +106,7 @@ Item {

102106 topLevelSurfaceList: topSurfaceList

103107 interactive: true

104108 mode: "windowed"

109+ panelState: panelState

105110 }

106111 }

107112 }

@@ -631,19 +636,19 @@ Item {

631636 maximizeDelegate(facebookAppDelegate);

632637

633638 // verify the drop shadow is still not visible

634− verify(PanelState.dropShadow == false);

639+ verify(panelState.dropShadow == false);

635640

636641 // start a foreground app, not maximized

637642 var dialerAppDelegate = startApplication("dialer-app");

638643

639644 // verify the drop shadow becomes visible

640− verify(PanelState.dropShadow == true);

645+ verify(panelState.dropShadow == true);

641646

642647 // close the maximized app

643648 ApplicationManager.stopApplication("facebook-webapp");

644649

645650 // verify the drop shadow is gone

646− tryCompare(PanelState, "dropShadow", false);

651+ tryCompare(panelState, "dropShadow", false);

647652 }

648653

649654 function test_threeFingerTapShowsWindowControls_data() {

tests/qmltests/Stage/tst_WindowResizeArea.qml+1−8

@@ -19,7 +19,6 @@ import QtQuick.Layouts 1.1

1919import QtTest 1.0

2020import Unity.Test 0.1

2121import ".."

22−import "../../../qml/Components/PanelState"

2322import "../../../qml/Stage"

2423import Ubuntu.Components 1.3

2524import Ubuntu.Components.ListItems 1.3 as ListItem

@@ -31,12 +30,6 @@ Item {

3130 height: units.gu(60)

3231 width: units.gu(85)

3332

34− Binding {

35− target: PanelState

36− property: "panelHeight"

37− value: units.gu(3)

38− }

39−

4033 Component {

4134 id: fakeWindowComponent

4235

@@ -362,7 +355,7 @@ Item {

362355

363356 // Make sure it's again where we left it in normal state before destroying

364357 compare(fakeWindow.requestedX >= 0, true)

365− compare(fakeWindow.requestedY >= PanelState.panelHeight, true)

358+ compare(fakeWindow.requestedY >= 0, true)

366359 compare(fakeWindow.requestedX + fakeWindow.width <= root.width, true)

367360 compare(fakeWindow.requestedY + fakeWindow.height <= root.height, true)

368361

tests/qmltests/tst_OrientedShell.qml+24−5

@@ -30,7 +30,6 @@ import Utils 0.1

3030

3131import "../../qml"

3232import "../../qml/Components"

33−import "../../qml/Components/PanelState"

3433import "Stage"

3534

3635Rectangle {

@@ -82,6 +81,12 @@ Rectangle {

8281 deviceFilter: InputInfo.Keyboard

8382 }

8483

84+ QtObject {

85+ id: _screenWindow

86+ property bool primary: true

87+ }

88+ property alias screenWindow: _screenWindow

89+

8590 property int physicalOrientation0

8691 property int physicalOrientation90

8792 property int physicalOrientation180

@@ -174,6 +179,11 @@ Rectangle {

174179 Component.onDestruction: {

175180 orientedShellLoader.itemDestroyed = true;

176181 }

182+

183+ SurfaceManager {

184+ id: surfaceMan

185+ }

186+ surfaceManager: surfaceMan

177187 }

178188 }

179189 }

@@ -446,6 +456,15 @@ Rectangle {

446456 property Item orientedShell: orientedShellLoader.status === Loader.Ready ? orientedShellLoader.item : null

447457 property Item shell

448458 property QtObject topLevelSurfaceList

459+ property var panelState: undefined

460+

461+ onOrientedShellChanged: {

462+ if (orientedShell) {

463+ panelState = findInvisibleChild(orientedShell, "panelState");

464+ } else {

465+ panelState = undefined;

466+ }

467+ }

449468

450469 SignalSpy { id: signalSpy }

451470 SignalSpy { id: signalSpy2 }

@@ -1510,13 +1529,13 @@ Rectangle {

15101529 print("exptectedAngle", expectedAngle, point.x, point.y)

15111530 switch (expectedAngle) {

15121531 case 0:

1513− return point.x === 0 && point.y === PanelState.panelHeight;

1532+ return point.x === 0 && point.y === panelState.panelHeight;

15141533 case 90:

1515− return point.x === orientedShell.width - PanelState.panelHeight && point.y === 0;

1534+ return point.x === orientedShell.width - panelState.panelHeight && point.y === 0;

15161535 case 180:

1517− return point.x === orientedShell.width && point.y === orientedShell.height - PanelState.panelHeight;

1536+ return point.x === orientedShell.width && point.y === orientedShell.height - panelState.panelHeight;

15181537 default: // 270

1519− return point.x === PanelState.panelHeight && point.y === orientedShell.height;

1538+ return point.x === panelState.panelHeight && point.y === orientedShell.height;

15201539 }

15211540 }

15221541

tests/qmltests/tst_Shell.qml+27−11

@@ -62,13 +62,22 @@ Rectangle {

6262 if (shell) {

6363 topLevelSurfaceList = testCase.findInvisibleChild(shell, "topLevelSurfaceList");

6464 appMenuData.surfaceManager = testCase.findInvisibleChild(shell, "surfaceManager");

65+ panelState = testCase.findInvisibleChild(shell, "panelState");

6566 } else {

6667 topLevelSurfaceList = null;

6768 appMenuData.surfaceManager = null;

69+ panelState = undefined;

6870 }

6971 }

7072

7173 property var topLevelSurfaceList: null

74+ property var panelState: undefined

75+

76+ QtObject {

77+ id: _screenWindow

78+ property bool primary: false

79+ }

80+ property alias screenWindow: _screenWindow

7281

7382 Item {

7483 id: shellContainer

@@ -143,6 +152,11 @@ Rectangle {

143152 Component.onDestruction: {

144153 shellLoader.itemDestroyed = true;

145154 }

155+

156+ SurfaceManager {

157+ id: surfaceMan

158+ }

159+ surfaceManager: surfaceMan

146160 }

147161 }

148162 }

@@ -261,6 +275,7 @@ Rectangle {

261275 anchors { left: parent.left; right: parent.right }

262276 activeFocusOnPress: false

263277 model: ["phone", "tablet", "desktop"]

278+ selectedIndex: 2

264279 onSelectedIndexChanged: {

265280 shellLoader.state = model[selectedIndex];

266281 }

@@ -274,6 +289,7 @@ Rectangle {

274289 anchors { left: parent.left; right: parent.right }

275290 activeFocusOnPress: false

276291 model: ["phone", "tablet", "desktop"]

292+ selectedIndex: 2

277293 }

278294 MouseTouchEmulationCheckbox {

279295 id: mouseEmulation

@@ -680,7 +696,7 @@ Rectangle {

680696 }

681697

682698 function ensureInputMethodSurface() {

683− var surfaceManager = findInvisibleChild(shell, "surfaceManager");

699+ var surfaceManager = shell.surfaceManager;

684700 verify(surfaceManager);

685701 surfaceManager.createInputMethodSurface();

686702

@@ -1868,21 +1884,21 @@ Rectangle {

18681884 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

18691885

18701886 tryCompare(appDelegate, "state", "normal");

1871− tryCompare(PanelState, "decorationsVisible", false)

1887+ tryCompare(panelState, "decorationsVisible", false)

18721888

18731889 mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);

18741890 tryCompare(appDelegate, "state", "maximized");

1875− tryCompare(PanelState, "decorationsVisible", true)

1891+ tryCompare(panelState, "decorationsVisible", true)

18761892

18771893 ApplicationManager.stopApplication(application.appId);

1878− tryCompare(PanelState, "decorationsVisible", false)

1894+ tryCompare(panelState, "decorationsVisible", false)

18791895

18801896 // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

18811897 // They won't be gone until those surface items are destroyed.

18821898 tryCompareFunction(function() { return application.surfaceList.count }, 0);

18831899

18841900 ApplicationManager.startApplication(application.appId);

1885− tryCompare(PanelState, "decorationsVisible", true)

1901+ tryCompare(panelState, "decorationsVisible", true)

18861902 }

18871903

18881904 function test_newAppHasValidGeometry() {

@@ -1939,7 +1955,7 @@ Rectangle {

19391955 mousePress(appDelegate, appDelegate.width / 2, units.gu(1))

19401956 mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))

19411957

1942− compare(appDelegate.y >= PanelState.panelHeight, true);

1958+ compare(appDelegate.y >= panelState.panelHeight, true);

19431959 }

19441960

19451961 function test_cantResizeWindowUnderPanel() {

@@ -1967,7 +1983,7 @@ Rectangle {

19671983 mouseMove(decoration, decoration.width/2, -units.gu(100));

19681984

19691985 // verify we don't go past the panel

1970− compare(appDelegate.y >= PanelState.panelHeight, true);

1986+ compare(appDelegate.y >= panelState.panelHeight, true);

19711987 }

19721988

19731989 function test_restoreWindowStateFixesIfUnderPanel() {

@@ -1991,7 +2007,7 @@ Rectangle {

19912007 tryCompareFunction(function () { return topLevelSurfaceList.applicationAt(0).appId; }, application.appId);

19922008

19932009 appDelegate = appRepeater.itemAt(0);

1994− compare(appDelegate.y >= PanelState.panelHeight, true);

2010+ compare(appDelegate.y >= panelState.panelHeight, true);

19952011 }

19962012

19972013 function test_lifecyclePolicyForNonTouchApp_data() {

@@ -2639,7 +2655,7 @@ Rectangle {

26392655 function test_oskDisplacesWindow_data() {

26402656 return [

26412657 {tag: "no need to displace", windowHeight: units.gu(10), windowY: units.gu(5), targetDisplacement: units.gu(5), oskEnabled: true},

2642− {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: PanelState.panelHeight, oskEnabled: true},

2658+ {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: panelState.panelHeight, oskEnabled: true},

26432659 {tag: "osk not on this screen", windowHeight: units.gu(40), windowY: units.gu(10), targetDisplacement: units.gu(10), oskEnabled: false},

26442660 ]

26452661 }

@@ -2662,8 +2678,8 @@ Rectangle {

26622678 dashAppDelegate.windowedY = data.windowY;

26632679 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

26642680 var initialY = dashAppDelegate.y;

2665− print("intial", initialY, "panel", PanelState.panelHeight);

2666− verify(initialY > PanelState.panelHeight);

2681+ print("intial", initialY, "panel", panelState.panelHeight);

2682+ verify(initialY > panelState.panelHeight);

26672683

26682684 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, root.height / 2, root.width, root.height / 2));

26692685 tryCompare(dashAppDelegate, "y", data.targetDisplacement);

tests/uqmlscene/main.cpp+2

@@ -479,6 +479,8 @@ int main(int argc, char ** argv)

479479 // TODO: as soon as the engine construction completes, the debug service is

480480 // listening for connections. But actually we aren't ready to debug anything.

481481 QQmlEngine engine;

482+ engine.rootContext()->setContextProperty("DebuggingController", new DebuggingController(&app));

483+

482484 QQmlComponent *component = new QQmlComponent(&engine);

483485 for (int i = 0; i < imports.size(); ++i)

484486 engine.addImportPath(imports.at(i));