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

git.iko.soy/unity8

on 16fa310 help sign in

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

507 lines 11 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>

22// local

23#include "SurfaceManager.h"

25#define MIRSURFACE_DEBUG 0

27#if MIRSURFACE_DEBUG

28#define DEBUG_MSG(params) qDebug().nospace() << "MirSurface[" << (void*)this << "," << m_name << "]::" << __func__ << " " << params

29#define XDEBUG_MSG(params) qDebug().nospace() << "MirSurface[" << (void*)this << "," << m_name << "]::" << params

31const char *stateToStr(Mir::State state)

32{

33 switch (state) {

34 case Mir::UnknownState:

35 return "unknown";

36 case Mir::RestoredState:

37 return "restored";

38 case Mir::MinimizedState:

39 return "minimized";

40 case Mir::MaximizedState:

41 return "maximized";

42 case Mir::VertMaximizedState:

43 return "vertMaximized";

44 case Mir::FullscreenState:

45 return "fullscreen";

46 case Mir::HorizMaximizedState:

47 return "horizMaximized";

48 case Mir::MaximizedLeftState:

49 return "maximizedLeft";

50 case Mir::MaximizedRightState:

51 return "maximizedRight";

52 case Mir::MaximizedTopLeftState:

53 return "maximizedTopLeft";

54 case Mir::MaximizedTopRightState:

55 return "maximizedTopRight";

56 case Mir::MaximizedBottomLeftState:

57 return "maximizedBottomLeft";

58 case Mir::MaximizedBottomRightState:

59 return "maximizedBottomRight";

60 case Mir::HiddenState:

61 return "hidden";

62 default:

63 return "???";

64 }

65}

67#else

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

69#define XDEBUG_MSG(params) ((void)0)

70#endif

72using namespace unity::shell::application;

74MirSurface::MirSurface(const QString& name,

75 Mir::Type type,

76 Mir::State state,

77 const QUrl& screenshot,

78 const QUrl &qmlFilePath)

79 : unity::shell::application::MirSurfaceInterface(nullptr)

80 , m_name(name)

81 , m_type(type)

82 , m_state(state)

83 , m_orientationAngle(Mir::Angle0)

84 , m_screenshotUrl(screenshot)

85 , m_qmlFilePath(qmlFilePath)

86 , m_live(true)

87 , m_focused(false)

88 , m_activeFocus(false)

89 , m_width(-1)

90 , m_height(-1)

91 , m_slowToResize(false)

92 , m_shellChrome(Mir::NormalChrome)

93{

94 DEBUG_MSG("state=" << stateToStr(state));

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

98 m_delayedResizeTimer.setInterval(600);

99 m_delayedResizeTimer.setSingleShot(true);

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

101

102 m_zombieTimer.setInterval(100);

103 m_zombieTimer.setSingleShot(true);

104 connect(&m_zombieTimer, &QTimer::timeout, this, [this](){ this->setLive(false); });

105

106 updateInputBoundsAfterResize();

107}

108

109MirSurface::~MirSurface()

110{

111 DEBUG_MSG("");

112

113 // Early warning, while MirSurface methods can still be accessed.

114 Q_EMIT destroyed(this);

115}

116

117QString MirSurface::name() const

118{

119 return m_name;

120}

121

122QString MirSurface::persistentId() const

123{

124 return m_name+"Id";

125}

126

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

128{

129 return m_type;

130}

131

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

133{

134 return m_state;

135}

136

137void MirSurface::requestState(Mir::State state)

138{

139 if (state == m_state) {

140 return;

141 }

142 DEBUG_MSG(stateToStr(state));

143 Q_EMIT stateRequested(state);

144}

145

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

147{

148 if (state == m_state) {

149 return;

150 }

151 DEBUG_MSG(stateToStr(state));

152

153 bool oldVisible = visible();

154

155 m_state = state;

156 Q_EMIT stateChanged(state);

157

158 if (visible() != oldVisible) {

159 XDEBUG_MSG("visibleChanged("<<visible()<<")");

160 Q_EMIT visibleChanged(visible());

161 }

162}

163

164bool MirSurface::live() const

165{

166 return m_live;

167}

168

169bool MirSurface::visible() const

