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

git.iko.soy/unity8

on 07cfd62 help sign in

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

269 lines 7.4 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 connect(surface, &QObject::destroyed, this, [=]() {

87 this->onSurfaceDestroyed(surface);

88 });

89}

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

92{

93 Q_EMIT surfaceCreated(surface);

94}

96void SurfaceManager::setNewSurfaceMinimumWidth(int value)

97{

98 if (m_newSurfaceMinimumWidth != value) {

99 m_newSurfaceMinimumWidth = value;

100 Q_EMIT newSurfaceMinimumWidthChanged(m_newSurfaceMinimumWidth);

101 }

102}

103

104void SurfaceManager::setNewSurfaceMaximumWidth(int value)

105{

106 if (m_newSurfaceMaximumWidth != value) {

107 m_newSurfaceMaximumWidth = value;

108 Q_EMIT newSurfaceMaximumWidthChanged(m_newSurfaceMaximumWidth);

109 }

110}

111

112void SurfaceManager::setNewSurfaceMinimumHeight(int value)

113{

114 if (m_newSurfaceMinimumHeight != value) {

115 m_newSurfaceMinimumHeight = value;

116 Q_EMIT newSurfaceMinimumHeightChanged(m_newSurfaceMinimumHeight);

117 }

118}

119

120void SurfaceManager::setNewSurfaceMaximumHeight(int value)

121{

122 if (m_newSurfaceMaximumHeight != value) {

123 m_newSurfaceMaximumHeight = value;

124 Q_EMIT newSurfaceMaximumHeightChanged(m_newSurfaceMaximumHeight);

125 }

126}

127

128void SurfaceManager::setNewSurfaceWidthIncrement(int value)

129{

130 if (m_newSurfaceWidthIncrement != value) {

131 m_newSurfaceWidthIncrement = value;

132 Q_EMIT newSurfaceWidthIncrementChanged(m_newSurfaceWidthIncrement);

133 }

134}

135

136void SurfaceManager::setNewSurfaceHeightIncrement(int value)

137{

138 if (m_newSurfaceHeightIncrement != value) {

139 m_newSurfaceHeightIncrement = value;

140 Q_EMIT newSurfaceHeightIncrementChanged(m_newSurfaceHeightIncrement);

141 }

142}

143

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

145{

146 if (m_underModification)

147 return;

148

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

150 Q_EMIT modificationsStarted();

151 m_underModification = true;

152

153 doRaise(surface);

154

155 m_underModification = false;

156 Q_EMIT modificationsEnded();

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

158}

159

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

161{

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

163 int index = m_surfaces.indexOf(surface);

164 Q_ASSERT(index != -1);

165 m_surfaces.move(index, 0);

166

167 QVector<MirSurfaceInterface*> surfaces;

168 surfaces.append(surface);

169 Q_EMIT surfacesRaised(surfaces);

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 surface->setState(Mir::RestoredState);

191 }

192 surface->setFocused(true);

193 doRaise(surface);

194 }

195 m_focusedSurface = surface;

196 m_underModification = false;

197 Q_EMIT modificationsEnded();

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

199}

200

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

202{

203 Q_ASSERT(!m_underModification);

204

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

206 Q_EMIT modificationsStarted();

207 m_underModification = true;

208

209 surface->setState(state);

210

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

212 Q_ASSERT(m_focusedSurface == surface);

213 surface->setFocused(false);

214 m_focusedSurface = nullptr;

215 focusFirstAvailableSurface();

216 }

217

218 m_underModification = false;

219 Q_EMIT modificationsEnded();

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

221}

222

223void SurfaceManager::onSurfaceDestroyed(MirSurface *surface)

224{

225 m_surfaces.removeAll(surface);

226 if (m_focusedSurface == surface) {

227 m_focusedSurface = nullptr;

228

229 Q_EMIT modificationsStarted();

230 m_underModification = true;

231

232 focusFirstAvailableSurface();

233

234 m_underModification = false;

235 Q_EMIT modificationsEnded();

236 }

237}

238

239void SurfaceManager::focusFirstAvailableSurface()

240{

241 MirSurface *chosenSurface = nullptr;

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

243 auto *surface = m_surfaces[i];

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

245 chosenSurface = surface;

246 }

247 }

248

249 if (!chosenSurface) {

250 return;

251 }

252

253 if (m_focusedSurface) {

254 m_focusedSurface->setFocused(false);

255 }

256 if (chosenSurface) {

257 chosenSurface->setFocused(true);

258 }

259 m_focusedSurface = chosenSurface;

260}

261

262void SurfaceManager::createInputMethodSurface()

263{

264 if (!m_virtualKeyboard) {

265 m_virtualKeyboard = new VirtualKeyboard;

266 registerSurface(m_virtualKeyboard);

267 Q_EMIT surfaceCreated(m_virtualKeyboard);

268 }

269}