tests/mocks/Unity/Application/SurfaceManager.cpp · unity8

git.iko.soy/unity8

on dcb2e88 help sign in

unity8/tests/mocks/Unity/Application/SurfaceManager.cpp

372 lines 12 kB history raw

1/*

3 *

4 * This program is free software; you can redistribute it and/or modify

5 * it under the terms of the GNU General Public License as published by

6 * the Free Software Foundation; version 3.

7 *

8 * This program is distributed in the hope that it will be useful,

9 * but WITHOUT ANY WARRANTY; without even the implied warranty of

10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11 * GNU General Public License for more details.

12 *

13 * You should have received a copy of the GNU General Public License

14 * along with this program. If not, see <http://www.gnu.org/licenses/>.

15 */

17#include "SurfaceManager.h"

19#include "ApplicationInfo.h"

20#include "VirtualKeyboard.h"

21#include "../../WindowManager/WindowManagementPolicy.h"

23#include <paths.h>

24#include <mirtest/mir/test/doubles/stub_surface.h>

26#define SURFACEMANAGER_DEBUG 1

28#if SURFACEMANAGER_DEBUG

29#define DEBUG_MSG(params) qDebug().nospace() << "SurfaceManager[" << (void*)this << "]::" << __func__ << params

30#else

31#define DEBUG_MSG(params) ((void)0)

32#endif

34namespace unityapi = unity::shell::application;

36uint qHash(const WindowWrapper &key, uint)

37{

38 std::shared_ptr<mir::scene::Surface> surface = key.window;

39 return (quintptr)surface.get();

40}

42SurfaceManager *SurfaceManager::m_instance = nullptr;

44SurfaceManager *SurfaceManager::instance()

45{

46 return m_instance;

47}

49SurfaceManager::SurfaceManager(QObject *)

50{

51 DEBUG_MSG("");

53 Q_ASSERT(m_instance == nullptr);

54 m_instance = this;

56 connect(WindowManagementPolicy::instance(), &WindowManagementPolicy::windowAdded,

57 this, [this](const miral::Window& window) {

58 Q_EMIT surfaceCreated(surfaceFor(window));

59 });

61 connect(WindowManagementPolicy::instance(), &WindowManagementPolicy::windowsAddedToWorkspace,

62 this, [this](const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows) {

63 Q_EMIT surfacesAddedToWorkspace(workspace, surfacesFor(windows));

64 });

66 connect(WindowManagementPolicy::instance(), &WindowManagementPolicy::windowsAboutToBeRemovedFromWorkspace,

67 this, [this](const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows) {

68 Q_EMIT surfacesAboutToBeRemovedFromWorkspace(workspace, surfacesFor(windows));

69 });

70}

72SurfaceManager::~SurfaceManager()

73{

74 DEBUG_MSG("");

76 if (m_virtualKeyboard) {

77 m_virtualKeyboard->setLive(false);

78 }

80 Q_ASSERT(m_instance == this);

81 m_instance = nullptr;

82}

84MirSurfaceInterface *SurfaceManager::surfaceFor(const miral::Window& window) const

85{

86 auto iter = m_windowToSurface.find({window});

87 if (iter != m_windowToSurface.end()) {

88 return *iter;

89 }

90 return nullptr;

91}

93QVector<MirSurfaceInterface*> SurfaceManager::surfacesFor(const std::vector<miral::Window> &windows) const

94{

95 QVector<unityapi::MirSurfaceInterface*> surfaces;

96 for (size_t i = 0; i < windows.size(); i++) {

97 auto mirSurface = surfaceFor(windows[i]);

98 if (mirSurface) {

99 surfaces.push_back(mirSurface);

100 }

101 }

102 return surfaces;

103}

104

105miral::Window SurfaceManager::windowFor(MirSurfaceInterface *surface) const

106{

107 auto iter = m_surfaceToWindow.find(surface);

108 if (iter != m_surfaceToWindow.end()) {

109 return iter->window;

110 }

111 return miral::Window();

112}

113

114MirSurface *SurfaceManager::createSurface(const QString& name,

115 Mir::Type type,

116 Mir::State state,

117 MirSurface *parentSurface,

118 const QUrl &screenshot,

119 const QUrl &qmlFilePath)

120{

121 MirSurface* surface = new MirSurface(name, type, state, parentSurface, screenshot, qmlFilePath);

122 registerSurface(surface);

123 if (parentSurface) {

124 static_cast<MirSurfaceListModel*>(parentSurface->childSurfaceList())->addSurface(surface);

125 }

126 return surface;

127}

