@@ -24,8 +24,20 @@
2424#include <QDir>
2525#include <QDBusArgument>
2626#include <QFileInfo>
27+#include <QGSettings>
2728#include <QDebug>
2829
30+class LauncherBackendItem
31+{
32+public:
33+ LauncherBackendItem(): pinned(false) {}
34+
35+ QString desktopFile;
36+ QString displayName;
37+ QString icon;
38+ bool pinned;
39+};
40+
2941LauncherBackend::LauncherBackend(bool useStorage, QObject *parent):
3042 QObject(parent),
3143 m_accounts(nullptr)
@@ -33,95 +45,122 @@ LauncherBackend::LauncherBackend(bool useStorage, QObject *parent):
3345 if (useStorage) {
3446 m_accounts = new AccountsService(this);
3547 }
36− setUser(qgetenv("USER"));
48+ m_user = qgetenv("USER");
49+ syncFromAccounts();
3750}
3851
3952LauncherBackend::~LauncherBackend()
4053{
41− clearItems();
42−}
54+ m_storedApps.clear();
4355
44−void LauncherBackend::clearItems()
45−{
46− for (LauncherBackendItem &app: m_storedApps) {
47− delete app.settings;
56+ Q_FOREACH(LauncherBackendItem *item, m_itemCache) {
57+ delete item;
4858 }
49− m_storedApps.clear();
59+ m_itemCache.clear();
5060}
5161
5262QStringList LauncherBackend::storedApplications() const
5363{
54− auto files = QStringList();
55− for (const LauncherBackendItem &app: m_storedApps) {
56− files << app.settings->fileName();
57− }
58− return files;
64+ return m_storedApps;
5965}
6066
6167void LauncherBackend::setStoredApplications(const QStringList &appIds)
6268{
63− // Record all existing pinned apps, so we can notice them in new list
64− auto pinnedItems = QStringList();
65− for (LauncherBackendItem &app: m_storedApps) {
66− if (app.pinned) {
67− pinnedItems.append(app.settings->fileName());
69+ if (appIds.count() < m_storedApps.count()) {
70+ Q_FOREACH(const QString &appId, m_storedApps) {
71+ if (!appIds.contains(appId)) {
72+ delete m_itemCache.take(appId);
73+ }
6874 }
6975 }
70−
71− clearItems();
72−
73− for (const QString &appId: appIds) {
74− loadApp(makeAppDetails(appId, pinnedItems.contains(desktopFile(appId))));
76+ m_storedApps = appIds;
77+ Q_FOREACH(const QString &appId, appIds) {
78+ if (!m_itemCache.contains(appId)) {
79+ QString df = findDesktopFile(appId);
80+ if (!df.isEmpty()) {
81+ LauncherBackendItem *item = parseDesktopFile(df);
82+ m_itemCache.insert(appId, item);
83+ } else {
84+ // Cannot find any data for that app... ignoring it.
85+ qDebug() << "cannot find desktop file for" << appId << ". discarding app";
86+ m_storedApps.removeAll(appId);
87+ }
88+ }
7589 }
76−
7790 syncToAccounts();
7891}
7992
8093QString LauncherBackend::desktopFile(const QString &appId) const
8194{
82− QFileInfo fileInfo(QDir("/usr/share/applications"), appId);
83− return fileInfo.absoluteFilePath();
95+ LauncherBackendItem *item = m_itemCache.value(appId);
96+ if (item) {
97+ return item->desktopFile;
98+ }
99+
100+ return findDesktopFile(appId);
84101}
85102
86103QString LauncherBackend::displayName(const QString &appId) const
87104{
88− auto desktopFile = parseDesktopFile(appId);
89− auto displayName = desktopFile->value("Desktop Entry/Name").toString();
90− delete desktopFile;
91− return displayName;
105+ LauncherBackendItem *item = m_itemCache.value(appId);
106+ if (item) {
107+ return item->displayName;
108+ }
109+
110+ QString df = findDesktopFile(appId);
111+ if (!df.isEmpty()) {
112+ LauncherBackendItem *item = parseDesktopFile(df);
113+ m_itemCache.insert(appId, item);
114+ return item->displayName;
115+ }
116+
117+ return QString();
92118}
93119
94120QString LauncherBackend::icon(const QString &appId) const
95121{
96− auto desktopFile = parseDesktopFile(appId);
97− auto iconName = desktopFile->value("Desktop Entry/Icon").toString();
98− delete desktopFile;
99−
100− if (!iconName.isEmpty()) {
101− QFileInfo iconFileInfo(iconName);
102− if (iconFileInfo.isRelative()) {
103− iconName = "image://gicon/" + iconName;
122+ QString iconName;
123+ LauncherBackendItem *item = m_itemCache.value(appId);
124+ if (item) {
125+ iconName = item->icon;
126+ } else {
127+ QString df = findDesktopFile(appId);
128+ if (!df.isEmpty()) {
129+ LauncherBackendItem *item = parseDesktopFile(df);
130+ m_itemCache.insert(appId, item);
131+ iconName = item->icon;
104132 }
105133 }
106134
107− return iconName;
135+ QFileInfo info(iconName);
136+ if (info.exists()) {
137+ return info.absoluteFilePath();
138+ }
139+ return "image://theme/" + iconName;
108140}
109141
110142bool LauncherBackend::isPinned(const QString &appId) const
111143{
112− auto index = findItem(appId);
113− if (index < 0) {
114− return false;
115− } else {
116− return m_storedApps[index].pinned;
144+ LauncherBackendItem *item = m_itemCache.value(appId);
145+ if (item) {
146+ return item->pinned;
117147 }
148+ return false;
118149}
119150
120151void LauncherBackend::setPinned(const QString &appId, bool pinned)
121152{
122− auto index = findItem(appId);
123− if (index >= 0 && !m_storedApps[index].pinned) {
124− m_storedApps[index].pinned = pinned;
153+ if (!m_storedApps.contains(appId)) {
154+ return;
155+ }
156+
157+ LauncherBackendItem *item = m_itemCache.value(appId);
158+ if (!item) {
159+ item = new LauncherBackendItem();
160+ m_itemCache.insert(appId, item);
161+ }
162+ if (item->pinned != pinned) {
163+ item->pinned = pinned;
125164 syncToAccounts();
126165 }
127166}
@@ -154,8 +193,10 @@ int LauncherBackend::count(const QString &appId) const
154193
155194void LauncherBackend::setUser(const QString &username)
156195{
157− m_user = username;
158− syncFromAccounts();
196+ if (qgetenv("USER") == "lightdm" && m_user != username) {
197+ m_user = username;
198+ syncFromAccounts();
199+ }
159200}
160201
161202void LauncherBackend::triggerQuickListAction(const QString &appId, const QString &quickListId)
@@ -170,76 +211,127 @@ void LauncherBackend::syncFromAccounts()
170211 QList<QVariantMap> apps;
171212 bool defaults = true;
172213
173− clearItems();
214+ m_storedApps.clear();
215+
216+ qDebug() << "syncing from accounts" << m_accounts << m_user;
174217
175− if (m_user != "" && m_accounts != nullptr) {
176− auto variant = m_accounts->getUserProperty(m_user, "launcher-items");
218+ if (m_accounts && !m_user.isEmpty()) {
219+ QVariant variant = m_accounts->getUserProperty(m_user, "launcher-items");
177220 apps = qdbus_cast<QList<QVariantMap>>(variant.value<QDBusArgument>());
178221 defaults = isDefaultsItem(apps);
179222 }
180223
181− // TODO: load default pinned ones from default config, instead of hardcoding here...
182− if (defaults) {
183− qDebug() << "loading default applications for launcher";
184− apps <<
185− makeAppDetails("dialer-app.desktop", true) <<
186− makeAppDetails("messaging-app.desktop", true) <<
187− makeAppDetails("address-book-app.desktop", true) <<
188− makeAppDetails("camera-app.desktop", true) <<
189− makeAppDetails("gallery-app.desktop", true) <<
190− makeAppDetails("facebook-webapp.desktop", true) <<
191− makeAppDetails("webbrowser-app.desktop", true) <<
192− makeAppDetails("twitter-webapp.desktop", true) <<
193− makeAppDetails("gmail-webapp.desktop", true) <<
194− makeAppDetails("ubuntu-weather-app.desktop", true) <<
195− makeAppDetails("notes-app.desktop", true) <<
196− makeAppDetails("calendar-app.desktop", true);
197− }
198−
199− for (const QVariant &app: apps) {
200− loadApp(app.toMap());
224+ qDebug() << "--------------------- should load defaults?" << defaults;
225+
226+ if (m_accounts && defaults) { // Checking accounts as it'll be null when !useStorage
227+ QGSettings gSettings("com.canonical.Unity.Launcher", "/com/canonical/unity/launcher/");
228+ Q_FOREACH(const QString &entry, gSettings.get("favorites").toStringList()) {
229+ if (entry.startsWith("application://")) {
230+ QString appId = entry;
231+ appId.remove("application://");
232+ QString df = findDesktopFile(appId);
233+
234+ if (!df.isEmpty()) {
235+ m_storedApps << appId;
236+
237+ if (!m_itemCache.contains(appId)) {
238+ m_itemCache.insert(appId, parseDesktopFile(df));
239+ }
240+ m_itemCache.value(appId)->pinned = true;
241+ }
242+ }
243+ }
244+ } else {
245+ for (const QVariant &app: apps) {
246+ qDebug() << "should load app" << app;
247+ loadFromVariant(app.toMap());
248+ }
201249 }
202250}
203251
204252void LauncherBackend::syncToAccounts()
205253{
206− if (m_user != "" && m_accounts != nullptr) {
254+ qDebug() << "syncing to accounts" << m_accounts << m_user << m_storedApps;
255+ if (m_accounts && !m_user.isEmpty()) {
207256 QList<QVariantMap> items;
208257
209− for (LauncherBackendItem &app: m_storedApps) {
210− items << makeAppDetails(app.settings->fileName(), app.pinned);
258+ Q_FOREACH(const QString &appId, m_storedApps) {
259+ qDebug() << "appending item" << appId;
260+ items << itemToVariant(appId);
211261 }
212262
263+ qDebug() << "syncing apps" << items;
213264 m_accounts->setUserProperty(m_user, "launcher-items", QVariant::fromValue(items));
214265 }
266+ qDebug() << "done synving";
215267}
216268
217−QSettings *LauncherBackend::parseDesktopFile(const QString &appId) const
269+QString LauncherBackend::findDesktopFile(const QString &appId) const
218270{
219− auto fullAppId = desktopFile(appId);
220− return new QSettings(fullAppId, QSettings::IniFormat);
271+ int dashPos = -1;
272+ QString helper = appId;
273+
274+ do {
275+ if (dashPos != -1) {
276+ helper = helper.replace(dashPos, 1, '/');
277+ }
278+
279+ QFileInfo fileInfo(QDir("/usr/share/applications"), helper);
280+ if (fileInfo.exists()) {
281+ return fileInfo.absoluteFilePath();
282+ }
283+
284+ dashPos = helper.indexOf("-");
285+ } while (dashPos != -1);
286+
287+ return QString();
221288}
222289
223−void LauncherBackend::loadApp(const QVariantMap &details)
290+LauncherBackendItem* LauncherBackend::parseDesktopFile(const QString &desktopFile) const
224291{
225− auto appId = details.value("id").toString();
226− auto isPinned = details.value("is-pinned").toBool();
292+ QSettings settings(desktopFile, QSettings::IniFormat);
293+
227294
228− if (appId.isEmpty()) {
295+ LauncherBackendItem* item = new LauncherBackendItem();
296+ item->desktopFile = desktopFile;
297+ item->displayName = settings.value("Desktop Entry/Name").toString();
298+ item->icon = settings.value("Desktop Entry/Icon").toString();
299+ item->pinned = false;
300+ return item;
301+}
302+
303+void LauncherBackend::loadFromVariant(const QVariantMap &details)
304+{
305+ if (!details.contains("id")) {
229306 return;
230307 }
308+ QString appId = details.value("id").toString();
309+
310+ LauncherBackendItem *item = m_itemCache.value(appId);
311+ if (item) {
312+ delete item;
313+ }
314+
315+ item = new LauncherBackendItem();
316+
317+ item->desktopFile = details.value("desktopFile").toString();
318+ item->displayName = details.value("name").toString();
319+ item->icon = details.value("icon").toString();
320+ item->pinned = details.value("is-pinned").toBool();
231321
232− LauncherBackendItem item;
233− item.settings = parseDesktopFile(appId);
234− item.pinned = isPinned;
235− m_storedApps.append(item);
322+ m_itemCache.insert(appId, item);
323+ m_storedApps.append(appId);
236324}
237325
238−QVariantMap LauncherBackend::makeAppDetails(const QString &appId, bool pinned) const
326+QVariantMap LauncherBackend::itemToVariant(const QString &appId) const
239327{
328+ LauncherBackendItem *item = m_itemCache.value(appId);
240329 QVariantMap details;
241330 details.insert("id", appId);
242− details.insert("is-pinned", pinned);
331+ details.insert("name", item->displayName);
332+ details.insert("icon", item->icon);
333+ details.insert("desktopFile", item->desktopFile);
334+ details.insert("is-pinned", item->pinned);
243335 return details;
244336}
245337
@@ -248,16 +340,6 @@ bool LauncherBackend::isDefaultsItem(const QList<QVariantMap> &apps) const
248340 // To differentiate between an empty list and a list that hasn't been set
249341 // yet (and should thus be populated with the defaults), we use a special
250342 // list of one item with the 'defaults' field set to true.
343+ qDebug() << "checking isDefaults" << apps;
251344 return (apps.size() == 1 && apps[0].value("defaults").toBool());
252345}
253−
254−int LauncherBackend::findItem(const QString &appId) const
255−{
256− auto fullAppId = desktopFile(appId);
257− for (int i = 0; i < m_storedApps.size(); ++i) {
258− if (m_storedApps[i].settings->fileName() == fullAppId) {
259− return i;
260− }
261− }
262− return -1;
263−}