plugins/Unity/Launcher/launchermodel.cpp · unity8

git.iko.soy/unity8

on 3df8bbc help sign in

unity8/plugins/Unity/Launcher/launchermodel.cpp

545 lines 18 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 Lesser 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 Lesser General Public License for more details.

12 *

13 * You should have received a copy of the GNU Lesser General Public License

14 * along with this program. If not, see <http://www.gnu.org/licenses/>.

15 *

16 * Authors:

17 * Michael Zanetti <michael.zanetti@canonical.com>

18 */

20#include "launchermodel.h"

21#include "launcheritem.h"

22#include "gsettings.h"

23#include "desktopfilehandler.h"

24#include "dbusinterface.h"

25#include "asadapter.h"

27#include <unity/shell/application/ApplicationInfoInterface.h>

29#include <QDesktopServices>

30#include <QDebug>

32using namespace unity::shell::application;

34LauncherModel::LauncherModel(QObject *parent):

35 LauncherModelInterface(parent),

36 m_settings(new GSettings(this)),

37 m_dbusIface(new DBusInterface(this)),

38 m_asAdapter(new ASAdapter()),

39 m_appManager(0)

40{

41 connect(m_dbusIface, &DBusInterface::countChanged, this, &LauncherModel::countChanged);

42 connect(m_dbusIface, &DBusInterface::countVisibleChanged, this, &LauncherModel::countVisibleChanged);

43 connect(m_dbusIface, &DBusInterface::refreshCalled, this, &LauncherModel::refresh);

45 connect(m_settings, &GSettings::changed, this, &LauncherModel::refresh);

47 refresh();

48}

50LauncherModel::~LauncherModel()

51{

52 while (!m_list.empty()) {

53 m_list.takeFirst()->deleteLater();

54 }

56 delete m_asAdapter;

57}

59int LauncherModel::rowCount(const QModelIndex &parent) const

60{

61 Q_UNUSED(parent)

62 return m_list.count();

63}

65QVariant LauncherModel::data(const QModelIndex &index, int role) const

66{

67 LauncherItem *item = m_list.at(index.row());

68 switch(role) {

69 case RoleAppId:

70 return item->appId();

71 case RoleName:

72 return item->name();

73 case RoleIcon:

74 return item->icon();

75 case RolePinned:

76 return item->pinned();

77 case RoleCount:

78 return item->count();

79 case RoleCountVisible:

80 return item->countVisible();

81 case RoleProgress:

82 return item->progress();

83 case RoleFocused:

84 return item->focused();

85 case RoleAlerting:

86 return item->alerting();

87 }

89 return QVariant();

90}

92void LauncherModel::setAlerting(const QString &appId, bool alerting) {

93 int index = findApplication(appId);

94 if (index >= 0) {

95 QModelIndex modelIndex = this->index(index);

96 LauncherItem *item = m_list.at(index);

97 if (!item->focused()) {

98 item->setAlerting(alerting);

99 Q_EMIT dataChanged(modelIndex, modelIndex, QVector<int>() << RoleAlerting);

100 }

101 }

102}

103

104unity::shell::launcher::LauncherItemInterface *LauncherModel::get(int index) const

105{

106 if (index < 0 || index >= m_list.count()) {

107 return 0;

108 }

109 return m_list.at(index);

110}

111

112void LauncherModel::move(int oldIndex, int newIndex)

113{

114 // Make sure its not moved outside the lists

115 if (newIndex < 0) {

116 newIndex = 0;

117 }

118 if (newIndex >= m_list.count()) {

119 newIndex = m_list.count()-1;

120 }

121

122 // Nothing to do?

123 if (oldIndex == newIndex) {

124 return;

125 }

126

127 // QList's and QAbstractItemModel's move implementation differ when moving an item up the list :/

128 // While QList needs the index in the resulting list, beginMoveRows expects it to be in the current list

129 // adjust the model's index by +1 in case we're moving upwards

130 int newModelIndex = newIndex > oldIndex ? newIndex+1 : newIndex;

131

132 beginMoveRows(QModelIndex(), oldIndex, oldIndex, QModelIndex(), newModelIndex);

133 m_list.move(oldIndex, newIndex);

134 endMoveRows();

135

136 if (!m_list.at(newIndex)->pinned()) {

137 pin(m_list.at(newIndex)->appId());

138 } else {

139 storeAppList();

140 }

141}

142

143void LauncherModel::pin(const QString &appId, int index)

