787fcde · unity8 · git.iko.soy

git.iko.soy/unity8

on xenial help sign in

merge trunky

787fcdeMichael Zanetti13 years ago

Dash/DashBar.qml+2−4

compare with xenial

unifiedsplit

@@ -59,8 +59,6 @@ Item {

59 objectName: "panel"

60 anchors.fill: parent

62− locked: true // TODO: remove this when lp bug #1179569 will be fixed

63−

64 Rectangle {

62 Rectangle {

65 color: "black"

63 color: "black"

66 anchors.fill: parent

64 anchors.fill: parent

@@ -84,13 +82,13 @@ Item {

85 delegate:

83 delegate:

86 Item {

84 Item {

87− signal clicked()

85+ signal trigger()

89 width: itemSize

87 width: itemSize

90 height: dashBar.height

88 height: dashBar.height

91 anchors.top: parent.top

89 anchors.top: parent.top

93− onClicked: {

91+ onTrigger: {

94 dashBar.itemSelected(index)

92 dashBar.itemSelected(index)

95 timeout.restart()

93 timeout.restart()

96 }

94 }

debian/control+1

@@ -9,6 +9,7 @@ Build-Depends: cmake,

9 libgl1-mesa-dev[!armhf] | libgl-dev[!armhf],

10 libgl1-mesa-dri,

11 libgles2-mesa-dev[armhf],

12+ libgsettings-qt-dev,

12 libhud-client2-dev,

13 libhud-client2-dev,

13 libjson-perl,

14 libjson-perl,

14 libnih-dbus-dev,

15 libnih-dbus-dev,

plugins/Unity/Launcher/CMakeLists.txt+4

@@ -1,11 +1,13 @@

1include(FindPkgConfig)

2pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=2)

3+pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)

4add_definitions(-DSM_BUSNAME=systemBus)

5add_definitions(-DSM_BUSNAME=systemBus)

6include_directories(

7include_directories(

7 ${CMAKE_CURRENT_SOURCE_DIR}

8 ${CMAKE_CURRENT_SOURCE_DIR}

8 ${CMAKE_SOURCE_DIR}/plugins/AccountsService

9 ${CMAKE_SOURCE_DIR}/plugins/AccountsService

10+ ${GSETTINGS_QT_INCLUDE_DIRS}

11)

11set(QMLLAUNCHERPLUGIN_SRC

13set(QMLLAUNCHERPLUGIN_SRC

@@ -25,6 +27,8 @@ add_library(UnityLauncher-qml MODULE

25 ${QMLLAUNCHERPLUGIN_SRC}

27 ${QMLLAUNCHERPLUGIN_SRC}

26 )

28 )

30+target_link_libraries(UnityLauncher-qml ${GSETTINGS_QT_LDFLAGS})

31+

28qt5_use_modules(UnityLauncher-qml DBus Qml)

32qt5_use_modules(UnityLauncher-qml DBus Qml)

30# export the qmldir and qmltypes files

34# export the qmldir and qmltypes files

plugins/Unity/Launcher/backend/launcherbackend.cpp+181−99

@@ -24,8 +24,20 @@

24#include <QDir>

25#include <QDBusArgument>

26#include <QFileInfo>

27+#include <QGSettings>

27#include <QDebug>

28#include <QDebug>

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+

29LauncherBackend::LauncherBackend(bool useStorage, QObject *parent):

41LauncherBackend::LauncherBackend(bool useStorage, QObject *parent):

30 QObject(parent),

42 QObject(parent),

31 m_accounts(nullptr)

43 m_accounts(nullptr)

@@ -33,95 +45,122 @@ LauncherBackend::LauncherBackend(bool useStorage, QObject *parent):

33 if (useStorage) {

45 if (useStorage) {

34 m_accounts = new AccountsService(this);

46 m_accounts = new AccountsService(this);

35 }

47 }

36− setUser(qgetenv("USER"));

48+ m_user = qgetenv("USER");

49+ syncFromAccounts();

37}

50}

39LauncherBackend::~LauncherBackend()

52LauncherBackend::~LauncherBackend()

40{

53{

41− clearItems();

54+ m_storedApps.clear();

42−}

44−void LauncherBackend::clearItems()

45−{

46− for (LauncherBackendItem &app: m_storedApps) {

56+ Q_FOREACH(LauncherBackendItem *item, m_itemCache) {

47− delete app.settings;

57+ delete item;

48 }

58 }

49− m_storedApps.clear();

59+ m_itemCache.clear();

50}

60}

52QStringList LauncherBackend::storedApplications() const

62QStringList LauncherBackend::storedApplications() const

53{

63{

54− auto files = QStringList();

55− for (const LauncherBackendItem &app: m_storedApps) {

56− files << app.settings->fileName();

57− }

58− return files;

64+ return m_storedApps;

59}

65}

61void LauncherBackend::setStoredApplications(const QStringList &appIds)

67void LauncherBackend::setStoredApplications(const QStringList &appIds)

62{

68{

63− // Record all existing pinned apps, so we can notice them in new list

69+ if (appIds.count() < m_storedApps.count()) {

64− auto pinnedItems = QStringList();

70+ Q_FOREACH(const QString &appId, m_storedApps) {

65− for (LauncherBackendItem &app: m_storedApps) {

71+ if (!appIds.contains(appId)) {

66− if (app.pinned) {

72+ delete m_itemCache.take(appId);

67− pinnedItems.append(app.settings->fileName());

73+ }

68 }

74 }

69 }

75 }

70−

76+ m_storedApps = appIds;

71− clearItems();

72−

73− for (const QString &appId: appIds) {

77+ Q_FOREACH(const QString &appId, appIds) {

74− loadApp(makeAppDetails(appId, pinnedItems.contains(desktopFile(appId))));

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+ }

75 }

89 }

76−

77 syncToAccounts();

90 syncToAccounts();

78}

91}

80QString LauncherBackend::desktopFile(const QString &appId) const

93QString LauncherBackend::desktopFile(const QString &appId) const

81{

94{

82− QFileInfo fileInfo(QDir("/usr/share/applications"), appId);

95+ LauncherBackendItem *item = m_itemCache.value(appId);

83− return fileInfo.absoluteFilePath();

96+ if (item) {

97+ return item->desktopFile;

98+ }

99+

100+ return findDesktopFile(appId);

84}

101}

102

86QString LauncherBackend::displayName(const QString &appId) const

103QString LauncherBackend::displayName(const QString &appId) const

87{

104{

88− auto desktopFile = parseDesktopFile(appId);

105+ LauncherBackendItem *item = m_itemCache.value(appId);

89− auto displayName = desktopFile->value("Desktop Entry/Name").toString();

106+ if (item) {

90− delete desktopFile;

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+

91− return displayName;

117+ return QString();

92}

118}

119

94QString LauncherBackend::icon(const QString &appId) const

120QString LauncherBackend::icon(const QString &appId) const

95{

121{

96− auto desktopFile = parseDesktopFile(appId);

122+ QString iconName;

97− auto iconName = desktopFile->value("Desktop Entry/Icon").toString();

123+ LauncherBackendItem *item = m_itemCache.value(appId);

98− delete desktopFile;

124+ if (item) {

99−

125+ iconName = item->icon;

126+ } else {

127+ QString df = findDesktopFile(appId);

100− if (!iconName.isEmpty()) {

128+ if (!df.isEmpty()) {

101− QFileInfo iconFileInfo(iconName);

129+ LauncherBackendItem *item = parseDesktopFile(df);

102− if (iconFileInfo.isRelative()) {

130+ m_itemCache.insert(appId, item);

103− iconName = "image://gicon/" + iconName;

131+ iconName = item->icon;

104 }

132 }

105 }

133 }

106

134

135+ QFileInfo info(iconName);

136+ if (info.exists()) {

137+ return info.absoluteFilePath();

138+ }

107− return iconName;

139+ return "image://theme/" + iconName;

108}

140}

109

141

110bool LauncherBackend::isPinned(const QString &appId) const

142bool LauncherBackend::isPinned(const QString &appId) const

111{

143{

112− auto index = findItem(appId);

144+ LauncherBackendItem *item = m_itemCache.value(appId);

113− if (index < 0) {

145+ if (item) {

114− return false;

146+ return item->pinned;

115− } else {

116− return m_storedApps[index].pinned;

117 }

147 }

148+ return false;

118}

149}

119

150

120void LauncherBackend::setPinned(const QString &appId, bool pinned)

151void LauncherBackend::setPinned(const QString &appId, bool pinned)

121{

152{

122− auto index = findItem(appId);

153+ if (!m_storedApps.contains(appId)) {

123− if (index >= 0 && !m_storedApps[index].pinned) {

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) {

124− m_storedApps[index].pinned = pinned;

163+ item->pinned = pinned;

125 syncToAccounts();

164 syncToAccounts();

126 }

165 }

127}

166}

@@ -154,8 +193,10 @@ int LauncherBackend::count(const QString &appId) const

154

193

155void LauncherBackend::setUser(const QString &username)

194void LauncherBackend::setUser(const QString &username)

156{

195{

196+ if (qgetenv("USER") == "lightdm" && m_user != username) {

157− m_user = username;

197+ m_user = username;

158− syncFromAccounts();

198+ syncFromAccounts();

199+ }

159}

200}

160

201

161void LauncherBackend::triggerQuickListAction(const QString &appId, const QString &quickListId)

202void LauncherBackend::triggerQuickListAction(const QString &appId, const QString &quickListId)

@@ -170,76 +211,127 @@ void LauncherBackend::syncFromAccounts()

170 QList<QVariantMap> apps;

211 QList<QVariantMap> apps;

171 bool defaults = true;

212 bool defaults = true;

172

213

173− clearItems();

214+ m_storedApps.clear();

215+

216+ qDebug() << "syncing from accounts" << m_accounts << m_user;

174

217

175− if (m_user != "" && m_accounts != nullptr) {

218+ if (m_accounts && !m_user.isEmpty()) {

176− auto variant = m_accounts->getUserProperty(m_user, "launcher-items");

219+ QVariant variant = m_accounts->getUserProperty(m_user, "launcher-items");

177 apps = qdbus_cast<QList<QVariantMap>>(variant.value<QDBusArgument>());

220 apps = qdbus_cast<QList<QVariantMap>>(variant.value<QDBusArgument>());

178 defaults = isDefaultsItem(apps);

221 defaults = isDefaultsItem(apps);

179 }

222 }

180

223

181− // TODO: load default pinned ones from default config, instead of hardcoding here...

224+ qDebug() << "--------------------- should load defaults?" << defaults;

182− if (defaults) {

225+

183− qDebug() << "loading default applications for launcher";

226+ if (m_accounts && defaults) { // Checking accounts as it'll be null when !useStorage

184− apps <<

227+ QGSettings gSettings("com.canonical.Unity.Launcher", "/com/canonical/unity/launcher/");

185− makeAppDetails("dialer-app.desktop", true) <<

228+ Q_FOREACH(const QString &entry, gSettings.get("favorites").toStringList()) {

186− makeAppDetails("messaging-app.desktop", true) <<

229+ if (entry.startsWith("application://")) {

187− makeAppDetails("address-book-app.desktop", true) <<

230+ QString appId = entry;

188− makeAppDetails("camera-app.desktop", true) <<

231+ appId.remove("application://");

189− makeAppDetails("gallery-app.desktop", true) <<

232+ QString df = findDesktopFile(appId);

190− makeAppDetails("facebook-webapp.desktop", true) <<

233+

191− makeAppDetails("webbrowser-app.desktop", true) <<

234+ if (!df.isEmpty()) {

192− makeAppDetails("twitter-webapp.desktop", true) <<

235+ m_storedApps << appId;

193− makeAppDetails("gmail-webapp.desktop", true) <<

236+

194− makeAppDetails("ubuntu-weather-app.desktop", true) <<

237+ if (!m_itemCache.contains(appId)) {

195− makeAppDetails("notes-app.desktop", true) <<

238+ m_itemCache.insert(appId, parseDesktopFile(df));

196− makeAppDetails("calendar-app.desktop", true);

239+ }

240+ m_itemCache.value(appId)->pinned = true;

197− }

241+ }

198−

242+ }

243+ }

244+ } else {

199− for (const QVariant &app: apps) {

245+ for (const QVariant &app: apps) {

246+ qDebug() << "should load app" << app;

200− loadApp(app.toMap());

247+ loadFromVariant(app.toMap());

248+ }

201 }

249 }

202}

250}

203

251

204void LauncherBackend::syncToAccounts()

252void LauncherBackend::syncToAccounts()

205{

253{

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()) {

207 QList<QVariantMap> items;

256 QList<QVariantMap> items;

208

257

209− for (LauncherBackendItem &app: m_storedApps) {

258+ Q_FOREACH(const QString &appId, m_storedApps) {

210− items << makeAppDetails(app.settings->fileName(), app.pinned);

259+ qDebug() << "appending item" << appId;

260+ items << itemToVariant(appId);

211 }

261 }

212

262

263+ qDebug() << "syncing apps" << items;

213 m_accounts->setUserProperty(m_user, "launcher-items", QVariant::fromValue(items));

264 m_accounts->setUserProperty(m_user, "launcher-items", QVariant::fromValue(items));

214 }

265 }

266+ qDebug() << "done synving";

215}

267}

