bbd0b9b · unity8 · git.iko.soy

git.iko.soy/unity8

WMScreens attached property & screen fixes

commitbbd0b9bd64c9e9886a6cba380f835eee91df79c0 authorNick Dedekind <nick.dedekind@canonical.com> dateFri 10 Mar 2017, 15:09 (10 years ago) parentfa498d0

16 files changed+575−220

compare with xenial

unifiedsplit

plugins/WindowManager/CMakeLists.txt+2−1

@@ -12,8 +12,9 @@ set(WINDOWMANAGER_SRC

1212 TopLevelWindowModel.cpp

1313 Window.cpp

1414 WindowManagerPlugin.cpp

15− Screens.cpp

1615 Screen.cpp

16+ ScreenAttached.cpp

17+ Screens.cpp

1718 ScreenWindow.cpp

1819 Workspace.cpp

1920 WorkspaceManager.cpp

plugins/WindowManager/Screen.cpp+142−104

@@ -15,163 +15,190 @@

1515 */

1616

1717#include "Screen.h"

18+#include "Screens.h"

1819#include "WorkspaceManager.h"

1920#include "Workspace.h"

2021

21−#include <QQmlEngine>

22−

23−Screen::Screen(qtmir::Screen* screen)

24− : m_wrapped(screen)

25− , m_workspaces(new WorkspaceModel)

26−{

27− QQmlEngine::setObjectOwnership(m_workspaces.data(), QQmlEngine::CppOwnership);

28−

29− connect(m_wrapped, &qtmir::Screen::usedChanged, this, &Screen::usedChanged);

30− connect(m_wrapped, &qtmir::Screen::nameChanged, this, &Screen::nameChanged);

31− connect(m_wrapped, &qtmir::Screen::outputTypeChanged, this, &Screen::outputTypeChanged);

32− connect(m_wrapped, &qtmir::Screen::scaleChanged, this, &Screen::scaleChanged);

33− connect(m_wrapped, &qtmir::Screen::formFactorChanged, this, &Screen::formFactorChanged);

34− connect(m_wrapped, &qtmir::Screen::physicalSizeChanged, this, &Screen::physicalSizeChanged);

35− connect(m_wrapped, &qtmir::Screen::positionChanged, this, &Screen::positionChanged);

36− connect(m_wrapped, &qtmir::Screen::activeChanged, this, &Screen::activeChanged);

37− connect(m_wrapped, &qtmir::Screen::currentModeIndexChanged, this, &Screen::currentModeIndexChanged);

38− connect(m_wrapped, &qtmir::Screen::availableModesChanged, this, &Screen::availableModesChanged);

39−

40− // Connect the active workspace to activate the screen.

41− connect(m_workspaces.data(), &WorkspaceModel::workspaceAdded, this, [this](Workspace* workspace) {

42− connect(workspace, &Workspace::activeChanged, this, [this, workspace](bool active) {

43− if (active) {

44− setCurrentWorkspace(workspace);

45− activate();

46− }

47− });

48− if (workspace->isActive()) {

49− activate();

50− setCurrentWorkspace(workspace);

51− }

52− if (!m_currentWorspace) {

53− setCurrentWorkspace(workspace);

54− }

55− });

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

57− disconnect(workspace, &Workspace::activeChanged, this, 0);

58− if (workspace == m_currentWorspace) {

59− resetCurrentWorkspace();

60− }

61− });

62− connect(this, &Screen::activeChanged, this, [this](bool active) {

63− if (active && m_currentWorspace) {

64− m_currentWorspace->activate();

65− }

66− });

67−

68− WorkspaceManager::instance()->createWorkspace()->assign(m_workspaces.data());

69− WorkspaceManager::instance()->createWorkspace()->assign(m_workspaces.data());

70−}

71−

72−Screen::Screen(const Screen &other)

73− : qtmir::Screen(nullptr)

74− , m_wrapped(other.m_wrapped)

75− , m_workspaces(new WorkspaceModelProxy(other.m_workspaces.data()))

22+ScreenInterface::ScreenInterface(QObject *parent)

23+ : QObject(parent)

