plugins/WindowManager/Screen.cpp · unity8

git.iko.soy/unity8

on 80fc88d help sign in

unity8/plugins/WindowManager/Screen.cpp

298 lines 8.2 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"

22Screen::Screen(QObject *parent)

23 : QObject(parent)

24{

25}

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

28{

29 m_wrapped = screen;

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

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

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

33 connect(screen, &qtmir::Screen::outputTypeChanged, this, &Screen::outputTypeNameChanged);

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

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

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

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

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

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

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

41}

43void Screen::connectToScreen(Screen *screen)

44{

45 connectToScreen(screen->wrapped());

46 connect(screen, &Screen::currentWorkspaceChanged, this, &Screen::currentWorkspaceChanged);

47}

49qtmir::OutputId Screen::outputId() const

50{

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

52 return m_wrapped->outputId();

53}

55bool Screen::used() const

56{

57 if (!m_wrapped) return false;

58 return m_wrapped->used();

59}

61QString Screen::name() const

62{

63 if (!m_wrapped) return QString();

64 return m_wrapped->name();

65}

67float Screen::scale() const

68{

69 if (!m_wrapped) return 1.0;

70 return m_wrapped->scale();

71}

73QSizeF Screen::physicalSize() const

74{

75 if (!m_wrapped) return QSizeF();

76 return m_wrapped->physicalSize();

77}

79qtmir::FormFactor Screen::formFactor() const

80{

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

82 return m_wrapped->formFactor();

83}

85qtmir::OutputTypes Screen::outputType() const

86{

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

88 return m_wrapped->outputType();

89}

91MirPowerMode Screen::powerMode() const

92{

93 if (!m_wrapped) return mir_power_mode_on;

94 return m_wrapped->powerMode();

95}

97Qt::ScreenOrientation Screen::orientation() const

98{

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

100 return m_wrapped->orientation();

101}

102

103QPoint Screen::position() const

104{

105 if (!m_wrapped) return QPoint();

106 return m_wrapped->position();

107}

108

109QQmlListProperty<qtmir::ScreenMode> Screen::availableModes()

110{

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

112 return m_wrapped->availableModes();

113}

114

115uint Screen::currentModeIndex() const

116{

117 if (!m_wrapped) return -1;

118 return m_wrapped->currentModeIndex();

119}

120

121bool Screen::isActive() const

122{

123 if (!m_wrapped) return false;

124 return m_wrapped->isActive();

125}

126

127void Screen::activate()

128{

129 setActive(true);

130}

131

132void Screen::setActive(bool active)

133{

134 if (!m_wrapped) return;

135 m_wrapped->setActive(active);

136}

137

138QScreen *Screen::qscreen() const

139{

140 if (!m_wrapped) return nullptr;

141 return m_wrapped->qscreen();

142}

143

144qtmir::ScreenConfiguration *Screen::beginConfiguration() const

145{

146 if (!m_wrapped) return nullptr;

147 return m_wrapped->beginConfiguration();

148}

149

150bool Screen::applyConfiguration(qtmir::ScreenConfiguration *configuration)

151{

152 if (!m_wrapped) return false;

153 return m_wrapped->applyConfiguration(configuration);

154}

155

156QString Screen::outputTypeName() const

157{

158 switch (m_wrapped->outputType()) {

159 case qtmir::Unknown:

160 return tr("Unknown");

161 case qtmir::VGA:

162 return tr("VGA");

163 case qtmir::DVII:

164 case qtmir::DVID:

165 case qtmir::DVIA:

166 return tr("DVI");

167 case qtmir::Composite:

168 return tr("Composite");

169 case qtmir::SVideo:

170 return tr("S-Video");

171 case qtmir::LVDS:

172 case qtmir::NinePinDIN:

173 case qtmir::EDP:

174 return tr("Internal");

175 case qtmir::Component:

176 return tr("Component");

177 case qtmir::DisplayPort:

178 return tr("DisplayPort");

179 case qtmir::HDMIA:

180 case qtmir::HDMIB:

181 return tr("HDMI");

182 case qtmir::TV:

183 return tr("TV");

184 }

185 return QString();

186}

187

188void Screen::setSyncing(bool syncing)

189{

190 workspaces()->setSyncing(syncing);

191}

192

193void Screen::sync(Screen *proxy)

194{

195 if (!proxy) return;

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

197}

198

199ConcreteScreen::ConcreteScreen(qtmir::Screen* wrapped)

200 : m_workspaces(new WorkspaceModel)

201{

202 connectToScreen(wrapped);

203

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

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

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

207 if (active) {

208 setCurrentWorkspace(workspace);

209 activate();

210 }

211 });

212 if (workspace->isActive()) {

213 activate();

214 setCurrentWorkspace(workspace);

215 }

216 if (!m_currentWorspace) {

217 setCurrentWorkspace(workspace);

218 }

219 });

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

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

222 if (workspace == m_currentWorspace) {

223 resetCurrentWorkspace();

224 }

225 });

226 connect(this, &ConcreteScreen::activeChanged, this, [this](bool active) {

227 if (active && m_currentWorspace) {

228 m_currentWorspace->activate();

229 }

230 });

231}

232

233void ConcreteScreen::resetCurrentWorkspace()

234{

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

236 if (m_currentWorspace != newCurrent) {

237 m_currentWorspace = newCurrent;

238 Q_EMIT currentWorkspaceChanged(newCurrent);

239 }

240}

241

242

243WorkspaceModel *ConcreteScreen::workspaces() const

244{

245 return m_workspaces.data();

246}

247

248Workspace *ConcreteScreen::currentWorkspace() const

249{

250 return m_currentWorspace.data();

251}

252

253void ConcreteScreen::setCurrentWorkspace(Workspace *workspace)

254{

255 if (m_currentWorspace != workspace) {

256 m_currentWorspace = workspace;

257 Q_EMIT currentWorkspaceChanged(workspace);

258 }

259}

260

261ProxyScreen::ProxyScreen(Screen *const screen)

262 : m_workspaces(new ProxyWorkspaceModel(screen->workspaces()))

263 , m_original(screen)

264{

265 connectToScreen(screen);

266

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

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

269 auto p = qobject_cast<ProxyWorkspace*>(workspace);

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

271 if (m_currentWorspace != p) {

272 m_currentWorspace = p;

273 Q_EMIT currentWorkspaceChanged(p);

274 }

275 }

276 }

277 };

278 connect(screen, &Screen::currentWorkspaceChanged, this, updateCurrentWorkspaceFn);

279 updateCurrentWorkspaceFn(screen->currentWorkspace());

280}

281

282WorkspaceModel *ProxyScreen::workspaces() const

283{

284 return m_workspaces.data();

285}

286

287Workspace *ProxyScreen::currentWorkspace() const

288{

289 return m_currentWorspace.data();

290}

291

292void ProxyScreen::setCurrentWorkspace(Workspace *workspace)

293{

294 auto p = qobject_cast<ProxyWorkspace*>(workspace);

295 if (p) {

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

297 }

298}