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

git.iko.soy/unity8

on 34be00a help sign in

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

387 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 "MirSurfaceItem.h"

19#include <paths.h>

21#include <QGuiApplication>

22#include <QQuickView>

23#include <QQmlContext>

24#include <QQmlProperty>

25#include <QQmlEngine>

26#include <QString>

28#include <QDebug>

30using namespace unity::shell::application;

32#define MIRSURFACEITEM_DEBUG 0

34#if MIRSURFACEITEM_DEBUG

35#define DEBUG_MSG(params) qDebug().nospace() << "MirSurfaceItem::" << __func__ << " " << params

36#else

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

38#endif

40MirSurfaceItem::MirSurfaceItem(QQuickItem *parent)

41 : MirSurfaceItemInterface(parent)

42 , m_qmlSurface(nullptr)

43 , m_qmlContentComponent(nullptr)

44 , m_qmlItem(nullptr)

45 , m_consumesInput(false)

46 , m_orientationAngle(nullptr)

47 , m_surfaceWidth(0)

48 , m_surfaceHeight(0)

49 , m_touchPressCount(0)

50 , m_touchReleaseCount(0)

51 , m_mousePressCount(0)

52 , m_mouseReleaseCount(0)

53{

54 DEBUG_MSG((void*)(this) << name());

55 setAcceptedMouseButtons(Qt::LeftButton | Qt::MiddleButton | Qt::RightButton |

56 Qt::ExtraButton1 | Qt::ExtraButton2 | Qt::ExtraButton3 | Qt::ExtraButton4 |

57 Qt::ExtraButton5 | Qt::ExtraButton6 | Qt::ExtraButton7 | Qt::ExtraButton8 |

58 Qt::ExtraButton9 | Qt::ExtraButton10 | Qt::ExtraButton11 |

59 Qt::ExtraButton12 | Qt::ExtraButton13);

61 connect(this, &QQuickItem::activeFocusChanged, this, &MirSurfaceItem::updateMirSurfaceActiveFocus);

62 connect(this, &QQuickItem::visibleChanged, this, &MirSurfaceItem::updateMirSurfaceVisibility);

63 connect(this, &MirSurfaceItem::consumesInputChanged, this, [this]() {

64 updateMirSurfaceActiveFocus(hasActiveFocus());

65 });

66}

68MirSurfaceItem::~MirSurfaceItem()

69{

70 DEBUG_MSG((void*)(this) << name());

71 setSurface(nullptr);

72 delete m_orientationAngle;

73}

75void MirSurfaceItem::printComponentErrors()

76{

77 QList<QQmlError> errors = m_qmlContentComponent->errors();

78 for (int i = 0; i < errors.count(); ++i) {

79 qDebug() << errors[i];

80 }

81}

83Mir::Type MirSurfaceItem::type() const

84{

85 if (m_qmlSurface) {

86 return m_qmlSurface->type();

87 } else {

88 return Mir::UnknownType;

89 }

90}

92Mir::State MirSurfaceItem::surfaceState() const

93{

94 if (m_qmlSurface) {

95 return m_qmlSurface->state();

96 } else {

97 return Mir::UnknownState;

98 }

99}

100

101QString MirSurfaceItem::name() const

102{

103 if (m_qmlSurface) {

104 return m_qmlSurface->name();

105 } else {

106 return QString();

107 }

108}

109

110bool MirSurfaceItem::live() const

111{

112 if (m_qmlSurface) {

113 return m_qmlSurface->live();

114 } else {

115 return false;

116 }

117}

118

119Mir::ShellChrome MirSurfaceItem::shellChrome() const

120{

121 if (m_qmlSurface) {

122 return m_qmlSurface->shellChrome();

123 } else {

124 return Mir::NormalChrome;

125 }

126}

127

128Mir::OrientationAngle MirSurfaceItem::orientationAngle() const

129{

130 if (m_orientationAngle) {

131 Q_ASSERT(!m_qmlSurface);

132 return *m_orientationAngle;

133 } else if (m_qmlSurface) {

134 return m_qmlSurface->orientationAngle();

135 } else {

136 return Mir::Angle0;

137 }

138}

139

140void MirSurfaceItem::setOrientationAngle(Mir::OrientationAngle angle)