7624{

77− QQmlEngine::setObjectOwnership(m_workspaces.data(), QQmlEngine::CppOwnership);

78−

79− connect(m_wrapped, &qtmir::Screen::usedChanged, this, &Screen::usedChanged);

80− connect(m_wrapped, &qtmir::Screen::nameChanged, this, &Screen::nameChanged);

81− connect(m_wrapped, &qtmir::Screen::outputTypeChanged, this, &Screen::outputTypeChanged);

82− connect(m_wrapped, &qtmir::Screen::scaleChanged, this, &Screen::scaleChanged);

83− connect(m_wrapped, &qtmir::Screen::formFactorChanged, this, &Screen::formFactorChanged);

84− connect(m_wrapped, &qtmir::Screen::physicalSizeChanged, this, &Screen::physicalSizeChanged);

85− connect(m_wrapped, &qtmir::Screen::positionChanged, this, &Screen::positionChanged);

86− connect(m_wrapped, &qtmir::Screen::activeChanged, this, &Screen::activeChanged);

87− connect(m_wrapped, &qtmir::Screen::currentModeIndexChanged, this, &Screen::currentModeIndexChanged);

88− connect(m_wrapped, &qtmir::Screen::availableModesChanged, this, &Screen::availableModesChanged);

8925}

9026

91−void Screen::resetCurrentWorkspace()

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

9228{

93− auto newCurrent = m_workspaces->rowCount() > 0 ? m_workspaces->get(0) : nullptr;

94− if (m_currentWorspace != newCurrent) {

95− m_currentWorspace = newCurrent;

96− Q_EMIT currentWorkspaceChanged(newCurrent);

97− }

29+ m_wrapped = screen;

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

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

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

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

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

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

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

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

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

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

9840}

9941

100−qtmir::OutputId Screen::outputId() const

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

10143{

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

10245 return m_wrapped->outputId();

10346}

10447

105−bool Screen::used() const

48+bool ScreenInterface::used() const

10649{

50+ if (!m_wrapped) return false;

10751 return m_wrapped->used();

10852}

10953

110−QString Screen::name() const

54+QString ScreenInterface::name() const

11155{

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

11257 return m_wrapped->name();

11358}

11459

115−float Screen::scale() const

60+float ScreenInterface::scale() const

11661{

62+ if (!m_wrapped) return 1.0;

11763 return m_wrapped->scale();

11864}

11965

120−QSizeF Screen::physicalSize() const

66+QSizeF ScreenInterface::physicalSize() const

12167{

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

12269 return m_wrapped->physicalSize();

12370}

12471

125−qtmir::FormFactor Screen::formFactor() const

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

12673{

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

12775 return m_wrapped->formFactor();

12876}

12977

130−qtmir::OutputTypes Screen::outputType() const

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

13179{

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

13281 return m_wrapped->outputType();

13382}

13483

135−MirPowerMode Screen::powerMode() const

84+MirPowerMode ScreenInterface::powerMode() const

13685{

86+ if (!m_wrapped) return mir_power_mode_on;

13787 return m_wrapped->powerMode();

13888}

13989

140−Qt::ScreenOrientation Screen::orientation() const

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

14191{

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

14293 return m_wrapped->orientation();

14394}

14495

145−QPoint Screen::position() const

96+QPoint ScreenInterface::position() const

14697{

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

14799 return m_wrapped->position();

148100}

149101

150−QQmlListProperty<qtmir::ScreenMode> Screen::availableModes()

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

151103{

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

152105 return m_wrapped->availableModes();

153106}

154107

155−uint Screen::currentModeIndex() const

108+uint ScreenInterface::currentModeIndex() const

156109{

110+ if (!m_wrapped) return -1;

157111 return m_wrapped->currentModeIndex();

158112}

159113

160−bool Screen::isActive() const

114+bool ScreenInterface::isActive() const

161115{

116+ if (!m_wrapped) return false;

162117 return m_wrapped->isActive();

163118}

164119

165−qtmir::ScreenConfiguration *Screen::beginConfiguration() const

120+void ScreenInterface::activate()

121+{

122+ setActive(true);

123+}

124+

125+void ScreenInterface::setActive(bool active)

126+{

127+ if (!m_wrapped) return;

128+ m_wrapped->setActive(active);

129+}

130+

131+QScreen *ScreenInterface::qscreen() const

166132{

133+ if (!m_wrapped) return nullptr;

134+ return m_wrapped->qscreen();

135+}

136+

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

138+{

139+ if (!m_wrapped) return nullptr;

167140 return m_wrapped->beginConfiguration();

168141}

169142

170−bool Screen::applyConfiguration(qtmir::ScreenConfiguration *configuration)

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

171144{

145+ if (!m_wrapped) return false;

172146 return m_wrapped->applyConfiguration(configuration);

173147}

174148

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

150+{

151+ if (!proxy) return;

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

153+}

154+

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

156+ : m_workspaces(new WorkspaceModel)

157+{

158+ connectToScreen(wrapped);

159+

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

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

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

163+ if (active) {

164+ setCurrentWorkspace(workspace);

165+ activate();

166+ }

167+ });

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

169+ activate();

170+ setCurrentWorkspace(workspace);

171+ }

