f01d240 · unity8 · git.iko.soy

git.iko.soy/unity8

on xenial help sign in

load launcher default config from existing dconf key.

f01d240Michael Zanetti13 years ago

debian/control+1

compare with xenial

unifiedsplit

@@ -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+159−99

@@ -24,6 +24,18 @@

24#include <QDir>

25#include <QDBusArgument>

26#include <QFileInfo>

27+#include <QGSettings>

28+

29+class LauncherBackendItem

30+{

31+public:

32+ LauncherBackendItem(): pinned(false) {}

33+

34+ QString desktopFile;

35+ QString displayName;

36+ QString icon;

37+ bool pinned;

38+};

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

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

29 QObject(parent),

41 QObject(parent),

@@ -32,95 +44,109 @@ LauncherBackend::LauncherBackend(bool useStorage, QObject *parent):

32 if (useStorage) {

44 if (useStorage) {

33 m_accounts = new AccountsService(this);

45 m_accounts = new AccountsService(this);

34 }

46 }

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

47+ m_user = qgetenv("USER");

48+ syncFromAccounts();

36}

49}

38LauncherBackend::~LauncherBackend()

51LauncherBackend::~LauncherBackend()

39{

52{

40− clearItems();

53+ m_storedApps.clear();

41−}

43−void LauncherBackend::clearItems()

44−{

45− for (LauncherBackendItem &app: m_storedApps) {

55+ Q_FOREACH(LauncherBackendItem *item, m_itemCache) {

46− delete app.settings;

56+ delete item;

47 }

57 }

48− m_storedApps.clear();

58+ m_itemCache.clear();

49}

59}

51QStringList LauncherBackend::storedApplications() const

61QStringList LauncherBackend::storedApplications() const

52{

62{

53− auto files = QStringList();

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

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

56− }

57− return files;

63+ return m_storedApps;

58}

64}

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

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

61{

67{

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

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

63− auto pinnedItems = QStringList();

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

64− for (LauncherBackendItem &app: m_storedApps) {

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

65− if (app.pinned) {

71+ delete m_itemCache.take(appId);

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

72+ }

67 }

73 }

68 }

74 }

69−

75+ m_storedApps = appIds;

70− clearItems();

71−

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

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

74− }

75−

76 syncToAccounts();

77}

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

80{

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

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

82− return fileInfo.absoluteFilePath();

82+ if (item) {

83+ return item->desktopFile;

84+ }

85+

86+ return findDesktopFile(appId);

83}

87}

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

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

86{

90{

87− auto desktopFile = parseDesktopFile(appId);

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

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

92+ if (item) {

89− delete desktopFile;

93+ return item->displayName;

94+ }

95+

96+ QString df = findDesktopFile(appId);

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

98+ LauncherBackendItem *item = parseDesktopFile(df);

99+ m_itemCache.insert(appId, item);

100+ return item->displayName;

101+ }

102+

90− return displayName;

103+ return QString();

91}

104}

105

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

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

94{

107{

95− auto desktopFile = parseDesktopFile(appId);

108+ QString iconName;

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

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

97− delete desktopFile;

110+ if (item) {

98−

111+ iconName = item->icon;

112+ } else {

113+ QString df = findDesktopFile(appId);

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

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

100− QFileInfo iconFileInfo(iconName);

115+ LauncherBackendItem *item = parseDesktopFile(df);

101− if (iconFileInfo.isRelative()) {

116+ m_itemCache.insert(appId, item);

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

117+ iconName = item->icon;

103 }

118 }

104 }

119 }

105

120

121+ QFileInfo info(iconName);

122+ if (info.exists()) {

123+ return info.absoluteFilePath();

124+ }

106− return iconName;

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

107}

126}

108

127

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

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

110{

129{

111− auto index = findItem(appId);

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

112− if (index < 0) {

131+ if (item) {

113− return false;

132+ return item->pinned;

114− } else {

115− return m_storedApps[index].pinned;

116 }

133 }

134+ return false;

117}

135}

118

136

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

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

