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

git.iko.soy/unity8

on bb3e943 help sign in

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

483 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;

73 return m_runningApplications.at(row);

74}

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

77 for (ApplicationInfo *app : m_runningApplications) {

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

79 return app;

80 }

81 }

82 return nullptr;

83}

85void ApplicationManager::add(ApplicationInfo *application) {

86 if (!application)

87 return;

89 beginInsertRows(QModelIndex(), m_runningApplications.size(), m_runningApplications.size());

90 m_runningApplications.append(application);

91 endInsertRows();

92 Q_EMIT countChanged();

93}

95void ApplicationManager::remove(ApplicationInfo *application) {

96 int i = m_runningApplications.indexOf(application);

97 if (i != -1) {

98 beginRemoveRows(QModelIndex(), i, i);

99 m_runningApplications.removeAt(i);

100 endRemoveRows();

101 Q_EMIT countChanged();

102 }

103}

104

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

106 if (from == to) return;

107

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

109 QModelIndex parent;

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

111 * by one, as explained in the documentation:

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

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

114 m_runningApplications.move(from, to);

115 endMoveRows();

116 }

117}

118

119int ApplicationManager::keyboardHeight() const

120{

121 return 0;

122}

123

124bool ApplicationManager::keyboardVisible() const

125{

126 return false;

127}

128

129int ApplicationManager::sideStageWidth() const

130{

131 return 0;

132}

133

134ApplicationManager::StageHint ApplicationManager::stageHint() const

135{

136 return MainStage;

137}

138

139ApplicationManager::FormFactorHint ApplicationManager::formFactorHint() const

140{

141 return PhoneFormFactor;

142}

143

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

145 const QStringList &arguments)

146{

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

148}

149

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

151 ExecFlags flags,

152 const QStringList &arguments)

153{

154 Q_UNUSED(arguments)

155 ApplicationInfo *application = 0;

156

157 for (ApplicationInfo *availableApp : m_availableApplications) {

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

159 application = availableApp;

160 break;

161 }

162 }

163

164 if (!application)

165 return 0;

166

167 add(application);

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

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

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

171 }

172

173 focusApplication(application->appId());

174 Q_EMIT focusedApplicationIdChanged();

175 return application;

176}

177

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

179{

180 ApplicationInfo *application = findApplication(appId);

181 if (application == nullptr)

182 return false;

183

184 remove(application);

185 Q_EMIT focusedApplicationIdChanged();

186 return true;

187}

188

189QString ApplicationManager::focusedApplicationId() const {

190 for (ApplicationInfo *app : m_runningApplications) {

191 if (app->focused()) {

192 return app->appId();

193 }

194 }

195 return QString();

196}

197

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

199{

200 ApplicationInfo *application = findApplication(appId);

201 if (application == nullptr)

202 return false;

203

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

205 // unfocus currently focused mainstage app

206 for (ApplicationInfo *app : m_runningApplications) {

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

208 app->setFocused(false);

209 }

210

211 // focus this app

212 application->setFocused(true);

213 if (!m_mainStage)

214 createMainStage();

215 application->showWindow(m_mainStage);

216 m_mainStage->setZ(-1000);

217 if (m_sideStage)

218 m_sideStage->setZ(-2000);

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

220 // unfocus currently focused sidestage app

221 for (ApplicationInfo *app : m_runningApplications) {

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

223 app->setFocused(false);

224 }

225

226 // focus this app

227 application->setFocused(true);

228 if (!m_sideStage)

229 createSideStage();

230 application->showWindow(m_sideStage);

231 m_sideStage->setZ(-1000);

232 if (m_mainStage)

233 m_mainStage->setZ(-2000);

234 }

235

236 // move app to top of stack

237 move(m_runningApplications.indexOf(application), 0);

238 Q_EMIT focusedApplicationIdChanged();

239 return true;

240}

241

242void ApplicationManager::unfocusCurrentApplication()

243{

244 for (ApplicationInfo *app : m_runningApplications) {

245 if (app->focused()) {

246 app->hideWindow();

247 app->setFocused(false);

248 }

249 }

250 Q_EMIT focusedApplicationIdChanged();

251}

252

253void ApplicationManager::generateQmlStrings(ApplicationInfo *application)