172+ if (!m_currentWorspace) {

173+ setCurrentWorkspace(workspace);

174+ }

175+ });

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

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

178+ if (workspace == m_currentWorspace) {

179+ resetCurrentWorkspace();

180+ }

181+ });

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

183+ if (active && m_currentWorspace) {

184+ m_currentWorspace->activate();

185+ }

186+ });

187+

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

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

190+}

191+

192+void Screen::resetCurrentWorkspace()

193+{

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

195+ if (m_currentWorspace != newCurrent) {

196+ m_currentWorspace = newCurrent;

197+ Q_EMIT currentWorkspaceChanged(newCurrent);

198+ }

199+}

200+

201+

175202WorkspaceModel *Screen::workspaces() const

176203{

177204 return m_workspaces.data();

@@ -190,32 +217,43 @@ void Screen::setCurrentWorkspace(Workspace *workspace)

190217 }

191218}

192219

193−void Screen::sync(Screen *proxy)

194−{

195− if (!proxy) return;

196−

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

198−}

199−

200−void Screen::activate()

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

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

222+ , m_original(screen)

201223{

202− setActive(true);

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

225+

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

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

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

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

230+ if (m_currentWorspace != p) {

231+ m_currentWorspace = p;

232+ Q_EMIT currentWorkspaceChanged(p);

233+ }

234+ }

235+ }

236+ };

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

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

203239}

204240

205−void Screen::setActive(bool active)

241+WorkspaceModel *ScreenProxy::workspaces() const

206242{

207− m_wrapped->setActive(active);

243+ return m_workspaces.data();

208244}

209245

210−QScreen *Screen::qscreen() const

246+Workspace *ScreenProxy::currentWorkspace() const

211247{

212− return m_wrapped->qscreen();

248+ return m_currentWorspace.data();

213249}

214250

215−ScreenProxy::ScreenProxy(ScreenProxy::Screen *const screen)

216− : Screen(*screen)

217− , m_original(screen)

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

218252{

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

254+ if (p) {

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

256+ }

219257}

220258

221259void ScreenProxy::addWorkspace()

plugins/WindowManager/Screen.h+86−36

@@ -8,74 +8,124 @@

88#include "WorkspaceModel.h"

1010class ScreenProxy;

11+class ScreenAttached;

1112

12−class Screen : public qtmir::Screen

13+class ScreenInterface: public QObject

1314{

1415 Q_OBJECT

16+

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

18+

19+ Q_PROPERTY(bool used READ used NOTIFY usedChanged)

20+ Q_PROPERTY(QString name READ name NOTIFY nameChanged)

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

22+ Q_PROPERTY(float scale READ scale NOTIFY scaleChanged)

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

24+ Q_PROPERTY(MirPowerMode powerMode READ powerMode NOTIFY powerModeChanged)

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

26+ Q_PROPERTY(QPoint position READ position NOTIFY positionChanged)

27+ Q_PROPERTY(uint currentModeIndex READ currentModeIndex NOTIFY currentModeIndexChanged)

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

29+ Q_PROPERTY(QSizeF physicalSize READ physicalSize NOTIFY physicalSizeChanged)

30+

1531 Q_PROPERTY(WorkspaceModel* workspaces READ workspaces CONSTANT)

1632 Q_PROPERTY(Workspace* currentWorkspace READ currentWorkspace WRITE setCurrentWorkspace NOTIFY currentWorkspaceChanged)

17−

1833public:

19− explicit Screen(qtmir::Screen*const wrapped);

20−

21− qtmir::OutputId outputId() const override;

22− bool used() const override;

23− QString name() const override;

24− float scale() const override;

25− QSizeF physicalSize() const override;

26− qtmir::FormFactor formFactor() const override;

27− qtmir::OutputTypes outputType() const override;

28− MirPowerMode powerMode() const override;

29− Qt::ScreenOrientation orientation() const override;

30− QPoint position() const override;

31− QQmlListProperty<qtmir::ScreenMode> availableModes() override;

32− uint currentModeIndex() const override;

33− bool isActive() const override;

34− void setActive(bool active) override;

35−

36− QScreen* qscreen() const override;

37−

38− qtmir::ScreenConfiguration *beginConfiguration() const override;

39− bool applyConfiguration(qtmir::ScreenConfiguration *configuration) override;

34+ // From qtmir::Screen

35+ qtmir::OutputId outputId() const;

36+ bool used() const;

37+ QString name() const;

38+ float scale() const;

39+ QSizeF physicalSize() const;

40+ qtmir::FormFactor formFactor() const;

41+ qtmir::OutputTypes outputType() const;

42+ MirPowerMode powerMode() const;

43+ Qt::ScreenOrientation orientation() const;

44+ QPoint position() const;

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

46+ uint currentModeIndex() const;

47+ bool isActive() const;

48+ void setActive(bool active);

49+ QScreen* qscreen() const;

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

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

52+

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

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

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

56+

57+ void sync(ScreenInterface* proxy);

4058

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

4260

43− WorkspaceModel* workspaces() const;

44−

45− Workspace *currentWorkspace() const;

46− void setCurrentWorkspace(Workspace* workspace);

47−

48− void sync(Screen* proxy);

49−

5061public Q_SLOTS:

5162 void activate();

5263

5364Q_SIGNALS:

65+ void usedChanged();

66+ void nameChanged();

67+ void outputTypeChanged();

68+ void scaleChanged();

69+ void formFactorChanged();

70+ void powerModeChanged();

71+ void orientationChanged();

72+ void positionChanged();

73+ void currentModeIndexChanged();

74+ void physicalSizeChanged();

75+ void availableModesChanged();

76+ void activeChanged(bool active);

5477 void currentWorkspaceChanged(Workspace*);

5578

5679protected:

57− Screen(Screen const& other);

80+ ScreenInterface(QObject* parent = 0);

81+

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

83+

84+protected:

85+ QPointer<qtmir::Screen> m_wrapped;

86+};