170{

171 return m_state != Mir::MinimizedState && m_state != Mir::HiddenState;

172}

173

174void MirSurface::setLive(bool live)

175{

176 if (live == m_live)

177 return;

178

179 DEBUG_MSG(live);

180 m_live = live;

181 Q_EMIT liveChanged(live);

182

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

184 deleteLater();

185 }

186}

187

188QUrl MirSurface::qmlFilePath() const

189{

190 return m_qmlFilePath;

191}

192

193QUrl MirSurface::screenshotUrl() const

194{

195 return m_screenshotUrl;

196}

197

198void MirSurface::setScreenshotUrl(QUrl screenshotUrl)

199{

200 if (screenshotUrl == m_screenshotUrl)

201 return;

202

203 m_screenshotUrl = screenshotUrl;

204 Q_EMIT screenshotUrlChanged(screenshotUrl);

205}

206

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

208{

209 return m_orientationAngle;

210}

211

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

213{

214 if (angle == m_orientationAngle)

215 return;

216

217 m_orientationAngle = angle;

218 Q_EMIT orientationAngleChanged(angle);

219}

220

221void MirSurface::setKeymap(const QString &value)

222{

223 if (value != m_keymap) {

224 DEBUG_MSG(value);

225 m_keymap = value;

226 Q_EMIT keymapChanged(m_keymap);

227 }

228}

229

230QString MirSurface::keymap() const

231{

232 return m_keymap;

233}

234

235Mir::ShellChrome MirSurface::shellChrome() const

236{

237 return m_shellChrome;

238}

239

240void MirSurface::setShellChrome(Mir::ShellChrome shellChrome)

241{

242 if (shellChrome == m_shellChrome)

243 return;

244

245 DEBUG_MSG(shellChrome);

246 m_shellChrome = shellChrome;

247 Q_EMIT shellChromeChanged(shellChrome);

248}

249

250void MirSurface::registerView(qintptr viewId)

251{

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

253 DEBUG_MSG(viewId << " after=" << m_views.count());

254}

255

256void MirSurface::unregisterView(qintptr viewId)

257{

258 m_views.remove(viewId);

259 DEBUG_MSG(viewId << " after=" << m_views.count() << " live=" << m_live);

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

261 deleteLater();

262 }

263 updateExposure();

264}

265

266void MirSurface::setViewExposure(qintptr viewId, bool visible)

267{

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

269

270 m_views[viewId].visible = visible;

271 updateExposure();

272}

273

274void MirSurface::updateExposure()

275{

276 bool newExposure = false;

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

278 while (i.hasNext()) {

279 i.next();

280 newExposure |= i.value().visible;

281 }

282

283 if (newExposure != m_exposed) {

284 m_exposed = newExposure;

285 DEBUG_MSG(m_exposed);

286 Q_EMIT exposedChanged(m_exposed);

287 updateInputBoundsAfterResize();

288 }

289}

290

291bool MirSurface::activeFocus() const

292{

293 return m_activeFocus;

294}

295

296void MirSurface::setActiveFocus(bool value)

297{

298 if (m_activeFocus == value)

299 return;

300

301 m_activeFocus = value;

302

303 Q_EMIT activeFocusChanged(value);

304

305 if (m_activeFocus && !m_focused) {

306 requestFocus();

307 }

308}

309

310int MirSurface::width() const

311{

312 return m_width;

313}

314

315int MirSurface::height() const

316{

317 return m_height;

318}

319

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

321{

322 if (m_slowToResize) {

323 if (!m_delayedResizeTimer.isActive()) {

324 m_delayedResize.setWidth(width);

325 m_delayedResize.setHeight(height);

326 m_delayedResizeTimer.start();

327 } else {

328 m_pendingResize.setWidth(width);

329 m_pendingResize.setHeight(height);

330 }

331 } else {

332 doResize(width, height);

333 }

334}

335

336void MirSurface::applyDelayedResize()

337{

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

339 m_delayedResize.setWidth(-1);

340 m_delayedResize.setHeight(-1);

341

342 if (m_pendingResize.isValid()) {

343 QSize size = m_pendingResize;

344 m_pendingResize.setWidth(-1);

345 m_pendingResize.setHeight(-1);

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

347 }

348}

