plugins/Unity/Launcher/launchermodel.cpp · unity8

git.iko.soy/unity8

on b520ab7 help sign in

unity8/plugins/Unity/Launcher/launchermodel.cpp

504 lines 16 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"

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

28#include <QDesktopServices>

29#include <QDebug>

31using namespace unity::shell::application;

33LauncherModel::LauncherModel(QObject *parent):

34 LauncherModelInterface(parent),

35 m_settings(new GSettings(this)),

36 m_dbusIface(new DBusInterface(this)),

37 m_appManager(0)

38{

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

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

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

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

45 refresh();

46}

48LauncherModel::~LauncherModel()

49{

50 while (!m_list.empty()) {

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

52 }

53}

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

56{

57 Q_UNUSED(parent)

58 return m_list.count();

59}

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

62{

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

64 switch(role) {

65 case RoleAppId:

66 return item->appId();

67 case RoleName:

68 return item->name();

69 case RoleIcon:

70 return item->icon();

71 case RolePinned:

72 return item->pinned();

73 case RoleCount:

74 return item->count();

75 case RoleCountVisible:

76 return item->countVisible();

77 case RoleProgress:

78 return item->progress();

79 case RoleFocused:

80 return item->focused();

81 }

83 return QVariant();

84}

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

87{

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

89 return 0;

90 }

91 return m_list.at(index);

92}

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

95{

96 // Make sure its not moved outside the lists

97 if (newIndex < 0) {

98 newIndex = 0;

99 }

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

101 newIndex = m_list.count()-1;

102 }

103

104 // Nothing to do?

105 if (oldIndex == newIndex) {

106 return;

107 }

108

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

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

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

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

113

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

115 m_list.move(oldIndex, newIndex);

116 endMoveRows();

117

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

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

120 } else {

121 storeAppList();

122 }

123}

124

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

126{

127 int currentIndex = findApplication(appId);

128

129 if (currentIndex >= 0) {

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

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

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

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

134 } else {

135 move(currentIndex, index);

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

137 return;

138 }

139 } else {

140 if (index == -1) {

141 index = m_list.count();

142 }

143

144 DesktopFileHandler desktopFile(appId);

145 if (!desktopFile.isValid()) {

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

147 return;

148 }

149

150 beginInsertRows(QModelIndex(), index, index);

151 LauncherItem *item = new LauncherItem(appId,

152 desktopFile.displayName(),

153 desktopFile.icon(),

154 this);

155 item->setPinned(true);

156 m_list.insert(index, item);

157 endInsertRows();

158 }

159

160 storeAppList();

161}

162

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

164{

165 unpin(appId);

166 storeAppList();

167}

168

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

170{

171 int index = findApplication(appId);

172 if (index < 0) {

173 return;

174 }

175

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

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

178 if (model) {

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

180

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

182 if (actionId == "pin_item") {

183 if (item->pinned()) {

184 requestRemove(appId);

185 } else {

186 pin(appId);

187 }

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

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

190

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

192 } else {

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

194 }

195 }

196}

197

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

199{

200 Q_UNUSED(username)

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

202}

203

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

205{

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

207 if (appId.isEmpty()) {

208 return QString();

209 }

210

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

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

213 }

214

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

216 QString package = parts.value(0);

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

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

219}

220

221ApplicationManagerInterface *LauncherModel::applicationManager() const

222{

223 return m_appManager;

224}

225

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

227{

228 // Is there already another appmanager set?

229 if (m_appManager) {

230 // Disconnect any signals

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

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

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

234

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

236 QList<int> recentAppIndices;

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

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

239 recentAppIndices << i;

240 }

241 }

242 int run = 0;

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

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

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

246 endRemoveRows();

247 recentAppIndices.takeFirst();

248 ++run;

249 }

250 }

251

252 m_appManager = appManager;

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

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

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

256

257 Q_EMIT applicationManagerChanged();

258

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

260 applicationAdded(QModelIndex(), i);

261 }

262}

263

264

265void LauncherModel::storeAppList()

