xenial...3610fcc · unity8

plugins/Cursor/CMakeLists.txt+1

since splitsnapshots

unifiedsplit

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

15 CursorImageInfo.cpp

16 CursorImageProvider.cpp

17 MousePointer.cpp

18+ InputDispatcherFilter.cpp

18 # We need to run moc on this header

19 # We need to run moc on this header

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

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

20 )

21 )

plugins/Cursor/InputDispatcherFilter.cppnew file+146

@@ -0,0 +1,146 @@

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

23+#include <qpa/qplatformnativeinterface.h>

24+#include <qpa/qplatformscreen.h>

25+

26+InputDispatcherFilter *InputDispatcherFilter::instance()

27+{

28+ static InputDispatcherFilter filter;

29+ return &filter;

30+}

31+

32+InputDispatcherFilter::InputDispatcherFilter(QObject *parent)

33+ : QObject(parent)

34+{

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

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

37+ if (m_inputDispatcher) {

38+ m_inputDispatcher->installEventFilter(this);

39+ }

40+}

41+

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

43+{

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

45+ pointer->setVisible(m_pointers.count() == 0);

46+

47+ m_pointers.insert(pointer);

48+ connect(pointer, &MousePointer::mouseMoved, this, [this, pointer]() {

49+ Q_FOREACH(auto p, m_pointers) {

50+ p->setVisible(p == pointer);

51+ }

52+ });

53+}

54+

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

56+{

57+ m_pointers.remove(pointer);

58+ disconnect(pointer, &MousePointer::mouseMoved, this, 0);

59+}

60+

61+void InputDispatcherFilter::setPosition(const QPointF &pos)

62+{

63+ mousePosition = pos;

64+}

65+

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

67+{

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

69+

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

71+ case QEvent::MouseMove:

72+ case QEvent::MouseButtonPress:

73+ case QEvent::MouseButtonRelease:

74+ {

75+ // FIXME - removed all input filtering for now - this was for extended display

76+ return false;

77+

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

79+

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

81+// QPointF localPos = me->localPos();

82+// QPointF globalPos = me->screenPos();

83+

84+// // Adjust the position

85+// QPointF oldPos(mousePosition.isNull() ? globalPos : mousePosition);

86+// QPointF newPos = adjustedPositionForMovement(oldPos, localPos);

87+

88+// QScreen* currentScreen = screenAt(newPos);

89+// if (currentScreen) {

90+// QRect screenRect = currentScreen->geometry();

91+// qreal unadjustedX = (oldPos + localPos).x();

92+// if (unadjustedX < screenRect.left()) {

93+// Q_EMIT pushedLeftBoundary(currentScreen, qAbs(unadjustedX - screenRect.left()), me->buttons());

94+// } else if (unadjustedX > screenRect.right()) {

95+// Q_EMIT pushedRightBoundary(currentScreen, qAbs(unadjustedX - screenRect.right()), me->buttons());

96+// }

97+// }

98+

99+// // Send the event

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

101+// eCopy.setTimestamp(me->timestamp());

102+// o->event(&eCopy);

103+// return true;

104+ }

105+ default:

106+ break;

107+ }

108+ return false;

109+}

110+

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

112+{

113+ QPointF adjusted = pt + movement;

114+

115+ auto screen = screenAt(adjusted); // first check if our move was to a valid screen.

116+ if (screen) {

117+ return adjusted;

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

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

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

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

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

123+ } else {

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

125+

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

127+ Q_FOREACH(QScreen* screen, screens) {

128+ Q_FOREACH(MousePointer* pointer, m_pointers) {

129+ if (pointer->screen() == screen) {

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

131+ }

132+ }

133+ }

134+ }

135+ return adjusted;

136+}

137+

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

139+{

140+ Q_FOREACH(MousePointer* pointer, m_pointers) {

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

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

143+ return screen;

144+ }

145+ return nullptr;

146+}

plugins/Cursor/InputDispatcherFilter.hnew file+57

@@ -0,0 +1,57 @@

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+

35+ void unregisterPointer(MousePointer* pointer);

36+

37+ void setPosition(const QPointF &pos);

38+

39+Q_SIGNALS:

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

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

42+

43+protected:

44+ InputDispatcherFilter(QObject* parent = nullptr);

45+

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

47+

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

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

50+

51+private:

52+ QObject* m_inputDispatcher;

53+ QSet<MousePointer*> m_pointers;

54+ QPointF mousePosition;

55+};

56+

57+#endif // INPUTDISPATCHERFILTER_H

plugins/Cursor/MousePointer.cpp+39−73

@@ -16,84 +16,57 @@

16

17#include "MousePointer.h"

18#include "CursorImageProvider.h"

19−

19+#include "InputDispatcherFilter.h"

20−// Unity API

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

22

20

23#include <QQuickWindow>

21#include <QQuickWindow>

24−#include <QGuiApplication>

25−#include <QtMath>

26

22

27−#include <qpa/qwindowsysteminterface.h>

23+// Unity API

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

28

25

29MousePointer::MousePointer(QQuickItem *parent)

26MousePointer::MousePointer(QQuickItem *parent)

30 : MirMousePointerInterface(parent)

27 : MirMousePointerInterface(parent)

31 , m_cursorName(QStringLiteral("left_ptr"))

28 , m_cursorName(QStringLiteral("left_ptr"))

32 , m_themeName(QStringLiteral("default"))

29 , m_themeName(QStringLiteral("default"))

33{

30{

34−}

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

35

32

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

33+ auto mouseMovedFunc = [this]() {

37− Qt::KeyboardModifiers modifiers)

38−{

39− if (!parentItem()) {

40− return;

34+ if (!isEnabled() || !window()) return;

41− }

35+ QPointF globalPosition = mapToItem(nullptr, QPointF(0, 0));

42−

36+ InputDispatcherFilter::instance()->setPosition(globalPosition);

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

44 Q_EMIT mouseMoved();

37 Q_EMIT mouseMoved();

45− }

38+ };

46−

39+ connect(this, &QQuickItem::xChanged, this, mouseMovedFunc);

47− m_accumulatedMovement += movement;

40+ connect(this, &QQuickItem::yChanged, this, mouseMovedFunc);

48− // don't apply the fractional part

41+

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

42+ connect(this, &QQuickItem::enabledChanged, this, [this]() {

50− m_accumulatedMovement -= appliedMovement;

43+ if (!isEnabled()) setVisible(false);

51−

44+ });

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

45+

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

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

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

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

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

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

56−

49+ Q_EMIT pushedLeftBoundary(amount, buttons);

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

84− Q_EMIT pushStopped();

85− m_pushing = false;

86 }

50 }

87− }

51+ });

88

52

89− applyItemConfinement(newX, newY);

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

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

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

56+ Q_EMIT pushedRightBoundary(amount, buttons);

57+ }

58+ });

59+}

90

60

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

61+MousePointer::~MousePointer()

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

62+{

63+ registerScreen(nullptr);

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

65+}

93

66

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

67+void MousePointer::handleMouseEvent(ulong /*timestamp*/, QPointF /*movement*/, Qt::MouseButtons /*buttons*/,

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

96− buttons, modifiers);

68+ Qt::KeyboardModifiers /*modifiers*/)

69+{

97}

70}

98

71

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

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

@@ -121,15 +94,8 @@ void MousePointer::applyItemConfinement(qreal &newX, qreal &newY)

121 }

94 }

122}

95}

123

96

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

97+void MousePointer::handleWheelEvent(ulong /*timestamp*/, QPoint /*angleDelta*/, Qt::KeyboardModifiers /*modifiers*/)

125{

98{

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}

99}

134

100

135int MousePointer::topBoundaryOffset() const

101int MousePointer::topBoundaryOffset() const

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

