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

git.iko.soy/unity8

on 669c2af help sign in

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

275 lines 7.7 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"

22#include <paths.h>

24#define SURFACEMANAGER_DEBUG 0

26#if SURFACEMANAGER_DEBUG

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

28#else

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

30#endif

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

34SurfaceManager *SurfaceManager::m_instance = nullptr;

36SurfaceManager *SurfaceManager::instance()

37{

38 return m_instance;

39}

41SurfaceManager::SurfaceManager(QObject *)

42{

43 DEBUG_MSG("");

45 Q_ASSERT(m_instance == nullptr);

46 m_instance = this;

47}

49SurfaceManager::~SurfaceManager()

50{

51 DEBUG_MSG("");

53 if (m_virtualKeyboard) {

54 m_virtualKeyboard->setLive(false);

55 }

57 Q_ASSERT(m_instance == this);

58 m_instance = nullptr;

59}

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

62 Mir::Type type,

63 Mir::State state,

64 const QUrl& screenshot)

65{

66 MirSurface* surface = new MirSurface(name, type, state, screenshot);

67 registerSurface(surface);

68 return surface;

69}

71void SurfaceManager::registerSurface(MirSurface *surface)

72{

73 m_surfaces.prepend(surface);

75 surface->setMinimumWidth(m_newSurfaceMinimumWidth);

76 surface->setMaximumWidth(m_newSurfaceMaximumWidth);

77 surface->setMinimumHeight(m_newSurfaceMinimumHeight);

78 surface->setMaximumHeight(m_newSurfaceMaximumHeight);

79 surface->setWidthIncrement(m_newSurfaceWidthIncrement);

80 surface->setHeightIncrement(m_newSurfaceHeightIncrement);

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

83 this->onStateRequested(surface, state);

84 });

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

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

88 this->onSurfaceDestroyed(surface, persistentId);

89 });

91}

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

94{

95 Q_EMIT surfaceCreated(surface);

96}

98void SurfaceManager::setNewSurfaceMinimumWidth(int value)

99{

100 if (m_newSurfaceMinimumWidth != value) {

101 m_newSurfaceMinimumWidth = value;

102 Q_EMIT newSurfaceMinimumWidthChanged(m_newSurfaceMinimumWidth);

103 }

104}

105

106void SurfaceManager::setNewSurfaceMaximumWidth(int value)

107{

108 if (m_newSurfaceMaximumWidth != value) {

109 m_newSurfaceMaximumWidth = value;

110 Q_EMIT newSurfaceMaximumWidthChanged(m_newSurfaceMaximumWidth);

111 }

112}

113

114void SurfaceManager::setNewSurfaceMinimumHeight(int value)

115{

116 if (m_newSurfaceMinimumHeight != value) {

117 m_newSurfaceMinimumHeight = value;

118 Q_EMIT newSurfaceMinimumHeightChanged(m_newSurfaceMinimumHeight);

119 }

120}

121

122void SurfaceManager::setNewSurfaceMaximumHeight(int value)

123{

124 if (m_newSurfaceMaximumHeight != value) {

125 m_newSurfaceMaximumHeight = value;

126 Q_EMIT newSurfaceMaximumHeightChanged(m_newSurfaceMaximumHeight);

127 }

128}

129

130void SurfaceManager::setNewSurfaceWidthIncrement(int value)

131{

132 if (m_newSurfaceWidthIncrement != value) {

133 m_newSurfaceWidthIncrement = value;

134 Q_EMIT newSurfaceWidthIncrementChanged(m_newSurfaceWidthIncrement);

135 }

136}

137

138void SurfaceManager::setNewSurfaceHeightIncrement(int value)

139{

140 if (m_newSurfaceHeightIncrement != value) {

141 m_newSurfaceHeightIncrement = value;

142 Q_EMIT newSurfaceHeightIncrementChanged(m_newSurfaceHeightIncrement);

143 }

144}

145

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

147{

148 if (m_underModification)

149 return;

150

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

152 Q_EMIT modificationsStarted();

153 m_underModification = true;

154

155 doRaise(surface);

156

157 m_underModification = false;

158 Q_EMIT modificationsEnded();

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

160}

161

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

163{

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

165 int index = m_surfaces.indexOf(surface);

166 Q_ASSERT(index != -1);

167 m_surfaces.move(index, 0);

168

169 Q_EMIT surfacesRaised({surface});

170}

171

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

173{

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

175

176 if (surface == m_focusedSurface) {

177 return;

178 }

179

180 Q_ASSERT(!m_underModification);

181

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

183 Q_EMIT modificationsStarted();

184 m_underModification = true;

185 if (m_focusedSurface) {

186 m_focusedSurface->setFocused(false);

187 }

188 if (surface) {

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

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

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

192 } else {

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

194 }

195 }

196 surface->setFocused(true);

197 doRaise(surface);

198 }

199 m_focusedSurface = surface;

200 m_underModification = false;

201 Q_EMIT modificationsEnded();

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

203}

204

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

206{

207 Q_ASSERT(!m_underModification);

208

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

210 Q_EMIT modificationsStarted();

211 m_underModification = true;

212

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

214 surface->setState(state);

215

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

217 Q_ASSERT(m_focusedSurface == surface);

218 surface->setFocused(false);

219 m_focusedSurface = nullptr;

220 focusFirstAvailableSurface();

221 }

222

223 m_underModification = false;

224 Q_EMIT modificationsEnded();

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

226}

227

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

229{

230 m_surfaces.removeAll(surface);

231 if (m_focusedSurface == surface) {

232 m_focusedSurface = nullptr;

233

234 Q_EMIT modificationsStarted();

235 m_underModification = true;

236

237 focusFirstAvailableSurface();

238

239 m_underModification = false;

240 Q_EMIT modificationsEnded();

241 }

242 Q_EMIT surfaceDestroyed(persistentId);

243}

244

245void SurfaceManager::focusFirstAvailableSurface()

246{

247 MirSurface *chosenSurface = nullptr;

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

249 auto *surface = m_surfaces[i];

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

251 chosenSurface = surface;

252 }

253 }

254

255 if (!chosenSurface) {

256 return;

257 }

258

259 if (m_focusedSurface) {

260 m_focusedSurface->setFocused(false);

261 }

262 if (chosenSurface) {

263 chosenSurface->setFocused(true);

264 }

265 m_focusedSurface = chosenSurface;

266}

267

268void SurfaceManager::createInputMethodSurface()

269{

270 if (!m_virtualKeyboard) {

271 m_virtualKeyboard = new VirtualKeyboard;

272 registerSurface(m_virtualKeyboard);

273 Q_EMIT surfaceCreated(m_virtualKeyboard);

274 }

275}