216

268

217−QSettings *LauncherBackend::parseDesktopFile(const QString &appId) const

269+QString LauncherBackend::findDesktopFile(const QString &appId) const

218{

270{

219− auto fullAppId = desktopFile(appId);

271+ int dashPos = -1;

220− return new QSettings(fullAppId, QSettings::IniFormat);

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();

221}

288}

222

289

223−void LauncherBackend::loadApp(const QVariantMap &details)

290+LauncherBackendItem* LauncherBackend::parseDesktopFile(const QString &desktopFile) const

224{

291{

225− auto appId = details.value("id").toString();

292+ QSettings settings(desktopFile, QSettings::IniFormat);

226− auto isPinned = details.value("is-pinned").toBool();

293+

227

294

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")) {

229 return;

306 return;

230 }

307 }

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();

231

321

232− LauncherBackendItem item;

322+ m_itemCache.insert(appId, item);

233− item.settings = parseDesktopFile(appId);

234− item.pinned = isPinned;

235− m_storedApps.append(item);

323+ m_storedApps.append(appId);

236}

324}

237

325

238−QVariantMap LauncherBackend::makeAppDetails(const QString &appId, bool pinned) const

326+QVariantMap LauncherBackend::itemToVariant(const QString &appId) const

239{

327{

328+ LauncherBackendItem *item = m_itemCache.value(appId);

240 QVariantMap details;

329 QVariantMap details;

241 details.insert("id", appId);

330 details.insert("id", appId);

331+ details.insert("name", item->displayName);

332+ details.insert("icon", item->icon);

333+ details.insert("desktopFile", item->desktopFile);

242− details.insert("is-pinned", pinned);

334+ details.insert("is-pinned", item->pinned);

243 return details;

335 return details;

244}

336}

