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

git.iko.soy/unity8

on e5699ca help sign in

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

519 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 "MirSurface.h"

19#include <QDebug>

20#include <QQmlEngine>

22#define MIRSURFACE_DEBUG 0

24#if MIRSURFACE_DEBUG

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

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

28{

29 switch(state) {

30 case Mir::UnknownState:

31 return "unknown";

32 case Mir::RestoredState:

33 return "restored";

34 case Mir::MinimizedState:

35 return "minimized";

36 case Mir::MaximizedState:

37 return "maximized";

38 case Mir::VertMaximizedState:

39 return "vert-maximized";

40 case Mir::FullscreenState:

41 return "fullscreen";

42 case Mir::HorizMaximizedState:

43 return "horiz-maximized";

44 case Mir::HiddenState:

45 return "hidden";

46 default:

47 return "???";

48 };

49}

51#else

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

53#endif

55using namespace unity::shell::application;

57MirFocusController *MirFocusController::m_instance = nullptr;

59MirSurface::MirSurface(const QString& name,

60 Mir::Type type,

61 Mir::State state,

62 const QUrl& screenshot,

63 const QUrl &qmlFilePath)

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

65 , m_name(name)

66 , m_type(type)

67 , m_state(state)

68 , m_orientationAngle(Mir::Angle0)

69 , m_screenshotUrl(screenshot)

70 , m_qmlFilePath(qmlFilePath)

71 , m_live(true)

72 , m_visible(true)

73 , m_activeFocus(false)

74 , m_width(-1)

75 , m_height(-1)

76 , m_slowToResize(false)

77 , m_shellChrome(Mir::NormalChrome)

78{

79 DEBUG_MSG("");

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

83 m_delayedResizeTimer.setInterval(600);

84 m_delayedResizeTimer.setSingleShot(true);

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

87 m_zombieTimer.setInterval(100);

88 m_zombieTimer.setSingleShot(true);

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

91 updateInputBoundsAfterResize();

92}

94MirSurface::~MirSurface()

95{

96 DEBUG_MSG("");

98 // controller instance might have been already destroyed by QQmlEngine destructor

99 auto controller = MirFocusController::instance();

100 if (controller && controller->focusedSurface() == this) {

101 controller->clear();

102 }

103}

104

105QString MirSurface::name() const

106{

107 return m_name;

108}

109

110QString MirSurface::persistentId() const

111{

112 return m_name+"Id";

113}

114

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

116{

117 return m_type;

118}

119

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

121{

122 return m_state;

123}

124

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

126{

127 if (state == m_state)

128 return;

129

130 DEBUG_MSG(stateToStr(state));

131 m_state = state;

132 Q_EMIT stateChanged(state);

133}

134

135bool MirSurface::live() const

136{

137 return m_live;

138}

139

140bool MirSurface::visible() const

141{

142 return m_visible;

143}

144

145void MirSurface::setLive(bool live)

146{

147 if (live == m_live)

148 return;

149

150 DEBUG_MSG(live);

151 m_live = live;

152 Q_EMIT liveChanged(live);

153

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

155 deleteLater();

156 }

157}

158

159QUrl MirSurface::qmlFilePath() const

160{

161 return m_qmlFilePath;

162}

163

164QUrl MirSurface::screenshotUrl() const

165{

166 return m_screenshotUrl;

167}

168

169void MirSurface::setScreenshotUrl(QUrl screenshotUrl)

170{

171 if (screenshotUrl == m_screenshotUrl)

172 return;

173

174 m_screenshotUrl = screenshotUrl;

175 Q_EMIT screenshotUrlChanged(screenshotUrl);

176}

177

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

179{

180 return m_orientationAngle;

181}

182

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

184{

185 if (angle == m_orientationAngle)

186 return;

187

188 m_orientationAngle = angle;

189 Q_EMIT orientationAngleChanged(angle);

190}

191

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