141{

142 DEBUG_MSG(angle);

143

144 if (m_qmlSurface) {

145 Q_ASSERT(!m_orientationAngle);

146 m_qmlSurface->setOrientationAngle(angle);

147 } else if (!m_orientationAngle) {

148 m_orientationAngle = new Mir::OrientationAngle;

149 *m_orientationAngle = angle;

150 Q_EMIT orientationAngleChanged(angle);

151 } else if (*m_orientationAngle != angle) {

152 *m_orientationAngle = angle;

153 Q_EMIT orientationAngleChanged(angle);

154 }

155

156 if (m_qmlItem) {

157 QQmlProperty orientationProp(m_qmlItem, "orientationAngle");

158 orientationProp.write(QVariant::fromValue(orientationAngle()));

159 }

160}

161

162void MirSurfaceItem::updateScreenshot(QUrl screenshotUrl)

163{

164 if (m_qmlItem) {

165 QQmlProperty screenshotSource(m_qmlItem, "screenshotSource");

166 screenshotSource.write(QVariant::fromValue(screenshotUrl));

167 }

168}

169

170void MirSurfaceItem::onComponentStatusChanged(QQmlComponent::Status status)

171{

172 if (status == QQmlComponent::Ready) {

173 createQmlContentItem();

174 }

175}

176

177void MirSurfaceItem::createQmlContentItem()

178{

179 DEBUG_MSG("");

180

181 m_qmlItem = qobject_cast<QQuickItem*>(m_qmlContentComponent->create());

182 m_qmlItem->setParentItem(this);

183

184 setImplicitWidth(m_qmlItem->implicitWidth());

185 setImplicitHeight(m_qmlItem->implicitHeight());

186

187 {

188 QQmlProperty screenshotSource(m_qmlItem, "screenshotSource");

189 screenshotSource.write(QVariant::fromValue(m_qmlSurface->screenshotUrl()));

190 }

191

192 {

193 QQmlProperty orientationProp(m_qmlItem, "orientationAngle");

194 orientationProp.write(QVariant::fromValue(orientationAngle()));

195 }

196}

197

198void MirSurfaceItem::touchEvent(QTouchEvent * event)

199{

200 if (event->type() == QEvent::TouchBegin) {

201 m_touchTrail.clear();

202 }

203

204 if (event->touchPointStates() & Qt::TouchPointPressed) {

205 ++m_touchPressCount;

206 Q_EMIT touchPressCountChanged(m_touchPressCount);

207 } else if (event->touchPointStates() & Qt::TouchPointReleased) {

208 ++m_touchReleaseCount;

209 Q_EMIT touchReleaseCountChanged(m_touchReleaseCount);

210 }

211

212 Q_FOREACH(QTouchEvent::TouchPoint touchPoint, event->touchPoints()) {

213 QString id(touchPoint.id());

214 QVariantList list = m_touchTrail[id].toList();

215 list.append(QVariant::fromValue(touchPoint.pos()));

216 if (list.count() > 100) list.pop_front();

217 m_touchTrail[id] = list;

218 }

219

220 if (m_qmlItem) {

221 QQmlProperty touchTrail(m_qmlItem, "touchTrail");

222 touchTrail.write(m_touchTrail);

223 }

224}

225

226void MirSurfaceItem::mousePressEvent(QMouseEvent * event)

227{

228 m_mousePressCount++;

229 Q_EMIT mousePressCountChanged(m_mousePressCount);

230 event->accept();

231}

232

233void MirSurfaceItem::mouseMoveEvent(QMouseEvent * event)

234{

235 event->accept();

236}

237

238void MirSurfaceItem::mouseReleaseEvent(QMouseEvent * event)

239{

240 m_mouseReleaseCount++;

241 Q_EMIT mouseReleaseCountChanged(m_mouseReleaseCount);

242 event->accept();

243}

244

245void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