266{

267 QStringList appIds;

268 Q_FOREACH(LauncherItem *item, m_list) {

269 if (item->pinned()) {

270 appIds << item->appId();

271 }

272 }

273 m_settings->setStoredApplications(appIds);

274}

275

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

277{

278 int index = findApplication(appId);

279 if (index < 0) {

280 return;

281 }

282

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

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

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

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

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

288 }

289 } else {

290 beginRemoveRows(QModelIndex(), index, index);

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

292 endRemoveRows();

293 }

294}

295

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

297{

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

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

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

301 return i;

302 }

303 }

304 return -1;

305}

306

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

308{

309 int idx = findApplication(appId);

310 if (idx >= 0) {

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

312 item->setProgress(progress);

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

314 }

315}

316

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

318{

319 int idx = findApplication(appId);

320 if (idx >= 0) {

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

322 item->setCount(count);

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

324 }

325}

326

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

328{

329 int idx = findApplication(appId);

330 if (idx >= 0) {

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

332 item->setCountVisible(countVisible);

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

334

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

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

337 beginRemoveRows(QModelIndex(), idx, idx);

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

339 endRemoveRows();

340 }

341 } else {

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

343 DesktopFileHandler desktopFile(appId);

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

345 LauncherItem *item = new LauncherItem(appId,

346 desktopFile.displayName(),

347 desktopFile.icon());

348 item->setCountVisible(true);

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

350 m_list.append(item);

351 endInsertRows();

352 Q_EMIT hint();

353 }

354 }

355}

356

357void LauncherModel::refresh()

358{

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

360 QList<LauncherItem*> toBeRemoved;

361 Q_FOREACH (LauncherItem* item, m_list) {

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

363 if (!desktopFile.isValid()) {

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

365 toBeRemoved << item;

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

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

368 toBeRemoved << item;

369 } else {

370 int idx = m_list.indexOf(item);

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

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

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

374 }

375 }

376

377 Q_FOREACH (LauncherItem* item, toBeRemoved) {

378 unpin(item->appId());

379 }

380

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

382

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

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

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

386 // the settingsIndex minus the skipped items.

387 int addedIndex = 0;

388

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

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

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

392 int itemIndex = -1;

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

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

395 itemIndex = i;

396 break;

397 }

398 }

399

400 if (itemIndex == -1) {

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

402 // in the settings.

403 DesktopFileHandler desktopFile(entry);

404 if (!desktopFile.isValid()) {

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

406 continue;

407 }

408

409 LauncherItem *item = new LauncherItem(entry,

410 desktopFile.displayName(),

411 desktopFile.icon(),

412 this);

413 item->setPinned(true);

414 beginInsertRows(QModelIndex(), addedIndex, addedIndex);

415 m_list.insert(addedIndex, item);

416 endInsertRows();

417 changed = true;

418 } else if (itemIndex != addedIndex) {

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

420 // Move it to the addedIndex

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

422 m_list.move(itemIndex, addedIndex);

423 endMoveRows();

424 changed = true;

425 }

426

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

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

429 addedIndex++;

430 }

431

432 if (changed) {

433 Q_EMIT hint();

434 }

435}

436

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

438{

439 Q_UNUSED(parent);

440

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

442 if (!app) {

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

444 return;

445 }

446

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

448 // Not adding the dash app

449 return;

450 }

451

452 bool found = false;

453 Q_FOREACH(LauncherItem *item, m_list) {

454 if (app->appId() == item->appId()) {

455 found = true;

456 break;

457 }

458 }

459 if (found) {

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

461 } else {

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

463 item->setRecent(true);

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

465

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

467 m_list.append(item);

468 endInsertRows();

469 }

470}

471

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

473{

474 Q_UNUSED(parent)

475

476 int appIndex = -1;

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

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

479 appIndex = i;

480 break;

481 }

482 }

483

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

485 beginRemoveRows(QModelIndex(), appIndex, appIndex);

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

487 endRemoveRows();

488 }

489}

490

491void LauncherModel::focusedAppIdChanged()

492{

493 QString appId = m_appManager->focusedApplicationId();

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

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

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

497 item->setFocused(true);

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

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

500 item->setFocused(false);

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

502 }

503 }

504}