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

git.iko.soy/unity8

on 76feda2 help sign in

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

315 lines 8.8 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 <QQmlProperty>

24#include <QQmlEngine>

25#include <QString>

27#include <QDebug>

29using namespace unity::shell::application;

31MirSurfaceItem::MirSurfaceItem(QQuickItem *parent)

32 : MirSurfaceItemInterface(parent)

33 , m_qmlSurface(nullptr)

34 , m_qmlItem(nullptr)

35 , m_consumesInput(false)

36 , m_surfaceWidth(0)

37 , m_surfaceHeight(0)

38 , m_touchPressCount(0)

39 , m_touchReleaseCount(0)

40{

41// qDebug() << "MirSurfaceItem::MirSurfaceItem() " << (void*)(this) << name();

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

43 Qt::ExtraButton1 | Qt::ExtraButton2 | Qt::ExtraButton3 | Qt::ExtraButton4 |

44 Qt::ExtraButton5 | Qt::ExtraButton6 | Qt::ExtraButton7 | Qt::ExtraButton8 |

45 Qt::ExtraButton9 | Qt::ExtraButton10 | Qt::ExtraButton11 |

46 Qt::ExtraButton12 | Qt::ExtraButton13);

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

49}

51MirSurfaceItem::~MirSurfaceItem()

52{

53// qDebug() << "MirSurfaceItem::~MirSurfaceItem() " << (void*)(this) << name();

54 setSurface(nullptr);

55}

57void MirSurfaceItem::printComponentErrors()

58{

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

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

61 qDebug() << errors[i];

62 }

63}

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

66{

67 if (m_qmlSurface) {

68 return m_qmlSurface->type();

69 } else {

70 return Mir::UnknownType;

71 }

72}

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

75{

76 if (m_qmlSurface) {

77 return m_qmlSurface->state();

78 } else {

79 return Mir::UnknownState;

80 }

81}

83QString MirSurfaceItem::name() const

84{

85 if (m_qmlSurface) {

86 return m_qmlSurface->name();

87 } else {

88 return QString();

89 }

90}

92bool MirSurfaceItem::live() const

93{

94 if (m_qmlSurface) {

95 return m_qmlSurface->live();

96 } else {

97 return false;

98 }

99}

100

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

102{

103 if (m_qmlSurface) {

104 return m_qmlSurface->orientationAngle();

105 } else {

106 return Mir::Angle0;

107 }

108}

109

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

111{

112 if (!m_qmlSurface)

113 return;

114

115 if (m_qmlSurface->orientationAngle() == angle)

116 return;

117

118 m_qmlSurface->setOrientationAngle(angle);

119

120 QQmlProperty orientationProp(m_qmlItem, "orientationAngle");

121 orientationProp.write(QVariant::fromValue(m_qmlSurface->orientationAngle()));

122}

123

124void MirSurfaceItem::updateScreenshot(QUrl screenshotUrl)

125{

126 if (m_qmlItem) {

127 QQmlProperty screenshotSource(m_qmlItem, "screenshotSource");

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

129 }

130}

131

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

133{

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

135 createQmlContentItem();

136 }

137}

138

139void MirSurfaceItem::createQmlContentItem()

140{

141// qDebug() << "MirSurfaceItem::createQmlContentItem()";

142

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

144 m_qmlItem->setParentItem(this);

145

146 setImplicitWidth(m_qmlItem->implicitWidth());

147 setImplicitHeight(m_qmlItem->implicitHeight());

148

149 {

150 QQmlProperty screenshotSource(m_qmlItem, "screenshotSource");

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

152 }

153}

154

155void MirSurfaceItem::touchEvent(QTouchEvent * event)

156{

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

158 ++m_touchPressCount;

159 Q_EMIT touchPressCountChanged(m_touchPressCount);

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

161 ++m_touchReleaseCount;

162 Q_EMIT touchReleaseCountChanged(m_touchReleaseCount);

163 }

164}

165

166void MirSurfaceItem::mousePressEvent(QMouseEvent * event)