128

129void SurfaceManager::registerSurface(MirSurface *surface)

130{

131 auto fakeSurface = std::make_shared<mir::test::doubles::StubSurface>();

132 WindowWrapper window{miral::Window(nullptr, fakeSurface), fakeSurface};

133

134 m_surfaces.prepend(surface);

135 m_windowToSurface.insert(window, surface);

136 m_surfaceToWindow.insert(surface, window);

137

138 if (!surface->parentSurface()) {

139 surface->setMinimumWidth(m_newSurfaceMinimumWidth);

140 surface->setMaximumWidth(m_newSurfaceMaximumWidth);

141 surface->setMinimumHeight(m_newSurfaceMinimumHeight);

142 surface->setMaximumHeight(m_newSurfaceMaximumHeight);

143 surface->setWidthIncrement(m_newSurfaceWidthIncrement);

144 surface->setHeightIncrement(m_newSurfaceHeightIncrement);

145 }

146

147 connect(surface, &MirSurface::stateRequested, this, [=](Mir::State state) {

148 this->onStateRequested(surface, state);

149 });

150

151 const QString persistentId = surface->persistentId();

152 connect(surface, &QObject::destroyed, this, [=]() {

153 WindowWrapper key = m_surfaceToWindow.take(surface);

154 m_windowToSurface.remove(key);

155 this->onSurfaceDestroyed(surface, persistentId);

156 });

157

158}

159

160void SurfaceManager::notifySurfaceCreated(unityapi::MirSurfaceInterface *surface)

161{

162 if (Q_UNLIKELY(!m_surfaceToWindow.contains(surface))) {

163 Q_EMIT surfaceCreated(surface);

164 return;

165 }

166

167 WindowManagementPolicy::instance()->addWindow(m_surfaceToWindow[surface].window);

168}

169

170void SurfaceManager::setNewSurfaceMinimumWidth(int value)

171{

172 if (m_newSurfaceMinimumWidth != value) {

173 m_newSurfaceMinimumWidth = value;

174 Q_EMIT newSurfaceMinimumWidthChanged(m_newSurfaceMinimumWidth);

175 }

176}

177

178void SurfaceManager::setNewSurfaceMaximumWidth(int value)

179{

180 if (m_newSurfaceMaximumWidth != value) {

181 m_newSurfaceMaximumWidth = value;

182 Q_EMIT newSurfaceMaximumWidthChanged(m_newSurfaceMaximumWidth);

183 }

184}

185

186void SurfaceManager::setNewSurfaceMinimumHeight(int value)

187{

188 if (m_newSurfaceMinimumHeight != value) {

189 m_newSurfaceMinimumHeight = value;

190 Q_EMIT newSurfaceMinimumHeightChanged(m_newSurfaceMinimumHeight);

191 }

192}

193

194void SurfaceManager::setNewSurfaceMaximumHeight(int value)

195{

196 if (m_newSurfaceMaximumHeight != value) {

197 m_newSurfaceMaximumHeight = value;

198 Q_EMIT newSurfaceMaximumHeightChanged(m_newSurfaceMaximumHeight);

199 }

200}

201

202void SurfaceManager::setNewSurfaceWidthIncrement(int value)

203{

204 if (m_newSurfaceWidthIncrement != value) {

205 m_newSurfaceWidthIncrement = value;

206 Q_EMIT newSurfaceWidthIncrementChanged(m_newSurfaceWidthIncrement);

207 }

208}

209

210void SurfaceManager::setNewSurfaceHeightIncrement(int value)

211{

212 if (m_newSurfaceHeightIncrement != value) {

213 m_newSurfaceHeightIncrement = value;

214 Q_EMIT newSurfaceHeightIncrementChanged(m_newSurfaceHeightIncrement);

215 }

216}

217

218void SurfaceManager::raise(unityapi::MirSurfaceInterface *surface)

219{

220 if (m_underModification)

221 return;

222

223 DEBUG_MSG("("<<surface<<") started");

224 Q_EMIT modificationsStarted();

225 m_underModification = true;

226

227 doRaise(surface);

228

229 m_underModification = false;

230 Q_EMIT modificationsEnded();

231 DEBUG_MSG("("<<surface<<") ended");

232}

233

234void SurfaceManager::doRaise(unityapi::MirSurfaceInterface *apiSurface)

235{

236 auto surface = static_cast<MirSurface*>(apiSurface);

237 int index = m_surfaces.indexOf(surface);

238 Q_ASSERT(index != -1);

239 m_surfaces.move(index, 0);

240

241 Q_EMIT surfacesRaised({surface});

242}

