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

git.iko.soy/unity8

on cfcde21 help sign in

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

520 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 updateInputBoundsAfterResize();

260 }

261}

262

263bool MirSurface::activeFocus() const

264{

265 return m_activeFocus;

266}

267

268void MirSurface::setActiveFocus(bool value)

269{

270 if (m_activeFocus == value)

271 return;

272

273 m_activeFocus = value;

274

275 Q_EMIT activeFocusChanged(value);

276}

277

278int MirSurface::width() const

279{

280 return m_width;

281}

282

283int MirSurface::height() const

284{

285 return m_height;

286}

287

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

289{

290 if (m_slowToResize) {

291 if (!m_delayedResizeTimer.isActive()) {

292 m_delayedResize.setWidth(width);

293 m_delayedResize.setHeight(height);

294 m_delayedResizeTimer.start();

295 } else {

296 m_pendingResize.setWidth(width);

297 m_pendingResize.setHeight(height);

298 }

299 } else {

300 doResize(width, height);

301 }

302}

303

304void MirSurface::applyDelayedResize()

305{

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

307 m_delayedResize.setWidth(-1);

308 m_delayedResize.setHeight(-1);

309

310 if (m_pendingResize.isValid()) {

311 QSize size = m_pendingResize;

312 m_pendingResize.setWidth(-1);

313 m_pendingResize.setHeight(-1);

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

315 }

316}

317

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

319{

320 bool changed = false;

321

322 if (width != m_width) {

323 m_width = width;

324 Q_EMIT widthChanged();

325 changed = true;

326 }

327

328 if (m_height != height) {

329 m_height = height;

330 Q_EMIT heightChanged();

331 changed = true;

332 }

333

334 if (changed) {

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

336 }

337

338 updateInputBoundsAfterResize();

339}

340

341void MirSurface::updateInputBoundsAfterResize()

342{

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

344}

345

346bool MirSurface::isSlowToResize() const

347{

348 return m_slowToResize;

349}

350

351void MirSurface::setSlowToResize(bool value)

352{

353 if (m_slowToResize != value) {

354 DEBUG_MSG(value);

355 m_slowToResize = value;

356 Q_EMIT slowToResizeChanged();

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

358 m_delayedResizeTimer.stop();

359 applyDelayedResize();

360 }

361 }

362}

363

364void MirSurface::setMinimumWidth(int value)

365{

366 if (value != m_minimumWidth) {

367 m_minimumWidth = value;

368 Q_EMIT minimumWidthChanged(m_minimumWidth);

369 }

370}

371

372void MirSurface::setMaximumWidth(int value)

373{

374 if (value != m_maximumWidth) {

375 m_maximumWidth = value;

376 Q_EMIT maximumWidthChanged(m_maximumWidth);

377 }

378}

379

380void MirSurface::setMinimumHeight(int value)

381{

382 if (value != m_minimumHeight) {

383 m_minimumHeight = value;

384 Q_EMIT minimumHeightChanged(m_minimumHeight);

385 }

386}

387

388void MirSurface::setMaximumHeight(int value)

389{

390 if (value != m_maximumHeight) {

391 m_maximumHeight = value;

392 Q_EMIT maximumHeightChanged(m_maximumHeight);

393 }

394}

395

396void MirSurface::setWidthIncrement(int value)

397{

398 if (value != m_widthIncrement) {

399 m_widthIncrement = value;

400 Q_EMIT widthIncrementChanged(m_widthIncrement);

401 }

402}

403

404void MirSurface::setHeightIncrement(int value)

405{

406 if (value != m_heightIncrement) {

407 m_heightIncrement = value;

408 Q_EMIT heightIncrementChanged(m_heightIncrement);

409 }

410}

411

412void MirSurface::raise()

413{

414 Q_EMIT raiseRequested();

415}

416

417void MirSurface::close()

418{

419 DEBUG_MSG("");

420 if (!m_zombieTimer.isActive()) {

421 m_zombieTimer.start();

422 Q_EMIT closeRequested();

423 }

424}

425

426void MirSurface::requestFocus()

427{

428 DEBUG_MSG("");

429 Q_EMIT focusRequested();

430}

431

432void MirSurface::setFocused(bool value)

433{

434 DEBUG_MSG(value);

435

436 auto controller = MirFocusController::instance();

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

438 if (!controller) {

439 return;

440 }

441

442 if (value) {

443 controller->setFocusedSurface(this);

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

445 controller->setFocusedSurface(nullptr);

446 }

447}

448

449bool MirSurface::focused() const

450{

451 auto controller = MirFocusController::instance();

452

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

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

455}

456

457QRect MirSurface::inputBounds() const

458{

459 return m_inputBounds;

460}

461

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

463{

464 if (boundsRect != m_inputBounds) {

465 m_inputBounds = boundsRect;

466 Q_EMIT inputBoundsChanged(m_inputBounds);

467 }

468}

469#if MIRSURFACE_DEBUG

470#undef DEBUG_MSG

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

472#endif

473

474void MirFocusController::setFocusedSurface(MirSurfaceInterface *surface)

475{

476 if (m_focusedSurface == surface) {

477 return;

478 }

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

480

481 m_previouslyFocusedSurface = m_focusedSurface;

482 m_focusedSurface = surface;

483

484 if (m_previouslyFocusedSurface != m_focusedSurface) {

485 Q_EMIT focusedSurfaceChanged();

486 }

487

488 if (m_previouslyFocusedSurface) {

489 Q_EMIT m_previouslyFocusedSurface->focusedChanged(false);

490 }

491

492 if (m_focusedSurface) {

493 Q_EMIT m_focusedSurface->focusedChanged(true);

494 m_focusedSurface->raise();

495 }

496}

497

498MirFocusController* MirFocusController::instance()

499{

500 return m_instance;

501}

502

503MirFocusController::MirFocusController()

504{

505 DEBUG_MSG("");

506 Q_ASSERT(m_instance == nullptr);

507 m_instance = this;

508}

509

510MirFocusController::~MirFocusController()

511{

512 Q_ASSERT(m_instance == this);

513 m_instance = nullptr;

514}

515

516void MirFocusController::clear()

517{

518 m_focusedSurface = m_previouslyFocusedSurface = nullptr;

519 Q_EMIT focusedSurfaceChanged();

520}