plugins/WindowManager/Screen.cpp · unity8

git.iko.soy/unity8

on 945dd8e help sign in

unity8/plugins/WindowManager/Screen.cpp

305 lines 8.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 "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}

49void Screen::setCurrentWorkspace2(Workspace *workspace)

50{

51 // Make sure we use the correct concrete class. Don't want to use a Proxy.

52 workspace->setCurrentOn(this);

53}

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

56{

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

58 return m_wrapped->outputId();

59}

61bool Screen::used() const

62{

63 if (!m_wrapped) return false;

64 return m_wrapped->used();

65}

67QString Screen::name() const

68{

69 if (!m_wrapped) return QString();

70 return m_wrapped->name();

71}

73float Screen::scale() const

74{

75 if (!m_wrapped) return 1.0;

76 return m_wrapped->scale();

77}

79QSizeF Screen::physicalSize() const

80{

81 if (!m_wrapped) return QSizeF();

82 return m_wrapped->physicalSize();

83}

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

86{

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

88 return m_wrapped->formFactor();

89}

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

92{

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

94 return m_wrapped->outputType();

95}

97MirPowerMode Screen::powerMode() const

98{

99 if (!m_wrapped) return mir_power_mode_on;

100 return m_wrapped->powerMode();

101}

102

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

104{

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

106 return m_wrapped->orientation();

107}

108

109QPoint Screen::position() const

110{

111 if (!m_wrapped) return QPoint();

112 return m_wrapped->position();

113}

114

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

116{

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

118 return m_wrapped->availableModes();

119}

120

121uint Screen::currentModeIndex() const

122{

123 if (!m_wrapped) return -1;

124 return m_wrapped->currentModeIndex();

125}

126

127bool Screen::isActive() const

128{

129 if (!m_wrapped) return false;

130 return m_wrapped->isActive();

131}

132

133void Screen::activate()

134{

135 setActive(true);

136}

137

138void Screen::setActive(bool active)

139{

140 if (!m_wrapped) return;

141 m_wrapped->setActive(active);

142}

143

144QScreen *Screen::qscreen() const

145{

146 if (!m_wrapped) return nullptr;

147 return m_wrapped->qscreen();

148}

149

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

151{

152 if (!m_wrapped) return nullptr;

153 return m_wrapped->beginConfiguration();

154}

155

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

157{

158 if (!m_wrapped) return false;

159 return m_wrapped->applyConfiguration(configuration);

160}

161

162QString Screen::outputTypeName() const

163{

164 switch (m_wrapped->outputType()) {

165 case qtmir::Unknown:

166 return tr("Unknown");

167 case qtmir::VGA:

168 return tr("VGA");

169 case qtmir::DVII:

170 case qtmir::DVID:

171 case qtmir::DVIA:

172 return tr("DVI");

173 case qtmir::Composite:

174 return tr("Composite");

175 case qtmir::SVideo:

176 return tr("S-Video");

177 case qtmir::LVDS:

178 case qtmir::NinePinDIN:

179 case qtmir::EDP:

180 return tr("Internal");

181 case qtmir::Component:

182 return tr("Component");

183 case qtmir::DisplayPort:

184 return tr("DisplayPort");

185 case qtmir::HDMIA:

186 case qtmir::HDMIB:

187 return tr("HDMI");

188 case qtmir::TV:

189 return tr("TV");

190 }

191 return QString();

192}

193

194void Screen::sync(Screen *proxy)

195{

196 if (!proxy) return;

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

198}

199

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

201 : m_workspaces(new WorkspaceModel)

202{

203 connectToScreen(wrapped);

204

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

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

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

208 if (active) {

209 setCurrentWorkspace(workspace);

210 activate();

211 }

212 });

213 if (workspace->isActive()) {

214 activate();

215 setCurrentWorkspace(workspace);

216 }

217 if (!m_currentWorspace) {

218 setCurrentWorkspace(workspace);

219 }

220 });

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

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

223 if (workspace == m_currentWorspace) {

224 resetCurrentWorkspace();

225 }

226 });

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

228 if (active && m_currentWorspace) {

229 m_currentWorspace->activate();

230 }

231 });

232}

233

234void ConcreteScreen::resetCurrentWorkspace()

235{

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

237 if (m_currentWorspace != newCurrent) {

238 m_currentWorspace = newCurrent;

239 Q_EMIT currentWorkspaceChanged(newCurrent);

240 }

241}

242

243

244WorkspaceModel *ConcreteScreen::workspaces() const

245{

246 return m_workspaces.data();

247}

248

249Workspace *ConcreteScreen::currentWorkspace() const

250{

251 return m_currentWorspace.data();

252}

253

254void ConcreteScreen::setCurrentWorkspace(Workspace *workspace)

255{

256 if (m_currentWorspace != workspace) {

257 m_currentWorspace = workspace;

258 Q_EMIT currentWorkspaceChanged(workspace);

259 }

260}

261

262ProxyScreen::ProxyScreen(Screen *const screen, ProxyScreens* screens)

263 : m_workspaces(new ProxyWorkspaceModel(screen->workspaces(), this))

264 , m_original(screen)

265 , m_screens(screens)

266{

267 connectToScreen(screen);

268

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

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

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

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

273 if (m_currentWorspace != p) {

274 m_currentWorspace = p;

275 Q_EMIT currentWorkspaceChanged(p);

276 }

277 }

278 }

279 };

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

281 updateCurrentWorkspaceFn(screen->currentWorkspace());

282}

283

284WorkspaceModel *ProxyScreen::workspaces() const

285{

286 return m_workspaces.data();

287}

288

289Workspace *ProxyScreen::currentWorkspace() const

290{

291 return m_currentWorspace.data();

292}

293

294void ProxyScreen::setCurrentWorkspace(Workspace *workspace)

295{

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

297 if (p) {

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

299 }

300}

301

302bool ProxyScreen::isSyncing() const

303{

304 return m_screens->isSyncing();

305}