plugins/WindowManager/Screens.cpp · unity8

git.iko.soy/unity8

on 27ac232 help sign in

unity8/plugins/WindowManager/Screens.cpp

219 lines 6.0 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 "Screen.h"

19#include "WorkspaceManager.h"

21// qtmirserver

22#include <qtmir/screens.h>

23#include <QGuiApplication>

24#include <QQmlEngine>

26// Qt

27#include <QScreen>

28#include <QWindow>

30ConcreteScreens* ConcreteScreens::m_self{nullptr};

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

33 : m_wrapped(model)

34{

35}

37Screens::~Screens()

38{

39 qDeleteAll(m_screens);

40 m_screens.clear();

41}

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

44{

45 QHash<int, QByteArray> roles;

46 roles[ScreenRole] = "screen";

47 return roles;

48}

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

51{

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

53 return QVariant();

54 }

56 switch(role) {

57 case ScreenRole:

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

59 } // switch

61 return QVariant();

62}

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

65{

66 return count();

67}

69int Screens::count() const

70{

71 return m_screens.size();

72}

74QVariant Screens::activeScreen() const

75{

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

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

78 }

79 return QVariant();

80}

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

83{

84 bool ok = false;

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

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

88 auto screen = m_screens.at(index);

89 screen->setActive(true);

90}

93ConcreteScreens::ConcreteScreens(const QSharedPointer<qtmir::Screens> &model)

94 : Screens(model)

95{

96 m_self = this;

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

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

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

100

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

102 auto screenWrapper(new ConcreteScreen(screen));

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

104 m_screens.push_back(screenWrapper);

105 }

106}

107

108ConcreteScreens *ConcreteScreens::self()

109{

110 return ConcreteScreens::m_self;

111}

112

113ProxyScreens *ConcreteScreens::createProxy()

114{

115 return new ProxyScreens(this);

116}

117

118void ConcreteScreens::sync(Screens *proxy)

119{

120 if (!proxy) return;

121

122 for (auto screen : m_screens) {

123 screen->setSyncing(true);

124 }

125

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

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

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

129 }

130

131 for (auto screen : m_screens) {

132 screen->setSyncing(false);

133 }

134}

135

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

137{

138 Q_FOREACH(auto screenWrapper, m_screens) {

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

140 }

141

142 beginInsertRows(QModelIndex(), count(), count());

143 auto screenWrapper(new ConcreteScreen(added));

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

145 m_screens.push_back(screenWrapper);

146 endInsertRows();

147 Q_EMIT screenAdded(screenWrapper);

148 Q_EMIT countChanged();

149}

150

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

152{

153 int index = 0;

154 QMutableVectorIterator<Screen*> iter(m_screens);

155 while(iter.hasNext()) {

156 auto screenWrapper = iter.next();

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

158

159 beginRemoveRows(QModelIndex(), index, index);

160 iter.remove();

161 endRemoveRows();

162

163 Q_EMIT screenRemoved(screenWrapper);

164 Q_EMIT countChanged();

165

166 screenWrapper->deleteLater();

167 break;

168 }

169 index++;

170 }

171}

172

173

174ProxyScreens::ProxyScreens(Screens * const screens)

175 : Screens(screens->m_wrapped)

176 , m_original(screens)

177{

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

179 Q_FOREACH(auto screen, m_screens) {

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

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

182 }

183

184 beginInsertRows(QModelIndex(), count(), count());

185 auto screenWrapper(new ProxyScreen(added));

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

187 m_screens.push_back(screenWrapper);

188 endInsertRows();

189 Q_EMIT screenAdded(screenWrapper);

190 Q_EMIT countChanged();

191 });

192

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

194 int index = 0;

195 QMutableVectorIterator<Screen*> iter(m_screens);

196 while(iter.hasNext()) {

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

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

199

200 beginRemoveRows(QModelIndex(), index, index);

201 iter.remove();

202 endRemoveRows();

203

204 Q_EMIT screenRemoved(proxy);

205 Q_EMIT countChanged();

206

207 delete proxy;

208 break;

209 }

210 index++;

211 }

212 });

213

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

215 auto screenWrapper(new ProxyScreen(screen));

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

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

218 }

219}