d55f783 · unity8 · git.iko.soy

plugins/WindowManager/Screen.cpp+8−7

compare with xenial

unifiedsplit

@@ -185,11 +185,6 @@ QString Screen::outputTypeName() const

185 return QString();

186}

187

188−void Screen::setSyncing(bool syncing)

189−{

190− workspaces()->setSyncing(syncing);

191−}

192−

193void Screen::sync(Screen *proxy)

188void Screen::sync(Screen *proxy)

194{

189{

195 if (!proxy) return;

190 if (!proxy) return;

@@ -258,9 +253,10 @@ void ConcreteScreen::setCurrentWorkspace(Workspace *workspace)

258 }

253 }

259}

254}

260

255

261−ProxyScreen::ProxyScreen(Screen *const screen)

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

262− : m_workspaces(new ProxyWorkspaceModel(screen->workspaces()))

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

263 , m_original(screen)

258 , m_original(screen)

259+ , m_screens(screens)

264{

260{

265 connectToScreen(screen);

261 connectToScreen(screen);

266

262

@@ -296,3 +292,8 @@ void ProxyScreen::setCurrentWorkspace(Workspace *workspace)

296 m_original->setCurrentWorkspace(p->proxyObject());

292 m_original->setCurrentWorkspace(p->proxyObject());

297 }

293 }

298}

294}

295+

296+bool ProxyScreen::isSyncing() const

297+{

298+ return m_screens->isSyncing();

299+}

plugins/WindowManager/Screen.h+5−5

@@ -8,7 +8,7 @@

8#include "WorkspaceModel.h"

9

10class ProxyScreen;

11−class ScreenAttached;

11+class ProxyScreens;

12

13class Screen: public QObject

14{

@@ -56,7 +56,6 @@ public:

56 virtual Workspace *currentWorkspace() const = 0;

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

58

59− void setSyncing(bool);

60 void sync(Screen* proxy);

59 void sync(Screen* proxy);

61

60

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

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

@@ -102,8 +101,6 @@ public:

102 Workspace *currentWorkspace() const override;

101 Workspace *currentWorkspace() const override;

103 void setCurrentWorkspace(Workspace* workspace) override;

102 void setCurrentWorkspace(Workspace* workspace) override;

104

103

105− static ScreenAttached *qmlAttachedProperties(QObject *owner);

106−

107protected:

104protected:

108 void resetCurrentWorkspace();

105 void resetCurrentWorkspace();

109

106

@@ -115,7 +112,7 @@ class ProxyScreen : public Screen

115{

112{

116 Q_OBJECT

113 Q_OBJECT

117public:

114public:

118− explicit ProxyScreen(Screen*const screen);

115+ explicit ProxyScreen(Screen*const screen, ProxyScreens* screens);

119

116

120 // From qtmir::Screen

117 // From qtmir::Screen

121 WorkspaceModel* workspaces() const override;

118 WorkspaceModel* workspaces() const override;

@@ -124,9 +121,12 @@ public:

124

121

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

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

126

123

124+ bool isSyncing() const;

125+

127private:

126private:

128 const QScopedPointer<WorkspaceModel> m_workspaces;

127 const QScopedPointer<WorkspaceModel> m_workspaces;

129 const QPointer<Screen> m_original;

128 const QPointer<Screen> m_original;

129+ const ProxyScreens* m_screens;

130 QPointer<Workspace> m_currentWorspace;

131};

132

plugins/WindowManager/Screens.cpp+12−11

@@ -127,22 +127,17 @@ ProxyScreens *ConcreteScreens::createProxy()

127 return new ProxyScreens(this);

128}

129

130−void ConcreteScreens::sync(Screens *proxy)

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

131{

132 if (!proxy) return;

133−

134− for (auto screen : m_screens) {

135− screen->setSyncing(true);

133+ proxy->setSyncing(true);

136− }

137

134

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

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

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

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

140 m_screens[i]->sync(proxyList[i]);

137 m_screens[i]->sync(proxyList[i]);

141 }

138 }

142

139

143− for (auto screen : m_screens) {

144− screen->setSyncing(false);

140+ proxy->setSyncing(true);

145− }

146}

141}

147

142

148void ConcreteScreens::onScreenAdded(qtmir::Screen *added)

143void ConcreteScreens::onScreenAdded(qtmir::Screen *added)