349

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

351{

352 bool changed = false;

353

354 if (width != m_width) {

355 m_width = width;

356 Q_EMIT widthChanged();

357 changed = true;

358 }

359

360 if (m_height != height) {

361 m_height = height;

362 Q_EMIT heightChanged();

363 changed = true;

364 }

365

366 if (changed) {

367 XDEBUG_MSG("sizeChanged(width="<<width<<", height="<<height<<")");

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

369 }

370

371 updateInputBoundsAfterResize();

372}

373

374void MirSurface::updateInputBoundsAfterResize()

375{

376 setInputBounds(QRect(0, 0, m_width, m_height));

377}

378

379bool MirSurface::isSlowToResize() const

380{

381 return m_slowToResize;

382}

383

384void MirSurface::setSlowToResize(bool value)

385{

386 if (m_slowToResize != value) {

387 DEBUG_MSG(value);

388 m_slowToResize = value;

389 Q_EMIT slowToResizeChanged();

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

391 m_delayedResizeTimer.stop();

392 applyDelayedResize();

393 }

394 }

395}

396

397void MirSurface::setMinimumWidth(int value)

398{

399 if (value != m_minimumWidth) {

400 m_minimumWidth = value;

401 Q_EMIT minimumWidthChanged(m_minimumWidth);

402 }

403}

404

405void MirSurface::setMaximumWidth(int value)

406{

407 if (value != m_maximumWidth) {

408 m_maximumWidth = value;

409 Q_EMIT maximumWidthChanged(m_maximumWidth);

410 }

411}

412

413void MirSurface::setMinimumHeight(int value)

414{

415 if (value != m_minimumHeight) {

416 m_minimumHeight = value;

417 Q_EMIT minimumHeightChanged(m_minimumHeight);

418 }

419}

420

421void MirSurface::setMaximumHeight(int value)

422{

423 if (value != m_maximumHeight) {

424 m_maximumHeight = value;

425 Q_EMIT maximumHeightChanged(m_maximumHeight);

426 }

427}

428

429void MirSurface::setWidthIncrement(int value)

430{

431 if (value != m_widthIncrement) {

432 m_widthIncrement = value;

433 Q_EMIT widthIncrementChanged(m_widthIncrement);

434 }

435}

436

437void MirSurface::setHeightIncrement(int value)

438{

439 if (value != m_heightIncrement) {

440 m_heightIncrement = value;

441 Q_EMIT heightIncrementChanged(m_heightIncrement);

442 }

443}

444

445void MirSurface::close()

446{

447 DEBUG_MSG("");

448 if (!m_zombieTimer.isActive()) {

449 m_zombieTimer.start();

450 Q_EMIT closeRequested();

451 }

452}

453

454void MirSurface::activate()

455{

456 DEBUG_MSG("");

457 SurfaceManager::instance()->activate(this);

458}

459

460void MirSurface::requestFocus()

461{

462 DEBUG_MSG("");

463 Q_EMIT focusRequested();

464}

465

466void MirSurface::setFocused(bool value)

467{

468 if (m_focused == value)

469 return;

470

471 DEBUG_MSG("(" << value << ")");

472

473 m_focused = value;

474 Q_EMIT focusedChanged(value);

475}

476

477bool MirSurface::focused() const

478{

479 return m_focused;

480}

481

482QRect MirSurface::inputBounds() const

483{

484 return m_inputBounds;

485}

486

487void MirSurface::setInputBounds(const QRect &boundsRect)

488{

489 if (boundsRect != m_inputBounds) {

490 m_inputBounds = boundsRect;

491 DEBUG_MSG("(" << m_inputBounds << ")");

492 Q_EMIT inputBoundsChanged(m_inputBounds);

493 }

494}

495

496void MirSurface::setRequestedPosition(const QPoint &value)

497{

498 if (value != m_requestedPosition) {

499 m_requestedPosition = value;

500 Q_EMIT requestedPositionChanged(value);

501

502 // fake-miral: always comply

503 m_position = m_requestedPosition;

504 XDEBUG_MSG("positionChanged("<<m_position<<")");

505 Q_EMIT positionChanged(m_position);

506 }

507}