144{

145 int currentIndex = findApplication(appId);

146

147 if (currentIndex >= 0) {

148 if (index == -1 || index == currentIndex) {

149 m_list.at(currentIndex)->setPinned(true);

150 QModelIndex modelIndex = this->index(currentIndex);

151 Q_EMIT dataChanged(modelIndex, modelIndex, QVector<int>() << RolePinned);

152 } else {

153 move(currentIndex, index);

154 // move() will store the list to the backend itself, so just exit at this point.

155 return;

156 }

157 } else {

158 if (index == -1) {

159 index = m_list.count();

160 }

161

162 DesktopFileHandler desktopFile(appId);

163 if (!desktopFile.isValid()) {

164 qWarning() << "Can't pin this application, there is no .destkop file available.";

165 return;

166 }

167

168 beginInsertRows(QModelIndex(), index, index);

169 LauncherItem *item = new LauncherItem(appId,

170 desktopFile.displayName(),

171 desktopFile.icon(),

172 this);

173 item->setPinned(true);

174 m_list.insert(index, item);

175 endInsertRows();

176 }

177

178 storeAppList();

179}

180

181void LauncherModel::requestRemove(const QString &appId)

182{

183 unpin(appId);

184 storeAppList();

185}

186

187void LauncherModel::quickListActionInvoked(const QString &appId, int actionIndex)

188{

189 int index = findApplication(appId);

190 if (index < 0) {

191 return;

192 }

193

194 LauncherItem *item = m_list.at(index);

195 QuickListModel *model = qobject_cast<QuickListModel*>(item->quickList());

196 if (model) {

197 QString actionId = model->get(actionIndex).actionId();

198

199 // Check if this is one of the launcher actions we handle ourselves

200 if (actionId == "pin_item") {

201 if (item->pinned()) {

202 requestRemove(appId);

203 } else {

204 pin(appId);

205 }

206 } else if (actionId == "launch_item") {

207 QDesktopServices::openUrl(getUrlForAppId(appId));

208

209 // Nope, we don't know this action, let the backend forward it to the application

210 } else {

211 // TODO: forward quicklist action to app, possibly via m_dbusIface

212 }

213 }

214}

215

216void LauncherModel::setUser(const QString &username)

217{

218 Q_UNUSED(username)

219 qWarning() << "This backend doesn't support multiple users";

220}

221

222QString LauncherModel::getUrlForAppId(const QString &appId) const

223{

224 // appId is either an appId or a legacy app name. Let's find out which

225 if (appId.isEmpty()) {

226 return QString();

227 }

228

229 if (!appId.contains("_")) {

230 return "application:///" + appId + ".desktop";

231 }

232

233 QStringList parts = appId.split('_');

234 QString package = parts.value(0);

235 QString app = parts.value(1, "first-listed-app");

236 return "appid://" + package + "/" + app + "/current-user-version";

237}

238

239ApplicationManagerInterface *LauncherModel::applicationManager() const

240{

241 return m_appManager;

242}

243

244void LauncherModel::setApplicationManager(unity::shell::application::ApplicationManagerInterface *appManager)

245{

246 // Is there already another appmanager set?

247 if (m_appManager) {

248 // Disconnect any signals

249 disconnect(this, SLOT(applicationAdded(QModelIndex,int)));

250 disconnect(this, SLOT(applicationRemoved(QModelIndex,int)));

251 disconnect(this, SLOT(focusedAppIdChanged()));

252

253 // remove any recent/running apps from the launcher

254 QList<int> recentAppIndices;

255 for (int i = 0; i < m_list.count(); ++i) {

256 if (m_list.at(i)->recent()) {

257 recentAppIndices << i;

258 }

259 }

260 int run = 0;

261 while (recentAppIndices.count() > 0) {

262 beginRemoveRows(QModelIndex(), recentAppIndices.first() - run, recentAppIndices.first() - run);

263 m_list.takeAt(recentAppIndices.first() - run)->deleteLater();

264 endRemoveRows();

265 recentAppIndices.takeFirst();

266 ++run;

267 }

268 }

269

270 m_appManager = appManager;

271 connect(m_appManager, SIGNAL(rowsInserted(QModelIndex, int, int)), SLOT(applicationAdded(QModelIndex,int)));

272 connect(m_appManager, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)), SLOT(applicationRemoved(QModelIndex,int)));

273 connect(m_appManager, SIGNAL(focusedApplicationIdChanged()), SLOT(focusedAppIdChanged()));

274

275 Q_EMIT applicationManagerChanged();

276

277 for (int i = 0; i < appManager->count(); ++i) {

278 applicationAdded(QModelIndex(), i);

279 }

280}

281

282bool LauncherModel::onlyPinned() const

283{

284 return false;

285}

286

287void LauncherModel::setOnlyPinned(bool onlyPinned) {

288 Q_UNUSED(onlyPinned);

289 qWarning() << "This launcher implementation does not support showing only pinned apps";

290}