245

337

@@ -248,16 +340,6 @@ bool LauncherBackend::isDefaultsItem(const QList<QVariantMap> &apps) const

248 // To differentiate between an empty list and a list that hasn't been set

340 // To differentiate between an empty list and a list that hasn't been set

249 // yet (and should thus be populated with the defaults), we use a special

341 // yet (and should thus be populated with the defaults), we use a special

250 // list of one item with the 'defaults' field set to true.

342 // list of one item with the 'defaults' field set to true.

343+ qDebug() << "checking isDefaults" << apps;

251 return (apps.size() == 1 && apps[0].value("defaults").toBool());

344 return (apps.size() == 1 && apps[0].value("defaults").toBool());

252}

345}

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−}

plugins/Unity/Launcher/backend/launcherbackend.h+10−12

@@ -31,6 +31,8 @@ class AccountsService;

31 * @brief An interface that provides all the data needed by the launcher.

32 */

34+class LauncherBackendItem;

35+

34class LauncherBackend : public QObject

36class LauncherBackend : public QObject

35{

37{

36 Q_OBJECT

38 Q_OBJECT

@@ -141,23 +143,19 @@ Q_SIGNALS:

141 void countChanged(const QString &appId, int count);

143 void countChanged(const QString &appId, int count);

142

144

143private:

145private:

146+ QString findDesktopFile(const QString &appId) const;

144− QSettings *parseDesktopFile(const QString &appId) const;

147+ LauncherBackendItem* parseDesktopFile(const QString &desktopFile) const;

148+

145− QVariantMap makeAppDetails(const QString &appId, bool pinned) const;

149+ QVariantMap itemToVariant(const QString &appId) const;

146− void loadApp(const QVariantMap &details);

150+ void loadFromVariant(const QVariantMap &details);

147− int findItem(const QString &appId) const;

151+

148 bool isDefaultsItem(const QList<QVariantMap> &apps) const;

152 bool isDefaultsItem(const QList<QVariantMap> &apps) const;

149 void syncFromAccounts();

153 void syncFromAccounts();

150 void syncToAccounts();

154 void syncToAccounts();

151− void clearItems();

152

155

156+ QList<QString> m_storedApps;

153− class LauncherBackendItem

157+ mutable QHash<QString, LauncherBackendItem*> m_itemCache;

154− {

155− public:

156− QSettings *settings;

157− bool pinned;

158− };

159

158

160− QList<LauncherBackendItem> m_storedApps;

161 AccountsService *m_accounts;

159 AccountsService *m_accounts;

162 QString m_user;

160 QString m_user;

163};

161};