246{

247 DEBUG_MSG("this=" << (void*)(this) << " name=" << name() << " surface=" << surface);

248

249 if (m_qmlSurface == surface) {

250 return;

251 }

252

253 if (m_qmlSurface) {

254 delete m_qmlItem;

255 m_qmlItem = nullptr;

256

257 delete m_qmlContentComponent;

258 m_qmlContentComponent = nullptr;

259

260 if (hasActiveFocus() && m_consumesInput && m_qmlSurface->live()) {

261 m_qmlSurface->setActiveFocus(false);

262 }

263

264 disconnect(m_qmlSurface, nullptr, this, nullptr);

265 m_qmlSurface->unregisterView((qintptr)this);

266 }

267

268 m_qmlSurface = static_cast<MirSurface*>(surface);

269

270 if (m_qmlSurface) {

271 m_qmlSurface->registerView((qintptr)this);

272

273 updateSurfaceSize();

274 updateMirSurfaceVisibility();

275

276 if (m_orientationAngle) {

277 m_qmlSurface->setOrientationAngle(*m_orientationAngle);

278 connect(m_qmlSurface, &MirSurfaceInterface::orientationAngleChanged, this, &MirSurfaceItem::orientationAngleChanged);

279 delete m_orientationAngle;

280 m_orientationAngle = nullptr;

281 } else {

282 connect(m_qmlSurface, &MirSurfaceInterface::orientationAngleChanged, this, &MirSurfaceItem::orientationAngleChanged);

283 Q_EMIT orientationAngleChanged(m_qmlSurface->orientationAngle());

284 }

285

286 connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);

287 connect(m_qmlSurface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);

288 connect(m_qmlSurface, &MirSurface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);

289

290 QUrl qmlComponentFilePath;

291 if (!m_qmlSurface->qmlFilePath().isEmpty()) {

292 qmlComponentFilePath = m_qmlSurface->qmlFilePath();

293 } else {

294 qmlComponentFilePath = QUrl("qrc:///Unity/Application/MirSurfaceItem.qml");

295 }

296

297 m_qmlContentComponent = new QQmlComponent(QQmlEngine::contextForObject(parent())->engine(), qmlComponentFilePath);

298

299 switch (m_qmlContentComponent->status()) {

300 case QQmlComponent::Ready:

301 createQmlContentItem();

302 break;

303 case QQmlComponent::Loading:

304 connect(m_qmlContentComponent, &QQmlComponent::statusChanged,

305 this, &MirSurfaceItem::onComponentStatusChanged);

306 break;

307 case QQmlComponent::Error:

308 printComponentErrors();

309 qFatal("MirSurfaceItem: failed to create content component.");

310 break;

311 default:

312 qFatal("MirSurfaceItem: Unhandled component status");

313 }

314

315 if (m_consumesInput) {

316 m_qmlSurface->setActiveFocus(hasActiveFocus());

317 }

318 }

319

320 Q_EMIT surfaceChanged(m_qmlSurface);

321}

322

323

324void MirSurfaceItem::updateMirSurfaceActiveFocus(bool focused)

325{

326 if (m_qmlSurface && m_consumesInput && m_qmlSurface->live()) {

327 m_qmlSurface->setActiveFocus(focused);

328 }

329}

330

331void MirSurfaceItem::updateMirSurfaceVisibility()

332{

333 if (!m_qmlSurface) return;

334

335 m_qmlSurface->setViewVisibility((qintptr)this, isVisible());

336}

337

338void MirSurfaceItem::setConsumesInput(bool value)

339{

340 if (m_consumesInput != value) {

341 m_consumesInput = value;

342 Q_EMIT consumesInputChanged(value);

343 }

344}

345

346int MirSurfaceItem::surfaceWidth() const

347{

348 return m_surfaceWidth;

349}

350

351void MirSurfaceItem::setSurfaceWidth(int value)

352{

353 if (value != -1 && m_surfaceWidth != value) {

354 m_surfaceWidth = value;

355 Q_EMIT surfaceWidthChanged(m_surfaceWidth);

356 updateSurfaceSize();

357 }

358}

359

360int MirSurfaceItem::surfaceHeight() const

361{

362 return m_surfaceHeight;

363}

364

365void MirSurfaceItem::setSurfaceHeight(int value)

366{

367 if (value != -1 && m_surfaceHeight != value) {

368 m_surfaceHeight = value;

369 Q_EMIT surfaceHeightChanged(m_surfaceHeight);

370 updateSurfaceSize();

371 }

372}

373

374void MirSurfaceItem::updateSurfaceSize()

375{

376 if (m_qmlSurface && m_surfaceWidth > 0 && m_surfaceHeight > 0) {

377 m_qmlSurface->resize(m_surfaceWidth, m_surfaceHeight);

378 }

379}

380

381void MirSurfaceItem::setFillMode(FillMode value)

382{

383 if (value != m_fillMode) {

384 m_fillMode = value;

385 Q_EMIT fillModeChanged(m_fillMode);

386 }

387}