254{

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

256 // application height?

257 QString topMargin;

258 if (application->fullscreen()) {

259 topMargin.append("0");

260 } else {

261 // Taken from Panel.panelHeight

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

263 }

264

265 QString windowQml = QString(

266 "import QtQuick 2.0\n"

267 "Image {\n"

268 " anchors.fill: parent\n"

269 " anchors.topMargin: %1\n"

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

271 " smooth: true\n"

272 " fillMode: Image.PreserveAspectCrop\n"

273 "}").arg(topMargin)

274 .arg(shellAppDirectory())

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

276 application->setWindowQml(windowQml);

277

278 QString imageQml = QString(

279 "import QtQuick 2.0\n"

280 "Image {\n"

281 " anchors.fill: parent\n"

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

283 " smooth: true\n"

284 " fillMode: Image.PreserveAspectCrop\n"

285 "}").arg(shellAppDirectory())

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

287 application->setImageQml(imageQml);

288}

289

290void ApplicationManager::buildListOfAvailableApplications()

291{

292 ApplicationInfo *application;

293

294 application = new ApplicationInfo(this);

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

296 application->setName("Phone");

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

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

299 generateQmlStrings(application);

300 m_availableApplications.append(application);

301

302 application = new ApplicationInfo(this);

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

304 application->setName("Camera");

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

306 application->setFullscreen(true);

307 generateQmlStrings(application);

308 m_availableApplications.append(application);

309

310 application = new ApplicationInfo(this);

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

312 application->setName("Gallery");

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

314 generateQmlStrings(application);

315 m_availableApplications.append(application);

316

317 application = new ApplicationInfo(this);

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

319 application->setName("Facebook");

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

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

322 generateQmlStrings(application);

323 m_availableApplications.append(application);

324

325 application = new ApplicationInfo(this);

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

327 application->setName("Browser");

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

329 generateQmlStrings(application);

330 m_availableApplications.append(application);

331

332 application = new ApplicationInfo(this);

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

334 application->setName("Twitter");

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

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

337 generateQmlStrings(application);

338 m_availableApplications.append(application);

339

340 application = new ApplicationInfo(this);

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

342 application->setName("GMail");

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

344 m_availableApplications.append(application);

345

346 application = new ApplicationInfo(this);

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

348 application->setName("Weather");

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

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

351 generateQmlStrings(application);

352 m_availableApplications.append(application);

353

354 application = new ApplicationInfo(this);

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

356 application->setName("Notepad");

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

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

359 m_availableApplications.append(application);

360

361 application = new ApplicationInfo(this);

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

363 application->setName("Calendar");

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

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

366 m_availableApplications.append(application);

367

368 application = new ApplicationInfo(this);

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

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

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

372 application->setFullscreen(true);

373 m_availableApplications.append(application);

374

375 application = new ApplicationInfo(this);

376 application->setAppId("evernote");

377 application->setName("Evernote");

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

379 m_availableApplications.append(application);

380

381 application = new ApplicationInfo(this);

382 application->setAppId("map");

383 application->setName("Map");

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

385 generateQmlStrings(application);

386 m_availableApplications.append(application);

387

388 application = new ApplicationInfo(this);

389 application->setAppId("pinterest");

390 application->setName("Pinterest");

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

392 m_availableApplications.append(application);

393

394 application = new ApplicationInfo(this);

395 application->setAppId("soundcloud");

396 application->setName("SoundCloud");

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

398 m_availableApplications.append(application);

399

400 application = new ApplicationInfo(this);

401 application->setAppId("wikipedia");

402 application->setName("Wikipedia");

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

404 m_availableApplications.append(application);

405

406 application = new ApplicationInfo(this);

407 application->setAppId("youtube");

408 application->setName("YouTube");

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

410 m_availableApplications.append(application);

411}

412

413void ApplicationManager::createMainStageComponent()

414{

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

416 QQuickView *quickView =

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

418

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

420

421 m_mainStageComponent = new QQmlComponent(engine, this);

422 QString mainStageQml =

423 "import QtQuick 2.0\n"

424 "Rectangle {\n"

425 " anchors.fill: parent\n"

426 " color: 'black'\n"

427 " z: -2000\n"

428 "}\n";

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

430}

431

432void ApplicationManager::createMainStage()

433{

434 if (!m_mainStageComponent)

435 createMainStageComponent();

436

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

438 QQuickView *quickView =

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

440

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

442

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

444 m_mainStage->setParentItem(shell);

445}

446

447void ApplicationManager::createSideStageComponent()

448{

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

450 QQuickView *quickView =

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

452

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

454

455 m_sideStageComponent = new QQmlComponent(engine, this);

456 QString sideStageQml =

457 "import QtQuick 2.0\n"

458 "import Ubuntu.Components 0.1\n"

459 "Item {\n"

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

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

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

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

464 " z: -1000\n"

465 "}\n";

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

467}

468

469void ApplicationManager::createSideStage()

470{

471 if (!m_sideStageComponent)

472 createSideStageComponent();

473

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

475 QQuickView *quickView =

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

477

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

479

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

481 m_sideStage->setParentItem(shell);

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

483}