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

git.iko.soy/unity8

on 46b6ebd help sign in

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

320 lines 7.2 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 "MirSurface.h"

19#include <QDebug>

20#include <QQmlEngine>

22MirSurface::MirSurface(const QString& name,

23 Mir::Type type,

24 Mir::State state,

25 const QUrl& screenshot,

26 const QUrl &qmlFilePath,

27 QObject *parent)

28 : unity::shell::application::MirSurfaceInterface(parent)

29 , m_name(name)

30 , m_type(type)

31 , m_state(state)

32 , m_orientationAngle(Mir::Angle0)

33 , m_screenshotUrl(screenshot)

34 , m_qmlFilePath(qmlFilePath)

35 , m_live(true)

36 , m_visible(true)

37 , m_activeFocus(false)

38 , m_width(-1)

39 , m_height(-1)

40 , m_slowToResize(false)

41{

42// qDebug() << "MirSurface::MirSurface() " << name;

43 QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership);

45 m_delayedResizeTimer.setInterval(600);

46 m_delayedResizeTimer.setSingleShot(true);

47 connect(&m_delayedResizeTimer, &QTimer::timeout, this, &MirSurface::applyDelayedResize);

48}

50MirSurface::~MirSurface()

51{

52// qDebug() << "MirSurface::~MirSurface() " << name();

53}

55QString MirSurface::name() const

56{

57 return m_name;

58}

60Mir::Type MirSurface::type() const

61{

62 return m_type;

63}

65Mir::State MirSurface::state() const

66{

67 return m_state;

68}

70void MirSurface::setState(Mir::State state)

71{

72 if (state == m_state)

73 return;

75 m_state = state;

76 Q_EMIT stateChanged(state);

77}

79bool MirSurface::live() const

80{

81 return m_live;

82}

84bool MirSurface::visible() const

85{

86 return m_visible;

87}

89void MirSurface::setLive(bool live)

90{

91// qDebug().nospace() << "MirSurface::setLive("<<live<<") " << name();

92 if (live == m_live)

93 return;

95 m_live = live;

96 Q_EMIT liveChanged(live);

98 if (!m_live && m_views.count() == 0) {

99 deleteLater();

100 }

101}

102

103QUrl MirSurface::qmlFilePath() const

104{

105 return m_qmlFilePath;

106}

107

108QUrl MirSurface::screenshotUrl() const

109{

110 return m_screenshotUrl;

111}

112

113void MirSurface::setScreenshotUrl(QUrl screenshotUrl)

114{

115 if (screenshotUrl == m_screenshotUrl)

116 return;

117

118 m_screenshotUrl = screenshotUrl;

119 Q_EMIT screenshotUrlChanged(screenshotUrl);

120}

121

122Mir::OrientationAngle MirSurface::orientationAngle() const

123{

124 return m_orientationAngle;

125}

126

127void MirSurface::setOrientationAngle(Mir::OrientationAngle angle)

128{

129 if (angle == m_orientationAngle)

130 return;

131

132 m_orientationAngle = angle;

133 Q_EMIT orientationAngleChanged(angle);

134}

135

136

137

138void MirSurface::registerView(qintptr viewId)

139{

140 m_views.insert(viewId, MirSurface::View{false});

141// qDebug().nospace() << "MirSurface[" << name() << "]::registerView(" << viewId << ")"

142// << " after=" << m_views.count();

143}

144

145void MirSurface::unregisterView(qintptr viewId)

146{

147// qDebug().nospace() << "MirSurface[" << name() << "]::unregisterView(" << viewId << ")"

148// << " after=" << m_views.count() << " live=" << m_live;

149 m_views.remove(viewId);

150 if (!m_live && m_views.count() == 0) {

151 deleteLater();

152 }

153 updateVisibility();

154}

155

156void MirSurface::setViewVisibility(qintptr viewId, bool visible)

157{

158 if (!m_views.contains(viewId)) return;

159

160 m_views[viewId].visible = visible;

161 updateVisibility();

162}

163

164void MirSurface::updateVisibility()

