plugins/WindowManager/Screen.cpp · unity8

git.iko.soy/unity8

on bcbc40d help sign in

unity8/plugins/WindowManager/Screen.cpp

262 lines 7.6 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 "Screen.h"

18#include "Screens.h"

19#include "WorkspaceManager.h"

20#include "Workspace.h"

22ScreenInterface::ScreenInterface(QObject *parent)

23 : QObject(parent)

24{

25}

27void ScreenInterface::connectToScreen(qtmir::Screen *screen)

28{

29 m_wrapped = screen;

30 connect(screen, &qtmir::Screen::usedChanged, this, &ScreenInterface::usedChanged);

31 connect(screen, &qtmir::Screen::nameChanged, this, &ScreenInterface::nameChanged);

32 connect(screen, &qtmir::Screen::outputTypeChanged, this, &ScreenInterface::outputTypeChanged);

33 connect(screen, &qtmir::Screen::scaleChanged, this, &ScreenInterface::scaleChanged);

34 connect(screen, &qtmir::Screen::formFactorChanged, this, &ScreenInterface::formFactorChanged);

35 connect(screen, &qtmir::Screen::physicalSizeChanged, this, &ScreenInterface::physicalSizeChanged);

36 connect(screen, &qtmir::Screen::positionChanged, this, &ScreenInterface::positionChanged);

37 connect(screen, &qtmir::Screen::activeChanged, this, &ScreenInterface::activeChanged);

38 connect(screen, &qtmir::Screen::currentModeIndexChanged, this, &ScreenInterface::currentModeIndexChanged);

39 connect(screen, &qtmir::Screen::availableModesChanged, this, &ScreenInterface::availableModesChanged);

40}

42qtmir::OutputId ScreenInterface::outputId() const

43{

44 if (!m_wrapped) return qtmir::OutputId(-1);

45 return m_wrapped->outputId();

46}

48bool ScreenInterface::used() const

49{

50 if (!m_wrapped) return false;

51 return m_wrapped->used();

52}

54QString ScreenInterface::name() const

55{

56 if (!m_wrapped) return QString();

57 return m_wrapped->name();

58}

60float ScreenInterface::scale() const

61{

62 if (!m_wrapped) return 1.0;

63 return m_wrapped->scale();

64}

66QSizeF ScreenInterface::physicalSize() const

67{

68 if (!m_wrapped) return QSizeF();

69 return m_wrapped->physicalSize();

70}

72qtmir::FormFactor ScreenInterface::formFactor() const

73{

74 if (!m_wrapped) return qtmir::FormFactorUnknown;

75 return m_wrapped->formFactor();

76}

78qtmir::OutputTypes ScreenInterface::outputType() const

79{

80 if (!m_wrapped) return qtmir::Unknown;

81 return m_wrapped->outputType();

82}

84MirPowerMode ScreenInterface::powerMode() const

85{

86 if (!m_wrapped) return mir_power_mode_on;

87 return m_wrapped->powerMode();

88}

90Qt::ScreenOrientation ScreenInterface::orientation() const

91{

92 if (!m_wrapped) return Qt::PrimaryOrientation;

93 return m_wrapped->orientation();

94}

96QPoint ScreenInterface::position() const

97{

98 if (!m_wrapped) return QPoint();

99 return m_wrapped->position();

100}

101

102QQmlListProperty<qtmir::ScreenMode> ScreenInterface::availableModes()

103{

104 if (!m_wrapped) return QQmlListProperty<qtmir::ScreenMode>();

105 return m_wrapped->availableModes();

106}

107

108uint ScreenInterface::currentModeIndex() const

109{

110 if (!m_wrapped) return -1;

111 return m_wrapped->currentModeIndex();

112}

113

114bool ScreenInterface::isActive() const

115{

116 if (!m_wrapped) return false;

117 return m_wrapped->isActive();

118}

119

120void ScreenInterface::activate()

121{

122 setActive(true);

123}

124

125void ScreenInterface::setActive(bool active)

126{

127 if (!m_wrapped) return;

128 m_wrapped->setActive(active);

129}

130

131QScreen *ScreenInterface::qscreen() const

132{

133 if (!m_wrapped) return nullptr;

134 return m_wrapped->qscreen();

135}

136

137qtmir::ScreenConfiguration *ScreenInterface::beginConfiguration() const