plugins/Unity/Launcher/launchermodel.cpp+6

@@ -21,6 +21,8 @@

21#include "launcheritem.h"

22#include "backend/launcherbackend.h"

24+#include <QDebug>

25+

24LauncherModel::LauncherModel(QObject *parent):

26LauncherModel::LauncherModel(QObject *parent):

25 LauncherModelInterface(parent),

27 LauncherModelInterface(parent),

26 m_backend(new LauncherBackend(true, this))

28 m_backend(new LauncherBackend(true, this))

@@ -207,6 +209,7 @@ void LauncherModel::applicationFocused(const QString &appId)

207 QString icon = m_backend->icon(appId);

209 QString icon = m_backend->icon(appId);

208

210

209 LauncherItem *item = new LauncherItem(appId, desktopFile, appName, icon);

211 LauncherItem *item = new LauncherItem(appId, desktopFile, appName, icon);

212+ item->setRecent(true);

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

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

211 m_list.append(item);

214 m_list.append(item);

212 endInsertRows();

215 endInsertRows();

@@ -218,10 +221,13 @@ void LauncherModel::storeAppList()

218{

221{

219 QStringList appIds;

222 QStringList appIds;

220 Q_FOREACH(LauncherItem *item, m_list) {

223 Q_FOREACH(LauncherItem *item, m_list) {

224+ qDebug() << "shouldI store app" << item->appId();

221 if (item->pinned() || item->recent()) {

225 if (item->pinned() || item->recent()) {

226+ qDebug() << "yes";

222 appIds << item->appId();

227 appIds << item->appId();

223 }

228 }

224 }

229 }

230+ qDebug() << "storing appids" << appIds;

225 m_backend->setStoredApplications(appIds);

231 m_backend->setStoredApplications(appIds);

226}

232}