182 if (m_registeredScreen) {

148 if (m_registeredScreen) {

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

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

184 if (previousCursor) {

150 if (previousCursor) {

185− previousCursor->setMousePointer(nullptr);

151+ previousCursor->unregisterMousePointer(this);

186 } else {

152 } else {

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

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

188 }

154 }

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

193 if (m_registeredScreen) {

159 if (m_registeredScreen) {

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

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

195 if (cursor) {

161 if (cursor) {

196− cursor->setMousePointer(this);

162+ cursor->registerMousePointer(this);

197 } else {

163 } else {

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

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

199 }

165 }

plugins/Cursor/MousePointer.h+3

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

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

32public:

33 MousePointer(QQuickItem *parent = nullptr);

34+ ~MousePointer();

34

35

35 void setCursorName(const QString &qtCursorName) override;

36 void setCursorName(const QString &qtCursorName) override;

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

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

@@ -46,6 +47,8 @@ public:

46 int topBoundaryOffset() const;

47 int topBoundaryOffset() const;

47 void setTopBoundaryOffset(int topBoundaryOffset);

48 void setTopBoundaryOffset(int topBoundaryOffset);

48

49

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

51+

49public Q_SLOTS:

52public Q_SLOTS:

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

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

51 Qt::KeyboardModifiers modifiers) override;

54 Qt::KeyboardModifiers modifiers) override;

plugins/UInput/plugin.cpp+7−1

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

19

20#include <QtQml/qqml.h>

21

22+

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

24+{

25+ return new UInput;

26+}

27+

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

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

23{

29{

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

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

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

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

26}

32}

qml/CMakeLists.txt+1−1

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

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

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

2

3install(FILES ${QML_JS_FILES}

4 DESTINATION ${SHELL_APP_DIR}

qml/Components/PanelState/PanelState.qml−1

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

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

15 */

16

17−pragma Singleton

18import QtQuick 2.4

17import QtQuick 2.4

19

18

20QtObject {

19QtObject {

qml/Components/PanelState/qmldir+1−1

@@ -1 +1 @@

1−singleton PanelState 1.0 PanelState.qml

1+PanelState 1.0 PanelState.qml

qml/Components/VirtualTouchPad.qml+13−19

@@ -24,16 +24,14 @@ import "../Components"

24

25Item {

26 id: root

27− property var uinput: UInput {

28− Component.onCompleted: createMouse();

29− Component.onDestruction: removeMouse();

30− }

31

27

32 Component.onCompleted: {

28 Component.onCompleted: {

29+ UInput.createMouse();

33 if (!settings.touchpadTutorialHasRun) {

30 if (!settings.touchpadTutorialHasRun) {

34 root.runTutorial()

31 root.runTutorial()

35 }

32 }

36 }

33 }

34+ Component.onDestruction: UInput.removeMouse()

37

35

38 function runTutorial() {

36 function runTutorial() {

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

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

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

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

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

86 && clickTimer.running) {

84 && clickTimer.running) {

87 clickTimer.stop();

85 clickTimer.stop();

88− uinput.pressMouse(UInput.ButtonLeft)

86+ UInput.pressMouse(UInput.ButtonLeft)

89 isDoubleClick = true;

87 isDoubleClick = true;

90 }

88 }

91 isClick = true;

89 isClick = true;

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

104

102

105 onReleased: {

103 onReleased: {

106 if (isDoubleClick || isDrag) {

104 if (isDoubleClick || isDrag) {

107− uinput.releaseMouse(UInput.ButtonLeft)

105+ UInput.releaseMouse(UInput.ButtonLeft)

108 isDoubleClick = false;

106 isDoubleClick = false;

109 }

107 }

110 if (isClick) {

108 if (isClick) {

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

120 interval: 200

118 interval: 200

121 property int button: UInput.ButtonLeft

119 property int button: UInput.ButtonLeft

122 onTriggered: {

120 onTriggered: {

123− uinput.pressMouse(button);

121+ UInput.pressMouse(button);

124− uinput.releaseMouse(button);

122+ UInput.releaseMouse(button);

125 }

123 }

126 function scheduleClick(button) {

124 function scheduleClick(button) {

127 clickTimer.button = button;

125 clickTimer.button = button;

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

138 isDrag = true;

136 isDrag = true;

139 }

137 }

140

138

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

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

142 }

140 }

143

141

144 function scroll(touchPoints) {

142 function scroll(touchPoints) {

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

166 dh /= 2;

164 dh /= 2;

167 dv /= 2;

165 dv /= 2;

168

166

169− uinput.scrollMouse(dh, dv);

167+ UInput.scrollMouse(dh, dv);

170 }

168 }

171

169

172 touchPoints: [

170 touchPoints: [

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

189 objectName: "leftButton"

187 objectName: "leftButton"

190 Layout.fillWidth: true

188 Layout.fillWidth: true

191 Layout.fillHeight: true

189 Layout.fillHeight: true

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

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

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

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

194 property bool highlight: false

192 property bool highlight: false

195 UbuntuShape {

193 UbuntuShape {

196 anchors.fill: parent

194 anchors.fill: parent

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

204 objectName: "rightButton"

202 objectName: "rightButton"

205 Layout.fillWidth: true

203 Layout.fillWidth: true

206 Layout.fillHeight: true

204 Layout.fillHeight: true

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

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

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

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

209 property bool highlight: false

207 property bool highlight: false

210 UbuntuShape {

208 UbuntuShape {

211 anchors.fill: parent

209 anchors.fill: parent

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

239 }

237 }

240 }

238 }

241

239

242− Screens {

243− id: screens

244− }

245−

246 InputMethod {

240 InputMethod {

247 id: inputMethod

241 id: inputMethod

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

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

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

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

250 objectName: "inputMethod"

244 objectName: "inputMethod"

251 anchors.fill: parent

245 anchors.fill: parent

252 }

246 }

qml/DisabledScreenNotice.qml+2−1

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

28 property var screen: Screen

29 property var orientationLock: OrientationLock

30

31+ property alias deviceConfiguration: _deviceConfiguration

31 DeviceConfiguration {

32 DeviceConfiguration {

32− id: deviceConfiguration

33+ id: _deviceConfiguration

33 name: applicationArguments.deviceName

34 name: applicationArguments.deviceName

34 }

35 }

35

36

qml/Greeter/Greeter.qml+21−3

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

25import Unity.Session 0.1

26

27import "." 0.1

28+import ".." 0.1

28import "../Components"

29import "../Components"

29

30

30Showable {

31Showable {

@@ -234,7 +235,7 @@ Showable {

234 if (forcedUnlock && shown) {

235 if (forcedUnlock && shown) {

235 hideView();

236 hideView();

236 if (hideNow) {

237 if (hideNow) {

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

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

238 }

239 }

240 }

241 }

@@ -397,7 +398,7 @@ Showable {

397 onEmergencyCall: root.emergencyCall()

398 onEmergencyCall: root.emergencyCall()

398 onRequiredChanged: {

399 onRequiredChanged: {

399 if (!loader.item.required) {

400 if (!loader.item.required) {

400− root.hide();

401+ ShellNotifier.greeter.hide(false);

401 }

402 }

403 }

404 }

@@ -529,12 +530,29 @@ Showable {

529 onRequestAuthenticationUser: d.selectUser(d.getUserIndex(user), true)

530 onRequestAuthenticationUser: d.selectUser(d.getUserIndex(user), true)

530 }

531 }

531

532

533+ Connections {

534+ target: ShellNotifier.greeter

535+ onHide: {

536+ if (now) {

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

538+ } else {

539+ root.hide();

540+ }

541+ }

542+ }

543+

544+ Binding {

545+ target: ShellNotifier.greeter

546+ property: "shown"

547+ value: root.shown

548+ }

549+

532 Connections {

550 Connections {

533 target: DBusUnitySessionService

551 target: DBusUnitySessionService

534 onLockRequested: root.forceShow()

552 onLockRequested: root.forceShow()

535 onUnlocked: {

553 onUnlocked: {

536 root.forcedUnlock = true;

554 root.forcedUnlock = true;

537− root.hideNow();

555+ ShellNotifier.greeter.hide(true);

538 }

556 }

539 }

557 }

540

558

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

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

32 implicitWidth: units.gu(40)

33 implicitHeight: units.gu(71)

34

35+ property alias deviceConfiguration: _deviceConfiguration

36+ property alias orientations: d.orientations

37+ property alias surfaceManager: shell.surfaceManager

38+

35 onWidthChanged: calculateUsageMode();

39 onWidthChanged: calculateUsageMode();

36

40

37 DeviceConfiguration {

41 DeviceConfiguration {

38− id: deviceConfiguration

42+ id: _deviceConfiguration

39 name: applicationArguments.deviceName

43 name: applicationArguments.deviceName

40 }

44 }

41

45

42− property alias orientations: d.orientations

43−

44 Item {

46 Item {

45 id: d

47 id: d

46

48

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

157 return false;

159 return false;

158 }

160 }

159

161

160− Screens {

161− id: screens

162− }

163−

164 property int orientation

162 property int orientation

165 onPhysicalOrientationChanged: {

163 onPhysicalOrientationChanged: {

166 if (!orientationLocked) {

164 if (!orientationLocked) {

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

258

256

259 Shell {

257 Shell {

260 id: shell

258 id: shell

261− objectName: "shell"

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

262 width: root.width

260 width: root.width

263 height: root.height

261 height: root.height

264 orientation: root.angleToOrientation(orientationAngle)

262 orientation: root.angleToOrientation(orientationAngle)

@@ -271,7 +269,7 @@ Item {

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

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

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

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

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

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

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

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

275 forceOSKEnabled

273 forceOSKEnabled

276

274

277 usageScenario: {

275 usageScenario: {

qml/Panel/Panel.qml+14−14

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

47 property bool fullscreenMode: false

48 property real panelAreaShowProgress: 1.0

49 property bool greeterShown: false

50−

51 property string mode: "staged"

50 property string mode: "staged"

51+ property PanelState panelState

52

53 MouseArea {

54 id: backMouseEater

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

65 }

66

67 Binding {

68− target: PanelState

68+ target: panelState

69 property: "panelHeight"

70 value: minimizedPanelHeight

71 }

72

73 RegisteredApplicationMenuModel {

74 id: registeredMenuModel

75− persistentSurfaceId: PanelState.focusedPersistentSurfaceId

75+ persistentSurfaceId: panelState.focusedPersistentSurfaceId

76 }

77

78 QtObject {

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

83 !indicators.shown &&

84 (decorationMouseArea.containsMouse || menuBarLoader.menusRequested)

85

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

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

87− PanelState.decorationsAlwaysVisible

87+ panelState.decorationsAlwaysVisible

88

89 property bool showPointerMenu: revealControls &&

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

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

91

92 property bool enablePointerMenu: revealControls &&

93 applicationMenus.available &&

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

139 fill: panelAreaBackground

140 bottomMargin: -units.gu(1)

141 }

142− visible: PanelState.dropShadow

142+ visible: panelState.dropShadow

143 source: "graphics/rectangular_dropshadow.sci"

144 }

145

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

192 visible: opacity != 0

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

194

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

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

196 windowIsMaximized: true

197− onCloseClicked: PanelState.closeClicked()

197+ onCloseClicked: panelState.closeClicked()

198− onMinimizeClicked: PanelState.minimizeClicked()

198+ onMinimizeClicked: panelState.minimizeClicked()

199− onMaximizeClicked: PanelState.restoreClicked()

199+ onMaximizeClicked: panelState.restoreClicked()

200− closeButtonShown: PanelState.closeButtonShown

200+ closeButtonShown: panelState.closeButtonShown

201 }

202

203 Loader {

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

217 anchors.left: parent.left

218 anchors.margins: units.gu(1)

219 height: menuBarLoader.height

220− enableKeyFilter: valid && PanelState.decorationsVisible

220+ enableKeyFilter: valid && panelState.decorationsVisible

221 unityMenuModel: __applicationMenus.model

222

223 Connections {

@@ -265,7 +265,7 @@ Item {

265 }

266

267 showRowTitle: !expanded

268− rowTitle: PanelState.title

268+ rowTitle: panelState.title

269 rowItemDelegate: ActionItem {

270 id: actionItem

271 property int ownIndex: index

qml/Shell.qml+25−21

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

1−/*

1+/*

3 *

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

@@ -38,6 +38,7 @@ import "Notifications"

38import "Stage"

39import "Tutorial"

40import "Wizard"

41+import "Components/PanelState"

41import Unity.Notifications 1.0 as NotificationBackend

42import Unity.Notifications 1.0 as NotificationBackend

42import Unity.Session 0.1

43import Unity.Session 0.1

43import Unity.DashCommunicator 0.1

44import Unity.DashCommunicator 0.1

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

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

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

53

54

54 // to be set from outside

55 // to be set from outside

56+ property alias surfaceManager: topLevelSurfaceList.surfaceManager

55 property int orientationAngle: 0

57 property int orientationAngle: 0

56 property int orientation

58 property int orientation

57 property Orientations orientations

59 property Orientations orientations

@@ -249,7 +251,6 @@ StyledItem {

249 var mappedCoords = mapFromItem(null, pos.x, pos.y);

251 var mappedCoords = mapFromItem(null, pos.x, pos.y);

250 cursor.x = mappedCoords.x;

252 cursor.x = mappedCoords.x;

251 cursor.y = mappedCoords.y;

253 cursor.y = mappedCoords.y;

252− cursor.mouseNeverMoved = false;

253 }

254 }

255 }

255

256

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

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

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

259 }

260 }

260

261

262+ PanelState {

263+ id: panelState

264+ objectName: "panelState"

265+ }

266+

261 Item {

267 Item {

262 id: stages

268 id: stages

263 objectName: "stages"

269 objectName: "stages"

264 width: parent.width

270 width: parent.width

265 height: parent.height

271 height: parent.height

266

272

267− SurfaceManager {

268− id: surfaceMan

269− objectName: "surfaceManager"

270− }

271 TopLevelWindowModel {

273 TopLevelWindowModel {

272 id: topLevelSurfaceList

274 id: topLevelSurfaceList

273 objectName: "topLevelSurfaceList"

275 objectName: "topLevelSurfaceList"

274 applicationManager: ApplicationManager // it's a singleton

276 applicationManager: ApplicationManager // it's a singleton

275− surfaceManager: surfaceMan

276 }

277 }

277

278

278 Stage {

279 Stage {

@@ -313,6 +314,7 @@ StyledItem {

313 altTabPressed: physicalKeysMapper.altTabPressed

314 altTabPressed: physicalKeysMapper.altTabPressed

314 oskEnabled: shell.oskEnabled

315 oskEnabled: shell.oskEnabled

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

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

317+ panelState: panelState

316

318

317 onSpreadShownChanged: {

319 onSpreadShownChanged: {

318 panel.indicators.hide();

320 panel.indicators.hide();

@@ -338,8 +340,13 @@ StyledItem {

338 objectName: "greeterLoader"

340 objectName: "greeterLoader"

339 anchors.fill: parent

341 anchors.fill: parent

340 anchors.topMargin: panel.panelHeight

342 anchors.topMargin: panel.panelHeight

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

343+ sourceComponent: {

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

345+ if (screenWindow.primary) return integratedGreeter;

346+ return secondaryGreeter;

347+ }

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

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

349+ }

343 onLoaded: {

350 onLoaded: {

344 item.objectName = "greeter"

351 item.objectName = "greeter"

345 }

352 }

@@ -379,6 +386,13 @@ StyledItem {

379 }

386 }

380 }

387 }

381

388

389+ Component {

390+ id: secondaryGreeter

391+ SecondaryGreeter {

392+ hides: [launcher, panel.indicators]

393+ }

394+ }

395+

382 Timer {

396 Timer {

383 // See powerConnection for why this is useful

397 // See powerConnection for why this is useful

384 id: showGreeterDelayed

398 id: showGreeterDelayed

@@ -489,6 +503,7 @@ StyledItem {

489 fullscreenMode: (focusedSurfaceIsFullscreen && !LightDMService.greeter.active && launcher.progress == 0)

503 fullscreenMode: (focusedSurfaceIsFullscreen && !LightDMService.greeter.active && launcher.progress == 0)

490 || greeter.hasLockedApp

504 || greeter.hasLockedApp

491 greeterShown: greeter && greeter.shown

505 greeterShown: greeter && greeter.shown

506+ panelState: panelState

492 }

507 }

493

508

494 Launcher {

509 Launcher {

@@ -699,23 +714,13 @@ StyledItem {

699

714

700 Cursor {

715 Cursor {

701 id: cursor

716 id: cursor

702− objectName: "cursor"

703 visible: shell.hasMouse

717 visible: shell.hasMouse

704 z: itemGrabber.z + 1

718 z: itemGrabber.z + 1

719+ opacity: 0

705 topBoundaryOffset: panel.panelHeight

720 topBoundaryOffset: panel.panelHeight

706

721

707 confiningItem: stage.itemConfiningMouseCursor

722 confiningItem: stage.itemConfiningMouseCursor

708

723

709− property bool mouseNeverMoved: true

710− Binding {

711− target: cursor; property: "x"; value: shell.width / 2

712− when: cursor.mouseNeverMoved && cursor.visible

713− }

714− Binding {

715− target: cursor; property: "y"; value: shell.height / 2

716− when: cursor.mouseNeverMoved && cursor.visible

717− }

718−

719 height: units.gu(3)

724 height: units.gu(3)

720

725

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

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

@@ -770,7 +775,6 @@ StyledItem {

770 }

775 }

771

776

772 onMouseMoved: {

777 onMouseMoved: {

773− mouseNeverMoved = false;

774 cursor.opacity = 1;

778 cursor.opacity = 1;

775 }

779 }

776

780

qml/ShellApplication.qmlnew file+51

@@ -0,0 +1,51 @@

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 Unity.Screens 0.1

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: screen

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: screen

39+ property: "width"

40+ value: applicationArguments.windowGeometry.width

41+ }

42+ Binding {

43+ when: applicationArguments.hasGeometry

44+ target: screen

45+ property: "height"

46+ value: applicationArguments.windowGeometry.height

47+ }

48+

49+ primary: index == 0

50+ }

51+}

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

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

1/*

3 *

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

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

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

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

15 */

16

17−#ifndef UNITY_SECONDARY_WINDOW_H

17+/*

18−#define UNITY_SECONDARY_WINDOW_H

18+ Shared signals & properties on multi-window desktop

19−

19+ */

20−#include <QQuickView>

21

20

22−class SecondaryWindow : public QQuickView

21+pragma Singleton

23−{

22+import QtQuick 2.4

24− Q_OBJECT

25

23

26−public:

24+QtObject {

27− SecondaryWindow(QQmlEngine *engine);

25+ property var greeter: QtObject {

28−};

26+ signal hide(bool now)

29

27

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 Unity.Screens 0.1

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+4−1

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

73

74 readonly property Item clientAreaItem: applicationWindow

75

76+ property PanelState panelState

77+

76 signal closeClicked()

78 signal closeClicked()

77 signal maximizeClicked()

79 signal maximizeClicked()

78 signal maximizeHorizontallyClicked()

80 signal maximizeHorizontallyClicked()

@@ -232,7 +234,7 @@ FocusScope {

232 enableMenus: {

234 enableMenus: {

233 return active &&

235 return active &&

234 surface &&

236 surface &&

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

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

236 }

238 }

237 menu: sharedAppModel.model

239 menu: sharedAppModel.model

238

240

@@ -297,6 +299,7 @@ FocusScope {

297 objectName: "moveHandler"

299 objectName: "moveHandler"

298 target: root.parent

300 target: root.parent

299 buttonsWidth: decoration.buttonsWidth

301 buttonsWidth: decoration.buttonsWidth

302+ panelState: root.panelState

300 }

303 }

301

304

302 Rectangle {

305 Rectangle {

qml/Stage/FakeMaximizeDelegate.qml+12−11

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

35 property int leftMargin

36 property real appContainerWidth

37 property real appContainerHeight

38+ property PanelState panelState

38

39

39 readonly property real hintThreshold: 0.1

40 readonly property real hintThreshold: 0.1

40

41

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

178 ParallelAnimation {

179 ParallelAnimation {

179 id: fakeMaximizeAnimation

180 id: fakeMaximizeAnimation

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

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

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

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

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

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

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

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

184 }

185 }

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

186 ParallelAnimation {

187 ParallelAnimation {

187 id: fakeMaximizeLeftAnimation

188 id: fakeMaximizeLeftAnimation

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

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

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

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

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

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

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

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

192 }

193 }

193

194

194 ParallelAnimation {

195 ParallelAnimation {

195 id: fakeMaximizeRightAnimation

196 id: fakeMaximizeRightAnimation

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

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

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

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

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

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

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

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

200 }

201 }

201

202

202 ParallelAnimation {

203 ParallelAnimation {

203 id: fakeMaximizeTopLeftAnimation

204 id: fakeMaximizeTopLeftAnimation

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

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

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

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

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

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

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

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

208 }

209 }

209

210

210 ParallelAnimation {

211 ParallelAnimation {

211 id: fakeMaximizeTopRightAnimation

212 id: fakeMaximizeTopRightAnimation

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

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

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

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

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

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

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

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

216 }

217 }

217

218

218 ParallelAnimation {

219 ParallelAnimation {

219 id: fakeMaximizeBottomLeftAnimation

220 id: fakeMaximizeBottomLeftAnimation

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

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

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

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

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

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

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

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

224 }

225 }

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

226 ParallelAnimation {

227 ParallelAnimation {

227 id: fakeMaximizeBottomRightAnimation

228 id: fakeMaximizeBottomRightAnimation

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

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

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

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

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

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

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

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

232 }

233 }

qml/Stage/MoveHandler.qml+8−7

@@ -28,6 +28,7 @@ QtObject {

28 property int stageWidth

29 property int stageHeight

30 property real buttonsWidth: 0

31+ property PanelState panelState

31

32

32 readonly property bool dragging: priv.dragging

33 readonly property bool dragging: priv.dragging

33

34

@@ -122,18 +123,18 @@ QtObject {

122 // position. Mouse movement could have subpixel precision, yielding a fractional

123 // position. Mouse movement could have subpixel precision, yielding a fractional

123 // mouse position.

124 // mouse position.

124 target.windowedX = Math.round(pos.x - priv.distanceX);

125 target.windowedX = Math.round(pos.x - priv.distanceX);

125− target.windowedY = Math.round(Math.max(pos.y - priv.distanceY, PanelState.panelHeight));

126+ target.windowedY = Math.round(Math.max(pos.y - priv.distanceY, panelState.panelHeight));

126

127

127 if (sensingPoints) { // edge/corner detection when dragging via the touch overlay

128 if (sensingPoints) { // edge/corner detection when dragging via the touch overlay

128− if (sensingPoints.topLeft.x < priv.triggerArea && sensingPoints.topLeft.y < PanelState.panelHeight + priv.triggerArea

129+ if (sensingPoints.topLeft.x < priv.triggerArea && sensingPoints.topLeft.y < panelState.panelHeight + priv.triggerArea

129 && target.canBeCornerMaximized) { // top left

130 && target.canBeCornerMaximized) { // top left

130− priv.progress = priv.progressInCorner(0, PanelState.panelHeight, sensingPoints.topLeft.x, sensingPoints.topLeft.y);

131+ priv.progress = priv.progressInCorner(0, panelState.panelHeight, sensingPoints.topLeft.x, sensingPoints.topLeft.y);

131 priv.resetEdges();

132 priv.resetEdges();

132 priv.nearTopLeftCorner = true;

133 priv.nearTopLeftCorner = true;

133 root.fakeMaximizeTopLeftAnimationRequested(priv.progress);

134 root.fakeMaximizeTopLeftAnimationRequested(priv.progress);

134− } else if (sensingPoints.topRight.x > stageWidth - priv.triggerArea && sensingPoints.topRight.y < PanelState.panelHeight + priv.triggerArea

135+ } else if (sensingPoints.topRight.x > stageWidth - priv.triggerArea && sensingPoints.topRight.y < panelState.panelHeight + priv.triggerArea

135 && target.canBeCornerMaximized) { // top right

136 && target.canBeCornerMaximized) { // top right

136− priv.progress = priv.progressInCorner(stageWidth, PanelState.panelHeight, sensingPoints.topRight.x, sensingPoints.topRight.y);

137+ priv.progress = priv.progressInCorner(stageWidth, panelState.panelHeight, sensingPoints.topRight.x, sensingPoints.topRight.y);

137 priv.resetEdges();

138 priv.resetEdges();

138 priv.nearTopRightCorner = true;

139 priv.nearTopRightCorner = true;

139 root.fakeMaximizeTopRightAnimationRequested(priv.progress);

140 root.fakeMaximizeTopRightAnimationRequested(priv.progress);

@@ -159,8 +160,8 @@ QtObject {

159 priv.resetEdges();

160 priv.resetEdges();

160 priv.nearRightEdge = true;

161 priv.nearRightEdge = true;

161 root.fakeMaximizeRightAnimationRequested(priv.progress);

162 root.fakeMaximizeRightAnimationRequested(priv.progress);

162− } else if (sensingPoints.top.y < PanelState.panelHeight + priv.triggerArea && target.canBeMaximized) { // top

163+ } else if (sensingPoints.top.y < panelState.panelHeight + priv.triggerArea && target.canBeMaximized) { // top

163− priv.progress = MathUtils.clampAndProject(sensingPoints.top.y, PanelState.panelHeight + priv.triggerArea, 0, 0, 1);

164+ priv.progress = MathUtils.clampAndProject(sensingPoints.top.y, panelState.panelHeight + priv.triggerArea, 0, 0, 1);

164 priv.resetEdges();

165 priv.resetEdges();

165 priv.nearTopEdge = true;

166 priv.nearTopEdge = true;

166 root.fakeMaximizeAnimationRequested(priv.progress);

167 root.fakeMaximizeAnimationRequested(priv.progress);

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

@@ -0,0 +1,26 @@

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+

7+Item {

8+ id: root

9+ property string background

10+

11+ Row {

12+ anchors.bottom: parent.bottom

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

14+ anchors.horizontalCenter: parent.horizontalCenter

15+ spacing: units.gu(1)

16+

17+ Repeater {

18+ model: Screens

19+

20+ delegate: WorkspacePreview {

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

22+ background: root.background

23+ }

24+ }

25+ }

26+}

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

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

28 property var spreadFlickable

29

30 // some config options

31− property real contentMargin: 0.16 * root.height

31+ property real contentMargin: 0.1 * root.height

32− property real contentTopMargin: contentMargin

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

33− property real contentBottomMargin: 0.35 * contentMargin

33+ property real contentBottomMargin: contentMargin

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

34+ property real windowTitleTopMargin: contentMargin - windowTitle.height

35 property int stackItemCount: 3

36 property real leftRotationAngle: 22

37 property real rightRotationAngle: 32

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

51

52 readonly property real spreadWidth: rightStackXPos - leftStackXPos

53 readonly property real spreadHeight: root.height

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

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

55 readonly property real spreadItemWidth: stackHeight

56

57 readonly property real dynamicLeftRotationAngle: leftRotationAngle * rotationAngleFactor

qml/Stage/Stage.qml+38−27

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

46 property int leftMargin: 0

47 property bool oskEnabled: false

48 property rect inputMethodRect

49+ property PanelState panelState

49

50

50 // Configuration

51 // Configuration

51 property string mode: "staged"

52 property string mode: "staged"

@@ -348,20 +349,20 @@ FocusScope {

348 Component.onCompleted: priv.updateMainAndSideStageIndexes();

349 Component.onCompleted: priv.updateMainAndSideStageIndexes();

349

350

350 Connections {

351 Connections {

351− target: PanelState

352+ target: panelState

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

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

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

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

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

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

355 }

356 }

356

357

357 Binding {

358 Binding {

358− target: PanelState

359+ target: panelState

359 property: "decorationsVisible"

360 property: "decorationsVisible"

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

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

361 }

362 }

362

363

363 Binding {

364 Binding {

364− target: PanelState

365+ target: panelState

365 property: "title"

366 property: "title"

366 value: {

367 value: {

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

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

@@ -376,7 +377,7 @@ FocusScope {

376 }

377 }

377

378

378 Binding {

379 Binding {

379− target: PanelState

380+ target: panelState

380 property: "focusedPersistentSurfaceId"

381 property: "focusedPersistentSurfaceId"

381 value: {

382 value: {

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

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

@@ -390,21 +391,21 @@ FocusScope {

390 }

391 }

391

392

392 Binding {

393 Binding {

393− target: PanelState

394+ target: panelState

394 property: "dropShadow"

395 property: "dropShadow"

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

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

396 }

397 }

397

398

398 Binding {

399 Binding {

399− target: PanelState

400+ target: panelState

400 property: "closeButtonShown"

401 property: "closeButtonShown"

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

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

402 }

403 }

403

404

404 Component.onDestruction: {

405 Component.onDestruction: {

405− PanelState.title = "";

406+ panelState.title = "";

406− PanelState.decorationsVisible = false;

407+ panelState.decorationsVisible = false;

407− PanelState.dropShadow = false;

408+ panelState.dropShadow = false;

408 }

409 }

409

410

410 Instantiator {

411 Instantiator {

@@ -482,7 +483,7 @@ FocusScope {

482 },

483 },

483 State {

484 State {

484 name: "staged"; when: root.mode === "staged"

485 name: "staged"; when: root.mode === "staged"

485− PropertyChanges { target: wallpaper; visible: false }

486+ PropertyChanges { target: wallpaper; visible: priv.focusedAppDelegate && priv.focusedAppDelegate.x === 0 }

486 },

487 },

487 State {

488 State {

488 name: "stagedWithSideStage"; when: root.mode === "stagedWithSideStage"

489 name: "stagedWithSideStage"; when: root.mode === "stagedWithSideStage"

@@ -559,10 +560,17 @@ FocusScope {

559 visible: false

560 visible: false

560 }

561 }

561

562

563+ ScreensAndWorkspaces {

564+ id: screensAndWorkspaces

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

566+ height: parent.height / 3

567+ background: root.background

568+ }

569+

562 Spread {

570 Spread {

563 id: spreadItem

571 id: spreadItem

564 objectName: "spreadItem"

572 objectName: "spreadItem"

565− anchors.fill: appContainer

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

566 leftMargin: root.leftMargin

574 leftMargin: root.leftMargin

567 model: root.topLevelSurfaceList

575 model: root.topLevelSurfaceList

568 spreadFlickable: floatingFlickable

576 spreadFlickable: floatingFlickable

@@ -753,7 +761,7 @@ FocusScope {

753 target: appDelegate

761 target: appDelegate

754 property: "y"

762 property: "y"

755 value: appDelegate.requestedY -

763 value: appDelegate.requestedY -

756− Math.min(appDelegate.requestedY - PanelState.panelHeight,

764+ Math.min(appDelegate.requestedY - panelState.panelHeight,

757 Math.max(0, priv.virtualKeyboardHeight - (appContainer.height - (appDelegate.requestedY + appDelegate.height))))

765 Math.max(0, priv.virtualKeyboardHeight - (appContainer.height - (appDelegate.requestedY + appDelegate.height))))

758 when: root.oskEnabled && appDelegate.focus && (appDelegate.state == "normal" || appDelegate.state == "restored")

766 when: root.oskEnabled && appDelegate.focus && (appDelegate.state == "normal" || appDelegate.state == "restored")

759 && root.inputMethodRect.height > 0

767 && root.inputMethodRect.height > 0

@@ -890,7 +898,7 @@ FocusScope {

890 screenWidth: appContainer.width

898 screenWidth: appContainer.width

891 screenHeight: appContainer.height

899 screenHeight: appContainer.height

892 leftMargin: root.leftMargin

900 leftMargin: root.leftMargin

893− minimumY: PanelState.panelHeight

901+ minimumY: panelState.panelHeight

894 }

902 }

895

903

896 Connections {

904 Connections {

@@ -1130,7 +1138,7 @@ FocusScope {

1130 progress: 0

1138 progress: 0

1131 targetHeight: spreadItem.stackHeight

1139 targetHeight: spreadItem.stackHeight

1132 targetX: spreadMaths.targetX

1140 targetX: spreadMaths.targetX

1133− startY: appDelegate.fullscreen ? 0 : PanelState.panelHeight

1141+ startY: appDelegate.fullscreen ? 0 : panelState.panelHeight

1134 targetY: spreadMaths.targetY

1142 targetY: spreadMaths.targetY

1135 targetAngle: spreadMaths.targetAngle

1143 targetAngle: spreadMaths.targetAngle

1136 targetScale: spreadMaths.targetScale

1144 targetScale: spreadMaths.targetScale

@@ -1249,9 +1257,9 @@ FocusScope {

1249 PropertyChanges {

1257 PropertyChanges {

1250 target: appDelegate

1258 target: appDelegate

1251 x: stageMaths.itemX

1259 x: stageMaths.itemX

1252− y: appDelegate.fullscreen ? 0 : PanelState.panelHeight

1260+ y: appDelegate.fullscreen ? 0 : panelState.panelHeight

1253 requestedWidth: appContainer.width

1261 requestedWidth: appContainer.width

1254− requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - PanelState.panelHeight

1262+ requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - panelState.panelHeight

1255 visuallyMaximized: true

1263 visuallyMaximized: true

1256 visible: appDelegate.x < root.width

1264 visible: appDelegate.x < root.width

1257 }

1265 }

@@ -1277,10 +1285,10 @@ FocusScope {

1277 PropertyChanges {

1285 PropertyChanges {

1278 target: appDelegate

1286 target: appDelegate

1279 x: stageMaths.itemX

1287 x: stageMaths.itemX

1280− y: appDelegate.fullscreen ? 0 : PanelState.panelHeight

1288+ y: appDelegate.fullscreen ? 0 : panelState.panelHeight

1281 z: stageMaths.itemZ

1289 z: stageMaths.itemZ

1282 requestedWidth: stageMaths.itemWidth

1290 requestedWidth: stageMaths.itemWidth

1283− requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - PanelState.panelHeight

1291+ requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - panelState.panelHeight

1284 visuallyMaximized: true

1292 visuallyMaximized: true

1285 visible: appDelegate.x < root.width

1293 visible: appDelegate.x < root.width

1286 }

1294 }

@@ -1345,9 +1353,9 @@ FocusScope {

1345 PropertyChanges {

1353 PropertyChanges {

1346 target: appDelegate

1354 target: appDelegate

1347 windowedX: root.leftMargin

1355 windowedX: root.leftMargin

1348− windowedY: PanelState.panelHeight

1356+ windowedY: panelState.panelHeight

1349 windowedWidth: (appContainer.width - root.leftMargin)/2

1357 windowedWidth: (appContainer.width - root.leftMargin)/2

1350− windowedHeight: appContainer.height - PanelState.panelHeight

1358+ windowedHeight: appContainer.height - panelState.panelHeight

1351 }

1359 }

1352 },

1360 },

1353 State {

1361 State {

@@ -1364,9 +1372,9 @@ FocusScope {

1364 PropertyChanges {

1372 PropertyChanges {

1365 target: appDelegate

1373 target: appDelegate

1366 windowedX: root.leftMargin

1374 windowedX: root.leftMargin

1367− windowedY: PanelState.panelHeight

1375+ windowedY: panelState.panelHeight

1368 windowedWidth: (appContainer.width - root.leftMargin)/2

1376 windowedWidth: (appContainer.width - root.leftMargin)/2

1369− windowedHeight: (appContainer.height - PanelState.panelHeight)/2

1377+ windowedHeight: (appContainer.height - panelState.panelHeight)/2

1370 }

1378 }

1371 },

1379 },

1372 State {

1380 State {

@@ -1383,7 +1391,7 @@ FocusScope {

1383 PropertyChanges {

1391 PropertyChanges {

1384 target: appDelegate

1392 target: appDelegate

1385 windowedX: root.leftMargin

1393 windowedX: root.leftMargin

1386− windowedY: (appContainer.height + PanelState.panelHeight)/2

1394+ windowedY: (appContainer.height + panelState.panelHeight)/2

1387 windowedWidth: (appContainer.width - root.leftMargin)/2

1395 windowedWidth: (appContainer.width - root.leftMargin)/2

1388 windowedHeight: appContainer.height/2

1396 windowedHeight: appContainer.height/2

1389 }

1397 }

@@ -1405,8 +1413,8 @@ FocusScope {

1405 State {

1413 State {

1406 name: "maximizedVertically"; when: appDelegate.maximizedVertically && !appDelegate.minimized

1414 name: "maximizedVertically"; when: appDelegate.maximizedVertically && !appDelegate.minimized

1407 extend: "normal"

1415 extend: "normal"

1408− PropertyChanges { target: appDelegate; windowedX: windowedX; windowedY: PanelState.panelHeight;

1416+ PropertyChanges { target: appDelegate; windowedX: windowedX; windowedY: panelState.panelHeight;

1409− windowedWidth: windowedWidth; windowedHeight: appContainer.height - PanelState.panelHeight }

1417+ windowedWidth: windowedWidth; windowedHeight: appContainer.height - panelState.panelHeight }

1410 },

1418 },

1411 State {

1419 State {

1412 name: "minimized"; when: appDelegate.minimized

1420 name: "minimized"; when: appDelegate.minimized

@@ -1505,7 +1513,7 @@ FocusScope {

1505 ]

1513 ]

1506

1514

1507 Binding {

1515 Binding {

1508− target: PanelState

1516+ target: panelState

1509 property: "decorationsAlwaysVisible"

1517 property: "decorationsAlwaysVisible"

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

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

1511 }

1519 }

@@ -1520,7 +1528,7 @@ FocusScope {

1520 anchors.margins: touchControls.overlayShown ? borderThickness/2 : -borderThickness

1528 anchors.margins: touchControls.overlayShown ? borderThickness/2 : -borderThickness

1521

1529

1522 target: appDelegate

1530 target: appDelegate

1523− minimumY: PanelState.panelHeight // disallow resizing up past Panel

1531+ minimumY: panelState.panelHeight // disallow resizing up past Panel

1524 minWidth: units.gu(10)

1532 minWidth: units.gu(10)

1525 minHeight: units.gu(10)

1533 minHeight: units.gu(10)

1526 borderThickness: units.gu(2)

1534 borderThickness: units.gu(2)

@@ -1550,6 +1558,7 @@ FocusScope {

1550 highlightSize: windowInfoItem.iconMargin / 2

1558 highlightSize: windowInfoItem.iconMargin / 2

1551 stageWidth: appContainer.width

1559 stageWidth: appContainer.width

1552 stageHeight: appContainer.height

1560 stageHeight: appContainer.height

1561+ panelState: root.panelState

1553

1562

1554 requestedWidth: appDelegate.requestedWidth

1563 requestedWidth: appDelegate.requestedWidth

1555 requestedHeight: appDelegate.requestedHeight

1564 requestedHeight: appDelegate.requestedHeight

@@ -1609,6 +1618,7 @@ FocusScope {

1609 visible: enabled

1618 visible: enabled

1610 stageWidth: appContainer.width

1619 stageWidth: appContainer.width

1611 stageHeight: appContainer.height

1620 stageHeight: appContainer.height

1621+ panelState: root.panelState

1612

1622

1613 onFakeMaximizeAnimationRequested: if (!appDelegate.maximized) fakeRectangle.maximize(amount, true)

1623 onFakeMaximizeAnimationRequested: if (!appDelegate.maximized) fakeRectangle.maximize(amount, true)

1614 onFakeMaximizeLeftAnimationRequested: if (!appDelegate.maximizedLeft) fakeRectangle.maximizeLeft(amount, true)

1624 onFakeMaximizeLeftAnimationRequested: if (!appDelegate.maximizedLeft) fakeRectangle.maximizeLeft(amount, true)

@@ -1713,6 +1723,7 @@ FocusScope {

1713 leftMargin: root.leftMargin

1723 leftMargin: root.leftMargin

1714 appContainerWidth: appContainer.width

1724 appContainerWidth: appContainer.width

1715 appContainerHeight: appContainer.height

1725 appContainerHeight: appContainer.height

1726+ panelState: root.panelState

1716 }

1727 }

1717

1728

1718 EdgeBarrier {

1729 EdgeBarrier {

qml/Stage/SurfaceContainer.qml+2

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

66 fillMode: MirSurfaceItem.PadOrCrop

67 consumesInput: true

68

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

70+

69 surfaceWidth: root.requestedWidth

71 surfaceWidth: root.requestedWidth

70 surfaceHeight: root.requestedHeight

72 surfaceHeight: root.requestedHeight

71

73

qml/Stage/WindowControlsOverlay.qml+2

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

27

28 // to be set from outside

29 property Item target // appDelegate

30+ property PanelState panelState

30 property alias stageWidth: moveHandler.stageWidth

31 property alias stageWidth: moveHandler.stageWidth

31 property alias stageHeight: moveHandler.stageHeight

32 property alias stageHeight: moveHandler.stageHeight

32

33

@@ -161,6 +162,7 @@ Item {

161 id: moveHandler

162 id: moveHandler

162 objectName: "moveHandler"

163 objectName: "moveHandler"

163 target: root.target

164 target: root.target

165+ panelState: root.panelState

164

166

165 onFakeMaximizeAnimationRequested: root.fakeMaximizeAnimationRequested(amount)

167 onFakeMaximizeAnimationRequested: root.fakeMaximizeAnimationRequested(amount)

166 onFakeMaximizeLeftAnimationRequested: root.fakeMaximizeLeftAnimationRequested(amount)

168 onFakeMaximizeLeftAnimationRequested: root.fakeMaximizeLeftAnimationRequested(amount)

qml/Stage/WorkspacePreview.qmlnew file+92

@@ -0,0 +1,92 @@

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

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+ Column {

24+ anchors.fill: parent

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

26+

27+ Label {

28+ text: model.name

29+ color: "black"

30+ }

31+

32+ Label {

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

34+ color: "black"

35+ fontSize: "x-small"

36+ }

37+

38+ Label {

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

40+ color: "black"

41+ fontSize: "x-small"

42+ }

43+ }

44+ }

45+

46+

47+ Wallpaper {

48+ anchors.fill: parent

49+ anchors.topMargin: header.height

50+ source: previewSpace.background

51+ clip: true

52+

53+ Repeater {

54+ id: topLevelSurfaceRepeater

55+ model: topLevelSurfaceList

56+ delegate: Rectangle {

57+ width: surfaceItem.width

58+ height: surfaceItem.height + decorationHeight * previewScale

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

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

61+ color: "blue"

62+ z: topLevelSurfaceRepeater.count - index

63+

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

65+

66+ WindowDecoration {

67+ width: surfaceItem.implicitWidth

68+ height: parent.decorationHeight

69+ transform: Scale {

70+ origin.x: 0

71+ origin.y: 0

72+ xScale: previewScale

73+ yScale: previewScale

74+ }

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

76+ z: 3

77+ }

78+

79+ MirSurfaceItem {

80+ id: surfaceItem

81+ y: parent.decorationHeight * previewScale

82+ width: implicitWidth * previewScale

83+ height: implicitHeight * previewScale

84+ surfaceWidth: -1

85+ surfaceHeight: -1

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

87+ surface: model.window.surface

88+ }

89+ }

90+ }

91+ }

92+}

qml/qmldirnew file+1

@@ -0,0 +1 @@

1+singleton ShellNotifier 0.1 ShellNotifier.qml

src/ApplicationArguments.cpp+11−2

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

16

17#include "ApplicationArguments.h"

18

19−ApplicationArguments::ApplicationArguments(QObject *parent)

19+ApplicationArguments::ApplicationArguments(QCoreApplication *app)

20− : QObject(parent)

20+ : QObject(app)

21+ , UnityCommandLineParser(*app)

21{

22{

22}

23}

24+

25+void ApplicationArguments::setDeviceName(const QString &deviceName)

26+{

27+ if (deviceName != m_deviceName) {

28+ m_deviceName = deviceName;

29+ Q_EMIT deviceNameChanged(m_deviceName);

30+ }

31+}

src/ApplicationArguments.h+16−15

@@ -23,31 +23,32 @@

23#include <QSize>

24#include <QString>

25

26+#include "UnityCommandLineParser.h"

27+

26−class ApplicationArguments : public QObject

28+class ApplicationArguments : public QObject,

29+ public UnityCommandLineParser

27{

30{

28 Q_OBJECT

31 Q_OBJECT

29 Q_PROPERTY(QString deviceName READ deviceName NOTIFY deviceNameChanged)

32 Q_PROPERTY(QString deviceName READ deviceName NOTIFY deviceNameChanged)

30 Q_PROPERTY(QString mode READ mode CONSTANT)

33 Q_PROPERTY(QString mode READ mode CONSTANT)

34+

35+ Q_PROPERTY(bool hasGeometry READ hasGeometry CONSTANT)

36+ Q_PROPERTY(QSize windowGeometry READ windowGeometry CONSTANT)

37+ Q_PROPERTY(bool hasTestability READ hasTestability CONSTANT)

38+ Q_PROPERTY(bool hasFrameless READ hasFrameless CONSTANT)

39+#ifdef UNITY8_ENABLE_TOUCH_EMULATION

40+ Q_PROPERTY(bool hasMouseToTouch READ hasMouseToTouch CONSTANT)

41+#endif

42+

31public:

43public:

32− ApplicationArguments(QObject *parent = nullptr);

44+ ApplicationArguments(QCoreApplication *app);

33

45

34− void setDeviceName(const QString &deviceName) {

46+ void setDeviceName(const QString &deviceName);

35− if (deviceName != m_deviceName) {

36− m_deviceName = deviceName;

37− Q_EMIT deviceNameChanged(m_deviceName);

38− }

39− }

40− QString deviceName() const { return m_deviceName; }

41

47

42− void setMode(const QString &mode) { m_mode = mode; }

48+ bool hasGeometry() const { return m_windowGeometry.isValid(); }

43− QString mode() const { return m_mode; }

44

49

45Q_SIGNALS:

50Q_SIGNALS:

46 void deviceNameChanged(const QString&);

51 void deviceNameChanged(const QString&);

47−

48−private:

49− QString m_deviceName;

50− QString m_mode;

51};

52};

52

53

53#endif // APPLICATION_ARGUMENTS_H

54#endif // APPLICATION_ARGUMENTS_H

src/CMakeLists.txt−2

@@ -27,9 +27,7 @@ set(SOURCE_FILES

27 ApplicationArguments.cpp

28 main.cpp

29 CachingNetworkManagerFactory.cpp

30− SecondaryWindow.cpp

31 ShellApplication.cpp

30 ShellApplication.cpp

32− ShellView.cpp

33 UnityCommandLineParser.cpp

31 UnityCommandLineParser.cpp

34 UnixSignalHandler.cpp

32 UnixSignalHandler.cpp

35 DebuggingController.cpp

33 DebuggingController.cpp

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+29−106

@@ -20,6 +20,7 @@

20#include <QLibrary>

21#include <QProcess>

22#include <QScreen>

23+#include <QQmlContext>

23

24

24#include <libintl.h>

25#include <libintl.h>

25

26

@@ -34,30 +35,22 @@

34

35

35ShellApplication::ShellApplication(int & argc, char ** argv, bool isMirServer)

36ShellApplication::ShellApplication(int & argc, char ** argv, bool isMirServer)

36 : QGuiApplication(argc, argv)

37 : QGuiApplication(argc, argv)

38+ , m_qmlArgs(this)

37{

39{

38 setApplicationName(QStringLiteral("unity8"));

40 setApplicationName(QStringLiteral("unity8"));

39 setOrganizationName(QStringLiteral("Canonical"));

41 setOrganizationName(QStringLiteral("Canonical"));

40

42

41− connect(this, &QGuiApplication::screenAdded, this, &ShellApplication::onScreenAdded);

42−

43 setupQmlEngine(isMirServer);

44

45− UnityCommandLineParser parser(*this);

46−

47− if (!parser.deviceName().isEmpty()) {

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

48− m_deviceName = parser.deviceName();

49− } else {

50 char buffer[200];

46 char buffer[200];

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

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

52− m_deviceName = QString(buffer);

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

53 }

49 }

54− m_qmlArgs.setDeviceName(m_deviceName);

55−

56− m_qmlArgs.setMode(parser.mode());

57

50

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

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

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

52 // 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")) {

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

61 QLibrary testLib(QStringLiteral("qttestability"));

54 QLibrary testLib(QStringLiteral("qttestability"));

62 if (testLib.load()) {

55 if (testLib.load()) {

63 typedef void (*TasInitialize)(void);

56 typedef void (*TasInitialize)(void);

@@ -75,58 +68,41 @@ ShellApplication::ShellApplication(int & argc, char ** argv, bool isMirServer)

75 bindtextdomain("unity8", translationDirectory().toUtf8().data());

68 bindtextdomain("unity8", translationDirectory().toUtf8().data());

76 textdomain("unity8");

69 textdomain("unity8");

77

70

78− m_shellView = new ShellView(m_qmlEngine, &m_qmlArgs);

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

79−

80− if (parser.windowGeometry().isValid()) {

81− m_shellView->setWidth(parser.windowGeometry().width());

82− m_shellView->setHeight(parser.windowGeometry().height());

83− }

84

72

85− if (parser.hasFrameless()) {

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

86− m_shellView->setFlags(Qt::FramelessWindowHint);

74+ bool ok;

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

76+ if (!ok) {

77+ pxpgu = 8;

87 }

78 }

88−

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

80+ m_qmlEngine->load(::qmlDirectory() + "/ShellApplication.qml");

89

81

90 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

82 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

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

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

92 // Needed only when manually testing on a desktop.

84 // Needed only when manually testing on a desktop.

93− if (parser.hasMouseToTouch()) {

85+ if (m_qmlArgs.hasMouseToTouch()) {

94 m_mouseTouchAdaptor = MouseTouchAdaptor::instance();

86 m_mouseTouchAdaptor = MouseTouchAdaptor::instance();

95 }

87 }

96 #endif

88 #endif

97

89

98 new DebuggingController(this);

90 new DebuggingController(this);

99

91

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

92+// if (parser.mode().compare("greeter") == 0) {

117− QSize primaryScreenSize = this->primaryScreen()->size();

93+// QSize primaryScreenSize = this->primaryScreen()->size();

118− m_shellView->setHeight(primaryScreenSize.height());

94+// m_shellView->setHeight(primaryScreenSize.height());

119− m_shellView->setWidth(primaryScreenSize.width());

95+// m_shellView->setWidth(primaryScreenSize.width());

120− m_shellView->show();

96+// m_shellView->show();

121− m_shellView->requestActivate();

97+// m_shellView->requestActivate();

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

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

123− qDebug() << "Unable to send unity8-greeter-started event to Upstart";

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

124− }

100+// }

125− } else if (isMirServer || parser.hasFullscreen()) {

101+// } else if (isMirServer || parser.hasFullscreen()) {

126− m_shellView->showFullScreen();

102+// m_shellView->showFullScreen();

127− } else {

103+// } else {

128− m_shellView->show();

104+// m_shellView->show();

129− }

105+// }

130}

106}

131

107

132ShellApplication::~ShellApplication()

108ShellApplication::~ShellApplication()

@@ -136,14 +112,6 @@ ShellApplication::~ShellApplication()

136

112

137void ShellApplication::destroyResources()

113void ShellApplication::destroyResources()

138{

114{

139− // Deletion order is important. Don't use QScopedPointers and the like

140− // Otherwise the process will hang on shutdown (bug somewhere I guess).

141− delete m_shellView;

142− m_shellView = nullptr;

143−

144− delete m_secondaryWindow;

145− m_secondaryWindow = nullptr;

146−

147 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

115 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

148 delete m_mouseTouchAdaptor;

116 delete m_mouseTouchAdaptor;

149 m_mouseTouchAdaptor = nullptr;

117 m_mouseTouchAdaptor = nullptr;

@@ -155,7 +123,7 @@ void ShellApplication::destroyResources()

155

123

156void ShellApplication::setupQmlEngine(bool isMirServer)

124void ShellApplication::setupQmlEngine(bool isMirServer)

157{

125{

158− m_qmlEngine = new QQmlEngine(this);

126+ m_qmlEngine = new QQmlApplicationEngine(this);

159

127

160 m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));

128 m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));

161

129

@@ -169,48 +137,3 @@ void ShellApplication::setupQmlEngine(bool isMirServer)

169

137

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

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

171}

139}

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

@@ -18,7 +18,7 @@

18#define SHELLAPPLICATION_H

19

20#include <QGuiApplication>

21−#include <QQmlEngine>

21+#include <QQmlApplicationEngine>

22#include <QQuickView>

23#include <QScopedPointer>

24

@@ -28,9 +28,6 @@

28#include "MouseTouchAdaptor.h"

29#endif

30

31−#include "SecondaryWindow.h"

32−#include "ShellView.h"

33−

34class ShellApplication : public QGuiApplication

31class ShellApplication : public QGuiApplication

35{

32{

36 Q_OBJECT

33 Q_OBJECT

@@ -39,25 +36,16 @@ public:

39 virtual ~ShellApplication();

36 virtual ~ShellApplication();

40

37

41 void destroyResources();

38 void destroyResources();

42−public Q_SLOTS:

43− // called by qtmir

44− void onScreenAboutToBeRemoved(QScreen *screen);

45−

46−private Q_SLOTS:

47− void onScreenAdded(QScreen*);

48

39

49private:

40private:

50 void setupQmlEngine(bool isMirServer);

41 void setupQmlEngine(bool isMirServer);

51− QString m_deviceName;

52 ApplicationArguments m_qmlArgs;

42 ApplicationArguments m_qmlArgs;

53− ShellView *m_shellView{nullptr};

54− SecondaryWindow *m_secondaryWindow{nullptr};

55

43

56 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

44 #ifdef UNITY8_ENABLE_TOUCH_EMULATION

57 MouseTouchAdaptor *m_mouseTouchAdaptor{nullptr};

45 MouseTouchAdaptor *m_mouseTouchAdaptor{nullptr};

58 #endif

46 #endif

59

47

60− QQmlEngine *m_qmlEngine{nullptr};

48+ QQmlApplicationEngine *m_qmlEngine{nullptr};

61};

49};

62

50

63#endif // SHELLAPPLICATION_H

51#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/ShellView.hdeleted−34

@@ -1,34 +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−#ifndef UNITY_SHELL_VIEW_H

18−#define UNITY_SHELL_VIEW_H

19−

20−#include <QQuickView>

21−

22−class ShellView : public QQuickView

23−{

24− Q_OBJECT

25−

26−public:

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

28−

29−private Q_SLOTS:

30− void onWidthChanged(int);

31− void onHeightChanged(int);

32−};

33−

34−#endif // UNITY_SHELL_VIEW_H

src/UnityCommandLineParser.h+1−1

@@ -36,8 +36,8 @@ public:

36 bool hasFullscreen() const { return m_hasFullscreen; }

37 QString deviceName() const { return m_deviceName; }

38 QString mode() const { return m_mode; }

39−private:

40

39

40+protected:

41 int parsePixelsValue(const QString &str);

42 static float getenvFloat(const char* name, float defaultValue);

43 void resolveMode(QCommandLineParser &parser, QCommandLineOption &modeOption);

tests/mocks/Cursor/Cursor.qml+49−2

@@ -15,8 +15,11 @@

15 */

16

17import QtQuick 2.4

18+import UInput 0.1

19+

20+Canvas {

21+ id: root

18

22

19−Item {

20 property int topBoundaryOffset // effectively panel height

23 property int topBoundaryOffset // effectively panel height

21 property Item confiningItem

24 property Item confiningItem

22

25

@@ -30,5 +33,49 @@ Item {

30 signal pushStopped()

33 signal pushStopped()

31 signal mouseMoved()

34 signal mouseMoved()

32

35

36+ width: units.gu(2)

37+ height: units.gu(2)

38+ antialiasing: true

39+

40+ onPaint: {

41+ var ctx = getContext("2d");

42+ ctx.save();

43+ ctx.clearRect(0,0,width, height);

44+ ctx.strokeStyle = "#000000";

45+ ctx.lineWidth = 1

46+ ctx.fillStyle = "#ffffff";

47+ ctx.globalAlpha = 1.0;

48+ ctx.lineJoin = "round";

49+ ctx.beginPath();

50+

51+ // put rectangle in the middle

52+ // draw the rectangle

53+ ctx.moveTo(width/2,height);

54+ ctx.lineTo(width, height/2);

55+ ctx.lineTo(0,0);

56+

57+ ctx.closePath();

58+ ctx.fill();

59+ ctx.stroke();

60+ ctx.restore();

61+ }

62+

63+ Connections {

64+ target: UInput

33− onMouseMoved: opacity = 1;

65+ onMouseMoved: {

66+ var newX = root.x;

67+ newX += dx;

68+ if (newX < 0) newX = 0;

69+ else if (newX >= parent.width) newX = parent.width-1;

70+

71+ var newY = root.y;

72+ newY += dy;

73+ if (newY < 0) newY = 0;

74+ else if (newY >= parent.height) newY = parent.height-1;

75+

76+ root.x = newX;

77+ root.y = newY;

78+ root.mouseMoved();

79+ }

80+ }

34}

81}

tests/mocks/GSettings.1.0/plugin.cpp+12

@@ -18,6 +18,8 @@

18#include "fake_gsettings.h"

19

20#include <QtQml/qqml.h>

21+#include <QQmlEngine>

22+#include <QQmlContext>

21

23

22static QObject* controllerProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)

24static QObject* controllerProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)

23{

25{

@@ -31,3 +33,13 @@ void FakeGSettingsQmlPlugin::registerTypes(const char *uri)

31 qmlRegisterUncreatableType<GSettingsSchemaQml>(uri, 1, 0, "GSettingsSchema",

33 qmlRegisterUncreatableType<GSettingsSchemaQml>(uri, 1, 0, "GSettingsSchema",

32 "GSettingsSchema can only be used inside of a GSettings component");

34 "GSettingsSchema can only be used inside of a GSettings component");

33}

35}

36+

37+void FakeGSettingsQmlPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

38+{

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

40+

41+ QString usageType = qgetenv("UNITY_MOCK_DESKTOP");

42+ if (!usageType.isEmpty()) {

43+ GSettingsControllerQml::instance()->setUsageMode("Windowed");

44+ }

45+}

tests/mocks/GSettings.1.0/plugin.h+1

@@ -26,6 +26,7 @@ class FakeGSettingsQmlPlugin : public QQmlExtensionPlugin

26

27public:

28 void registerTypes(const char *uri) override;

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

29};

30};

30

31

31#endif // PLUGIN_H

32#endif // PLUGIN_H

tests/mocks/UInput/plugin.cpp+6−1

@@ -19,8 +19,13 @@

19

20#include <QtQml/qqml.h>

21

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

23+{

24+ return new MockUInput;

25+}

26+

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

27void MockUInputPlugin::registerTypes(const char *uri)

23{

28{

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

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

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

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

26}

31}

tests/mocks/Unity/Application/MirSurfaceItem.cpp+23−4

@@ -185,8 +185,13 @@ void MirSurfaceItem::createQmlContentItem()

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

186 m_qmlItem->setParentItem(this);

187

188+ if (m_fillMode == FillMode::Stretch) {

189+ m_qmlItem->setWidth(width());

190+ m_qmlItem->setHeight(height());

191+ } else {

188− m_qmlItem->setWidth(m_surfaceWidth);

192+ m_qmlItem->setWidth(m_surfaceWidth);

189− m_qmlItem->setHeight(m_surfaceHeight);

193+ m_qmlItem->setHeight(m_surfaceHeight);

194+ }

190

195

191 setImplicitWidth(m_qmlItem->implicitWidth());

196 setImplicitWidth(m_qmlItem->implicitWidth());

192 setImplicitHeight(m_qmlItem->implicitHeight());

197 setImplicitHeight(m_qmlItem->implicitHeight());

@@ -293,6 +298,14 @@ void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

293 connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);

298 connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);

294 connect(m_qmlSurface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);

299 connect(m_qmlSurface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);

295 connect(m_qmlSurface, &MirSurface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);

300 connect(m_qmlSurface, &MirSurface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);

301+ connect(m_qmlSurface, &MirSurface::sizeChanged, this, [this] () {

302+ if (m_fillMode == FillMode::Stretch) {

303+ m_qmlItem->setSize(QSize(this->width(), this->height()));

304+ } else {

305+ m_qmlItem->setSize(m_qmlSurface->size());

306+ }

307+ setImplicitSize(m_qmlSurface->width(), m_qmlSurface->height());

308+ });

296

309

297 QUrl qmlComponentFilePath;

310 QUrl qmlComponentFilePath;

298 if (!m_qmlSurface->qmlFilePath().isEmpty()) {

311 if (!m_qmlSurface->qmlFilePath().isEmpty()) {

@@ -384,9 +397,15 @@ void MirSurfaceItem::updateSurfaceSize()

384 if (m_qmlSurface && m_surfaceWidth > 0 && m_surfaceHeight > 0) {

397 if (m_qmlSurface && m_surfaceWidth > 0 && m_surfaceHeight > 0) {

385 m_qmlSurface->resize(m_surfaceWidth, m_surfaceHeight);

398 m_qmlSurface->resize(m_surfaceWidth, m_surfaceHeight);

386 if (m_qmlItem) {

399 if (m_qmlItem) {

400+ if (m_fillMode == FillMode::Stretch) {

401+ m_qmlItem->setWidth(width());

402+ m_qmlItem->setHeight(height());

403+ } else {

387− m_qmlItem->setWidth(m_surfaceWidth);

404+ m_qmlItem->setWidth(m_surfaceWidth);

388− m_qmlItem->setHeight(m_surfaceHeight);

405+ m_qmlItem->setHeight(m_surfaceHeight);

406+ }

389 }

407 }

408+ qDebug() << this << "setting implicitsize" << m_surfaceWidth << m_surfaceHeight;

390 setImplicitSize(m_surfaceWidth, m_surfaceHeight);

409 setImplicitSize(m_surfaceWidth, m_surfaceHeight);

391 }

410 }

392}

411}

tests/mocks/Unity/Application/SurfaceManager.cpp+1−1

@@ -21,7 +21,7 @@

21

22#include <paths.h>

23

24−#define SURFACEMANAGER_DEBUG 0

24+#define SURFACEMANAGER_DEBUG 1

25

26#if SURFACEMANAGER_DEBUG

27#define DEBUG_MSG(params) qDebug().nospace() << "SurfaceManager[" << (void*)this << "]::" << __func__ << params

tests/mocks/Unity/InputInfo/InputWindow.qmlnew file+68

@@ -0,0 +1,68 @@

1+import QtQuick 2.4

2+import Ubuntu.Components 1.3

3+import Unity.InputInfo 0.1

4+

5+Rectangle {

6+ id: rect

7+ color: "white"

8+ width: parent.width

9+ height: parent.height

10+

11+ Action {

12+ id: mouseAction

13+ text: checked ? "Remove Mouse" : "Add Mouse"

14+ onTriggered: {

15+ if (checked) {

16+ console.log("ADD")

17+ MockInputDeviceBackend.addMockDevice("/mouse0", InputInfo.Mouse);

18+ } else {

19+ console.log("REMOVE")

20+ MockInputDeviceBackend.removeDevice("/mouse0");

21+ }

22+ }

23+ iconName: "input-mouse-symbolic"

24+ checkable: true

25+ checked: false

26+ }

27+

28+ Action {

29+ id: kbAction

30+ text: checked ? "Remove Keyboard" : "Add Keyboard"

31+ onTriggered: {

32+ if (checked) {

33+ MockInputDeviceBackend.addMockDevice("/kbd0", InputInfo.Keyboard);

34+ } else {

35+ MockInputDeviceBackend.removeDevice("/kbd0");

36+ }

37+ }

38+ iconName: "input-keyboard-symbolic"

39+ checkable: true

40+ checked: false

41+ }

42+

43+ Column {

44+ anchors {

45+ fill: parent

46+ margins: units.gu(1)

47+ }

48+ spacing: units.gu(1)

49+

50+ Button {

51+ anchors {

52+ left: parent.left

53+ right: parent.right

54+ }

55+ action: mouseAction

56+ color: mouseAction.checked ? UbuntuColors.red : UbuntuColors.green

57+ }

58+

59+ Button {

60+ anchors {

61+ left: parent.left

62+ right: parent.right

63+ }

64+ action: kbAction

65+ color: kbAction.checked ? UbuntuColors.red : UbuntuColors.green

66+ }

67+ }

68+}

tests/mocks/Unity/InputInfo/mockcontroller.cpp+24−2

@@ -18,10 +18,32 @@

18

19#include "qinputdeviceinfo_mock_p.h"

20

21+#include <QQuickView>

22+#include <QQmlComponent>

23+#include <QQuickItem>

24+#include <paths.h>

25+

21−MockController::MockController(QObject *parent):

26+MockController::MockController(QQmlEngine *engine)

22− QObject(parent)

23{

27{

28+ QQmlComponent component(engine);

29+ component.setData("import QtQuick 2.4; import Unity.InputInfo 0.1; InputWindow { }", ::qmlDirectory());

30+ QObject *myObject = component.create();

31+ QQuickItem *item = qobject_cast<QQuickItem*>(myObject);

32+ if (item) {

33+ auto window = new QQuickView();

34+ window->setTitle("Input");

35+ item->setParentItem(window->contentItem());

36+ window->setResizeMode(QQuickView::SizeRootObjectToView);

37+ window->setWidth(200);

38+ window->setHeight(100);

39+ window->show();

40+ }

41+}

24

42

43+MockController *MockController::instance(QQmlEngine *engine)

44+{

45+ static MockController* controller = new MockController(engine);

46+ return controller;

25}

47}

26

48

27QInputDevice *MockController::addMockDevice(const QString &devicePath, QInputDevice::InputType type)

49QInputDevice *MockController::addMockDevice(const QString &devicePath, QInputDevice::InputType type)

tests/mocks/Unity/InputInfo/mockcontroller.h+5−1

@@ -20,13 +20,17 @@

20#include <QObject>

21#include "qinputinfo.h"

22

23+class QQmlEngine;

24+

23class MockController: public QObject

25class MockController: public QObject

24{

26{

25 Q_OBJECT

27 Q_OBJECT

26public:

28public:

27− MockController(QObject *parent = 0);

29+ MockController(QQmlEngine *engine);

28 ~MockController() = default;

30 ~MockController() = default;

29

31

32+ static MockController *instance(QQmlEngine *engine);

33+

30 Q_INVOKABLE QInputDevice* addMockDevice(const QString &devicePath, QInputDevice::InputType type);

34 Q_INVOKABLE QInputDevice* addMockDevice(const QString &devicePath, QInputDevice::InputType type);

31 Q_INVOKABLE void removeDevice(const QString &devicePath);

35 Q_INVOKABLE void removeDevice(const QString &devicePath);

32};

36};

tests/mocks/Unity/InputInfo/plugin.cpp+1−2

@@ -26,9 +26,8 @@

26

27static QObject *backendProvider(QQmlEngine *engine, QJSEngine *scriptEngine)

28{

29− Q_UNUSED(engine)

30 Q_UNUSED(scriptEngine)

29 Q_UNUSED(scriptEngine)

31− return new MockController(engine);

30+ return MockController::instance(engine);

32}

31}

33

32

34void InputInfoPlugin::registerTypes(const char *uri)

33void InputInfoPlugin::registerTypes(const char *uri)

tests/mocks/Unity/InputInfo/qmldir+2

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

1module Unity.InputInfo

2plugin MockInputInfo

3+

4+InputWindow 0.1 InputWindow.qml

tests/mocks/Unity/Screens/CMakeLists.txt+2−1

@@ -5,10 +5,11 @@ include_directories(

5set(MockScreens_SOURCES

6 plugin.cpp

7 screens.cpp

8+ screenwindow.cpp

8)

9)

9

10

10add_library(MockScreensPlugin MODULE ${MockScreens_SOURCES})

11add_library(MockScreensPlugin MODULE ${MockScreens_SOURCES})

11

12

12−qt5_use_modules(MockScreensPlugin Gui Qml)

13+qt5_use_modules(MockScreensPlugin Gui Qml Quick)

13

14

14add_unity8_mock(Unity.Screens 0.1 Unity/Screens PREFIX mocks TARGETS MockScreensPlugin)

15add_unity8_mock(Unity.Screens 0.1 Unity/Screens PREFIX mocks TARGETS MockScreensPlugin)

tests/mocks/Unity/Screens/plugin.cpp+12−1

@@ -16,14 +16,25 @@

16

17#include "plugin.h"

18#include "screens.h"

19+#include "screenwindow.h"

19

20

20#include <QScreen>

21#include <QScreen>

21

22

23+namespace {

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

25+ Q_UNUSED(engine);

26+ Q_UNUSED(scriptEngine);

27+ return new Screens();

28+}

29+}

30+

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

31void UnityScreensPlugin::registerTypes(const char* uri)

23{

32{

24 Q_ASSERT(QLatin1String(uri) == QLatin1String("Unity.Screens"));

33 Q_ASSERT(QLatin1String(uri) == QLatin1String("Unity.Screens"));

25

34

26 qRegisterMetaType<QScreen*>("QScreen*");

35 qRegisterMetaType<QScreen*>("QScreen*");

27

36

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

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

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

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

29}

40}

tests/mocks/Unity/Screens/screens.cpp+44−2

@@ -26,8 +26,25 @@ Q_DECLARE_METATYPE(QScreen*)

26Screens::Screens(QObject *parent) :

27 QAbstractListModel(parent)

28{

29− // start with one screen attached

29+ bool ok = false;

30− m_screenList.append(new Screen());

30+ int screenCount = qEnvironmentVariableIntValue("UNITY_MOCK_SCREEN_COUNT", &ok);

31+ if (!ok) screenCount = 1;

32+ QPoint lastPoint(0,0);

33+ for (int i = 0; i < screenCount; ++i) {

34+ auto screen = new Screen();

35+ screen->enabled = i == 0;

36+ if (i == 0) {

37+ screen->outputTypes = OutputTypes::LVDS;

38+ } else {

39+ screen->outputTypes = OutputTypes::HDMIA;

40+ }

41+ screen->name = QString("Monitor %1").arg(i);

42+ screen->sizes = { QSize(640,480), QSize(1024,748), QSize(1280,1024), QSize(1440,900), QSize(1920,1080) };

43+ screen->geometry = QRect(lastPoint.x(), lastPoint.y(), 1024, 786 );

44+ m_screenList.append(screen);

45+

46+ lastPoint.rx() += screen->geometry.width();

47+ }

31}

48}

32

49

33Screens::~Screens() noexcept

50Screens::~Screens() noexcept

@@ -41,6 +58,12 @@ QHash<int, QByteArray> Screens::roleNames() const

41 QHash<int, QByteArray> roles;

58 QHash<int, QByteArray> roles;

42 roles[ScreenRole] = "screen";

59 roles[ScreenRole] = "screen";

43 roles[OutputTypeRole] = "outputType";

60 roles[OutputTypeRole] = "outputType";

61+ roles[EnabledRole] = "enabled";

62+ roles[NameRole] = "name";

63+ roles[ScaleRole] = "scale";

64+ roles[FormFactorRole] = "formFactor";

65+ roles[GeometryRole] = "geometry";

66+ roles[SizesRole] = "sizes";

44 return roles;

67 return roles;

45}

68}

46

69

@@ -55,6 +78,25 @@ QVariant Screens::data(const QModelIndex &index, int role) const

55 return QVariant::fromValue(m_screenList.at(index.row())->qScreen);

78 return QVariant::fromValue(m_screenList.at(index.row())->qScreen);

56 case OutputTypeRole:

79 case OutputTypeRole:

57 return m_screenList.at(index.row())->outputTypes;

80 return m_screenList.at(index.row())->outputTypes;

81+ case EnabledRole:

82+ return m_screenList.at(index.row())->enabled;

83+ case NameRole:

84+ return m_screenList.at(index.row())->name;

85+ case ScaleRole:

86+ return m_screenList.at(index.row())->scale;

87+ case FormFactorRole:

88+ return m_screenList.at(index.row())->formFactor;

89+ case GeometryRole:

90+ return m_screenList.at(index.row())->geometry;

91+ case SizesRole:

92+ {

93+ QVariantList sizes;

94+ auto availableSizes = m_screenList.at(index.row())->sizes;

95+ Q_FOREACH(auto size, availableSizes) {

96+ sizes.append(QVariant(size));

97+ }

98+ return sizes;

99+ }

58 }

100 }

59

101

60 return QVariant();

102 return QVariant();

tests/mocks/Unity/Screens/screens.h+22−1

@@ -31,7 +31,13 @@ class Screens : public QAbstractListModel

31public:

32 enum ItemRoles {

33 ScreenRole = Qt::UserRole + 1,

34− OutputTypeRole

34+ OutputTypeRole,

35+ EnabledRole,

36+ NameRole,

37+ ScaleRole,

38+ FormFactorRole,

39+ GeometryRole,

40+ SizesRole

35 };

41 };

36

42

37 enum OutputTypes {

43 enum OutputTypes {

@@ -53,6 +59,15 @@ public:

53 };

59 };

54 Q_ENUM(OutputTypes)

60 Q_ENUM(OutputTypes)

55

61

62+ enum FormFactor {

63+ FormFactorUnknown,

64+ FormFactorPhone,

65+ FormFactorTablet,

66+ FormFactorMonitor,

67+ FormFactorTV,

68+ FormFactorProjector,

69+ };

70+

56 explicit Screens(QObject *parent = 0);

71 explicit Screens(QObject *parent = 0);

57 virtual ~Screens() noexcept;

72 virtual ~Screens() noexcept;

58

73

@@ -77,6 +92,12 @@ class Screen

77public:

92public:

78 Screens::OutputTypes outputTypes = Screens::Unknown;

93 Screens::OutputTypes outputTypes = Screens::Unknown;

79 QScreen *qScreen = nullptr;

94 QScreen *qScreen = nullptr;

95+ bool enabled = false;

96+ QString name = QString();

97+ float scale = 1.0;

98+ Screens::FormFactor formFactor = Screens::FormFactorMonitor;

99+ QRect geometry;

100+ QList<QSize> sizes;

80};

101};

81

102

82#endif // SCREENS_H

103#endif // SCREENS_H

tests/mocks/Unity/Screens/screenwindow.cppnew file+32

@@ -0,0 +1,32 @@

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+

19+ScreenWindow::ScreenWindow(QWindow *parent)

20+ : QQuickWindow(parent)

21+{

22+}

23+

24+QScreen *ScreenWindow::screen() const

25+{

26+ return QQuickWindow::screen();

27+}

28+

29+void ScreenWindow::setScreen(QScreen *screen)

30+{

31+ QQuickWindow::setScreen(screen);

32+}

tests/mocks/Unity/Screens/screenwindow.hnew file+36

@@ -0,0 +1,36 @@

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 SCREENWINDOW_H

18+#define SCREENWINDOW_H

19+

20+#include <QQuickWindow>

21+

22+class ScreenWindow : public QQuickWindow

23+{

24+ Q_OBJECT

25+ Q_PROPERTY(QScreen *screen READ screen WRITE setScreen NOTIFY screenChanged)

26+public:

27+ ScreenWindow(QWindow *parent = 0);

28+

29+ QScreen *screen() const;

30+ void setScreen(QScreen *screen);

31+

32+Q_SIGNALS:

33+ void screenChanged(QScreen *screen);

34+};

35+

36+#endif // SCREENWINDOW_H

tests/qmltests/Components/tst_VirtualTouchPad.qml+2−2

@@ -39,11 +39,11 @@ Rectangle {

39

40 SignalSpy {

41 id: mouseEventSpy1

42− target: touchScreenPad.uinput

42+ target: UInput

43 }

44 SignalSpy {

45 id: mouseEventSpy2

46− target: touchScreenPad.uinput

46+ target: UInput

47 }

48

49 UnityTestCase {

tests/qmltests/Panel/tst_Panel.qml+14−12

@@ -42,6 +42,8 @@ PanelTest {

42 value: keyboardAttached.checked

43 }

44

45+ readonly property alias panelState: panel.panelState

46+

45 SurfaceManager { id: sMgr }

47 SurfaceManager { id: sMgr }

46 ApplicationMenuDataLoader {

48 ApplicationMenuDataLoader {

47 id: appMenuData

49 id: appMenuData

@@ -148,7 +150,7 @@ PanelTest {

148 Layout.fillWidth: true

150 Layout.fillWidth: true

149 CheckBox {

151 CheckBox {

150 id: windowControlsCB

152 id: windowControlsCB

151− onClicked: PanelState.decorationsVisible = checked

153+ onClicked: panelState.decorationsVisible = checked

152 }

154 }

153 Label {

155 Label {

154 text: "Show window decorations"

156 text: "Show window decorations"

@@ -159,7 +161,7 @@ PanelTest {

159 RowLayout {

161 RowLayout {

160 Layout.fillWidth: true

162 Layout.fillWidth: true

161 CheckBox {

163 CheckBox {

162− onClicked: PanelState.title = checked ? "Fake window title" : ""

164+ onClicked: panelState.title = checked ? "Fake window title" : ""

163 }

165 }

164 Label {

166 Label {

165 text: "Show fake window title"

167 text: "Show fake window title"

@@ -245,7 +247,7 @@ PanelTest {

245

247

246 SignalSpy {

248 SignalSpy {

247 id: windowControlButtonsSpy

249 id: windowControlButtonsSpy

248− target: PanelState

250+ target: panelState

249 signalName: "closeClicked"

251 signalName: "closeClicked"

250 }

252 }

251

253

@@ -255,8 +257,8 @@ PanelTest {

255 panel.fullscreenMode = false;

257 panel.fullscreenMode = false;

256 callManager.foregroundCall = null;

258 callManager.foregroundCall = null;

257

259

258− PanelState.title = "";

260+ panelState.title = "";

259− PanelState.decorationsVisible = false;

261+ panelState.decorationsVisible = false;

260

262

261 // Wait for the indicators to get into position.

263 // Wait for the indicators to get into position.

262 // (switches between normal and fullscreen modes are animated)

264 // (switches between normal and fullscreen modes are animated)

@@ -445,7 +447,7 @@ PanelTest {

445 }

447 }

446

448

447 function test_hint(data) {

449 function test_hint(data) {

448− PanelState.title = "Fake Title"

450+ panelState.title = "Fake Title"

449 panel.fullscreenMode = data.fullscreen;

451 panel.fullscreenMode = data.fullscreen;

450 callManager.foregroundCall = data.call;

452 callManager.foregroundCall = data.call;

451

453

@@ -487,7 +489,7 @@ PanelTest {

487 // menus, first by running the hint animation, then after dragging down will

489 // menus, first by running the hint animation, then after dragging down will

488 // expose more of the panel. Releasing the touch will complete the show.

490 // expose more of the panel. Releasing the touch will complete the show.

489 function test_drag_applicationMenu_down_shows_menu(data) {

491 function test_drag_applicationMenu_down_shows_menu(data) {

490− PanelState.title = "Fake Title";

492+ panelState.title = "Fake Title";

491 panel.fullscreenMode = data.fullscreen;

493 panel.fullscreenMode = data.fullscreen;

492 callManager.foregroundCall = data.call;

494 callManager.foregroundCall = data.call;

493

495

@@ -578,7 +580,7 @@ PanelTest {

578 }

580 }

579

581

580 function test_darkenedAreaEatsAllApplicationMenuEvents() {

582 function test_darkenedAreaEatsAllApplicationMenuEvents() {

581− PanelState.title = "Fake Title"

583+ panelState.title = "Fake Title"

582

584

583 // The center of the area not covered by the indicators menu

585 // The center of the area not covered by the indicators menu

584 // Ie, the visible darkened area behind the menu

586 // Ie, the visible darkened area behind the menu

@@ -699,7 +701,7 @@ PanelTest {

699 var windowControlArea = findChild(panel, "windowControlArea");

701 var windowControlArea = findChild(panel, "windowControlArea");

700 verify(windowControlArea, "Window control area should have been created in windowed mode")

702 verify(windowControlArea, "Window control area should have been created in windowed mode")

701

703

702− PanelState.decorationsVisible = true;

704+ panelState.decorationsVisible = true;

703 // click in very topleft corner and verify the close button got clicked too

705 // click in very topleft corner and verify the close button got clicked too

704 mouseMove(panel, 0, 0);

706 mouseMove(panel, 0, 0);

705 mouseClick(panel, 0, 0, undefined /*button*/, undefined /*modifiers*/, 100 /*short delay*/);

707 mouseClick(panel, 0, 0, undefined /*button*/, undefined /*modifiers*/, 100 /*short delay*/);

@@ -760,7 +762,7 @@ PanelTest {

760 }

762 }

761

763

762 function test_stagedApplicationMenuBarShowOnMouseHover() {

764 function test_stagedApplicationMenuBarShowOnMouseHover() {

763− PanelState.title = "Fake Title";

765+ panelState.title = "Fake Title";

764 panel.mode = "staged";

766 panel.mode = "staged";

765 mouseEmulation.checked = false;

767 mouseEmulation.checked = false;

766

768

@@ -778,7 +780,7 @@ PanelTest {

778 }

780 }

779

781

780 function test_windowedApplicationMenuShowOnMouseHoverWhenDecorationsShown() {

782 function test_windowedApplicationMenuShowOnMouseHoverWhenDecorationsShown() {

781− PanelState.title = "Fake Title";

783+ panelState.title = "Fake Title";

782 panel.mode = "windowed";

784 panel.mode = "windowed";

783 mouseEmulation.checked = false;

785 mouseEmulation.checked = false;

784

786

@@ -794,7 +796,7 @@ PanelTest {

794 tryCompare(appTitle, "visible", true, undefined, "App title should still be visible on mouse hover when panel decorations are not visible");

796 tryCompare(appTitle, "visible", true, undefined, "App title should still be visible on mouse hover when panel decorations are not visible");

795 tryCompare(appMenuBar, "visible", false, undefined, "App menu bar should be visible on mouse hover when panel decorations are not visible");

797 tryCompare(appMenuBar, "visible", false, undefined, "App menu bar should be visible on mouse hover when panel decorations are not visible");

796

798

797− PanelState.decorationsVisible = true;

799+ panelState.decorationsVisible = true;

798

800

799 tryCompare(appTitle, "visible", false, undefined, "App title should still be visible on mouse hover when panel decorations are visible");

801 tryCompare(appTitle, "visible", false, undefined, "App title should still be visible on mouse hover when panel decorations are visible");

800 tryCompare(appMenuBar, "visible", true, undefined, "App menu bar should be visible on mouse hover when panel decorations not visible");

802 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 {

52 surfaceManager: sMgr

53 }

54

55+ PanelState {

56+ id: panelState

57+ }

58+

55 Item {

59 Item {

56 id: fakeShell

60 id: fakeShell

57

61

@@ -99,7 +103,7 @@ Rectangle {

99 surface: fakeApplication && fakeApplication.surfaceList.count > 0 ? fakeApplication.surfaceList.get(0) : null

103 surface: fakeApplication && fakeApplication.surfaceList.count > 0 ? fakeApplication.surfaceList.get(0) : null

100

104

101 Binding {

105 Binding {

102− target: PanelState

106+ target: panelState

103 property: "focusedPersistentSurfaceId"

107 property: "focusedPersistentSurfaceId"

104 value: decoratedWindow.surface ? decoratedWindow.surface.persistentId : "x"

108 value: decoratedWindow.surface ? decoratedWindow.surface.persistentId : "x"

105 }

109 }

tests/qmltests/Stage/tst_DesktopStage.qml+8−3

@@ -43,6 +43,10 @@ Item {

43 value: false

44 }

45

46+ PanelState {

47+ id: panelState

48+ }

49+

46 Component.onCompleted: {

50 Component.onCompleted: {

47 QuickUtils.keyboardAttached = true;

51 QuickUtils.keyboardAttached = true;

48 theme.name = "Ubuntu.Components.Themes.SuruDark";

52 theme.name = "Ubuntu.Components.Themes.SuruDark";

@@ -100,6 +104,7 @@ Item {

100 topLevelSurfaceList: topSurfaceList

104 topLevelSurfaceList: topSurfaceList

101 interactive: true

105 interactive: true

102 mode: "windowed"

106 mode: "windowed"

107+ panelState: panelState

103 }

108 }

104 }

109 }

105 }

110 }

@@ -618,19 +623,19 @@ Item {

618 maximizeDelegate(facebookAppDelegate);

623 maximizeDelegate(facebookAppDelegate);

619

624

620 // verify the drop shadow is still not visible

625 // verify the drop shadow is still not visible

621− verify(PanelState.dropShadow == false);

626+ verify(panelState.dropShadow == false);

622

627

623 // start a foreground app, not maximized

628 // start a foreground app, not maximized

624 var dialerAppDelegate = startApplication("dialer-app");

629 var dialerAppDelegate = startApplication("dialer-app");

625

630

626 // verify the drop shadow becomes visible

631 // verify the drop shadow becomes visible

627− verify(PanelState.dropShadow == true);

632+ verify(panelState.dropShadow == true);

628

633

629 // close the maximized app

634 // close the maximized app

630 ApplicationManager.stopApplication("facebook-webapp");

635 ApplicationManager.stopApplication("facebook-webapp");

631

636

632 // verify the drop shadow is gone

637 // verify the drop shadow is gone

633− tryCompare(PanelState, "dropShadow", false);

638+ tryCompare(panelState, "dropShadow", false);

634 }

639 }

635

640

636 function test_threeFingerTapShowsWindowControls_data() {

641 function test_threeFingerTapShowsWindowControls_data() {

tests/qmltests/Stage/tst_WindowResizeArea.qml+1−8

@@ -19,7 +19,6 @@ import QtQuick.Layouts 1.1

19import QtTest 1.0

20import Unity.Test 0.1

21import ".."

22−import "../../../qml/Components/PanelState"

23import "../../../qml/Stage"

22import "../../../qml/Stage"

24import Ubuntu.Components 1.3

23import Ubuntu.Components 1.3

25import Ubuntu.Components.ListItems 1.3 as ListItem

24import Ubuntu.Components.ListItems 1.3 as ListItem

@@ -31,12 +30,6 @@ Item {

31 height: units.gu(60)

30 height: units.gu(60)

32 width: units.gu(85)

31 width: units.gu(85)

33

32

34− Binding {

35− target: PanelState

36− property: "panelHeight"

37− value: units.gu(3)

38− }

39−

40 Component {

33 Component {

41 id: fakeWindowComponent

34 id: fakeWindowComponent

42

35

@@ -352,7 +345,7 @@ Item {

352

345

353 // Make sure it's again where we left it in normal state before destroying

346 // Make sure it's again where we left it in normal state before destroying

354 compare(fakeWindow.requestedX >= 0, true)

347 compare(fakeWindow.requestedX >= 0, true)

355− compare(fakeWindow.requestedY >= PanelState.panelHeight, true)

348+ compare(fakeWindow.requestedY >= 0, true)

356 compare(fakeWindow.requestedX + fakeWindow.width <= root.width, true)

349 compare(fakeWindow.requestedX + fakeWindow.width <= root.width, true)

357 compare(fakeWindow.requestedY + fakeWindow.height <= root.height, true)

350 compare(fakeWindow.requestedY + fakeWindow.height <= root.height, true)

358

351

tests/qmltests/tst_OrientedShell.qml+24−5

@@ -29,7 +29,6 @@ import Utils 0.1

29

30import "../../qml"

31import "../../qml/Components"

32−import "../../qml/Components/PanelState"

33import "Stage"

32import "Stage"

34

33

35Rectangle {

34Rectangle {

@@ -75,6 +74,12 @@ Rectangle {

75 deviceFilter: InputInfo.Keyboard

74 deviceFilter: InputInfo.Keyboard

76 }

75 }

77

76

77+ QtObject {

78+ id: _screenWindow

79+ property bool primary: true

80+ }

81+ property alias screenWindow: _screenWindow

82+

78 property int physicalOrientation0

83 property int physicalOrientation0

79 property int physicalOrientation90

84 property int physicalOrientation90

80 property int physicalOrientation180

85 property int physicalOrientation180

@@ -167,6 +172,11 @@ Rectangle {

167 Component.onDestruction: {

172 Component.onDestruction: {

168 orientedShellLoader.itemDestroyed = true;

173 orientedShellLoader.itemDestroyed = true;

169 }

174 }

175+

176+ SurfaceManager {

177+ id: surfaceMan

178+ }

179+ surfaceManager: surfaceMan

170 }

180 }

171 }

181 }

172 }

182 }

@@ -439,6 +449,15 @@ Rectangle {

439 property Item orientedShell: orientedShellLoader.status === Loader.Ready ? orientedShellLoader.item : null

449 property Item orientedShell: orientedShellLoader.status === Loader.Ready ? orientedShellLoader.item : null

440 property Item shell

450 property Item shell

441 property QtObject topLevelSurfaceList

451 property QtObject topLevelSurfaceList

452+ property var panelState: undefined

453+

454+ onOrientedShellChanged: {

455+ if (orientedShell) {

456+ panelState = findInvisibleChild(orientedShell, "panelState");

457+ } else {

458+ panelState = undefined;

459+ }

460+ }

442

461

443 SignalSpy { id: signalSpy }

462 SignalSpy { id: signalSpy }

444 SignalSpy { id: signalSpy2 }

463 SignalSpy { id: signalSpy2 }

@@ -1507,13 +1526,13 @@ Rectangle {

1507 print("exptectedAngle", expectedAngle, point.x, point.y)

1526 print("exptectedAngle", expectedAngle, point.x, point.y)

1508 switch (expectedAngle) {

1527 switch (expectedAngle) {

1509 case 0:

1528 case 0:

1510− return point.x === 0 && point.y === PanelState.panelHeight;

1529+ return point.x === 0 && point.y === panelState.panelHeight;

1511 case 90:

1530 case 90:

1512− return point.x === orientedShell.width - PanelState.panelHeight && point.y === 0;

1531+ return point.x === orientedShell.width - panelState.panelHeight && point.y === 0;

1513 case 180:

1532 case 180:

1514− return point.x === orientedShell.width && point.y === orientedShell.height - PanelState.panelHeight;

1533+ return point.x === orientedShell.width && point.y === orientedShell.height - panelState.panelHeight;

1515 default: // 270

1534 default: // 270

1516− return point.x === PanelState.panelHeight && point.y === orientedShell.height;

1535+ return point.x === panelState.panelHeight && point.y === orientedShell.height;

1517 }

1536 }

1518 }

1537 }

1519

1538

tests/qmltests/tst_Shell.qml+25−11

@@ -62,13 +62,22 @@ Rectangle {

62 if (shell) {

63 topLevelSurfaceList = testCase.findInvisibleChild(shell, "topLevelSurfaceList");

64 appMenuData.surfaceManager = testCase.findInvisibleChild(shell, "surfaceManager");

65+ panelState = testCase.findInvisibleChild(shell, "panelState");

65 } else {

66 } else {

66 topLevelSurfaceList = null;

67 topLevelSurfaceList = null;

67 appMenuData.surfaceManager = null;

68 appMenuData.surfaceManager = null;

69+ panelState = undefined;

68 }

70 }

69 }

71 }

70

72

71 property var topLevelSurfaceList: null

73 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

72

81

73 Item {

82 Item {

74 id: shellContainer

83 id: shellContainer

@@ -143,6 +152,11 @@ Rectangle {

143 Component.onDestruction: {

152 Component.onDestruction: {

144 shellLoader.itemDestroyed = true;

153 shellLoader.itemDestroyed = true;

145 }

154 }

155+

156+ SurfaceManager {

157+ id: surfaceMan

158+ }

159+ surfaceManager: surfaceMan

146 }

160 }

147 }

161 }

148 }

162 }

@@ -679,7 +693,7 @@ Rectangle {

679 }

693 }

680

694

681 function ensureInputMethodSurface() {

695 function ensureInputMethodSurface() {

682− var surfaceManager = findInvisibleChild(shell, "surfaceManager");

696+ var surfaceManager = shell.surfaceManager;

683 verify(surfaceManager);

697 verify(surfaceManager);

684 surfaceManager.createInputMethodSurface();

698 surfaceManager.createInputMethodSurface();

685

699

@@ -1886,21 +1900,21 @@ Rectangle {

1886 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

1900 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

1887

1901

1888 tryCompare(appDelegate, "state", "normal");

1902 tryCompare(appDelegate, "state", "normal");

1889− tryCompare(PanelState, "decorationsVisible", false)

1903+ tryCompare(panelState, "decorationsVisible", false)

1890

1904

1891 mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);

1905 mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);

1892 tryCompare(appDelegate, "state", "maximized");

1906 tryCompare(appDelegate, "state", "maximized");

1893− tryCompare(PanelState, "decorationsVisible", true)

1907+ tryCompare(panelState, "decorationsVisible", true)

1894

1908

1895 ApplicationManager.stopApplication(application.appId);

1909 ApplicationManager.stopApplication(application.appId);

1896− tryCompare(PanelState, "decorationsVisible", false)

1910+ tryCompare(panelState, "decorationsVisible", false)

1897

1911

1898 // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

1912 // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

1899 // They won't be gone until those surface items are destroyed.

1913 // They won't be gone until those surface items are destroyed.

1900 tryCompareFunction(function() { return application.surfaceList.count }, 0);

1914 tryCompareFunction(function() { return application.surfaceList.count }, 0);

1901

1915

1902 ApplicationManager.startApplication(application.appId);

1916 ApplicationManager.startApplication(application.appId);

1903− tryCompare(PanelState, "decorationsVisible", true)

1917+ tryCompare(panelState, "decorationsVisible", true)

1904 }

1918 }

1905

1919

1906 function test_newAppHasValidGeometry() {

1920 function test_newAppHasValidGeometry() {

@@ -1957,7 +1971,7 @@ Rectangle {

1957 mousePress(appDelegate, appDelegate.width / 2, units.gu(1))

1971 mousePress(appDelegate, appDelegate.width / 2, units.gu(1))

1958 mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))

1972 mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))

1959

1973

1960− compare(appDelegate.y >= PanelState.panelHeight, true);

1974+ compare(appDelegate.y >= panelState.panelHeight, true);

1961 }

1975 }

1962

1976

1963 function test_cantResizeWindowUnderPanel() {

1977 function test_cantResizeWindowUnderPanel() {

@@ -1985,7 +1999,7 @@ Rectangle {

1985 mouseMove(decoration, decoration.width/2, -units.gu(100));

1999 mouseMove(decoration, decoration.width/2, -units.gu(100));

1986

2000

1987 // verify we don't go past the panel

2001 // verify we don't go past the panel

1988− compare(appDelegate.y >= PanelState.panelHeight, true);

2002+ compare(appDelegate.y >= panelState.panelHeight, true);

1989 }

2003 }

1990

2004

1991 function test_restoreWindowStateFixesIfUnderPanel() {

2005 function test_restoreWindowStateFixesIfUnderPanel() {

@@ -2009,7 +2023,7 @@ Rectangle {

2009 tryCompareFunction(function () { return topLevelSurfaceList.applicationAt(0).appId; }, application.appId);

2023 tryCompareFunction(function () { return topLevelSurfaceList.applicationAt(0).appId; }, application.appId);

2010

2024

2011 appDelegate = appRepeater.itemAt(0);

2025 appDelegate = appRepeater.itemAt(0);

2012− compare(appDelegate.y >= PanelState.panelHeight, true);

2026+ compare(appDelegate.y >= panelState.panelHeight, true);

2013 }

2027 }

2014

2028

2015 function test_lifecyclePolicyForNonTouchApp_data() {

2029 function test_lifecyclePolicyForNonTouchApp_data() {

@@ -2610,7 +2624,7 @@ Rectangle {

2610 function test_oskDisplacesWindow_data() {

2624 function test_oskDisplacesWindow_data() {

2611 return [

2625 return [

2612 {tag: "no need to displace", windowHeight: units.gu(10), windowY: units.gu(5), targetDisplacement: units.gu(5), oskEnabled: true},

2626 {tag: "no need to displace", windowHeight: units.gu(10), windowY: units.gu(5), targetDisplacement: units.gu(5), oskEnabled: true},

2613− {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: PanelState.panelHeight, oskEnabled: true},

2627+ {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: panelState.panelHeight, oskEnabled: true},

2614 {tag: "osk not on this screen", windowHeight: units.gu(40), windowY: units.gu(10), targetDisplacement: units.gu(10), oskEnabled: false},

2628 {tag: "osk not on this screen", windowHeight: units.gu(40), windowY: units.gu(10), targetDisplacement: units.gu(10), oskEnabled: false},

2615 ]

2629 ]

2616 }

2630 }

@@ -2633,8 +2647,8 @@ Rectangle {

2633 dashAppDelegate.windowedY = data.windowY;

2647 dashAppDelegate.windowedY = data.windowY;

2634 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2648 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));

2635 var initialY = dashAppDelegate.y;

2649 var initialY = dashAppDelegate.y;

2636− print("intial", initialY, "panel", PanelState.panelHeight);

2650+ print("intial", initialY, "panel", panelState.panelHeight);

2637− verify(initialY > PanelState.panelHeight);

2651+ verify(initialY > panelState.panelHeight);

2638

2652

2639 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, root.height / 2, root.width, root.height / 2));

2653 topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, root.height / 2, root.width, root.height / 2));

2640 tryCompare(dashAppDelegate, "y", data.targetDisplacement);

2654 tryCompare(dashAppDelegate, "y", data.targetDisplacement);