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

git.iko.soy/unity8

on fc480e9 help sign in

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

463 lines 15 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 "ApplicationManager.h"

18#include "ApplicationInfo.h"

19#include "paths.h"

21#include <QDir>

22#include <QGuiApplication>

23#include <QQuickItem>

24#include <QQuickView>

25#include <QQmlComponent>

27ApplicationManager::ApplicationManager(QObject *parent)

28 : ApplicationManagerInterface(parent)

29 , m_mainStageComponent(0)

30 , m_mainStage(0)

31 , m_sideStageComponent(0)

32 , m_sideStage(0)

33{

34 buildListOfAvailableApplications();

35}

37ApplicationManager::~ApplicationManager()

38{

39}

41int ApplicationManager::rowCount(const QModelIndex& parent) const {

42 return !parent.isValid() ? m_runningApplications.size() : 0;

43}

45QVariant ApplicationManager::data(const QModelIndex& index, int role) const {

46 if (index.row() < 0 || index.row() >= m_runningApplications.size())

47 return QVariant();

49 auto app = m_runningApplications.at(index.row());

50 switch(role) {

51 case RoleAppId:

52 return app->appId();

53 case RoleName:

54 return app->name();

55 case RoleComment:

56 return app->comment();

57 case RoleIcon:

58 return app->icon();

59 case RoleStage:

60 return app->stage();

61 case RoleState:

62 return app->state();

63 case RoleFocused:

64 return app->focused();

65 default:

66 return QVariant();

67 }

68}

70ApplicationInfo *ApplicationManager::get(int row) const {

71 if (row < 0 || row >= m_runningApplications.size())

72 return nullptr;

74 return m_runningApplications.at(row);

75}

77ApplicationInfo *ApplicationManager::findApplication(const QString &appId) const {

78 for (ApplicationInfo *app : m_runningApplications) {

79 if (app->appId() == appId) {

80 return app;

81 }

82 }

83 return nullptr;

84}

86void ApplicationManager::move(int from, int to) {

87 if (from == to) return;

89 if (from >= 0 && from < m_runningApplications.size() && to >= 0 && to < m_runningApplications.size()) {

90 QModelIndex parent;

91 /* When moving an item down, the destination index needs to be incremented

92 * by one, as explained in the documentation:

93 * http://qt-project.org/doc/qt-5.0/qtcore/qabstractitemmodel.html#beginMoveRows */

94 beginMoveRows(parent, from, from, parent, to + (to > from ? 1 : 0));

95 m_runningApplications.move(from, to);

96 endMoveRows();

97 }

98}

100int ApplicationManager::keyboardHeight() const

101{

102 return 0;

103}

104

105bool ApplicationManager::keyboardVisible() const

106{

107 return false;

108}

109

110int ApplicationManager::sideStageWidth() const

111{

112 return 0;

113}

114

115ApplicationManager::StageHint ApplicationManager::stageHint() const

116{

117 return MainStage;

118}

119

120ApplicationManager::FormFactorHint ApplicationManager::formFactorHint() const

121{

122 return PhoneFormFactor;

123}

124

125ApplicationInfo* ApplicationManager::startApplication(const QString &appId,

126 const QStringList &arguments)

127{

128 return this->startApplication(appId, NoFlag, arguments);

129}

130

131ApplicationInfo* ApplicationManager::startApplication(const QString &appId,

132 ExecFlags flags,

133 const QStringList &arguments)

134{

135 Q_UNUSED(arguments)

136 ApplicationInfo *application = 0;

137

138 for (int i = 0; i < m_availableApplications.count(); ++i) {

139 ApplicationInfo *availableApp = m_availableApplications[i];

140 if (availableApp->appId() == appId) {

141 application = availableApp;

142 break;

143 }

144 }

145

146 if (!application)

147 return 0;

148

149 m_runningApplications.append(application);

150 if (flags.testFlag(ApplicationManager::ForceMainStage)

151 && application->stage() == ApplicationInfo::SideStage) {

152 application->setStage(ApplicationInfo::MainStage);

153 }

154

155 application->setFocused(true);

156 Q_EMIT focusedApplicationIdChanged();

157 return application;

158}

159

160bool ApplicationManager::stopApplication(const QString &appId)

161{

162 ApplicationInfo *application = this->findApplication(appId);

163 if (application == nullptr)

164 return false;

165

166 application->setFocused(false);

167 m_runningApplications.removeAll(application);

168 Q_EMIT focusedApplicationIdChanged();

169 return true;

170}

171

172QString ApplicationManager::focusedApplicationId() const {

173 for (ApplicationInfo *app : m_runningApplications) {

174 if (app->focused())

175 return app->appId();

176 }

177 return QString();

178}

179

180bool ApplicationManager::focusApplication(const QString &appId)