227

233

tests/plugins/Unity/Launcher/CMakeLists.txt+4

@@ -1,8 +1,11 @@

1+pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)

1include_directories(

3include_directories(

2 ${CMAKE_CURRENT_BINARY_DIR}

4 ${CMAKE_CURRENT_BINARY_DIR}

3 ${CMAKE_SOURCE_DIR}/plugins/AccountsService

5 ${CMAKE_SOURCE_DIR}/plugins/AccountsService

4 ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher

6 ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher

5 ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher/backend

7 ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher/backend

8+ ${GSETTINGS_QT_INCLUDE_DIRS}

6 )

9 )

8add_definitions(-DSM_BUSNAME=sessionBus)

11add_definitions(-DSM_BUSNAME=sessionBus)

@@ -19,4 +22,5 @@ add_executable(launcherbackendtestExec

19 ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher/backend/launcherbackend.cpp

22 ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher/backend/launcherbackend.cpp

20 ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher/common/quicklistentry.cpp

23 ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher/common/quicklistentry.cpp

21 )

24 )

25+target_link_libraries(launcherbackendtestExec ${GSETTINGS_QT_LDFLAGS})

22qt5_use_modules(launcherbackendtestExec Test Core DBus)

26qt5_use_modules(launcherbackendtestExec Test Core DBus)

tests/plugins/Unity/Launcher/launcherbackendtest.cpp+1−34