291

292void LauncherModel::storeAppList()

293{

294 QStringList appIds;

295 Q_FOREACH(LauncherItem *item, m_list) {

296 if (item->pinned()) {

297 appIds << item->appId();

298 }

299 }

300 m_settings->setStoredApplications(appIds);

301 m_asAdapter->syncItems(m_list);

302}

303

304void LauncherModel::unpin(const QString &appId)

305{

306 int index = findApplication(appId);

307 if (index < 0) {

308 return;

309 }

310

311 if (m_appManager->findApplication(appId)) {

312 if (m_list.at(index)->pinned()) {

313 m_list.at(index)->setPinned(false);

314 QModelIndex modelIndex = this->index(index);

315 Q_EMIT dataChanged(modelIndex, modelIndex, QVector<int>() << RolePinned);

316 }

317 } else {

318 beginRemoveRows(QModelIndex(), index, index);

319 m_list.takeAt(index)->deleteLater();

320 endRemoveRows();

321 }

322}

323

324int LauncherModel::findApplication(const QString &appId)

325{

326 for (int i = 0; i < m_list.count(); ++i) {

327 LauncherItem *item = m_list.at(i);

328 if (item->appId() == appId) {

329 return i;

330 }

331 }

332 return -1;

333}

334

335void LauncherModel::progressChanged(const QString &appId, int progress)

336{

337 int idx = findApplication(appId);

338 if (idx >= 0) {

339 LauncherItem *item = m_list.at(idx);

340 item->setProgress(progress);

341 Q_EMIT dataChanged(index(idx), index(idx), QVector<int>() << RoleProgress);

342 }

343}

344

345void LauncherModel::countChanged(const QString &appId, int count)

346{

347 int idx = findApplication(appId);

348 if (idx >= 0) {

349 LauncherItem *item = m_list.at(idx);

350 item->setCount(count);

351 if (item->countVisible()) {

352 setAlerting(item->appId(), true);

353 }

354 Q_EMIT dataChanged(index(idx), index(idx), QVector<int>() << RoleCount);

355 m_asAdapter->syncItems(m_list);

356 }

357}

358

359void LauncherModel::countVisibleChanged(const QString &appId, int countVisible)

360{

361 int idx = findApplication(appId);

362 if (idx >= 0) {

363 LauncherItem *item = m_list.at(idx);

364 item->setCountVisible(countVisible);

365 if (countVisible) {

366 setAlerting(item->appId(), true);

367 }

368 Q_EMIT dataChanged(index(idx), index(idx), QVector<int>() << RoleCountVisible);

369

370 // If countVisible goes to false, and the item is neither pinned nor recent we can drop it

371 if (!countVisible && !item->pinned() && !item->recent()) {

372 beginRemoveRows(QModelIndex(), idx, idx);

373 m_list.takeAt(idx)->deleteLater();

374 endRemoveRows();

375 }

376 } else {

377 // Need to create a new LauncherItem and show the highlight

378 DesktopFileHandler desktopFile(appId);

379 if (countVisible && desktopFile.isValid()) {

380 LauncherItem *item = new LauncherItem(appId,

381 desktopFile.displayName(),

382 desktopFile.icon());

383 item->setCountVisible(true);

384 beginInsertRows(QModelIndex(), m_list.count(), m_list.count());

385 m_list.append(item);

386 endInsertRows();

387 Q_EMIT hint();

388 }

389 }

390 m_asAdapter->syncItems(m_list);

391}

392

393void LauncherModel::refresh()