181{

182 ApplicationInfo *application = this->findApplication(appId);

183 if (application == nullptr)

184 return false;

185

186 if (application->stage() == ApplicationInfo::MainStage) {

187 // unfocus currently focused mainstage app

188 for (ApplicationInfo *app : m_runningApplications) {

189 if (app->focused() && app->stage() == ApplicationInfo::MainStage)

190 app->setFocused(false);

191 }

192

193 // focus this app

194 application->setFocused(true);

195 if (!m_mainStage)

196 createMainStage();

197 application->showWindow(m_mainStage);

198 m_mainStage->setZ(-1000);

199 if (m_sideStage)

200 m_sideStage->setZ(-2000);

201 } else if (application->stage() == ApplicationInfo::SideStage) {

202 // unfocus currently focused sidestage app

203 for (ApplicationInfo *app : m_runningApplications) {

204 if (app->focused() && app->stage() == ApplicationInfo::SideStage)

205 app->setFocused(false);

206 }

207

208 // focus this app

209 application->setFocused(true);

210 if (!m_sideStage)

211 createSideStage();

212 application->showWindow(m_sideStage);

213 m_sideStage->setZ(-1000);

214 if (m_mainStage)

215 m_mainStage->setZ(-2000);

216 }

217

218 // move app to top of stack

219 this->move(m_runningApplications.indexOf(application), 0);

220 Q_EMIT focusedApplicationIdChanged();

221 return true;

222}

223

224void ApplicationManager::unfocusCurrentApplication()

225{

226 for (ApplicationInfo *app : m_runningApplications) {

227 if (app->focused())

228 app->setFocused(false);

229 }

230 Q_EMIT focusedApplicationIdChanged();

231}

232

233void ApplicationManager::generateQmlStrings(ApplicationInfo *application)

234{

235 // TODO: Is there a better way of solving this fullscreen vs. regular

236 // application height?

237 QString topMargin;

238 if (application->fullscreen()) {

239 topMargin.append("0");

240 } else {

241 // Taken from Panel.panelHeight

242 topMargin.append("units.gu(3) + units.dp(2)");

243 }

244

245 QString windowQml = QString(

246 "import QtQuick 2.0\n"

247 "Image {\n"

248 " anchors.fill: parent\n"

249 " anchors.topMargin: %1\n"

250 " source: \"file://%2/Dash/graphics/phone/screenshots/%3.png\"\n"

251 " smooth: true\n"

252 " fillMode: Image.PreserveAspectCrop\n"

253 "}").arg(topMargin)

254 .arg(shellAppDirectory())

255 .arg(application->icon().toString());

256 application->setWindowQml(windowQml);

257

258 QString imageQml = QString(

259 "import QtQuick 2.0\n"

260 "Image {\n"

261 " anchors.fill: parent\n"

262 " source: \"file://%1/Dash/graphics/phone/screenshots/%2.png\"\n"

263 " smooth: true\n"

264 " fillMode: Image.PreserveAspectCrop\n"

265 "}").arg(shellAppDirectory())

266 .arg(application->icon().toString());

267 application->setImageQml(imageQml);

268}

269

270void ApplicationManager::buildListOfAvailableApplications()