243

244void SurfaceManager::activate(unityapi::MirSurfaceInterface *apiSurface)

245{

246 auto surface = static_cast<MirSurface*>(apiSurface);

247

248 if (surface == m_focusedSurface) {

249 return;

250 }

251

252 Q_ASSERT(!m_underModification);

253

254 DEBUG_MSG("("<<surface<<") started");

255 Q_EMIT modificationsStarted();

256 m_underModification = true;

257 if (m_focusedSurface) {

258 m_focusedSurface->setFocused(false);

259 }

260 if (surface) {

261 if (surface->state() == Mir::HiddenState || surface->state() == Mir::MinimizedState) {

262 if (surface->previousState() != Mir::UnknownState) {

263 surface->setState(surface->previousState());

264 } else {

265 surface->setState(Mir::RestoredState);

266 }

267 }

268 surface->setFocused(true);

269 doRaise(surface);

270 }

271 m_focusedSurface = surface;

272 m_underModification = false;

273 Q_EMIT modificationsEnded();

274 DEBUG_MSG("("<<surface<<") ended");

275}

276

277void SurfaceManager::forEachSurfaceInWorkspace(const std::shared_ptr<miral::Workspace> &workspace,

278 const std::function<void(unity::shell::application::MirSurfaceInterface*)> &callback)

279{

280 WindowManagementPolicy::instance()->forEachWindowInWorkspace(workspace, [&](const miral::Window &window) {

281 auto surface = surfaceFor(window);

282 if (surface) {

283 callback(surface);

284 }

285 });

286}

287

288void SurfaceManager::moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface* surface,

289 const std::shared_ptr<miral::Workspace> &workspace)

290{

291 auto window = windowFor(surface);

292 if (window) {

293 WindowManagementPolicy::instance()->moveWindowToWorkspace(window, workspace);

294 }

295}

296

297void SurfaceManager::moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to,

298 const std::shared_ptr<miral::Workspace> &from)

299{

300 WindowManagementPolicy::instance()->moveWorkspaceContentToWorkspace(to, from);

301}

302

303void SurfaceManager::onStateRequested(MirSurface *surface, Mir::State state)

304{

305 DEBUG_MSG("("<<surface<<","<<state<<") started");

306 Q_EMIT modificationsStarted();

307 m_underModification = true;

308

309 surface->setPreviousState(surface->state());

310 surface->setState(state);

311

312 if ((state == Mir::MinimizedState || state == Mir::HiddenState) && surface->focused()) {

313 Q_ASSERT(m_focusedSurface == surface);

314 surface->setFocused(false);

315 m_focusedSurface = nullptr;

316 focusFirstAvailableSurface();

317 }

318

319 m_underModification = false;

320 Q_EMIT modificationsEnded();

321 DEBUG_MSG("("<<surface<<","<<state<<") ended");

322}

323

324void SurfaceManager::onSurfaceDestroyed(MirSurface *surface, const QString& persistentId)

325{

326 m_surfaces.removeAll(surface);

327 if (m_focusedSurface == surface) {

328 m_focusedSurface = nullptr;

329

330 Q_EMIT modificationsStarted();

331 m_underModification = true;

332

333 focusFirstAvailableSurface();

334

335 m_underModification = false;

336 Q_EMIT modificationsEnded();

337 }

338 Q_EMIT surfaceDestroyed(persistentId);

339}

340

341void SurfaceManager::focusFirstAvailableSurface()

342{

343 MirSurface *chosenSurface = nullptr;

344 for (int i = 0; i < m_surfaces.count() && !chosenSurface; ++i) {

345 auto *surface = m_surfaces[i];

346 if (surface->state() != Mir::HiddenState && surface->state() != Mir::MinimizedState) {

347 chosenSurface = surface;

348 }

349 }

350

351 if (!chosenSurface) {

352 return;

353 }

354

355 if (m_focusedSurface) {

356 m_focusedSurface->setFocused(false);

357 }

358

359 chosenSurface->setFocused(true);

360 doRaise(chosenSurface);

361

362 m_focusedSurface = chosenSurface;

363}

364

365void SurfaceManager::createInputMethodSurface()

366{

367 if (!m_virtualKeyboard) {

368 m_virtualKeyboard = new VirtualKeyboard;

369 registerSurface(m_virtualKeyboard);

370 Q_EMIT surfaceCreated(m_virtualKeyboard);

371 }

372}