plugins/WindowManager/Screen.cpp · unity8

git.iko.soy/unity8

on 0bcac19 help sign in

unity8/plugins/WindowManager/Screen.cpp

294 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"

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

149QString ScreenInterface::outputTypeName() const

150{

151 switch (m_wrapped->outputType()) {

152 case qtmir::Unknown:

153 return tr("Unknown");

154 case qtmir::VGA:

155 return tr("VGA");

156 case qtmir::DVII:

157 case qtmir::DVID:

158 case qtmir::DVIA:

159 return tr("DVI");

160 case qtmir::Composite:

161 return tr("Composite");

162 case qtmir::SVideo:

163 return tr("S-Video");

164 case qtmir::LVDS:

165 case qtmir::NinePinDIN:

166 case qtmir::EDP:

167 return tr("Internal");

168 case qtmir::Component:

169 return tr("Component");

170 case qtmir::DisplayPort:

171 return tr("DisplayPort");

172 case qtmir::HDMIA:

173 case qtmir::HDMIB:

174 return tr("HDMI");

175 case qtmir::TV:

176 return tr("TV");

177 }

178 return QString();

179}

180

181void ScreenInterface::sync(ScreenInterface *proxy)

182{

183 if (!proxy) return;

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

185}

186

187Screen::Screen(qtmir::Screen* wrapped)

188 : m_workspaces(new WorkspaceModel)

189{

190 connectToScreen(wrapped);

191

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

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

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

195 if (active) {

196 setCurrentWorkspace(workspace);

197 activate();

198 }

199 });

200 if (workspace->isActive()) {

201 activate();

202 setCurrentWorkspace(workspace);

203 }

204 if (!m_currentWorspace) {

205 setCurrentWorkspace(workspace);

206 }

207 });

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

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

210 if (workspace == m_currentWorspace) {

211 resetCurrentWorkspace();

212 }

213 });

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

215 if (active && m_currentWorspace) {

216 m_currentWorspace->activate();

217 }

218 });

219

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

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

222}

223

224void Screen::resetCurrentWorkspace()

225{

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

227 if (m_currentWorspace != newCurrent) {

228 m_currentWorspace = newCurrent;

229 Q_EMIT currentWorkspaceChanged(newCurrent);

230 }

231}

232

233

234WorkspaceModel *Screen::workspaces() const

235{

236 return m_workspaces.data();

237}

238

239Workspace *Screen::currentWorkspace() const

240{

241 return m_currentWorspace.data();

242}

243

244void Screen::setCurrentWorkspace(Workspace *workspace)

245{

246 if (m_currentWorspace != workspace) {

247 m_currentWorspace = workspace;

248 Q_EMIT currentWorkspaceChanged(workspace);

249 }

250}

251

252ScreenProxy::ScreenProxy(ScreenInterface *const screen)

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

254 , m_original(screen)

255{

256 connectToScreen(screen->wrapped());

257

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

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

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

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

262 if (m_currentWorspace != p) {

263 m_currentWorspace = p;

264 Q_EMIT currentWorkspaceChanged(p);

265 }

266 }

267 }

268 };

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

270 updateCurrentWorkspaceFn(screen->currentWorkspace());

271}

272

273WorkspaceModel *ScreenProxy::workspaces() const

274{

275 return m_workspaces.data();

276}

277

278Workspace *ScreenProxy::currentWorkspace() const

279{

280 return m_currentWorspace.data();

281}

282

283void ScreenProxy::setCurrentWorkspace(Workspace *workspace)

284{

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

286 if (p) {

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

288 }

289}

290

291void ScreenProxy::addWorkspace()

292{

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

294}