plugins/WindowManager/Screens.cpp · unity8

git.iko.soy/unity8

on 3a0ec61 help sign in

unity8/plugins/WindowManager/Screens.cpp

198 lines 5.3 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 connect(m_wrapped.data(), &qtmir::Screens::screenAdded, this, &Screens::onScreenAdded);

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

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

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

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

38 }

39}

41Screens::~Screens()

42{

43 qDeleteAll(m_screens);

44 m_screens.clear();

45}

47Screens::Screens(const Screens &other)

48 : QAbstractListModel(nullptr)

49 , m_wrapped(other.m_wrapped)

50{

51}

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

54{

55 QHash<int, QByteArray> roles;

56 roles[ScreenRole] = "screen";

57 return roles;

58}

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

61{

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

63 return QVariant();

64 }

66 switch(role) {

67 case ScreenRole:

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

69 } // switch

71 return QVariant();

72}

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

75{

76 return count();

77}

79int Screens::count() const

80{

81 return m_screens.size();

82}

84QVariant Screens::activeScreen() const

85{

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

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

88 }

89 return QVariant();

90}

92ScreensProxy *Screens::createProxy()

93{

94 return new ScreensProxy(this);

95}

97void Screens::sync(Screens *proxy)

98{

99 if (!proxy) return;

100

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

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

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

104 }

105

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

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

108}

109

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

111{

112 bool ok = false;

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

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

115

116 auto screen = m_screens.at(index);

117 screen->setActive(true);

118}

119

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

121{

122 Q_FOREACH(auto screenWrapper, m_screens) {

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

124 }

125

126 beginInsertRows(QModelIndex(), count(), count());

127 auto screenWrapper(new Screen(added));

128 m_screens.push_back(screenWrapper);

129 endInsertRows();

130 Q_EMIT screenAdded(screenWrapper);

131 Q_EMIT countChanged();

132}

133

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

135{

136 int index = 0;

137 QMutableVectorIterator<Screen*> iter(m_screens);

138 while(iter.hasNext()) {

139 auto screenWrapper = iter.next();

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

141

142 beginRemoveRows(QModelIndex(), index, index);

143 iter.remove();

144 endRemoveRows();

145

146 Q_EMIT screenRemoved(screenWrapper);

147 Q_EMIT countChanged();

148

149 screenWrapper->deleteLater();

150 break;

151 }

152 index++;

153 }

154}

155

156ScreensProxy::ScreensProxy(Screens * const screens)

157 : Screens(*screens)

158 , m_original(screens)

159{

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

161 Q_FOREACH(auto screen, m_screens) {

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

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

164 }

165

166 beginInsertRows(QModelIndex(), count(), count());

167 auto screenWrapper(new ScreenProxy(added));

168 m_screens.push_back(screenWrapper);

169 endInsertRows();

170 Q_EMIT screenAdded(screenWrapper);

171 Q_EMIT countChanged();

172 });

173

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

175 int index = 0;

176 QMutableVectorIterator<Screen*> iter(m_screens);

177 while(iter.hasNext()) {

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

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

180

181 beginRemoveRows(QModelIndex(), index, index);

182 iter.remove();

183 endRemoveRows();

184

185 Q_EMIT screenRemoved(proxy);

186 Q_EMIT countChanged();

187

188 delete proxy;

189 break;

190 }

191 index++;

192 }

193 });

194

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

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

197 }

198}