5887

88+

89+class Screen : public ScreenInterface

90+{

91+ Q_OBJECT

92+public:

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

94+

95+ // From qtmir::Screen

96+ WorkspaceModel* workspaces() const override;

97+ Workspace *currentWorkspace() const override;

98+ void setCurrentWorkspace(Workspace* workspace) override;

99+

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

101+

102+protected:

59103 void resetCurrentWorkspace();

60104

61− qtmir::Screen*const m_wrapped;

62105 const QScopedPointer<WorkspaceModel> m_workspaces;

63106 QPointer<Workspace> m_currentWorspace;

64107};

65108

66−class ScreenProxy : public Screen

109+class ScreenProxy : public ScreenInterface

67110{

68111 Q_OBJECT

69112public:

70− explicit ScreenProxy(Screen*const screen);

113+ explicit ScreenProxy(ScreenInterface*const screen);

71114

72− Screen* proxyObject() const { return m_original.data(); }

115+ // From qtmir::Screen

116+ WorkspaceModel* workspaces() const override;

117+ Workspace *currentWorkspace() const override;

118+ void setCurrentWorkspace(Workspace* workspace) override;

119+

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

73121

74122public Q_SLOTS:

75123 void addWorkspace();

76124

77125private:

78− const QPointer<Screen> m_original;

126+ const QScopedPointer<WorkspaceModel> m_workspaces;

127+ const QPointer<ScreenInterface> m_original;

128+ QPointer<Workspace> m_currentWorspace;

79129};

80130

81131#endif // SCREEN_H

plugins/WindowManager/ScreenAttached.cppnew file+149

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

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#include "ScreenAttached.h"

18+#include "ScreenWindow.h"

19+#include "Screens.h"

20+

21+#include <QQuickItem>

22+#include <QScreen>

23+

24+ScreenAttached::ScreenAttached(QObject *owner)

25+ : ScreenInterface(owner)

26+ , m_window(nullptr)

27+{

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

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

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

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

32+ windowChanged(window);

33+ }

34+}

35+

36+WorkspaceModel *ScreenAttached::workspaces() const

37+{

38+ if (!m_screen) return nullptr;

39+ return m_screen->workspaces();

40+}

41+

42+Workspace *ScreenAttached::currentWorkspace() const

43+{

44+ if (!m_screen) return nullptr;

45+ return m_screen->currentWorkspace();

46+}

47+

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

49+{

50+ if (!m_screen) return;

51+ return m_screen->setCurrentWorkspace(workspace);

52+}

53+

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

55+{

56+ if (m_window) {

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

58+ }

59+

60+ m_window = window;

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

62+

63+ if (screenWindow) {

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

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

66+ } else {

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

68+ if (window) {

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

70+ }

71+ }

72+}

73+

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

75+{

76+ // Find a screen that matches.

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

78+ ScreenInterface* screen{nullptr};

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

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

81+ screen = s;

82+ }

83+ }

84+ screenChanged2(screen);

85+}

86+

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