271{

272 ApplicationInfo *application;

273

274 application = new ApplicationInfo(this);

275 application->setAppId("phone-app");

276 application->setName("Phone");

277 application->setIcon(QUrl("phone"));

278 application->setStage(ApplicationInfo::SideStage);

279 generateQmlStrings(application);

280 m_availableApplications.append(application);

281

282 application = new ApplicationInfo(this);

283 application->setAppId("camera-app");

284 application->setName("Camera");

285 application->setIcon(QUrl("camera"));

286 application->setFullscreen(true);

287 generateQmlStrings(application);

288 m_availableApplications.append(application);

289

290 application = new ApplicationInfo(this);

291 application->setAppId("gallery-app");

292 application->setName("Gallery");

293 application->setIcon(QUrl("gallery"));

294 generateQmlStrings(application);

295 m_availableApplications.append(application);

296

297 application = new ApplicationInfo(this);

298 application->setAppId("facebook-webapp");

299 application->setName("Facebook");

300 application->setIcon(QUrl("facebook"));

301 application->setStage(ApplicationInfo::SideStage);

302 generateQmlStrings(application);

303 m_availableApplications.append(application);

304

305 application = new ApplicationInfo(this);

306 application->setAppId("webbrowser-app");

307 application->setName("Browser");

308 application->setIcon(QUrl("browser"));

309 generateQmlStrings(application);

310 m_availableApplications.append(application);

311

312 application = new ApplicationInfo(this);

313 application->setAppId("twitter-webapp");

314 application->setName("Twitter");

315 application->setIcon(QUrl("twitter"));

316 application->setStage(ApplicationInfo::SideStage);

317 generateQmlStrings(application);

318 m_availableApplications.append(application);

319

320 application = new ApplicationInfo(this);

321 application->setAppId("gmail-webapp");

322 application->setName("GMail");

323 application->setIcon(QUrl("gmail"));

324 m_availableApplications.append(application);

325

326 application = new ApplicationInfo(this);

327 application->setAppId("ubuntu-weather-app");

328 application->setName("Weather");

329 application->setIcon(QUrl("weather"));

330 application->setStage(ApplicationInfo::SideStage);

331 generateQmlStrings(application);

332 m_availableApplications.append(application);

333

334 application = new ApplicationInfo(this);

335 application->setAppId("notes-app");

336 application->setName("Notepad");

337 application->setIcon(QUrl("notepad"));

338 application->setStage(ApplicationInfo::SideStage);

339 m_availableApplications.append(application);

340

341 application = new ApplicationInfo(this);

342 application->setAppId("calendar-app");

343 application->setName("Calendar");

344 application->setIcon(QUrl("calendar"));

345 application->setStage(ApplicationInfo::SideStage);

346 m_availableApplications.append(application);

347

348 application = new ApplicationInfo(this);

349 application->setAppId("mediaplayer-app");

350 application->setName("Media Player");

351 application->setIcon(QUrl("mediaplayer-app"));

352 application->setFullscreen(true);

353 m_availableApplications.append(application);

354

355 application = new ApplicationInfo(this);

356 application->setAppId("evernote");

357 application->setName("Evernote");

358 application->setIcon(QUrl("evernote"));

359 m_availableApplications.append(application);

360

361 application = new ApplicationInfo(this);

362 application->setAppId("map");

363 application->setName("Map");

364 application->setIcon(QUrl("map"));

365 generateQmlStrings(application);

366 m_availableApplications.append(application);

367

368 application = new ApplicationInfo(this);

369 application->setAppId("pinterest");

370 application->setName("Pinterest");

371 application->setIcon(QUrl("pinterest"));

372 m_availableApplications.append(application);

373

374 application = new ApplicationInfo(this);

375 application->setAppId("soundcloud");

376 application->setName("SoundCloud");

377 application->setIcon(QUrl("soundcloud"));

378 m_availableApplications.append(application);

379

380 application = new ApplicationInfo(this);

381 application->setAppId("wikipedia");

382 application->setName("Wikipedia");

383 application->setIcon(QUrl("wikipedia"));

384 m_availableApplications.append(application);

385

386 application = new ApplicationInfo(this);

387 application->setAppId("youtube");

388 application->setName("YouTube");

389 application->setIcon(QUrl("youtube"));

390 m_availableApplications.append(application);

391}

392

393void ApplicationManager::createMainStageComponent()

394{

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

396 QQuickView *quickView =

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

398

399 QQmlEngine *engine = quickView->engine();

400

401 m_mainStageComponent = new QQmlComponent(engine, this);

402 QString mainStageQml =

403 "import QtQuick 2.0\n"

404 "Rectangle {\n"

405 " anchors.fill: parent\n"

406 " color: 'black'\n"

407 " z: -2000\n"

408 "}\n";

409 m_mainStageComponent->setData(mainStageQml.toLatin1(), QUrl());

410}

411

412void ApplicationManager::createMainStage()

413{

414 if (!m_mainStageComponent)

415 createMainStageComponent();

416

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

418 QQuickView *quickView =

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

420

421 QQuickItem *shell = quickView->rootObject();

422

423 m_mainStage = qobject_cast<QQuickItem *>(m_mainStageComponent->create());

424 m_mainStage->setParentItem(shell);

425}

426

427void ApplicationManager::createSideStageComponent()

428{

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

430 QQuickView *quickView =

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

432

433 QQmlEngine *engine = quickView->engine();

434

435 m_sideStageComponent = new QQmlComponent(engine, this);

436 QString sideStageQml =

437 "import QtQuick 2.0\n"

438 "import Ubuntu.Components 0.1\n"

439 "Item {\n"

440 " width: units.gu(40)\n" // from SideStage in Shell.qml

441 " anchors.top: parent.top\n"

442 " anchors.bottom: parent.bottom\n"

443 " anchors.right: parent.right\n"

444 " z: -1000\n"

445 "}\n";

446 m_sideStageComponent->setData(sideStageQml.toLatin1(), QUrl());

447}

448

449void ApplicationManager::createSideStage()

450{

451 if (!m_sideStageComponent)

452 createSideStageComponent();

453

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

455 QQuickView *quickView =

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

457

458 QQuickItem *shell = quickView->rootObject();

459

460 m_sideStage = qobject_cast<QQuickItem *>(m_sideStageComponent->create());

461 m_sideStage->setParentItem(shell);

462 m_sideStage->setFlag(QQuickItem::ItemHasContents, false);

463}