394{

395 // First walk through all the existing items and see if we need to remove something

396 QList<LauncherItem*> toBeRemoved;

397 Q_FOREACH (LauncherItem* item, m_list) {

398 DesktopFileHandler desktopFile(item->appId());

399 if (!desktopFile.isValid()) {

400 // Desktop file not available for this app => drop it!

401 toBeRemoved << item;

402 } else if (!m_settings->storedApplications().contains(item->appId())) {

403 // Item not in settings any more => drop it!

404 toBeRemoved << item;

405 } else {

406 int idx = m_list.indexOf(item);

407 item->setName(desktopFile.displayName());

408 item->setIcon(desktopFile.icon());

409 item->setPinned(item->pinned()); // update pinned text if needed

410 Q_EMIT dataChanged(index(idx), index(idx), QVector<int>() << RoleName << RoleIcon);

411 }

412 }

413

414 Q_FOREACH (LauncherItem* item, toBeRemoved) {

415 unpin(item->appId());

416 }

417

418 bool changed = toBeRemoved.count() > 0;

419

420 // This brings the Launcher into sync with the settings backend again. There's an issue though:

421 // If we can't find a .desktop file for an entry we need to skip it. That makes our settingsIndex

422 // go out of sync with the actual index of items. So let's also use an addedIndex which reflects

423 // the settingsIndex minus the skipped items.

424 int addedIndex = 0;

425

426 // Now walk through settings and see if we need to add something

427 for (int settingsIndex = 0; settingsIndex < m_settings->storedApplications().count(); ++settingsIndex) {

428 QString entry = m_settings->storedApplications().at(settingsIndex);

429 int itemIndex = -1;

430 for (int i = 0; i < m_list.count(); ++i) {

431 if (m_list.at(i)->appId() == entry) {

432 itemIndex = i;

433 break;

434 }

435 }

436

437 if (itemIndex == -1) {

438 // Need to add it. Just add it into the addedIndex to keep same ordering as the list

439 // in the settings.

440 DesktopFileHandler desktopFile(entry);

441 if (!desktopFile.isValid()) {

442 qWarning() << "Couldn't find a .desktop file for" << entry << ". Skipping...";

443 continue;

444 }

445

446 LauncherItem *item = new LauncherItem(entry,

447 desktopFile.displayName(),

448 desktopFile.icon(),

449 this);

450 item->setPinned(true);

451 beginInsertRows(QModelIndex(), addedIndex, addedIndex);

452 m_list.insert(addedIndex, item);

453 endInsertRows();

454 changed = true;

455 } else if (itemIndex != addedIndex) {

456 // The item is already there, but it is in a different place than in the settings.

457 // Move it to the addedIndex

458 beginMoveRows(QModelIndex(), itemIndex, itemIndex, QModelIndex(), addedIndex);

459 m_list.move(itemIndex, addedIndex);

460 endMoveRows();

461 changed = true;

462 }

463

464 // Just like settingsIndex, this will increase with every item, except the ones we

465 // skipped with the "continue" call above.

466 addedIndex++;

467 }

468

469 if (changed) {

470 Q_EMIT hint();

471 }

472

473 m_asAdapter->syncItems(m_list);

474}

475

476void LauncherModel::applicationAdded(const QModelIndex &parent, int row)

477{

478 Q_UNUSED(parent);

479

480 ApplicationInfoInterface *app = m_appManager->get(row);

481 if (!app) {

482 qWarning() << "LauncherModel received an applicationAdded signal, but there's no such application!";

483 return;

484 }

485

486 if (app->appId() == "unity8-dash") {

487 // Not adding the dash app

488 return;

489 }

490

491 int itemIndex = findApplication(app->appId());

492 if (itemIndex != -1) {

493 LauncherItem *item = m_list.at(itemIndex);

494 if (!item->recent()) {

495 item->setRecent(true);

496 m_asAdapter->syncItems(m_list);

497 Q_EMIT dataChanged(index(itemIndex), index(itemIndex), QVector<int>() << RoleRecent);

498 }

499 // Shall we paint some running/recent app highlight? If yes, do it here.

500 } else {

501 LauncherItem *item = new LauncherItem(app->appId(), app->name(), app->icon().toString(), this);

502 item->setRecent(true);

503 item->setFocused(app->focused());

504

505 beginInsertRows(QModelIndex(), m_list.count(), m_list.count());

506 m_list.append(item);

507 endInsertRows();

508 m_asAdapter->syncItems(m_list);

509 }

510}

511

512void LauncherModel::applicationRemoved(const QModelIndex &parent, int row)

513{

514 Q_UNUSED(parent)

515

516 int appIndex = -1;

517 for (int i = 0; i < m_list.count(); ++i) {

518 if (m_list.at(i)->appId() == m_appManager->get(row)->appId()) {

519 appIndex = i;

520 break;

521 }

522 }

523

524 if (appIndex > -1 && !m_list.at(appIndex)->pinned()) {

525 beginRemoveRows(QModelIndex(), appIndex, appIndex);

526 m_list.takeAt(appIndex)->deleteLater();

527 endRemoveRows();

528 m_asAdapter->syncItems(m_list);

529 }

530}

531

532void LauncherModel::focusedAppIdChanged()

533{

534 QString appId = m_appManager->focusedApplicationId();

535 for (int i = 0; i < m_list.count(); ++i) {

536 LauncherItem *item = m_list.at(i);

537 if (!item->focused() && item->appId() == appId) {

538 item->setFocused(true);

539 Q_EMIT dataChanged(index(i), index(i), QVector<int>() << RoleFocused);

540 } else if (item->focused() && item->appId() != appId) {

541 item->setFocused(false);

542 Q_EMIT dataChanged(index(i), index(i), QVector<int>() << RoleFocused);

543 }

544 }

545}