@@ -32,46 +32,13 @@ private Q_SLOTS:

32 LauncherBackend backend(false);

34 backend.setStoredApplications(QStringList() << "relative.path" << "/full/path");

35− QCOMPARE(backend.storedApplications(), QStringList() << "/usr/share/applications/relative.path" << "/full/path");

35+ QCOMPARE(backend.storedApplications(), QStringList() << "relative.path" << "/full/path");

36−

37− QCOMPARE(backend.desktopFile("one.desktop"), QString("/usr/share/applications/one.desktop"));

38− QCOMPARE(backend.desktopFile("two"), QString("/usr/share/applications/two"));

39− QCOMPARE(backend.desktopFile("/full"), QString("/full"));

40−

41− QCOMPARE(backend.desktopFile("/usr/share/applications/one.desktop"), QString("/usr/share/applications/one.desktop"));

42− }

43−

44− void testDesktopReading()

45− {

46− LauncherBackend backend(false);

47−

48− QCOMPARE(backend.displayName(SRCDIR "/rel-icon.desktop"), QString("Relative Icon"));

49− QCOMPARE(backend.icon(SRCDIR "/rel-icon.desktop"), QString("image://gicon/rel-icon"));

50−

51− QCOMPARE(backend.displayName(SRCDIR "/abs-icon.desktop"), QString("Absolute Icon"));

52− QCOMPARE(backend.icon(SRCDIR "/abs-icon.desktop"), QString("/path/to/icon.png"));

53−

54− QCOMPARE(backend.displayName(SRCDIR "/no-icon.desktop"), QString("No Icon"));

55− QCOMPARE(backend.icon(SRCDIR "/no-icon.desktop"), QString(""));

56−

57− QCOMPARE(backend.displayName(SRCDIR "/no-name.desktop"), QString(""));

58− QCOMPARE(backend.icon(SRCDIR "/no-name.desktop"), QString("image://gicon/no-name"));

59−

60− QCOMPARE(backend.displayName(SRCDIR "/no-exist.desktop"), QString(""));

61− QCOMPARE(backend.icon(SRCDIR "/no-exist.desktop"), QString(""));

62 }

36 }

64 void testPinning()

38 void testPinning()

65 {

39 {

66 LauncherBackend backend(false);

40 LauncherBackend backend(false);

68− // Confirm that default entries are all pinned

69− auto defaultApps = backend.storedApplications();

70− QVERIFY(defaultApps.size() > 0);

71− for (auto app: defaultApps) {

72− QCOMPARE(backend.isPinned(app), true);

73− }

74−

75 backend.setStoredApplications(QStringList() << "one" << "two");

42 backend.setStoredApplications(QStringList() << "one" << "two");

76 QCOMPARE(backend.isPinned("one"), false);

43 QCOMPARE(backend.isPinned("one"), false);

77 QCOMPARE(backend.isPinned("two"), false);

44 QCOMPARE(backend.isPinned("two"), false);