165{

166 bool newVisible = false;

167 QHashIterator<qintptr, View> i(m_views);

168 while (i.hasNext()) {

169 i.next();

170 newVisible |= i.value().visible;

171 }

172

173 if (newVisible != visible()) {

174// qDebug().nospace() << "MirSurface[" << name() << "]::updateVisibility(" << newVisible << ")";

175

176 m_visible = newVisible;

177 Q_EMIT visibleChanged(m_visible);

178 }

179}

180

181bool MirSurface::activeFocus() const

182{

183 return m_activeFocus;

184}

185

186void MirSurface::setActiveFocus(bool value)

187{

188 if (m_activeFocus == value)

189 return;

190

191 m_activeFocus = value;

192

193 Q_EMIT activeFocusChanged(value);

194}

195

196int MirSurface::width() const

197{

198 return m_width;

199}

200

201int MirSurface::height() const

202{

203 return m_height;

204}

205

206void MirSurface::resize(int width, int height)

207{

208 if (m_slowToResize) {

209 if (!m_delayedResizeTimer.isActive()) {

210 m_delayedResize.setWidth(width);

211 m_delayedResize.setHeight(height);

212 m_delayedResizeTimer.start();

213 } else {

214 m_pendingResize.setWidth(width);

215 m_pendingResize.setHeight(height);

216 }

217 } else {

218 doResize(width, height);

219 }

220}

221

222void MirSurface::applyDelayedResize()

223{

224 doResize(m_delayedResize.width(), m_delayedResize.height());

225 m_delayedResize.setWidth(-1);

226 m_delayedResize.setHeight(-1);

227

228 if (m_pendingResize.isValid()) {

229 QSize size = m_pendingResize;

230 m_pendingResize.setWidth(-1);

231 m_pendingResize.setHeight(-1);

232 resize(size.width(), size.height());

233 }

234}

235

236void MirSurface::doResize(int width, int height)

237{

238 bool changed = false;

239

240 if (width != m_width) {

241 m_width = width;

242 Q_EMIT widthChanged();

243 changed = true;

244 }

245

246 if (m_height != height) {

247 m_height = height;

248 Q_EMIT heightChanged();

249 changed = true;

250 }

251

252 if (changed) {

253 Q_EMIT sizeChanged(QSize(width, height));

254 }

255}

256

257bool MirSurface::isSlowToResize() const

258{

259 return m_slowToResize;

260}

261

262void MirSurface::setSlowToResize(bool value)

263{

264 if (m_slowToResize != value) {

265 m_slowToResize = value;

266 Q_EMIT slowToResizeChanged();

267 if (!m_slowToResize && m_delayedResizeTimer.isActive()) {

268 m_delayedResizeTimer.stop();

269 applyDelayedResize();

270 }

271 }

272}

273

274void MirSurface::setMinimumWidth(int value)

275{

276 if (value != m_minimumWidth) {

277 m_minimumWidth = value;

278 Q_EMIT minimumWidthChanged(m_minimumWidth);

279 }

280}

281

282void MirSurface::setMaximumWidth(int value)

283{

284 if (value != m_maximumWidth) {

285 m_maximumWidth = value;

286 Q_EMIT maximumWidthChanged(m_maximumWidth);

287 }

288}

289

290void MirSurface::setMinimumHeight(int value)

291{

292 if (value != m_minimumHeight) {

293 m_minimumHeight = value;

294 Q_EMIT minimumHeightChanged(m_minimumHeight);

295 }

296}

297

298void MirSurface::setMaximumHeight(int value)

299{

300 if (value != m_maximumHeight) {

301 m_maximumHeight = value;

302 Q_EMIT maximumHeightChanged(m_maximumHeight);

303 }

304}

305

306void MirSurface::setWidthIncrement(int value)

307{

308 if (value != m_widthIncrement) {

309 m_widthIncrement = value;

310 Q_EMIT widthIncrementChanged(m_widthIncrement);

311 }

312}

313

314void MirSurface::setHeightIncrement(int value)

315{

316 if (value != m_heightIncrement) {

317 m_heightIncrement = value;

318 Q_EMIT heightIncrementChanged(m_heightIncrement);

319 }

320}