88+{

89+ if (screen == m_screen) return;

90+

91+ ScreenInterface* oldScreen = m_screen;

92+ m_screen = screen;

93+

94+ if (oldScreen)

95+ oldScreen->disconnect(this);

96+

97+ if (!screen)

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

99+

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

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

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

103+ Q_EMIT usedChanged();

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

105+ Q_EMIT nameChanged();

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

107+ Q_EMIT outputTypeChanged();

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

109+ Q_EMIT scaleChanged();

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

111+ Q_EMIT formFactorChanged();

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

113+ Q_EMIT powerModeChanged();

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

115+ Q_EMIT orientationChanged();

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

117+ Q_EMIT positionChanged();

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

119+ Q_EMIT currentModeIndexChanged();

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

121+ Q_EMIT physicalSizeChanged();

122+

123+ if (oldScreen) {

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

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

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

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

128+ }

129+

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

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

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

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

134+ }

135+

136+ if (newModes != newModes) {

137+ Q_EMIT availableModesChanged();

138+ }

139+ } else {

140+ Q_EMIT availableModesChanged();

141+ }

142+

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

144+}

145+

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

147+{

148+ return new ScreenAttached(owner);

149+}

plugins/WindowManager/ScreenAttached.hnew file+55

@@ -0,0 +1,55 @@

1+/*

3+ *

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

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

6+ * the Free Software Foundation.

7+ *

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

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

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

11+ * Lesser General Public License for more details.

12+ *

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

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

15+ */

16+

17+#ifndef SCREENATTACHED_H

18+#define SCREENATTACHED_H

19+

20+#include "Screen.h"

21+

22+#include <QQmlEngine>

23+

24+class QQuickWindow;

25+

26+class ScreenAttached : public ScreenInterface

27+{

28+ Q_OBJECT

29+public:

30+ ScreenAttached(QObject* owner);

31+

32+ WorkspaceModel* workspaces() const override;

33+ Workspace *currentWorkspace() const override;

34+ void setCurrentWorkspace(Workspace* workspace) override;

35+

36+private Q_SLOTS:

37+ void windowChanged(QQuickWindow*);

38+ void screenChanged(QScreen*);

39+ void screenChanged2(ScreenInterface* screen);

40+

41+private:

42+ QPointer<ScreenInterface> m_screen;

43+ QQuickWindow* m_window;

44+};

45+

46+class WMScreen : public QObject

47+{

48+ Q_OBJECT

49+public:

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

51+};

52+

53+QML_DECLARE_TYPEINFO(WMScreen, QML_HAS_ATTACHED_PROPERTIES)

54+

55+#endif // SCREENATTACHED_H

plugins/WindowManager/ScreenWindow.cpp+1−4

@@ -24,9 +24,6 @@

2424ScreenWindow::ScreenWindow(QQuickWindow *parent)

2525 : QQuickWindow(parent)

2626{

27− if (qGuiApp->platformName() != QLatin1String("mirserver")) {

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

29− }

3027}

3128

3229ScreenWindow::~ScreenWindow()

@@ -42,7 +39,7 @@ void ScreenWindow::setScreenWrapper(Screen *screen)

4239{

4340 if (m_screen != screen) {

4441 m_screen = screen;

45− Q_EMIT screenWrapperChanged();

42+ Q_EMIT screenWrapperChanged(screen);

4643 }

4744 QQuickWindow::setScreen(screen->qscreen());

4845}

plugins/WindowManager/ScreenWindow.h+1−1

@@ -40,7 +40,7 @@ public:

4040 void setScreenWrapper(Screen *screen);

4141

4242Q_SIGNALS:

43− void screenWrapperChanged();

43+ void screenWrapperChanged(Screen* screen);

4444

4545private:

4646 QPointer<Screen> m_screen;

plugins/WindowManager/Screens.cpp+13−5

@@ -27,9 +27,12 @@

2727#include <QScreen>

2828#include <QWindow>

2929

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

31+

3032Screens::Screens(const QSharedPointer<qtmir::Screens>& model)

3133 : m_wrapped(model)

3234{

35+ m_self = this;

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

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

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

@@ -92,6 +95,11 @@ QVariant Screens::activeScreen() const

9295 return QVariant();

9396}

9497

98+Screens *Screens::self()

99+{

100+ return Screens::m_self;

101+}

102+

95103ScreensProxy *Screens::createProxy()