138{

139 if (!m_wrapped) return nullptr;

140 return m_wrapped->beginConfiguration();

141}

142

143bool ScreenInterface::applyConfiguration(qtmir::ScreenConfiguration *configuration)

144{

145 if (!m_wrapped) return false;

146 return m_wrapped->applyConfiguration(configuration);

147}

148

149void ScreenInterface::sync(ScreenInterface *proxy)

150{

151 if (!proxy) return;

152 workspaces()->sync(proxy->workspaces());

153}

154

155Screen::Screen(qtmir::Screen* wrapped)

156 : m_workspaces(new WorkspaceModel)

157{

158 connectToScreen(wrapped);

159

160 // Connect the active workspace to activate the screen.

161 connect(m_workspaces.data(), &WorkspaceModel::workspaceInserted, this, [this](int, Workspace* workspace) {

162 connect(workspace, &Workspace::activeChanged, this, [this, workspace](bool active) {

163 if (active) {

164 setCurrentWorkspace(workspace);

165 activate();

166 }

167 });

168 if (workspace->isActive()) {

169 activate();

170 setCurrentWorkspace(workspace);

171 }

172 if (!m_currentWorspace) {

173 setCurrentWorkspace(workspace);

174 }

175 });

176 connect(m_workspaces.data(), &WorkspaceModel::workspaceRemoved, this, [this](Workspace* workspace) {

177 disconnect(workspace, &Workspace::activeChanged, this, 0);

178 if (workspace == m_currentWorspace) {

179 resetCurrentWorkspace();

180 }

181 });

182 connect(this, &Screen::activeChanged, this, [this](bool active) {

183 if (active && m_currentWorspace) {

184 m_currentWorspace->activate();

185 }

186 });

187

188 WorkspaceManager::instance()->createWorkspace()->assign(m_workspaces.data());

189 WorkspaceManager::instance()->createWorkspace()->assign(m_workspaces.data());

190}

191

192void Screen::resetCurrentWorkspace()

193{

194 auto newCurrent = m_workspaces->rowCount() > 0 ? m_workspaces->get(0) : nullptr;

195 if (m_currentWorspace != newCurrent) {

196 m_currentWorspace = newCurrent;

197 Q_EMIT currentWorkspaceChanged(newCurrent);

198 }

199}

200

201

202WorkspaceModel *Screen::workspaces() const

203{

204 return m_workspaces.data();

205}

206

207Workspace *Screen::currentWorkspace() const

208{

209 return m_currentWorspace.data();

210}

211

212void Screen::setCurrentWorkspace(Workspace *workspace)

213{

214 if (m_currentWorspace != workspace) {

215 m_currentWorspace = workspace;

216 Q_EMIT currentWorkspaceChanged(workspace);

217 }

218}

219

220ScreenProxy::ScreenProxy(ScreenInterface *const screen)

221 : m_workspaces(new WorkspaceModelProxy(screen->workspaces()))

222 , m_original(screen)

223{

224 connectToScreen(screen->wrapped());

225

226 auto updateCurrentWorkspaceFn = [this](Workspace* realWorkspace) {

227 Q_FOREACH(Workspace* workspace, m_workspaces->list()) {

228 auto p = qobject_cast<WorkspaceProxy*>(workspace);

229 if (p && p->proxyObject() == realWorkspace) {

230 if (m_currentWorspace != p) {

231 m_currentWorspace = p;

232 Q_EMIT currentWorkspaceChanged(p);

233 }

234 }

235 }

236 };

237 connect(screen, &ScreenInterface::currentWorkspaceChanged, this, updateCurrentWorkspaceFn);

238 updateCurrentWorkspaceFn(screen->currentWorkspace());

239}

240

241WorkspaceModel *ScreenProxy::workspaces() const

242{

243 return m_workspaces.data();

244}

245

246Workspace *ScreenProxy::currentWorkspace() const

247{

248 return m_currentWorspace.data();

249}

250

251void ScreenProxy::setCurrentWorkspace(Workspace *workspace)

252{

253 auto p = qobject_cast<WorkspaceProxy*>(workspace);

254 if (p) {

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

256 }

257}

258

259void ScreenProxy::addWorkspace()

260{

261 (new WorkspaceProxy(WorkspaceManager::instance()->createWorkspace()))->assign(workspaces());

262}