167{

168 event->accept();

169}

170

171void MirSurfaceItem::mouseMoveEvent(QMouseEvent * event)

172{

173 event->accept();

174}

175

176void MirSurfaceItem::mouseReleaseEvent(QMouseEvent * event)

177{

178 event->accept();

179}

180

181void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

182{

183// qDebug().nospace() << "MirSurfaceItem::setSurface() this=" << (void*)(this)

184// << " name=" << name()

185// << " surface=" << surface;

186

187 if (m_qmlSurface == surface) {

188 return;

189 }

190

191 if (m_qmlSurface) {

192 delete m_qmlItem;

193 m_qmlItem = nullptr;

194

195 delete m_qmlContentComponent;

196 m_qmlContentComponent = nullptr;

197

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

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

200 }

201

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

203

204 if (m_qmlSurface) {

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

206

207 m_qmlSurface->setActiveFocus(hasActiveFocus());

208

209 updateSurfaceSize();

210 updateMirSurfaceVisibility();

211

212 connect(m_qmlSurface, &MirSurface::orientationAngleChanged, this, &MirSurfaceItem::orientationAngleChanged);

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

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

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

216

217 // The assumptions I make here really should hold.

218 QQuickView *quickView =

219 qobject_cast<QQuickView*>(QGuiApplication::topLevelWindows()[0]);

220

221 QUrl qmlComponentFilePath;

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

223 qmlComponentFilePath = m_qmlSurface->qmlFilePath();

224 } else {

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

226 }

227

228 m_qmlContentComponent = new QQmlComponent(quickView->engine(), qmlComponentFilePath);

229

230 switch (m_qmlContentComponent->status()) {

231 case QQmlComponent::Ready:

232 createQmlContentItem();

233 break;

234 case QQmlComponent::Loading:

235 connect(m_qmlContentComponent, &QQmlComponent::statusChanged,

236 this, &MirSurfaceItem::onComponentStatusChanged);

237 break;

238 case QQmlComponent::Error:

239 printComponentErrors();

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

241 break;

242 default:

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

244 }

245 }

246

247 Q_EMIT surfaceChanged(m_qmlSurface);

248}

249

250void MirSurfaceItem::itemChange(ItemChange change, const ItemChangeData & value)

251{

252 if (change == QQuickItem::ItemActiveFocusHasChanged) {

253 if (m_qmlSurface) {

254 m_qmlSurface->setActiveFocus(value.boolValue);

255 }

256 }

257}

258

259void MirSurfaceItem::updateMirSurfaceVisibility()

260{

261 if (!m_qmlSurface) return;

262

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

264}

265

266void MirSurfaceItem::setConsumesInput(bool value)

267{

268 if (m_consumesInput != value) {

269 m_consumesInput = value;

270 Q_EMIT consumesInputChanged(value);

271 }

272}

273

274int MirSurfaceItem::surfaceWidth() const

275{

276 return m_surfaceWidth;

277}

278

279void MirSurfaceItem::setSurfaceWidth(int value)

280{

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

282 m_surfaceWidth = value;

283 Q_EMIT surfaceWidthChanged(m_surfaceWidth);

284 updateSurfaceSize();

285 }

286}

287

288int MirSurfaceItem::surfaceHeight() const

289{

290 return m_surfaceHeight;

291}

292

293void MirSurfaceItem::setSurfaceHeight(int value)

294{

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

296 m_surfaceHeight = value;

297 Q_EMIT surfaceHeightChanged(m_surfaceHeight);

298 updateSurfaceSize();

299 }

300}

301

302void MirSurfaceItem::updateSurfaceSize()

303{

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

305 m_qmlSurface->resize(m_surfaceWidth, m_surfaceHeight);

306 }

307}

308

309void MirSurfaceItem::setFillMode(FillMode value)

310{

311 if (value != m_fillMode) {

312 m_fillMode = value;

313 Q_EMIT fillModeChanged(m_fillMode);

314 }

315}