96104{

97105 return new ScreensProxy(this);

@@ -138,7 +146,7 @@ void Screens::onScreenAdded(qtmir::Screen *added)

138146void Screens::onScreenRemoved(qtmir::Screen *removed)

139147{

140148 int index = 0;

141− QMutableVectorIterator<Screen*> iter(m_screens);

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

142150 while(iter.hasNext()) {

143151 auto screenWrapper = iter.next();

144152 if (screenWrapper->wrapped() == removed) {

@@ -161,7 +169,7 @@ ScreensProxy::ScreensProxy(Screens * const screens)

161169 : Screens(*screens)

162170 , m_original(screens)

163171{

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

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

165173 Q_FOREACH(auto screen, m_screens) {

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

167175 if (proxy->proxyObject() == added) return;

@@ -176,9 +184,9 @@ ScreensProxy::ScreensProxy(Screens * const screens)

176184 Q_EMIT countChanged();

177185 });

178186

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

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

180188 int index = 0;

181− QMutableVectorIterator<Screen*> iter(m_screens);

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

182190 while(iter.hasNext()) {

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

184192 if (proxy->proxyObject() == removed) {

@@ -197,7 +205,7 @@ ScreensProxy::ScreensProxy(Screens * const screens)

197205 }

198206 });

199207

200− Q_FOREACH(Screen* screen, screens->list()) {

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

201209 auto screenWrapper(new ScreenProxy(screen));

202210 QQmlEngine::setObjectOwnership(screenWrapper, QQmlEngine::CppOwnership);

203211 m_screens.push_back(new ScreenProxy(screen));

plugins/WindowManager/Screens.h+8−5

@@ -27,7 +27,7 @@ class Screen;

2727class Screens;

2828}

2929

30−class Screen;

30+class ScreenInterface;

3131class ScreensProxy;

3232

3333class Screens : public QAbstractListModel

@@ -55,7 +55,9 @@ public:

5555 int count() const;

5656 QVariant activeScreen() const;

5757

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

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

59+

60+ static Screens *self();

5961

6062public Q_SLOTS:

6163 void activateScreen(const QVariant& index);

@@ -64,8 +66,8 @@ Q_SIGNALS:

6466 void countChanged();

6567 void activeScreenChanged();

6668

67− void screenAdded(Screen* screen);

68− void screenRemoved(Screen* screen);

69+ void screenAdded(ScreenInterface* screen);

70+ void screenRemoved(ScreenInterface* screen);

6971

7072private Q_SLOTS:

7173 void onScreenAdded(qtmir::Screen *screen);

@@ -74,8 +76,9 @@ private Q_SLOTS:

7476protected:

7577 Screens(const Screens& other);

7678

77− QVector<Screen*> m_screens;

79+ QVector<ScreenInterface*> m_screens;

7880 QSharedPointer<qtmir::Screens> m_wrapped;

81+ static Screens* m_self;

7982};

8083

8184class ScreensProxy : public Screens

plugins/WindowManager/WindowManagerPlugin.cpp+9−4

@@ -16,8 +16,9 @@

1616

1717#include "WindowManagerPlugin.h"

1818

19−#include "Screens.h"

2019#include "Screen.h"

20+#include "ScreenAttached.h"

21+#include "Screens.h"

2122#include "ScreenWindow.h"

2223#include "TopLevelWindowModel.h"

2324#include "Window.h"

@@ -28,6 +29,8 @@

2829#include <QtQml>

2930#include <qtmir/qtmir.h>

3031

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

33+

3134static QObject *workspace_manager(QQmlEngine *engine, QJSEngine *scriptEngine)

3235{

3336 Q_UNUSED(engine)

@@ -44,10 +47,10 @@ void WindowManagerPlugin::registerTypes(const char *uri)

4447{

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

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

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

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

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

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

50− qmlRegisterUncreatableType<Workspace>(uri, 1, 0, "Workspace", "Workspace is not creatable.");

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

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

5154

5255 qRegisterMetaType<Screen*>("Screen*");

5356 qRegisterMetaType<ScreensProxy*>("ScreensProxy*");

@@ -58,4 +61,6 @@ void WindowManagerPlugin::registerTypes(const char *uri)

5861

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

6063 qmlRegisterRevision<QWindow,1>(uri, 1, 0);

64+

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

6166}

tests/mocks/WindowManager/CMakeLists.txt+3−1

@@ -21,14 +21,16 @@ qt5_use_modules(mockwindowmanagmentpolicy Core)

2121

2222set(WINDOWMANAGER_SRC

2323 ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Screen.cpp

24+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/ScreenAttached.cpp

2425 ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Screens.cpp

26+ ${CMAKE_SOURCE_DIR}/plugins/WindowManager/ScreenWindow.cpp

2527 ${CMAKE_SOURCE_DIR}/plugins/WindowManager/TopLevelWindowModel.cpp

2628 ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Window.cpp

2729 ${CMAKE_SOURCE_DIR}/plugins/WindowManager/WorkspaceManager.cpp

2830 ${CMAKE_SOURCE_DIR}/plugins/WindowManager/WorkspaceModel.cpp

2931 ${CMAKE_SOURCE_DIR}/plugins/WindowManager/Workspace.cpp

3032 MockScreens.cpp

31− ScreenWindow.cpp

33+ MockScreenWindow.cpp

3234 WindowManagerPlugin.cpp

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

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

tests/mocks/WindowManager/ScreenWindow.cpp → tests/mocks/WindowManager/MockScreenWindow.cpprenamed+8−22

@@ -14,35 +14,21 @@

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

1515 */

1616

17−#include "ScreenWindow.h"

18−#include "Screen.h"

17+#include "MockScreenWindow.h"

18+#include "MockScreens.h"

1919

2020// Qt

2121#include <QGuiApplication>

2222#include <QDebug>

2323

24−ScreenWindow::ScreenWindow(QQuickWindow *parent)

25− : QQuickWindow(parent)

24+MockScreenWindow::MockScreenWindow(QQuickWindow *parent)

25+ : ScreenWindow(parent)

2626{

27− if (qGuiApp->platformName() != QLatin1String("mirserver")) {

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

29− }

27+ connect(this, &ScreenWindow::screenWrapperChanged, this, [this]() {

28+ MockScreens::instance()->connectWindow(this);

29+ });

3030}

3131

32−ScreenWindow::~ScreenWindow()

32+MockScreenWindow::~MockScreenWindow()

3333{

3434}

35−

36−Screen *ScreenWindow::screenWrapper() const

37−{

38− return m_screen.data();

39−}

40−

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

42−{

43− if (m_screen != screen) {

44− m_screen = screen;

45− Q_EMIT screenWrapperChanged();

46− }

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

48−}

tests/mocks/WindowManager/ScreenWindow.h → tests/mocks/WindowManager/MockScreenWindow.hrenamed+7−26

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

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

1515 */

1616

17−#ifndef UNITY_SCREENWINDOW_H

18−#define UNITY_SCREENWINDOW_H

17+#ifndef MOCK_SCREENWINDOW_H

18+#define MOCK_SCREENWINDOW_H

1919

20−#include <QQuickWindow>

21−#include <QPointer>

20+#include "ScreenWindow.h"

2221

23−#include "Screen.h"

24−

25−class ScreenAdapter;

26−

27−/*

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

29−**/

30−class ScreenWindow : public QQuickWindow

22+class MockScreenWindow : public ScreenWindow

3123{

3224 Q_OBJECT

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

34− Q_PROPERTY(int winId READ winId CONSTANT)

3525public:

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

37− ~ScreenWindow();

38−

39− Screen *screenWrapper() const;

40− void setScreenWrapper(Screen *screen);

41−

42−Q_SIGNALS:

43− void screenWrapperChanged();

44−

45−private:

46− QPointer<Screen> m_screen;

26+ explicit MockScreenWindow(QQuickWindow *parent = 0);

27+ ~MockScreenWindow();

4728};

4829

49−#endif // UNITY_SCREENWINDOW_H

30+#endif // MOCK_SCREENWINDOW_H

tests/mocks/WindowManager/MockScreens.cpp+69−1

@@ -15,12 +15,19 @@

1515 */

1616

1717#include "MockScreens.h"

18+#include "ScreenWindow.h"

1819

1920// qtmirserver

2021#include <qtmir/screen.h>

2122

23+#include <QGuiApplication>

24+#include <QWindow>

25+#include <QWeakPointer>

26+

2227namespace {

2328

29+QWeakPointer<MockScreens> m_screens;

30+

2431class MockScreen : public qtmir::Screen

2532{

2633 Q_OBJECT

@@ -33,6 +40,37 @@ public:

3340 m_sizes.append(new qtmir::ScreenMode(60, QSize(1920,1080)));

3441 m_physicalSize = QSize(800,568);

3542 }

43+ ~MockScreen() {

44+ qDeleteAll(m_sizes);

45+ m_sizes.clear();

46+ }

47+

48+ void connectToWindow(QWindow* w)

49+ {

50+ if (m_connectedWindow == w) return;

51+

52+ if (m_connectedWindow) {

53+ disconnect(m_connectedWindow.data());

54+ m_sizes.takeFirst()->deleteLater();

55+ }

56+

57+ m_connectedWindow = w;

58+

59+ if (w) {

60+ connect(w, &ScreenWindow::heightChanged, this, [this](int height) {

61+ m_sizes.first()->size.rheight() = height;

62+ Q_EMIT availableModesChanged();

63+

64+ });

65+ connect(w, &ScreenWindow::widthChanged, this, [this](int width) {

66+ m_sizes.first()->size.rwidth() = width;

67+ Q_EMIT availableModesChanged();

68+ });

69+

70+ m_sizes.push_front(new qtmir::ScreenMode(50, w->size()));

71+ Q_EMIT availableModesChanged();

72+ }

73+ }

3674

3775 qtmir::OutputId outputId() const override { return m_id; }

3876 bool used() const override { return m_used; }

@@ -58,7 +96,12 @@ public:

5896 }

5997 }

6098

61− QScreen* qscreen() const override { return nullptr; }

99+ QScreen* qscreen() const override {

100+ if (qGuiApp->topLevelWindows().count() > 0) {

101+ return qGuiApp->topLevelWindows()[0]->screen();

102+ }

103+ return qGuiApp->primaryScreen();

104+ }

62105

63106 qtmir::ScreenConfiguration *beginConfiguration() const override {

64107 auto config = new qtmir::ScreenConfiguration;

@@ -97,6 +140,8 @@ public:

97140 uint m_currentModeIndex{0};

98141 QList<qtmir::ScreenMode*> m_sizes;

99142 QSizeF m_physicalSize;

143+

144+ QPointer<QWindow> m_connectedWindow;

100145};

101146}

102147

@@ -122,6 +167,7 @@ MockScreens::MockScreens()

122167MockScreens::~MockScreens()

123168{

124169 qDeleteAll(m_mocks);

170+ m_mocks.clear();

125171}

126172

127173QVector<qtmir::Screen *> MockScreens::screens() const

@@ -137,4 +183,26 @@ qtmir::Screen *MockScreens::activeScreen() const

137183 return nullptr;

138184}

139185

186+QSharedPointer<MockScreens> MockScreens::instance()

187+{

188+ if (!m_screens) {

189+ QSharedPointer<MockScreens> screens(new MockScreens());

190+ m_screens = screens.toWeakRef();

191+ return screens;

192+ } else {

193+ return m_screens.lock();

194+ }

195+}

196+

197+void MockScreens::connectWindow(ScreenWindow *w)

198+{

199+ Screen* screen = w->screenWrapper();

200+ if (!screen) return;

201+

202+ auto mockScreen = qobject_cast<MockScreen*>(screen->wrapped());

203+ if (mockScreen) {

204+ mockScreen->connectToWindow(w);

205+ }

206+}

207+

140208#include "MockScreens.moc"

tests/mocks/WindowManager/MockScreens.h+9−1

@@ -22,12 +22,14 @@

2222

2323#include <qtmir/screens.h>

2424

25−class Screen;

2625namespace qtmir

2726{

2827class Screens;

2928}

3029

30+class Screen;

31+class ScreenWindow;

32+

3133class MockScreens : public qtmir::Screens

3234{

3335 Q_OBJECT

@@ -39,8 +41,14 @@ public:

3941

4042 qtmir::Screen *activeScreen() const override;

4143

44+ static QSharedPointer<MockScreens> instance();

45+

46+public Q_SLOTS:

47+ void connectWindow(ScreenWindow *w);

48+

4249private:

4350 QVector<qtmir::Screen*> m_mocks;

4451};

4552

53+

4654#endif // MOCK_SCREENS_H

tests/mocks/WindowManager/WindowManagerPlugin.cpp+13−9

@@ -16,10 +16,11 @@

1616

1717#include "WindowManagerPlugin.h"

1818

19−#include "Screens.h"

20−#include "Screen.h"

2119#include "MockScreens.h"

22−#include "ScreenWindow.h"

20+#include "MockScreenWindow.h"

21+#include "Screen.h"

22+#include "ScreenAttached.h"

23+#include "Screens.h"

2324#include "TopLevelWindowModel.h"

2425#include "Window.h"

2526#include "WorkspaceManager.h"

@@ -29,6 +30,8 @@

2930

3031#include <QtQml>

3132

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

34+

3235static QObject *workspace_manager(QQmlEngine *engine, QJSEngine *scriptEngine)

3336{

3437 Q_UNUSED(engine)

@@ -38,18 +41,17 @@ static QObject *workspace_manager(QQmlEngine *engine, QJSEngine *scriptEngine)

3841QObject* screensSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {

3942 Q_UNUSED(engine);

4043 Q_UNUSED(scriptEngine);

41− QSharedPointer<qtmir::Screens> mockScreens(new MockScreens());

42− return new Screens(mockScreens);

44+ return new Screens(MockScreens::instance());

4345}

4446

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

4648{

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

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

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

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

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

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

52− qmlRegisterUncreatableType<Workspace>(uri, 1, 0, "Workspace", "Workspace is not creatable.");

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

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

5355

5456 qRegisterMetaType<Screen*>("Screen*");

5557 qRegisterMetaType<ScreensProxy*>("ScreensProxy*");

@@ -58,8 +60,10 @@ void WindowManagerPlugin::registerTypes(const char *uri)

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

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

6062

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

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

6264 qmlRegisterRevision<QWindow,1>(uri, 1, 0);

65+

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

6367}

6468

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