blumia/dde-application-manager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refact: Autostart

Browse Source 
Signed-off-by: ComixHe <heyuming@deepin.org>
This commit is contained in:
ComixHe
2023-11-08 18:21:09 +08:00
committed by Comix
parent 74931e3d1a
commit b9bbfb7f6d
10 changed files with 284 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
src/applicationchecker.cpp
View File

@ -8,10 +8,10 @@
#include <QFileInfo>
#include <QStandardPaths>
bool ApplicationFilter::hiddenCheck(const std::unique_ptr<DesktopEntry> &entry) noexcept
bool ApplicationFilter::hiddenCheck(const DesktopEntry &entry) noexcept
{
bool hidden{false};
auto hiddenVal = entry->value(DesktopFileEntryKey, "Hidden");
auto hiddenVal = entry.value(DesktopFileEntryKey, DesktopEntryHidden);
if (hiddenVal.has_value()) {
bool ok{false};
@ -24,9 +24,9 @@ bool ApplicationFilter::hiddenCheck(const std::unique_ptr<DesktopEntry> &entry)
return hidden;
}
bool ApplicationFilter::tryExecCheck(const std::unique_ptr<DesktopEntry> &entry) noexcept
bool ApplicationFilter::tryExecCheck(const DesktopEntry &entry) noexcept
{
auto tryExecVal = entry->value(DesktopFileEntryKey, "TryExec");
auto tryExecVal = entry.value(DesktopFileEntryKey, "TryExec");
if (tryExecVal.has_value()) {
auto executable = toString(tryExecVal.value());
if (executable.isEmpty()) {
@ -44,7 +44,7 @@ bool ApplicationFilter::tryExecCheck(const std::unique_ptr<DesktopEntry> &entry)
return false;
}
bool ApplicationFilter::showInCheck(const std::unique_ptr<DesktopEntry> &entry) noexcept
bool ApplicationFilter::showInCheck(const DesktopEntry &entry) noexcept
{
auto desktops = QString::fromLocal8Bit(qgetenv("XDG_CURRENT_DESKTOP")).split(':', Qt::SkipEmptyParts);
if (desktops.isEmpty()) {
@ -53,7 +53,7 @@ bool ApplicationFilter::showInCheck(const std::unique_ptr<DesktopEntry> &entry)
desktops.removeDuplicates();
bool showInCurrentDE{true};
auto onlyShowInVal = entry->value(DesktopFileEntryKey, "OnlyShowIn");
auto onlyShowInVal = entry.value(DesktopFileEntryKey, "OnlyShowIn");
while (onlyShowInVal.has_value()) {
auto deStr = toString(onlyShowInVal.value());
if (deStr.isEmpty()) {
@ -75,7 +75,7 @@ bool ApplicationFilter::showInCheck(const std::unique_ptr<DesktopEntry> &entry)
}
bool notShowInCurrentDE{false};
auto notShowInVal = entry->value(DesktopFileEntryKey, "NotShowIn");
auto notShowInVal = entry.value(DesktopFileEntryKey, "NotShowIn");
while (notShowInVal.has_value()) {
auto deStr = toString(notShowInVal.value());
if (deStr.isEmpty()) {
@ -98,3 +98,18 @@ bool ApplicationFilter::showInCheck(const std::unique_ptr<DesktopEntry> &entry)
return !showInCurrentDE or notShowInCurrentDE;
}
bool ApplicationFilter::hiddenCheck(const std::unique_ptr<DesktopEntry> &entry) noexcept
{
return hiddenCheck(*entry);
}
bool ApplicationFilter::tryExecCheck(const std::unique_ptr<DesktopEntry> &entry) noexcept
{
return tryExecCheck(*entry);
}
bool ApplicationFilter::showInCheck(const std::unique_ptr<DesktopEntry> &entry) noexcept
{
return showInCheck(*entry);
}

3
src/applicationchecker.h
View File

@ -13,6 +13,9 @@ namespace ApplicationFilter {
bool hiddenCheck(const std::unique_ptr<DesktopEntry> &entry) noexcept;
bool tryExecCheck(const std::unique_ptr<DesktopEntry> &entry) noexcept;
bool showInCheck(const std::unique_ptr<DesktopEntry> &entry) noexcept;
bool hiddenCheck(const DesktopEntry &entry) noexcept;
bool tryExecCheck(const DesktopEntry &entry) noexcept;
bool showInCheck(const DesktopEntry &entry) noexcept;
} // namespace ApplicationFilter
#endif

2
src/constant.h
View File

@ -23,6 +23,8 @@ constexpr auto DDEApplicationManager1MimeManager1ObjectPath = u8"/org/desktopspe
constexpr auto DesktopFileEntryKey = u8"Desktop Entry";
constexpr auto DesktopFileActionKey = u8"Desktop Action ";
constexpr auto DesktopFileDefaultKeyLocale = "default";
constexpr auto X_Deepin_GenerateSource = u8"X-Deepin-GenerateSource";
constexpr auto DesktopEntryHidden = u8"Hidden";
constexpr auto ApplicationManagerServerDBusName =
#ifdef DDE_AM_USE_DEBUG_DBUS_NAME

165
src/dbus/applicationmanager1service.cpp
View File

@ -2,6 +2,7 @@
//
// SPDX-License-Identifier: LGPL-3.0-or-later
#include "applicationadaptor.h"
#include "applicationchecker.h"
#include "dbus/applicationmanager1adaptor.h"
#include "applicationservice.h"
#include "dbus/AMobjectmanager1adaptor.h"
@ -79,6 +80,8 @@ void ApplicationManager1Service::initService(QDBusConnection &connection) noexce
scanApplications();
auto needLaunch = scanAutoStart();
scanInstances();
loadHooks();
@ -112,16 +115,20 @@ void ApplicationManager1Service::initService(QDBusConnection &connection) noexce
constexpr auto XSettings = "org.deepin.dde.XSettings1";
auto *watcher =
new QDBusServiceWatcher{XSettings, QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForRegistration, this};
auto *watcher = new (std::nothrow)
QDBusServiceWatcher{XSettings, QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForRegistration, this};
auto *sigCon = new QMetaObject::Connection{};
auto *sigCon = new (std::nothrow) QMetaObject::Connection{};
auto singleSlot = [this, watcher, sigCon]() {
auto singleSlot = [watcher, sigCon, autostartList = std::move(needLaunch)]() {
QObject::disconnect(*sigCon);
delete sigCon;
qDebug() << XSettings << "is registered.";
scanAutoStart();
for (const auto &app : autostartList) {
app->Launch({}, {}, {});
}
watcher->deleteLater();
};
@ -236,23 +243,29 @@ void ApplicationManager1Service::scanApplications() noexcept
{
const auto &desktopFileDirs = getDesktopFileDirs();
std::map<QString, DesktopFile> fileMap;
applyIteratively(
QList<QDir>(desktopFileDirs.crbegin(), desktopFileDirs.crend()),
[this](const QFileInfo &info) -> bool {
[&fileMap](const QFileInfo &info) -> bool {
ParserError err{ParserError::NoError};
auto ret = DesktopFile::searchDesktopFileByPath(info.absoluteFilePath(), err);
if (!ret.has_value()) {
qWarning() << "failed to search File:" << err;
return false;
}
if (!this->addApplication(std::move(ret).value())) {
qWarning() << "add Application failed, skip...";
}
auto file = std::move(ret).value();
fileMap.insert_or_assign(file.desktopId(), std::move(file));
return false; // means to apply this function to the rest of the files
},
QDir::Readable | QDir::AllDirs | QDir::Files | QDir::NoDotAndDotDot,
{"*.desktop"},
QDir::Name | QDir::DirsLast);
for (auto &&[k, v] : std::move(fileMap)) {
if (!addApplication(std::move(v))) {
qWarning() << "add Application" << k << " failed, skip...";
}
}
}
void ApplicationManager1Service::scanInstances() noexcept
@ -278,32 +291,117 @@ void ApplicationManager1Service::scanInstances() noexcept
}
}
void ApplicationManager1Service::scanAutoStart() noexcept
QList<QSharedPointer<ApplicationService>> ApplicationManager1Service::scanAutoStart() noexcept
{
QList<QSharedPointer<ApplicationService>> ret;
auto autostartDirs = getAutoStartDirs();
QStringList needToLaunch;
std::map<QString, DesktopFile> autostartItems;
applyIteratively(
QList<QDir>{autostartDirs.cbegin(), autostartDirs.cend()},
[&needToLaunch](const QFileInfo &info) {
if (info.isSymbolicLink()) {
needToLaunch.emplace_back(info.symLinkTarget());
QList<QDir>{autostartDirs.crbegin(), autostartDirs.crend()},
[&autostartItems](const QFileInfo &info) {
ParserError err{ParserError::InternalError};
auto desktopSource = DesktopFile::searchDesktopFileByPath(info.absoluteFilePath(), err);
if (err != ParserError::NoError) {
qWarning() << "skip" << info.absoluteFilePath();
return false;
}
auto file = std::move(desktopSource).value();
autostartItems.insert_or_assign(file.desktopId(), std::move(file));
return false;
},
QDir::Readable | QDir::AllDirs | QDir::Files | QDir::NoDotAndDotDot,
QDir::Readable | QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot,
{"*.desktop"},
QDir::Name | QDir::DirsLast);
while (!needToLaunch.isEmpty()) {
const auto &filePath = needToLaunch.takeFirst();
auto appIt =
std::find_if(m_applicationList.constKeyValueBegin(),
m_applicationList.constKeyValueEnd(),
[&filePath](const auto &pair) { return pair.second->m_desktopSource.sourcePath() == filePath; });
if (appIt != m_applicationList.constKeyValueEnd()) {
appIt->second->Launch({}, {}, {});
for (auto &it : autostartItems) {
auto desktopFile = std::move(it.second);
DesktopFileGuard guard{desktopFile};
if (!guard.try_open()) {
continue;
}
auto &file = desktopFile.sourceFileRef();
QTextStream stream{&file};
DesktopEntry tmp;
auto err = tmp.parse(stream);
if (err != ParserError::NoError) {
qWarning() << "parse autostart file" << desktopFile.sourcePath() << " error:" << err;
continue;
}
QSharedPointer<ApplicationService> app{nullptr};
auto asApplication = tmp.value(DesktopFileEntryKey, X_Deepin_GenerateSource).value_or(DesktopEntry::Value{});
if (!asApplication.isNull()) { // modified by application manager
auto appSource = asApplication.toString();
QFileInfo sourceInfo{appSource};
if ((!sourceInfo.exists() or !sourceInfo.isFile()) and !file.remove()) {
qWarning() << "remove invalid autostart file error:" << file.error();
continue;
}
// add original application
auto desktopSource = DesktopFile::searchDesktopFileByPath(appSource, err);
if (err != ParserError::NoError) {
qWarning() << "search autostart application failed:" << err;
continue;
}
auto source = std::move(desktopSource).value();
if (source.desktopId().isEmpty()) {
qWarning() << X_Deepin_GenerateSource << "is" << appSource
<< ", but couldn't find it in applications, maybe this autostart file has been modified, skip.";
continue;
}
// add application directly, it wouldn't add the same application twice.
app = addApplication(std::move(source));
if (!app) {
qWarning() << "add autostart application failed, skip.";
continue;
}
}
auto shouldLaunch = tmp.value(DesktopFileEntryKey, DesktopEntryHidden).value_or(DesktopEntry::Value{});
if (!shouldLaunch.isNull() and (shouldLaunch.toString().compare("true", Qt::CaseInsensitive) == 0)) {
qInfo() << "shouldn't launch this autoStart item.";
continue;
}
if (app) {
ret.append(app);
continue;
}
// maybe some application generate autostart desktop by itself
if (ApplicationFilter::tryExecCheck(tmp) or ApplicationFilter::showInCheck(tmp)) {
qInfo() << "autostart application couldn't pass check.";
continue;
}
if (auto appIt = std::find_if(m_applicationList.cbegin(),
m_applicationList.cend(),
[&desktopFile](const auto &app) { return desktopFile.desktopId() == app->id(); });
appIt != m_applicationList.cend()) {
qInfo() << "app already exists. use it to launch instance.";
ret.append(*appIt);
continue;
}
guard.close();
// new application
auto newApp = addApplication(std::move(desktopFile));
if (!newApp) {
qWarning() << "add autostart application failed, skip.";
continue;
}
ret.append(newApp);
}
return ret;
}
void ApplicationManager1Service::loadHooks() noexcept
@ -337,36 +435,39 @@ QList<QDBusObjectPath> ApplicationManager1Service::list() const
return m_applicationList.keys();
}
bool ApplicationManager1Service::addApplication(DesktopFile desktopFileSource) noexcept
QSharedPointer<ApplicationService> ApplicationManager1Service::addApplication(DesktopFile desktopFileSource) noexcept
{
auto source = desktopFileSource.sourcePath();
QSharedPointer<ApplicationService> application =
ApplicationService::createApplicationService(std::move(desktopFileSource), this, m_storage);
if (!application) {
return false;
qWarning() << "can't create application" << source;
return nullptr;
}
if (m_applicationList.constFind(application->applicationPath()) != m_applicationList.cend()) {
if (auto app = m_applicationList.constFind(application->applicationPath()); app != m_applicationList.cend()) {
qInfo() << "this application already exists."
<< "desktop source:" << application->desktopFileSource().sourcePath();
return false;
<< "current desktop source:" << application->desktopFileSource().sourcePath()
<< "exists app source:" << app->data()->desktopFileSource().sourcePath();
return *app;
}
auto *ptr = application.data();
if (auto *adaptor = new (std::nothrow) ApplicationAdaptor{ptr}; adaptor == nullptr) {
qCritical() << "new ApplicationAdaptor failed.";
return false;
return nullptr;
}
if (!registerObjectToDBus(ptr, application->applicationPath().path(), ApplicationInterface)) {
return false;
return nullptr;
}
m_applicationList.insert(application->applicationPath(), application);
emit listChanged();
emit InterfacesAdded(application->applicationPath(), getChildInterfacesAndPropertiesFromObject(ptr));
return true;
return application;
}
void ApplicationManager1Service::removeOneApplication(const QDBusObjectPath &application) noexcept

4
src/dbus/applicationmanager1service.h
View File

@ -36,7 +36,7 @@ public:
[[nodiscard]] QList<QDBusObjectPath> list() const;
void initService(QDBusConnection &connection) noexcept;
bool addApplication(DesktopFile desktopFileSource) noexcept;
QSharedPointer<ApplicationService> addApplication(DesktopFile desktopFileSource) noexcept;
void removeOneApplication(const QDBusObjectPath &application) noexcept;
void removeAllApplication() noexcept;
[[nodiscard]] QMap<QDBusObjectPath, QSharedPointer<ApplicationService>>
@ -74,7 +74,7 @@ private:
void scanMimeInfos() noexcept;
void scanApplications() noexcept;
void scanInstances() noexcept;
void scanAutoStart() noexcept;
QList<QSharedPointer<ApplicationService>> scanAutoStart() noexcept;
void loadHooks() noexcept;
void addInstanceToApplication(const QString &unitName, const QDBusObjectPath &systemdUnitPath);
void removeInstanceFromApplication(const QString &unitName, const QDBusObjectPath &systemdUnitPath);

99
src/dbus/applicationservice.cpp
View File

@ -6,10 +6,14 @@
#include "APPobjectmanager1adaptor.h"
#include "applicationchecker.h"
#include "applicationmanagerstorage.h"
#include "constant.h"
#include "global.h"
#include "iniParser.h"
#include "propertiesForwarder.h"
#include "dbus/instanceadaptor.h"
#include "launchoptions.h"
#include "desktopentry.h"
#include "desktopfileparser.h"
#include <QUuid>
#include <QStringList>
#include <QList>
@ -19,6 +23,11 @@
#include <QStandardPaths>
#include <algorithm>
#include <new>
#include <qdbuserror.h>
#include <qfileinfo.h>
#include <qlogging.h>
#include <qnamespace.h>
#include <qtmetamacros.h>
#include <utility>
#include <wordexp.h>
@ -102,6 +111,7 @@ QSharedPointer<ApplicationService> ApplicationService::createApplicationService(
DesktopFileGuard guard{app->desktopFileSource()};
if (!guard.try_open()) {
qDebug() << "open source desktop failed.";
return nullptr;
}
@ -139,14 +149,17 @@ QSharedPointer<ApplicationService> ApplicationService::createApplicationService(
bool ApplicationService::shouldBeShown(const std::unique_ptr<DesktopEntry> &entry) noexcept
{
if (ApplicationFilter::hiddenCheck(entry)) {
qDebug() << "hidden check failed.";
return false;
}
if (ApplicationFilter::tryExecCheck(entry)) {
qDebug() << "tryExec check failed";
return false;
}
if (ApplicationFilter::showInCheck(entry)) {
qDebug() << "showIn check failed.";
return false;
}
@ -541,46 +554,76 @@ void ApplicationService::setScaleFactor(double value) noexcept
emit scaleFactorChanged();
}
bool ApplicationService::autostartCheck(const QString &linkPath) const noexcept
bool ApplicationService::autostartCheck(const QString &filePath) noexcept
{
QFileInfo info{linkPath};
qDebug() << "current check autostart file:" << filePath;
if (info.exists()) {
if (info.isSymbolicLink() and info.symLinkTarget() == m_desktopSource.sourcePath()) {
return true;
}
qWarning() << "same name desktop file exists:" << linkPath << "but this may not created by AM.";
QFile file{filePath};
if (!file.open(QFile::ExistingOnly | QFile::ReadOnly | QFile::Text)) {
qWarning() << "open" << filePath << "failed:" << file.errorString();
return false;
}
return false;
QTextStream stream{&file};
DesktopEntry s;
if (auto err = s.parse(stream); err != ParserError::NoError) {
qWarning() << "parse" << filePath << "failed:" << err;
return false;
}
auto hiddenVal = s.value(DesktopFileEntryKey, DesktopEntryHidden);
if (!hiddenVal) {
qDebug() << "no hidden in autostart desktop";
return true;
}
auto hidden = hiddenVal.value().toString();
return hidden.compare("false", Qt::CaseInsensitive) == 0;
}
bool ApplicationService::isAutoStart() const noexcept
{
auto path = getAutoStartDirs().first();
auto linkName = QDir{path}.filePath(m_desktopSource.desktopId() + ".desktop");
return autostartCheck(linkName);
auto autostartDirs = getAutoStartDirs();
auto sourcePath = m_desktopSource.sourcePath();
auto userAutostart = QDir{autostartDirs.first()}.filePath(id() + ".desktop");
QFileInfo info{userAutostart};
auto isOverride = info.exists() and info.isFile();
if (std::any_of(autostartDirs.cbegin(), autostartDirs.cend(), [&sourcePath](const QString &dir) {
return sourcePath.startsWith(dir);
})) { // load from autostart
return isOverride ? autostartCheck(userAutostart) : autostartCheck(sourcePath);
}
return isOverride and autostartCheck(userAutostart);
}
void ApplicationService::setAutoStart(bool autostart) noexcept
{
auto path = getAutoStartDirs().first();
auto linkName = QDir{path}.filePath(m_desktopSource.desktopId() + ".desktop");
auto &file = m_desktopSource.sourceFileRef();
if (isAutoStart() == autostart) {
return;
}
if (autostart) {
if (!autostartCheck(linkName) and !file.link(linkName)) {
qWarning() << "link to autostart failed:" << file.errorString();
return;
}
} else {
if (autostartCheck(linkName)) {
QFile linkFile{linkName};
if (!linkFile.remove()) {
qWarning() << "remove link failed:" << linkFile.errorString();
return;
}
}
auto fileName = QDir{getAutoStartDirs().first()}.filePath(m_desktopSource.desktopId() + ".desktop");
QFile autostartFile{fileName};
if (!autostartFile.open(QFile::WriteOnly | QFile::Text | QFile::Truncate)) {
qWarning() << "open file" << fileName << "failed:" << autostartFile.error();
sendErrorReply(QDBusError::Failed);
return;
}
auto newEntry = *m_entry;
newEntry.insert(DesktopFileEntryKey, X_Deepin_GenerateSource, m_desktopSource.sourcePath());
newEntry.insert(DesktopFileEntryKey, DesktopEntryHidden, !autostart);
auto hideAutostart = toString(newEntry.data()).toLocal8Bit();
auto writeBytes = autostartFile.write(hideAutostart);
if (writeBytes != hideAutostart.size() or !autostartFile.flush()) {
qWarning() << "incomplete write:" << autostartFile.error();
sendErrorReply(QDBusError::Failed, "set failed: filesystem error.");
return;
}
emit autostartChanged();
@ -1021,7 +1064,7 @@ double getScaleFactor() noexcept
QString getDeepinWineScaleFactor(const QString &appId) noexcept
{
qCritical() << "Don't using env to control the window scale factor, this function"
"should via using graphisc server(Wayland Compositor/Xorg Xft) in deepin wine.";
"should via using graphic server(Wayland Compositor/Xorg Xft) in deepin wine.";
QString factor{"1.0"};
auto objectPath = QString{"/dde_launcher/org_deepin_dde_launcher/%1"}.arg(getCurrentUID());

2
src/dbus/applicationservice.h
View File

@ -177,7 +177,7 @@ private:
QMap<QDBusObjectPath, QSharedPointer<InstanceService>> m_Instances;
void updateAfterLaunch(bool isLaunch) noexcept;
static bool shouldBeShown(const std::unique_ptr<DesktopEntry> &entry) noexcept;
[[nodiscard]] bool autostartCheck(const QString &linkPath) const noexcept;
[[nodiscard]] static bool autostartCheck(const QString &filePath) noexcept;
[[nodiscard]] ApplicationManager1Service *parent() { return dynamic_cast<ApplicationManager1Service *>(QObject::parent()); }
[[nodiscard]] const ApplicationManager1Service *parent() const
{

37
src/desktopentry.cpp
View File

@ -111,18 +111,31 @@ std::optional<DesktopFile> DesktopFile::searchDesktopFileByPath(const QString &d
return std::nullopt;
}
QString path{desktopFile};
QString id;
const auto &XDGDataDirs = getDesktopFileDirs();
auto idGen = std::any_of(XDGDataDirs.cbegin(), XDGDataDirs.cend(), [&desktopFile](const QString &suffixPath) {
const auto &autostartDirs = getAutoStartDirs();
auto IsCommonApp = std::any_of(XDGDataDirs.cbegin(), XDGDataDirs.cend(), [&desktopFile](const QString &suffixPath) {
return desktopFile.startsWith(suffixPath);
});
if (idGen) {
auto IsAutostartApp = std::any_of(autostartDirs.cbegin(), autostartDirs.cend(), [&desktopFile](const QString &suffixPath) {
return desktopFile.startsWith(suffixPath);
});
QString path{desktopFile};
QString id;
if (IsCommonApp or IsAutostartApp) {
auto tmp = path.chopped(sizeof(desktopSuffix) - 1);
auto components = tmp.split(QDir::separator()).toList();
auto it = std::find(components.cbegin(), components.cend(), "applications");
auto components = tmp.split(QDir::separator(), Qt::SkipEmptyParts).toList();
decltype(components)::const_iterator it;
if (auto appIt = std::find(components.cbegin(), components.cend(), "applications"); appIt != components.cend()) {
it = appIt;
} else if (auto autostartIt = std::find(components.cbegin(), components.cend(), "autostart");
autostartIt != components.cend()) {
it = autostartIt;
}
QString FileId;
++it;
while (it != components.cend()) {
@ -236,6 +249,16 @@ std::optional<DesktopEntry::Value> DesktopEntry::value(const QString &groupKey,
return *it;
}
void DesktopEntry::insert(const QString &key, const QString &valueKey, Value &&val) noexcept
{
auto outer = m_entryMap.find(key);
if (outer == m_entryMap.end()) {
outer = m_entryMap.insert(key, {});
}
outer->insert(valueKey, val);
}
QString unescape(const QString &str, bool shellMode) noexcept
{
QString unescapedStr;

14
src/desktopentry.h
View File

@ -78,6 +78,10 @@ struct DesktopFileGuard
bool try_open()
{
if (!fileRef.m_fileSource) {
return false;
}
if (fileRef.m_fileSource->isOpen()) {
return true;
}
@ -90,13 +94,19 @@ struct DesktopFileGuard
return ret;
}
~DesktopFileGuard()
void close()
{
if (!fileRef.m_fileSource) {
return;
}
if (fileRef.m_fileSource->isOpen()) {
fileRef.m_fileSource->close();
}
}
~DesktopFileGuard() { close(); }
private:
const DesktopFile &fileRef;
};
@ -116,6 +126,8 @@ public:
[[nodiscard]] ParserError parse(QTextStream &stream) noexcept;
[[nodiscard]] std::optional<QMap<QString, Value>> group(const QString &key) const noexcept;
[[nodiscard]] std::optional<Value> value(const QString &key, const QString &valueKey) const noexcept;
void insert(const QString &key, const QString &valueKey, Value &&val) noexcept;
[[nodiscard]] const auto &data() const noexcept { return m_entryMap; }
friend bool operator==(const DesktopEntry &lhs, const DesktopEntry &rhs);
friend bool operator!=(const DesktopEntry &lhs, const DesktopEntry &rhs);

8
src/global.h
View File

@ -403,7 +403,12 @@ inline QStringList getXDGDataDirs()
XDGDataDirs.append("/usr/share");
}
XDGDataDirs.push_front(getXDGDataHome());
auto XDGDataHome = getXDGDataHome();
if (XDGDataDirs.contains(XDGDataHome)) {
XDGDataDirs.removeAll(XDGDataHome);
}
XDGDataDirs.push_front(XDGDataHome);
return XDGDataDirs;
}
@ -416,6 +421,7 @@ inline QStringList getDesktopFileDirs()
}
str.append("applications");
});
return XDGDataDirs;
}