Unity 8
 All Classes Functions
launchermodel.cpp
1 /*
2  * Copyright 2013-2014 Canonical Ltd.
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  */
19 
20 #include "launchermodel.h"
21 #include "launcheritem.h"
22 #include "gsettings.h"
23 #include "desktopfilehandler.h"
24 #include "dbusinterface.h"
25 
26 #include <unity/shell/application/ApplicationInfoInterface.h>
27 
28 #include <QDesktopServices>
29 #include <QDebug>
30 
31 using namespace unity::shell::application;
32 
33 LauncherModel::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);
42 
43  connect(m_settings, &GSettings::changed, this, &LauncherModel::refresh);
44 
45  refresh();
46 }
47 
48 LauncherModel::~LauncherModel()
49 {
50  while (!m_list.empty()) {
51  m_list.takeFirst()->deleteLater();
52  }
53 }
54 
55 int LauncherModel::rowCount(const QModelIndex &parent) const
56 {
57  Q_UNUSED(parent)
58  return m_list.count();
59 }
60 
61 QVariant 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  }
82 
83  return QVariant();
84 }
85 
86 unity::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 }
93 
94 void 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 
125 void 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 
163 void LauncherModel::requestRemove(const QString &appId)
164 {
165  unpin(appId);
166  storeAppList();
167 }
168 
169 void 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 
198 void LauncherModel::setUser(const QString &username)
199 {
200  Q_UNUSED(username)
201  qWarning() << "This backend doesn't support multiple users";
202 }
203 
204 QString 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 
221 ApplicationManagerInterface *LauncherModel::applicationManager() const
222 {
223  return m_appManager;
224 }
225 
226 void 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 
265 void 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 
276 void 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 
296 int 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 
307 void 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 
317 void 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 
327 void 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 
357 void 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 
437 void 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 
472 void 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 
491 void 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 }