plugins/WindowManager/Screens.cpp · unity8

git.iko.soy/unity8

on 7b68b97 help sign in

unity8/plugins/WindowManager/Screens.cpp

244 lines 6.5 kB history raw

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 */

17#include "Screens.h"

18#include "ScreensConfiguration.h"

19#include "Screen.h"

20#include "WorkspaceManager.h"

22// qtmirserver

23#include <qtmir/screens.h>

24#include <QGuiApplication>

25#include <QQmlEngine>

27// Qt

28#include <QScreen>

29#include <QWindow>

31ConcreteScreens* ConcreteScreens::m_self{nullptr};

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

34 : m_wrapped(model)

35{

36}

38Screens::~Screens()

39{

40 qDeleteAll(m_screens);

41 m_screens.clear();

42}

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

45{

46 QHash<int, QByteArray> roles;

47 roles[ScreenRole] = "screen";

48 return roles;

49}

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

52{

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

54 return QVariant();

55 }

57 switch(role) {

58 case ScreenRole:

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

60 } // switch

62 return QVariant();

63}

65int Screens::rowCount(const QModelIndex &) const

66{

67 return count();

68}

70int Screens::indexOf(Screen *screen) const

71{

72 return m_screens.indexOf(screen);

73}

75Screen *Screens::get(int index) const

76{

77 return m_screens.at(index);

78}

80int Screens::count() const

81{

82 return m_screens.size();

83}

85QVariant Screens::activeScreen() const

86{

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

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

89 }

90 return QVariant();

91}

93void Screens::activateScreen(const QVariant& vindex)

94{

95 bool ok = false;

96 int index = vindex.toInt(&ok);

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

99 auto screen = m_screens.at(index);

100 screen->setActive(true);

101}

102

103

104ConcreteScreens::ConcreteScreens(const QSharedPointer<qtmir::Screens> &model, ScreensConfiguration* config)

105 : Screens(model)

106 , m_config(config)

107{

108 m_self = this;

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

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

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

112

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

114 auto screenWrapper(new ConcreteScreen(screen));

115 m_config->load(screenWrapper);

116

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

118 m_screens.push_back(screenWrapper);

119 }

120}

121

122ConcreteScreens::~ConcreteScreens()

123{

124 Q_FOREACH(Screen* screen, m_screens) {

125 m_config->save(screen);

126 }

127 delete m_config;

128}

129

130ConcreteScreens *ConcreteScreens::self()

131{

132 return ConcreteScreens::m_self;

133}

134

135ProxyScreens *ConcreteScreens::createProxy()

136{

137 return new ProxyScreens(this);

138}

139

140void ConcreteScreens::sync(Screens *proxy)

141{

142 if (!proxy) return;

143

144 for (auto screen : m_screens) {

145 screen->setSyncing(true);

146 }

147

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

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

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

151 }

152

153 for (auto screen : m_screens) {

154 screen->setSyncing(false);

155 }

156}

157

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

159{

160 Q_FOREACH(auto screenWrapper, m_screens) {

161 if (screenWrapper->wrapped() == added) return;

162 }

163

164 beginInsertRows(QModelIndex(), count(), count());

165 auto screenWrapper(new ConcreteScreen(added));

166 m_config->load(screenWrapper);

167

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

169 m_screens.push_back(screenWrapper);

170 endInsertRows();

171 Q_EMIT screenAdded(screenWrapper);

172 Q_EMIT countChanged();

173}

174

175void ConcreteScreens::onScreenRemoved(qtmir::Screen *removed)

176{

177 int index = 0;

178 QMutableVectorIterator<Screen*> iter(m_screens);

179 while(iter.hasNext()) {

180 auto screenWrapper = iter.next();

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

182 m_config->save(screenWrapper);

183

184 beginRemoveRows(QModelIndex(), index, index);

185 iter.remove();

186 endRemoveRows();

187

188 Q_EMIT screenRemoved(screenWrapper);

189 Q_EMIT countChanged();

190

191 screenWrapper->deleteLater();

192 break;

193 }

194 index++;

195 }

196}

197

198

199ProxyScreens::ProxyScreens(Screens * const screens)

200 : Screens(screens->m_wrapped)

201 , m_original(screens)

202{

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

204 Q_FOREACH(auto screen, m_screens) {

205 auto proxy = static_cast<ProxyScreen*>(screen);

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

207 }

208

209 beginInsertRows(QModelIndex(), count(), count());

210 auto screenWrapper(new ProxyScreen(added));

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

212 m_screens.push_back(screenWrapper);

213 endInsertRows();

214 Q_EMIT screenAdded(screenWrapper);

215 Q_EMIT countChanged();

216 });

217

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

219 int index = 0;

220 QMutableVectorIterator<Screen*> iter(m_screens);

221 while(iter.hasNext()) {

222 auto proxy = static_cast<ProxyScreen*>(iter.next());

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

224

225 beginRemoveRows(QModelIndex(), index, index);

226 iter.remove();

227 endRemoveRows();

228

229 Q_EMIT screenRemoved(proxy);

230 Q_EMIT countChanged();

231

232 delete proxy;

233 break;

234 }

235 index++;

236 }

237 });

238

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

240 auto screenWrapper(new ProxyScreen(screen));

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

242 m_screens.push_back(new ProxyScreen(screen));

243 }

244}