193{

194 if (value != m_keymap) {

195 DEBUG_MSG(value);

196 m_keymap = value;

197 Q_EMIT keymapChanged(m_keymap);

198 }

199}

200

201QString MirSurface::keymap() const

202{

203 return m_keymap;

204}

205

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

207{

208 return m_shellChrome;

209}

210

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

212{

213 if (shellChrome == m_shellChrome)

214 return;

215

216 DEBUG_MSG(shellChrome);

217 m_shellChrome = shellChrome;

218 Q_EMIT shellChromeChanged(shellChrome);

219}

220

221void MirSurface::registerView(qintptr viewId)

222{

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

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

225}

226

227void MirSurface::unregisterView(qintptr viewId)

228{

229 m_views.remove(viewId);

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

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

232 deleteLater();

233 }

234 updateVisibility();

235}

236

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

238{

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

240

241 m_views[viewId].visible = visible;

242 updateVisibility();

243}

244

245void MirSurface::updateVisibility()

246{

247 bool newVisible = false;

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

249 while (i.hasNext()) {

250 i.next();

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

252 }

253

254 if (newVisible != visible()) {

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

256

257 m_visible = newVisible;

258 Q_EMIT visibleChanged(m_visible);

259 }

260}

261

262bool MirSurface::activeFocus() const

263{

264 return m_activeFocus;

265}

266

267void MirSurface::setActiveFocus(bool value)

268{

269 if (m_activeFocus == value)

270 return;

271

272 m_activeFocus = value;

273

274 Q_EMIT activeFocusChanged(value);

275}

276

277int MirSurface::width() const

278{

279 return m_width;

280}

281

282int MirSurface::height() const

283{

284 return m_height;

285}

286

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

288{

289 if (m_slowToResize) {

290 if (!m_delayedResizeTimer.isActive()) {

291 m_delayedResize.setWidth(width);

292 m_delayedResize.setHeight(height);

293 m_delayedResizeTimer.start();

294 } else {

295 m_pendingResize.setWidth(width);

296 m_pendingResize.setHeight(height);

297 }

298 } else {

299 doResize(width, height);

300 }

301}

302

303void MirSurface::applyDelayedResize()

304{

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

306 m_delayedResize.setWidth(-1);

307 m_delayedResize.setHeight(-1);

308

309 if (m_pendingResize.isValid()) {

310 QSize size = m_pendingResize;

311 m_pendingResize.setWidth(-1);

312 m_pendingResize.setHeight(-1);

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

314 }

315}

316

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

318{

319 bool changed = false;

320

321 if (width != m_width) {

322 m_width = width;

323 Q_EMIT widthChanged();

324 changed = true;

325 }

326

327 if (m_height != height) {

328 m_height = height;

329 Q_EMIT heightChanged();

330 changed = true;

331 }

332

333 if (changed) {

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

335 }

336

337 updateInputBoundsAfterResize();

338}

339

340void MirSurface::updateInputBoundsAfterResize()

341{

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

343}

344

345bool MirSurface::isSlowToResize() const

346{

347 return m_slowToResize;

348}

349

350void MirSurface::setSlowToResize(bool value)

351{

352 if (m_slowToResize != value) {

353 DEBUG_MSG(value);

354 m_slowToResize = value;

355 Q_EMIT slowToResizeChanged();

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

357 m_delayedResizeTimer.stop();

358 applyDelayedResize();

359 }

360 }

361}

362

363void MirSurface::setMinimumWidth(int value)

364{

365 if (value != m_minimumWidth) {

366 m_minimumWidth = value;

367 Q_EMIT minimumWidthChanged(m_minimumWidth);

368 }

369}

370

371void MirSurface::setMaximumWidth(int value)

372{

373 if (value != m_maximumWidth) {

374 m_maximumWidth = value;

375 Q_EMIT maximumWidthChanged(m_maximumWidth);

376 }

377}

378

379void MirSurface::setMinimumHeight(int value)

