@@ -24,6 +24,17 @@
2424#include <QDir>
2525#include <QDBusArgument>
2626#include <QFileInfo>
27+#include <QGSettings>
28+#include <QDebug>
29+
30+class LauncherBackendItem
31+{
32+public:
33+ QString desktopFile;
34+ QString displayName;
35+ QString icon;
36+ bool pinned;
37+};
2738
2839LauncherBackend::LauncherBackend(bool useStorage, QObject *parent):
2940 QObject(parent),
@@ -37,90 +48,106 @@ LauncherBackend::LauncherBackend(bool useStorage, QObject *parent):
3748
3849LauncherBackend::~LauncherBackend()
3950{
40− clearItems();
41−}
51+ m_storedApps.clear();
4252
43−void LauncherBackend::clearItems()
44−{
45− for (LauncherBackendItem &app: m_storedApps) {
46− delete app.settings;
53+ Q_FOREACH(LauncherBackendItem *item, m_itemCache) {
54+ delete item;
4755 }
48− m_storedApps.clear();
56+ m_itemCache.clear();
4957}
5058
5159QStringList LauncherBackend::storedApplications() const
5260{
53− auto files = QStringList();
54− for (const LauncherBackendItem &app: m_storedApps) {
55− files << app.settings->fileName();
56− }
57− return files;
61+ return m_storedApps;
5862}
5963
6064void LauncherBackend::setStoredApplications(const QStringList &appIds)
6165{
62− // Record all existing pinned apps, so we can notice them in new list
63− auto pinnedItems = QStringList();
64− for (LauncherBackendItem &app: m_storedApps) {
65− if (app.pinned) {
66− pinnedItems.append(app.settings->fileName());
66+ if (appIds.count() << m_storedApps.count()) {
67+ Q_FOREACH(const QString &appId, m_storedApps) {
68+ if (!appIds.contains(appId)) {
69+ delete m_itemCache.take(appId);
70+ }
6771 }
6872 }
69−
70− clearItems();
71−
72− for (const QString &appId: appIds) {
73− loadApp(makeAppDetails(appId, pinnedItems.contains(desktopFile(appId))));
74− }
75−
73+ m_storedApps = appIds;
7674 syncToAccounts();
7775}
7876
7977QString LauncherBackend::desktopFile(const QString &appId) const
8078{
81− QFileInfo fileInfo(QDir("/usr/share/applications"), appId);
82− return fileInfo.absoluteFilePath();
79+ if (m_itemCache.contains(appId)) {
80+ return m_itemCache.value(appId)->desktopFile;
81+ }
82+
83+ return findDesktopFile(appId);
8384}
8485
8586QString LauncherBackend::displayName(const QString &appId) const
8687{
87− auto desktopFile = parseDesktopFile(appId);
88− auto displayName = desktopFile->value("Desktop Entry/Name").toString();
89− delete desktopFile;
90− return displayName;
88+ if (m_itemCache.contains(appId)) {
89+ return m_itemCache.value(appId)->displayName;
90+ }
91+
92+ QString df = findDesktopFile(appId);
93+ if (!df.isEmpty()) {
94+ LauncherBackendItem *item = parseDesktopFile(df);
95+ m_itemCache.insert(appId, item);
96+ return item->displayName;
97+ }
98+
99+ return QString();
91100}
92101
93102QString LauncherBackend::icon(const QString &appId) const
94103{
95− auto desktopFile = parseDesktopFile(appId);
96− auto iconName = desktopFile->value("Desktop Entry/Icon").toString();
97− delete desktopFile;
98−
99− if (!iconName.isEmpty()) {
100− QFileInfo iconFileInfo(iconName);
101− if (iconFileInfo.isRelative()) {
102− iconName = "image://gicon/" + iconName;
104+ qDebug() << "searching for icon >>>>>>>>>>>>>>>>>>>>" << appId;
105+ QString iconName;
106+ if (m_itemCache.contains(appId)) {
107+ qDebug() << "found icon in cache" << m_itemCache.value(appId)->icon;
108+ iconName = m_itemCache.value(appId)->icon;
109+ } else {
110+ QString df = findDesktopFile(appId);
111+ if (!df.isEmpty()) {
112+ LauncherBackendItem *item = parseDesktopFile(df);
113+ m_itemCache.insert(appId, item);
114+ iconName = item->icon;
103115 }
104116 }
105117
106− return iconName;
118+ QFileInfo info(iconName);
119+ if (info.exists()) {
120+ return info.absoluteFilePath();
121+ }
122+ return "image://theme/" + iconName;
107123}
108124
109125bool LauncherBackend::isPinned(const QString &appId) const
110126{
111− auto index = findItem(appId);
112− if (index < 0) {
113− return false;
114− } else {
115− return m_storedApps[index].pinned;
127+ if (m_itemCache.contains(appId)) {
128+ return m_itemCache.value(appId)->pinned;
116129 }
130+
131+ QString df = findDesktopFile(appId);
132+ if (!df.isEmpty()) {
133+ LauncherBackendItem *item = parseDesktopFile(df);
134+ m_itemCache.insert(appId, item);
135+ return item->pinned;
136+ }
137+
138+ return false;
117139}
118140
119141void LauncherBackend::setPinned(const QString &appId, bool pinned)
120142{
121− auto index = findItem(appId);
122− if (index >= 0 && !m_storedApps[index].pinned) {
123− m_storedApps[index].pinned = pinned;
143+ if (!m_storedApps.contains(appId)) {
144+ qDebug() << "Cannot pin item. Unknown appId";
145+ return;
146+ }
147+
148+ LauncherBackendItem *item = m_itemCache.value(appId);
149+ if (item->pinned != pinned) {
150+ item->pinned = pinned;
124151 syncToAccounts();
125152 }
126153}
@@ -169,75 +196,125 @@ void LauncherBackend::syncFromAccounts()
169196 QList<QVariantMap> apps;
170197 bool defaults = true;
171198
172− clearItems();
199+ m_storedApps.clear();
173200
201+ qDebug() << "syncing from accounts" << m_user << m_accounts;
174202 if (m_user != "" && m_accounts != nullptr) {
175− auto variant = m_accounts->getUserProperty(m_user, "launcher-items");
203+ qDebug() << "loading from user" << m_user << m_accounts;
204+ QVariant variant = m_accounts->getUserProperty(m_user, "launcher-items");
205+ qDebug() << "loaded launcher-items" << variant;
176206 apps = qdbus_cast<QList<QVariantMap>>(variant.value<QDBusArgument>());
177207 defaults = isDefaultsItem(apps);
178208 }
179209
180− // TODO: load default pinned ones from default config, instead of hardcoding here...
181210 if (defaults) {
182− apps <<
183− makeAppDetails("dialer-app.desktop", true) <<
184− makeAppDetails("messaging-app.desktop", true) <<
185− makeAppDetails("address-book-app.desktop", true) <<
186− makeAppDetails("camera-app.desktop", true) <<
187− makeAppDetails("gallery-app.desktop", true) <<
188− makeAppDetails("facebook-webapp.desktop", true) <<
189− makeAppDetails("webbrowser-app.desktop", true) <<
190− makeAppDetails("twitter-webapp.desktop", true) <<
191− makeAppDetails("gmail-webapp.desktop", true) <<
192− makeAppDetails("ubuntu-weather-app.desktop", true) <<
193− makeAppDetails("notes-app.desktop", true) <<
194− makeAppDetails("calendar-app.desktop", true);
195− }
196−
197− for (const QVariant &app: apps) {
198− loadApp(app.toMap());
211+ QGSettings gSettings("com.canonical.Unity.Launcher", "/com/canonical/unity/launcher/");
212+ qDebug() << "Got launcher gSettings" << gSettings.get("favorites");
213+ Q_FOREACH(const QString &entry, gSettings.get("favorites").toStringList()) {
214+ if (entry.startsWith("application://")) {
215+ QString appId = entry;
216+ appId.remove("application://");
217+ qDebug() << "searching for" << entry << appId;
218+ QString df = findDesktopFile(appId);
219+ qDebug() << "desktop file path" << df;
220+
221+ if (!df.isEmpty()) {
222+ m_storedApps << appId;
223+
224+ if (!m_itemCache.contains(appId)) {
225+ m_itemCache.insert(appId, parseDesktopFile(df));
226+ }
227+ m_itemCache.value(appId)->pinned = true;
228+ }
229+ }
230+ }
231+ } else {
232+ for (const QVariant &app: apps) {
233+ loadFromVariant(app.toMap());
234+ }
199235 }
200236}
201237
202238void LauncherBackend::syncToAccounts()
203239{
204− if (m_user != "" && m_accounts != nullptr) {
240+ qDebug() << "syncing to accounts";
241+ if (m_accounts && !m_user.isEmpty()) {
205242 QList<QVariantMap> items;
206243
207− for (LauncherBackendItem &app: m_storedApps) {
208− items << makeAppDetails(app.settings->fileName(), app.pinned);
244+ Q_FOREACH(const QString &appId, m_storedApps) {
245+ items << itemToVariant(appId);
209246 }
210247
211248 m_accounts->setUserProperty(m_user, "launcher-items", QVariant::fromValue(items));
212249 }
213250}
214251
215−QSettings *LauncherBackend::parseDesktopFile(const QString &appId) const
252+QString LauncherBackend::findDesktopFile(const QString &appId) const
216253{
217− auto fullAppId = desktopFile(appId);
218− return new QSettings(fullAppId, QSettings::IniFormat);
254+ int dashPos = -1;
255+ QString helper = appId;
256+
257+ do {
258+ if (dashPos != -1) {
259+ helper = helper.replace(dashPos, 1, '/');
260+ }
261+
262+ QFileInfo fileInfo(QDir("/usr/share/applications"), helper);
263+ if (fileInfo.exists()) {
264+ return fileInfo.absoluteFilePath();
265+ }
266+
267+ dashPos = helper.indexOf("-");
268+ } while (dashPos != -1);
269+
270+ return QString();
219271}
220272
221−void LauncherBackend::loadApp(const QVariantMap &details)
273+LauncherBackendItem* LauncherBackend::parseDesktopFile(const QString &desktopFile) const
222274{
223− auto appId = details.value("id").toString();
224− auto isPinned = details.value("is-pinned").toBool();
275+ QSettings settings(desktopFile, QSettings::IniFormat);
276+
225277
226− if (appId.isEmpty()) {
278+ LauncherBackendItem* item = new LauncherBackendItem();
279+ item->desktopFile = desktopFile;
280+ item->displayName = settings.value("Desktop Entry/Name").toString();
281+ item->icon = settings.value("Desktop Entry/Icon").toString();
282+ item->pinned = false;
283+ qDebug() << "reading file" << desktopFile << settings.value("Desktop Entry/Name") << item->icon;
284+ return item;
285+}
286+
287+void LauncherBackend::loadFromVariant(const QVariantMap &details)
288+{
289+ if (!details.contains("id")) {
227290 return;
228291 }
292+ QString appId = details.value("id").toString();
293+
294+ if (m_itemCache.contains(appId)) {
295+ delete m_itemCache.value(appId);
296+ }
229297
230− LauncherBackendItem item;
231− item.settings = parseDesktopFile(appId);
232− item.pinned = isPinned;
233− m_storedApps.append(item);
298+ LauncherBackendItem *item = new LauncherBackendItem();
299+
300+ item->desktopFile = details.value("desktopFile").toString();
301+ item->displayName = details.value("name").toString();
302+ item->icon = details.value("icon").toString();
303+ item->pinned = details.value("is-pinned").toBool();
304+
305+ m_itemCache.insert(appId, item);
306+ m_storedApps.append(appId);
234307}
235308
236−QVariantMap LauncherBackend::makeAppDetails(const QString &appId, bool pinned) const
309+QVariantMap LauncherBackend::itemToVariant(const QString &appId) const
237310{
311+ LauncherBackendItem *item = m_itemCache.value(appId);
238312 QVariantMap details;
239313 details.insert("id", appId);
240− details.insert("is-pinned", pinned);
314+ details.insert("name", item->displayName);
315+ details.insert("icon", item->icon);
316+ details.insert("desktopFile", item->desktopFile);
317+ details.insert("is-pinned", item->pinned);
241318 return details;
242319}
243320
@@ -246,16 +323,11 @@ bool LauncherBackend::isDefaultsItem(const QList<QVariantMap> &apps) const
246323 // To differentiate between an empty list and a list that hasn't been set
247324 // yet (and should thus be populated with the defaults), we use a special
248325 // list of one item with the 'defaults' field set to true.
326+ qDebug() << apps.size();
327+ if (apps.size() == 1)
328+ qDebug() << apps[0].value("defaults").toBool();
329+
249330 return (apps.size() == 1 && apps[0].value("defaults").toBool());
250331}
251332
252−int LauncherBackend::findItem(const QString &appId) const
253−{
254− auto fullAppId = desktopFile(appId);
255− for (int i = 0; i < m_storedApps.size(); ++i) {
256− if (m_storedApps[i].settings->fileName() == fullAppId) {
257− return i;
258− }
259− }
260− return -1;
261−}
333+