@@ -189,6 +184,7 @@ void ConcreteScreens::onScreenRemoved(qtmir::Screen *removed)

189ProxyScreens::ProxyScreens(Screens * const screens)

184ProxyScreens::ProxyScreens(Screens * const screens)

190 : Screens(screens->m_wrapped)

185 : Screens(screens->m_wrapped)

191 , m_original(screens)

186 , m_original(screens)

187+ , m_syncing(false)

192{

188{

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

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

194 Q_FOREACH(auto screen, m_screens) {

190 Q_FOREACH(auto screen, m_screens) {

@@ -197,7 +193,7 @@ ProxyScreens::ProxyScreens(Screens * const screens)

197 }

193 }

198

194

199 beginInsertRows(QModelIndex(), count(), count());

195 beginInsertRows(QModelIndex(), count(), count());

200− auto screenWrapper(new ProxyScreen(added));

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

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

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

202 m_screens.push_back(screenWrapper);

198 m_screens.push_back(screenWrapper);

203 endInsertRows();

199 endInsertRows();

@@ -227,8 +223,13 @@ ProxyScreens::ProxyScreens(Screens * const screens)

227 });

223 });

228

224

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

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

230− auto screenWrapper(new ProxyScreen(screen));

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

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

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

232− m_screens.push_back(new ProxyScreen(screen));

228+ m_screens.push_back(screenWrapper);

233 }

229 }

234}

230}

231+

232+void ProxyScreens::setSyncing(bool syncing)

233+{

234+ m_syncing = syncing;

235+}

plugins/WindowManager/Screens.h+5−4

@@ -52,8 +52,6 @@ public:

52 int count() const;

53 QVariant activeScreen() const;

54

55− bool isSyncing() const { return m_syncing; }

56−

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

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

58

56

59public Q_SLOTS:

57public Q_SLOTS:

@@ -71,7 +69,6 @@ protected:

71

69

72 QVector<Screen*> m_screens;

70 QVector<Screen*> m_screens;

73 const QSharedPointer<qtmir::Screens> m_wrapped;

71 const QSharedPointer<qtmir::Screens> m_wrapped;

74− bool m_syncing;

75

72

76 friend class ProxyScreens;

73 friend class ProxyScreens;

77};

74};

@@ -84,7 +81,7 @@ public:

84 ~ConcreteScreens();

81 ~ConcreteScreens();

85

82

86 Q_INVOKABLE ProxyScreens *createProxy();

83 Q_INVOKABLE ProxyScreens *createProxy();

87− Q_INVOKABLE void sync(Screens *proxy);

84+ Q_INVOKABLE void sync(ProxyScreens *proxy);

88

85

89 static ConcreteScreens *self();

86 static ConcreteScreens *self();

90

87

@@ -103,8 +100,12 @@ class ProxyScreens : public Screens

103public:

100public:

104 explicit ProxyScreens(Screens*const screens);

101 explicit ProxyScreens(Screens*const screens);

105

102

103+ void setSyncing(bool syncing);

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

105+

106private:

107 const QPointer<Screens> m_original;

108+ bool m_syncing;

108};

109};

109

110

110#endif // SCREENS_H

111#endif // SCREENS_H

plugins/WindowManager/WorkspaceModel.cpp+11−9

@@ -17,6 +17,7 @@

17#include "WorkspaceModel.h"

18#include "WorkspaceManager.h"

19#include "Workspace.h"

20+#include "Screen.h"

20

21

21#include <QQmlEngine>

22#include <QQmlEngine>

22

23

@@ -119,11 +120,6 @@ QVariant WorkspaceModel::data(const QModelIndex &index, int role) const

119 }

120 }

120}

121}

121

122

122−void WorkspaceModel::setSyncing(bool syncing)

123−{

124− m_syncing = syncing;

125−}

126−

127void WorkspaceModel::sync(WorkspaceModel *proxy)

123void WorkspaceModel::sync(WorkspaceModel *proxy)

128{

124{

129 if (!proxy) return;

125 if (!proxy) return;

@@ -206,8 +202,9 @@ void WorkspaceModel::insertUnassigned(Workspace *workspace)

206}

202}

207

203

208

204

209−ProxyWorkspaceModel::ProxyWorkspaceModel(WorkspaceModel * const model)