380{

381 if (value != m_minimumHeight) {

382 m_minimumHeight = value;

383 Q_EMIT minimumHeightChanged(m_minimumHeight);

384 }

385}

386

387void MirSurface::setMaximumHeight(int value)

388{

389 if (value != m_maximumHeight) {

390 m_maximumHeight = value;

391 Q_EMIT maximumHeightChanged(m_maximumHeight);

392 }

393}

394

395void MirSurface::setWidthIncrement(int value)

396{

397 if (value != m_widthIncrement) {

398 m_widthIncrement = value;

399 Q_EMIT widthIncrementChanged(m_widthIncrement);

400 }

401}

402

403void MirSurface::setHeightIncrement(int value)

404{

405 if (value != m_heightIncrement) {

406 m_heightIncrement = value;

407 Q_EMIT heightIncrementChanged(m_heightIncrement);

408 }

409}

410

411void MirSurface::raise()

412{

413 Q_EMIT raiseRequested();

414}

415

416void MirSurface::close()

417{

418 DEBUG_MSG("");

419 if (!m_zombieTimer.isActive()) {

420 m_zombieTimer.start();

421 Q_EMIT closeRequested();

422 }

423}

424

425void MirSurface::requestFocus()

426{

427 DEBUG_MSG("");

428 Q_EMIT focusRequested();

429}

430

431void MirSurface::setFocused(bool value)

432{

433 DEBUG_MSG(value);

434

435 auto controller = MirFocusController::instance();

436 // controller instance might have been already destroyed by QQmlEngine destructor

437 if (!controller) {

438 return;

439 }

440

441 if (value) {

442 controller->setFocusedSurface(this);

443 } else if (controller->focusedSurface() == this) {

444 controller->setFocusedSurface(nullptr);

445 }

446}

447

448bool MirSurface::focused() const

449{

450 auto controller = MirFocusController::instance();

451

452 // controller instance might have been already destroyed by QQmlEngine destructor

453 return controller ? controller->focusedSurface() == this : false;

454}

455

456QRect MirSurface::inputBounds() const

457{

458 return m_inputBounds;

459}

460

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

462{

463 if (boundsRect != m_inputBounds) {

464 m_inputBounds = boundsRect;

465 Q_EMIT inputBoundsChanged(m_inputBounds);

466 }

467}

468#if MIRSURFACE_DEBUG

469#undef DEBUG_MSG

470#define DEBUG_MSG(params) qDebug().nospace() << "MirFocusController::" << __func__ << " " << params

471#endif

472

473void MirFocusController::setFocusedSurface(MirSurfaceInterface *surface)

474{

475 if (m_focusedSurface == surface) {

476 return;

477 }

478 DEBUG_MSG("MirSurface[" << (void*)surface << "," << (surface?surface->name():"") << "]");

479

480 m_previouslyFocusedSurface = m_focusedSurface;

481 m_focusedSurface = surface;

482

483 if (m_previouslyFocusedSurface != m_focusedSurface) {

484 Q_EMIT focusedSurfaceChanged();

485 }

486

487 if (m_previouslyFocusedSurface) {

488 Q_EMIT m_previouslyFocusedSurface->focusedChanged(false);

489 }

490

491 if (m_focusedSurface) {

492 Q_EMIT m_focusedSurface->focusedChanged(true);

493 m_focusedSurface->raise();

494 }

495}

496

497MirFocusController* MirFocusController::instance()

498{

499 return m_instance;

500}

501

502MirFocusController::MirFocusController()

503{

504 DEBUG_MSG("");

505 Q_ASSERT(m_instance == nullptr);

506 m_instance = this;

507}

508

509MirFocusController::~MirFocusController()

510{

511 Q_ASSERT(m_instance == this);

512 m_instance = nullptr;

513}

514

515void MirFocusController::clear()

516{

517 m_focusedSurface = m_previouslyFocusedSurface = nullptr;

518 Q_EMIT focusedSurfaceChanged();

519}