120{

138{

121− auto index = findItem(appId);

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

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

140+ return;

141+ }

142+

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

144+ if (!item) {

145+ item = new LauncherBackendItem();

146+ m_itemCache.insert(appId, item);

147+ }

148+ if (item->pinned != pinned) {

123− m_storedApps[index].pinned = pinned;

149+ item->pinned = pinned;

124 syncToAccounts();

150 syncToAccounts();

125 }

151 }

126}

152}

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

153

179

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

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

155{

181{

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

156− m_user = username;

183+ m_user = username;

157− syncFromAccounts();

184+ syncFromAccounts();

185+ }

158}

186}

159

187

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

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

@@ -169,75 +197,118 @@ void LauncherBackend::syncFromAccounts()

169 QList<QVariantMap> apps;

197 QList<QVariantMap> apps;

170 bool defaults = true;

198 bool defaults = true;

171

199

172− clearItems();

200+ m_storedApps.clear();

173

201

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

202+ if (m_accounts && m_user.isEmpty()) {

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

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

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

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

177 defaults = isDefaultsItem(apps);

205 defaults = isDefaultsItem(apps);

178 }

206 }

179

207

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

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

181− if (defaults) {

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

182− apps <<

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

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

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

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

212+ QString appId = entry;

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

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

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

214+ QString df = findDesktopFile(appId);

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

215+

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

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

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

217+ m_storedApps << appId;

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

218+

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

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

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

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

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

221+ }

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

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

195− }

223+ }

196−

224+ }

225+ }

226+ } else {

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

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

198− loadApp(app.toMap());

228+ loadFromVariant(app.toMap());

229+ }

199 }

230 }

200}

231}

201

232

202void LauncherBackend::syncToAccounts()

233void LauncherBackend::syncToAccounts()

203{

234{

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

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

205 QList<QVariantMap> items;

236 QList<QVariantMap> items;

206

237

207− for (LauncherBackendItem &app: m_storedApps) {

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

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

239+ items << itemToVariant(appId);

209 }

240 }

210

241

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

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

212 }

243 }

213}

244}

214

245

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

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

216{

247{

217− auto fullAppId = desktopFile(appId);

248+ int dashPos = -1;

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

249+ QString helper = appId;

250+

251+ do {

252+ if (dashPos != -1) {

253+ helper = helper.replace(dashPos, 1, '/');

254+ }

255+

256+ QFileInfo fileInfo(QDir("/usr/share/applications"), helper);

257+ if (fileInfo.exists()) {

258+ return fileInfo.absoluteFilePath();

259+ }

260+

261+ dashPos = helper.indexOf("-");

262+ } while (dashPos != -1);

263+

264+ return QString();

219}

265}

220

266

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

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

222{

268{

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

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

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

270+

225

271

226− if (appId.isEmpty()) {

272+ LauncherBackendItem* item = new LauncherBackendItem();

273+ item->desktopFile = desktopFile;

274+ item->displayName = settings.value("Desktop Entry/Name").toString();

275+ item->icon = settings.value("Desktop Entry/Icon").toString();

276+ item->pinned = false;

277+ return item;

278+}

279+

280+void LauncherBackend::loadFromVariant(const QVariantMap &details)

281+{

282+ if (!details.contains("id")) {

227 return;

283 return;

228 }

284 }

285+ QString appId = details.value("id").toString();

286+

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

288+ if (item) {

289+ delete item;

290+ }

291+

292+ item = new LauncherBackendItem();

293+

294+ item->desktopFile = details.value("desktopFile").toString();

295+ item->displayName = details.value("name").toString();

296+ item->icon = details.value("icon").toString();

297+ item->pinned = details.value("is-pinned").toBool();

229

298

230− LauncherBackendItem item;

299+ m_itemCache.insert(appId, item);

231− item.settings = parseDesktopFile(appId);

232− item.pinned = isPinned;

233− m_storedApps.append(item);

300+ m_storedApps.append(appId);

234}

301}

235

302

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

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

237{

304{

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

238 QVariantMap details;

306 QVariantMap details;

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

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

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

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

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

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

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

241 return details;

312 return details;

242}

313}

243

314

@@ -248,14 +319,3 @@ bool LauncherBackend::isDefaultsItem(const QList<QVariantMap> &apps) const

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

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

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

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

250}

321}

251−

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

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

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