205+ProxyWorkspaceModel::ProxyWorkspaceModel(WorkspaceModel * const model, ProxyScreen* screen)

210 : m_original(model)

206 : m_original(model)

207+ , m_screen(screen)

211{

208{

212 Q_FOREACH(auto workspace, model->list()) {

209 Q_FOREACH(auto workspace, model->list()) {

213 auto proxy = new ProxyWorkspace(workspace);

210 auto proxy = new ProxyWorkspace(workspace);

@@ -215,12 +212,12 @@ ProxyWorkspaceModel::ProxyWorkspaceModel(WorkspaceModel * const model)

215 proxy->assign(this);

212 proxy->assign(this);

216 }

213 }

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

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

218− if (m_original->isSyncing()) return;

215+ if (isSyncing()) return;

219

216

220 (new ProxyWorkspace(inserted))->assign(this, index);

217 (new ProxyWorkspace(inserted))->assign(this, index);

221 });

218 });

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

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

223− if (m_original->isSyncing()) return;

220+ if (isSyncing()) return;

224

221

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

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

226 auto workspaceProxy = qobject_cast<ProxyWorkspace*>(get(i));

223 auto workspaceProxy = qobject_cast<ProxyWorkspace*>(get(i));

@@ -232,7 +229,7 @@ ProxyWorkspaceModel::ProxyWorkspaceModel(WorkspaceModel * const model)

232 }

229 }

233 });

230 });

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

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

235− if (m_original->isSyncing()) return;

232+ if (isSyncing()) return;

236

233

237 move(from, to);

234 move(from, to);

238 });

235 });

@@ -243,6 +240,11 @@ void ProxyWorkspaceModel::move(int from, int to)

243 WorkspaceModel::move(from, to);

240 WorkspaceModel::move(from, to);

244}

241}

245

242

243+bool ProxyWorkspaceModel::isSyncing() const

244+{

245+ return m_screen->isSyncing();

246+}

247+

246void ProxyWorkspaceModel::addWorkspace()

248void ProxyWorkspaceModel::addWorkspace()

247{

249{

248 auto newWorkspace = WorkspaceManager::instance()->createWorkspace();

250 auto newWorkspace = WorkspaceManager::instance()->createWorkspace();

plugins/WindowManager/WorkspaceModel.h+5−5

@@ -25,6 +25,7 @@ Q_DECLARE_LOGGING_CATEGORY(WORKSPACES)

25

26class Workspace;

27class ProxyWorkspaceModel;

28+class ProxyScreen;

28

29

29class WorkspaceModel : public QAbstractListModel

30class WorkspaceModel : public QAbstractListModel

30{

31{

@@ -61,12 +62,9 @@ public:

61

62

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

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

63

64

64− void setSyncing(bool);

65 void sync(WorkspaceModel* proxy);

66 void finishSync();

67

68− bool isSyncing() { return m_syncing; }

69−

70Q_SIGNALS:

68Q_SIGNALS:

71 void countChanged();

69 void countChanged();

72

70

@@ -79,7 +77,6 @@ protected:

79

77

80 QVector<Workspace*> m_workspaces;

78 QVector<Workspace*> m_workspaces;

81 QSet<Workspace*> m_unassignedWorkspaces;

79 QSet<Workspace*> m_unassignedWorkspaces;

82− bool m_syncing;

83

80

84 friend class ProxyWorkspaceModel;

81 friend class ProxyWorkspaceModel;

85};

82};

@@ -88,15 +85,18 @@ class ProxyWorkspaceModel : public WorkspaceModel

88{

85{

89 Q_OBJECT

86 Q_OBJECT

90public:

87public:

91− explicit ProxyWorkspaceModel(WorkspaceModel*const model);

88+ explicit ProxyWorkspaceModel(WorkspaceModel*const model, ProxyScreen* screen);

92

89

93 Q_INVOKABLE void move(int from, int to) override;

90 Q_INVOKABLE void move(int from, int to) override;

94

91

92+ bool isSyncing() const;

93+

95public Q_SLOTS:

94public Q_SLOTS:

96 void addWorkspace();

95 void addWorkspace();

97

96

98protected:

97protected:

99 const QPointer<WorkspaceModel> m_original;

98 const QPointer<WorkspaceModel> m_original;

99+ const ProxyScreen* m_screen;

100};

101

102#endif // WORKSPACEMODEL_H