plugins/WindowManager/Screens.cpp · unity8

git.iko.soy/unity8

on b3c03fa help sign in

unity8/plugins/WindowManager/Screens.cpp

202 lines 5.4 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>

25// Qt

26#include <QScreen>

27#include <QWindow>

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

30 : m_wrapped(model)

31{

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

33 qCritical("Not using 'mirserver' QPA plugin. Using qGuiApp may produce unknown results.");

34 }

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

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

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

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

41 m_screens.push_back(new Screen(screen));

42 }

43}

45Screens::~Screens()

46{

47 qDeleteAll(m_screens);

48 m_screens.clear();

49}

51Screens::Screens(const Screens &other)

52 : QAbstractListModel(nullptr)

53 , m_wrapped(other.m_wrapped)

54{

55}

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

58{

59 QHash<int, QByteArray> roles;

60 roles[ScreenRole] = "screen";

61 return roles;

62}

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

65{

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

67 return QVariant();

68 }

70 switch(role) {

71 case ScreenRole:

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

73 } // switch

75 return QVariant();

76}

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

79{

80 return count();

81}

83int Screens::count() const

84{

85 return m_screens.size();

86}

88QVariant Screens::activeScreen() const

89{

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

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

92 }

93 return QVariant();

94}

96ScreensProxy *Screens::createProxy()

97{

98 return new ScreensProxy(this);

99}

100

101void Screens::sync(Screens *proxy)

102{

103 if (!proxy) return;

104

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

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

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

108 }

109

110 // need to clean up all the workspaces we unassigned.

111 WorkspaceManager::instance()->destroyFloatingWorkspaces();

112}

113

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

115{

116 bool ok = false;

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

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

119

120 auto screen = m_screens.at(index);

121 screen->setActive(true);

122}

123

124void Screens::onScreenAdded(qtmir::Screen *added)

125{

126 Q_FOREACH(auto screenWrapper, m_screens) {

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

128 }

129

130 beginInsertRows(QModelIndex(), count(), count());

131 auto screenWrapper(new Screen(added));

132 m_screens.push_back(screenWrapper);

133 endInsertRows();

134 Q_EMIT screenAdded(screenWrapper);

135 Q_EMIT countChanged();

136}

137

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

139{

140 int index = 0;

141 QMutableVectorIterator<Screen*> iter(m_screens);

142 while(iter.hasNext()) {

143 auto screenWrapper = iter.next();

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

145

146 beginRemoveRows(QModelIndex(), index, index);

147 iter.remove();

148 endRemoveRows();

149

150 Q_EMIT screenRemoved(screenWrapper);

151 Q_EMIT countChanged();

152

153 screenWrapper->deleteLater();

154 break;

155 }

156 index++;

157 }

158}

159

160ScreensProxy::ScreensProxy(Screens * const screens)

161 : Screens(*screens)

162 , m_original(screens)

163{

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

165 Q_FOREACH(auto screen, m_screens) {

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

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

168 }

169

170 beginInsertRows(QModelIndex(), count(), count());

171 auto screenWrapper(new ScreenProxy(added));

172 m_screens.push_back(screenWrapper);

173 endInsertRows();

174 Q_EMIT screenAdded(screenWrapper);

175 Q_EMIT countChanged();

176 });

177

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

179 int index = 0;

180 QMutableVectorIterator<Screen*> iter(m_screens);

181 while(iter.hasNext()) {

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

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

184

185 beginRemoveRows(QModelIndex(), index, index);

186 iter.remove();

187 endRemoveRows();

188

189 Q_EMIT screenRemoved(proxy);

190 Q_EMIT countChanged();

191

192 delete proxy;

193 break;

194 }

195 index++;

196 }

197 });

198

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

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

201 }

202}