File indexing completed on 2024-12-01 06:43:58
0001 /* 0002 This file is part of the KDE libraries 0003 SPDX-FileCopyrightText: 1999 David Faure <faure@kde.org> 0004 SPDX-FileCopyrightText: 2000 Waldo Bastian <bastian@kde.org> 0005 0006 SPDX-License-Identifier: LGPL-2.0-only 0007 */ 0008 0009 #include "kded.h" 0010 #include "kded_debug.h" 0011 #include "kded_version.h" 0012 #include "kdedadaptor.h" 0013 0014 #include <KCrash> 0015 0016 #include <qplatformdefs.h> 0017 0018 #include <QApplication> 0019 #include <QCommandLineParser> 0020 #include <QDir> 0021 #include <QLoggingCategory> 0022 #include <QProcess> 0023 0024 #include <QDBusConnection> 0025 #include <QDBusConnectionInterface> 0026 #include <QDBusServiceWatcher> 0027 0028 #include <KConfigGroup> 0029 #include <KDBusService> 0030 #include <KDirWatch> 0031 #include <KPluginFactory> 0032 #include <KPluginMetaData> 0033 #include <KSharedConfig> 0034 0035 #include <memory> 0036 0037 Kded *Kded::_self = nullptr; 0038 0039 static bool delayedCheck; 0040 static bool bCheckSycoca; 0041 static bool bCheckUpdates; 0042 0043 #ifdef Q_DBUS_EXPORT 0044 extern Q_DBUS_EXPORT void qDBusAddSpyHook(void (*)(const QDBusMessage &)); 0045 #else 0046 extern QDBUS_EXPORT void qDBusAddSpyHook(void (*)(const QDBusMessage &)); 0047 #endif 0048 0049 static void runKonfUpdate() 0050 { 0051 QProcess kconfUpdate; 0052 kconfUpdate.start(QStringLiteral(KCONF_UPDATE_EXE), QStringList()); 0053 kconfUpdate.waitForFinished(); 0054 } 0055 0056 Kded::Kded() 0057 : m_pDirWatch(new KDirWatch(this)) 0058 , m_pTimer(new QTimer(this)) 0059 , m_needDelayedCheck(false) 0060 { 0061 _self = this; 0062 0063 m_serviceWatcher = new QDBusServiceWatcher(this); 0064 m_serviceWatcher->setConnection(QDBusConnection::sessionBus()); 0065 m_serviceWatcher->setWatchMode(QDBusServiceWatcher::WatchForUnregistration); 0066 QObject::connect(m_serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, this, &Kded::slotApplicationRemoved); 0067 0068 new KdedAdaptor(this); 0069 0070 QDBusConnection session = QDBusConnection::sessionBus(); 0071 session.registerObject(QStringLiteral("/kbuildsycoca"), this); 0072 session.registerObject(QStringLiteral("/kded"), this); 0073 0074 m_pTimer->setSingleShot(true); 0075 connect(m_pTimer, &QTimer::timeout, this, static_cast<void (Kded::*)()>(&Kded::recreate)); 0076 } 0077 0078 Kded::~Kded() 0079 { 0080 _self = nullptr; 0081 m_pTimer->stop(); 0082 0083 for (auto it = m_modules.cbegin(); it != m_modules.cend(); ++it) { 0084 delete *it; 0085 } 0086 m_modules.clear(); 0087 } 0088 0089 // on-demand module loading 0090 // this function is called by the D-Bus message processing function before 0091 // calls are delivered to objects 0092 void Kded::messageFilter(const QDBusMessage &message) 0093 { 0094 // This happens when kded goes down and some modules try to clean up. 0095 if (!self()) { 0096 return; 0097 } 0098 0099 QString obj = KDEDModule::moduleForMessage(message); 0100 if (obj.isEmpty() || obj == QLatin1String("ksycoca")) { 0101 return; 0102 } 0103 0104 if (self()->m_dontLoad.value(obj, nullptr)) { 0105 return; 0106 } 0107 0108 self()->loadModule(obj, true); 0109 } 0110 0111 static int phaseForModule(const KPluginMetaData &module) 0112 { 0113 return module.value(QStringLiteral("X-KDE-Kded-phase"), 2); 0114 } 0115 0116 QList<KPluginMetaData> Kded::availableModules() const 0117 { 0118 QList<KPluginMetaData> plugins = KPluginMetaData::findPlugins(QStringLiteral("kf6/kded")); 0119 QSet<QString> moduleIds; 0120 for (const KPluginMetaData &md : std::as_const(plugins)) { 0121 moduleIds.insert(md.pluginId()); 0122 } 0123 return plugins; 0124 } 0125 0126 static KPluginMetaData findModule(const QString &id) 0127 { 0128 KPluginMetaData module(QStringLiteral("kf6/kded/") + id); 0129 if (module.isValid()) { 0130 return module; 0131 } 0132 qCWarning(KDED) << "could not find kded module with id" << id; 0133 return KPluginMetaData(); 0134 } 0135 0136 void Kded::initModules() 0137 { 0138 m_dontLoad.clear(); 0139 0140 bool kde_running = !qEnvironmentVariableIsEmpty("KDE_FULL_SESSION"); 0141 if (kde_running) { 0142 // not the same user like the one running the session (most likely we're run via sudo or something) 0143 const QByteArray sessionUID = qgetenv("KDE_SESSION_UID"); 0144 if (!sessionUID.isEmpty() && uid_t(sessionUID.toInt()) != getuid()) { 0145 kde_running = false; 0146 } 0147 // not the same kde version as the current desktop 0148 const QByteArray kdeSession = qgetenv("KDE_SESSION_VERSION"); 0149 if (kdeSession.toInt() != 6) { 0150 kde_running = false; 0151 } 0152 } 0153 0154 // Preload kded modules. 0155 const QList<KPluginMetaData> kdedModules = availableModules(); 0156 for (const KPluginMetaData &module : kdedModules) { 0157 // Should the service load on startup? 0158 const bool autoload = isModuleAutoloaded(module); 0159 if (!platformSupportsModule(module)) { 0160 continue; 0161 } 0162 0163 // see ksmserver's README for description of the phases 0164 bool prevent_autoload = false; 0165 switch (phaseForModule(module)) { 0166 case 0: // always autoload 0167 break; 0168 case 1: // autoload only in KDE 0169 if (!kde_running) { 0170 prevent_autoload = true; 0171 } 0172 break; 0173 case 2: // autoload delayed, only in KDE 0174 default: 0175 if (!kde_running) { 0176 prevent_autoload = true; 0177 } 0178 break; 0179 } 0180 0181 // Load the module if necessary and allowed 0182 if (autoload && !prevent_autoload) { 0183 if (!loadModule(module, false)) { 0184 continue; 0185 } 0186 } 0187 0188 // Remember if the module is allowed to load on demand 0189 bool loadOnDemand = isModuleLoadedOnDemand(module); 0190 if (!loadOnDemand) { 0191 noDemandLoad(module.pluginId()); 0192 } 0193 0194 // In case of reloading the configuration it is possible for a module 0195 // to run even if it is now allowed to. Stop it then. 0196 if (!loadOnDemand && !autoload) { 0197 unloadModule(module.pluginId()); 0198 } 0199 } 0200 } 0201 0202 void Kded::noDemandLoad(const QString &obj) 0203 { 0204 m_dontLoad.insert(obj, this); 0205 } 0206 0207 void Kded::setModuleAutoloading(const QString &obj, bool autoload) 0208 { 0209 KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("kded5rc")); 0210 // Ensure the service exists. 0211 KPluginMetaData module = findModule(obj); 0212 if (!module.isValid()) { 0213 return; 0214 } 0215 KConfigGroup cg(config, QStringLiteral("Module-").append(module.pluginId())); 0216 cg.writeEntry("autoload", autoload); 0217 cg.sync(); 0218 } 0219 0220 bool Kded::isModuleAutoloaded(const QString &obj) const 0221 { 0222 return isModuleAutoloaded(findModule(obj)); 0223 } 0224 0225 bool Kded::isModuleAutoloaded(const KPluginMetaData &module) const 0226 { 0227 if (!module.isValid()) { 0228 return false; 0229 } 0230 KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("kded5rc")); 0231 bool autoload = module.value(QStringLiteral("X-KDE-Kded-autoload"), false); 0232 KConfigGroup cg(config, QStringLiteral("Module-").append(module.pluginId())); 0233 autoload = cg.readEntry("autoload", autoload); 0234 return autoload; 0235 } 0236 0237 bool Kded::platformSupportsModule(const KPluginMetaData &module) const 0238 { 0239 const QStringList supportedPlatforms = module.value(QStringLiteral("X-KDE-OnlyShowOnQtPlatforms"), QStringList()); 0240 0241 return supportedPlatforms.isEmpty() || supportedPlatforms.contains(qApp->platformName()); 0242 } 0243 0244 bool Kded::isModuleLoadedOnDemand(const QString &obj) const 0245 { 0246 return isModuleLoadedOnDemand(findModule(obj)); 0247 } 0248 0249 bool Kded::isModuleLoadedOnDemand(const KPluginMetaData &module) const 0250 { 0251 if (!module.isValid()) { 0252 return false; 0253 } 0254 KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("kded5rc")); 0255 return module.value(QStringLiteral("X-KDE-Kded-load-on-demand"), true); 0256 } 0257 0258 KDEDModule *Kded::loadModule(const QString &obj, bool onDemand) 0259 { 0260 // Make sure this method is only called with valid module names. 0261 if (obj.contains(QLatin1Char('/'))) { 0262 qCWarning(KDED) << "attempting to load invalid kded module name:" << obj; 0263 return nullptr; 0264 } 0265 KDEDModule *module = m_modules.value(obj, nullptr); 0266 if (module) { 0267 return module; 0268 } 0269 return loadModule(findModule(obj), onDemand); 0270 } 0271 0272 KDEDModule *Kded::loadModule(const KPluginMetaData &module, bool onDemand) 0273 { 0274 if (!module.isValid() || module.fileName().isEmpty()) { 0275 qCWarning(KDED) << "attempted to load an invalid module."; 0276 return nullptr; 0277 } 0278 const QString moduleId = module.pluginId(); 0279 KDEDModule *oldModule = m_modules.value(moduleId, nullptr); 0280 if (oldModule) { 0281 qCDebug(KDED) << "kded module" << moduleId << "is already loaded."; 0282 return oldModule; 0283 } 0284 0285 if (onDemand) { 0286 if (!module.value(QStringLiteral("X-KDE-Kded-load-on-demand"), true)) { 0287 noDemandLoad(moduleId); 0288 return nullptr; 0289 } 0290 } 0291 0292 KDEDModule *kdedModule = nullptr; 0293 0294 auto factoryResult = KPluginFactory::loadFactory(module); 0295 if (factoryResult) { 0296 kdedModule = factoryResult.plugin->create<KDEDModule>(this); 0297 } else { 0298 qCWarning(KDED).nospace() << "Could not load kded module " << moduleId << ":" << factoryResult.errorText << " (library path was:" << module.fileName() 0299 << ")"; 0300 } 0301 0302 if (kdedModule) { 0303 kdedModule->setModuleName(moduleId); 0304 m_modules.insert(moduleId, kdedModule); 0305 // m_libs.insert(moduleId, lib); 0306 qCDebug(KDED) << "Successfully loaded module" << moduleId; 0307 return kdedModule; 0308 } 0309 return nullptr; 0310 } 0311 0312 bool Kded::unloadModule(const QString &obj) 0313 { 0314 KDEDModule *module = m_modules.value(obj, nullptr); 0315 if (!module) { 0316 return false; 0317 } 0318 qCDebug(KDED) << "Unloading module" << obj; 0319 m_modules.remove(obj); 0320 delete module; 0321 return true; 0322 } 0323 0324 QStringList Kded::loadedModules() 0325 { 0326 return m_modules.keys(); 0327 } 0328 0329 void Kded::slotApplicationRemoved(const QString &name) 0330 { 0331 #if 0 // see kdedmodule.cpp (KDED_OBJECTS) 0332 foreach (KDEDModule *module, m_modules) { 0333 module->removeAll(appId); 0334 } 0335 #endif 0336 m_serviceWatcher->removeWatchedService(name); 0337 const QList<qlonglong> windowIds = m_windowIdList.value(name); 0338 for (const auto id : windowIds) { 0339 m_globalWindowIdList.remove(id); 0340 for (KDEDModule *module : std::as_const(m_modules)) { 0341 Q_EMIT module->windowUnregistered(id); 0342 } 0343 } 0344 m_windowIdList.remove(name); 0345 } 0346 0347 void Kded::updateDirWatch() 0348 { 0349 if (!bCheckUpdates) { 0350 return; 0351 } 0352 0353 delete m_pDirWatch; 0354 m_pDirWatch = new KDirWatch(this); 0355 0356 QObject::connect(m_pDirWatch, &KDirWatch::dirty, this, &Kded::update); 0357 QObject::connect(m_pDirWatch, &KDirWatch::created, this, &Kded::update); 0358 QObject::connect(m_pDirWatch, &KDirWatch::deleted, this, &Kded::dirDeleted); 0359 0360 // For each resource 0361 for (const QString &dir : std::as_const(m_allResourceDirs)) { 0362 readDirectory(dir); 0363 } 0364 0365 QStringList dataDirs = QStandardPaths::standardLocations(QStandardPaths::GenericDataLocation); 0366 for (auto &dir : dataDirs) { 0367 dir += QLatin1String("/icons"); 0368 if (!m_pDirWatch->contains(dir)) { 0369 m_pDirWatch->addDir(dir, KDirWatch::WatchDirOnly); 0370 } 0371 } 0372 } 0373 0374 void Kded::updateResourceList() 0375 { 0376 KSycoca::clearCaches(); 0377 0378 if (!bCheckUpdates) { 0379 return; 0380 } 0381 0382 if (delayedCheck) { 0383 return; 0384 } 0385 0386 const QStringList dirs = KSycoca::self()->allResourceDirs(); 0387 // For each resource 0388 for (const auto &dir : dirs) { 0389 if (!m_allResourceDirs.contains(dir)) { 0390 m_allResourceDirs.append(dir); 0391 readDirectory(dir); 0392 } 0393 } 0394 } 0395 0396 void Kded::recreate() 0397 { 0398 recreate(false); 0399 } 0400 0401 void Kded::runDelayedCheck() 0402 { 0403 if (m_needDelayedCheck) { 0404 recreate(false); 0405 } 0406 m_needDelayedCheck = false; 0407 } 0408 0409 void Kded::recreate(bool initial) 0410 { 0411 // Using KLauncher here is difficult since we might not have a 0412 // database 0413 0414 if (!initial) { 0415 updateDirWatch(); // Update tree first, to be sure to miss nothing. 0416 KSycoca::self()->ensureCacheValid(); 0417 recreateDone(); 0418 } else { 0419 if (!delayedCheck) { 0420 updateDirWatch(); // this would search all the directories 0421 } 0422 if (bCheckSycoca) { 0423 KSycoca::self()->ensureCacheValid(); 0424 } 0425 recreateDone(); 0426 if (delayedCheck) { 0427 // do a proper ksycoca check after a delay 0428 QTimer::singleShot(60000, this, &Kded::runDelayedCheck); 0429 m_needDelayedCheck = true; 0430 delayedCheck = false; 0431 } else { 0432 m_needDelayedCheck = false; 0433 } 0434 } 0435 } 0436 0437 void Kded::recreateDone() 0438 { 0439 updateResourceList(); 0440 0441 initModules(); 0442 } 0443 0444 void Kded::dirDeleted(const QString &path) 0445 { 0446 update(path); 0447 } 0448 0449 void Kded::update(const QString &path) 0450 { 0451 if (path.endsWith(QLatin1String("/icons")) && m_pDirWatch->contains(path)) { 0452 // If the dir was created or updated there could be new folders to merge into the active theme(s) 0453 QDBusMessage message = QDBusMessage::createSignal(QStringLiteral("/KIconLoader"), QStringLiteral("org.kde.KIconLoader"), QStringLiteral("iconChanged")); 0454 message << 0; 0455 QDBusConnection::sessionBus().send(message); 0456 } else { 0457 m_pTimer->start(1000); 0458 } 0459 } 0460 0461 void Kded::readDirectory(const QString &_path) 0462 { 0463 QString path(_path); 0464 if (!path.endsWith(QLatin1Char('/'))) { 0465 path += QLatin1Char('/'); 0466 } 0467 0468 if (m_pDirWatch->contains(path)) { // Already seen this one? 0469 return; 0470 } 0471 0472 Q_ASSERT(path != QDir::homePath()); 0473 m_pDirWatch->addDir(path, KDirWatch::WatchFiles | KDirWatch::WatchSubDirs); // add watch on this dir 0474 } 0475 0476 void Kded::registerWindowId(qlonglong windowId, const QString &sender) 0477 { 0478 if (!m_windowIdList.contains(sender)) { 0479 m_serviceWatcher->addWatchedService(sender); 0480 } 0481 0482 m_globalWindowIdList.insert(windowId); 0483 QList<qlonglong> windowIds = m_windowIdList.value(sender); 0484 windowIds.append(windowId); 0485 m_windowIdList.insert(sender, windowIds); 0486 0487 for (KDEDModule *module : std::as_const(m_modules)) { 0488 qCDebug(KDED) << module->moduleName(); 0489 Q_EMIT module->windowRegistered(windowId); 0490 } 0491 } 0492 0493 void Kded::unregisterWindowId(qlonglong windowId, const QString &sender) 0494 { 0495 m_globalWindowIdList.remove(windowId); 0496 QList<qlonglong> windowIds = m_windowIdList.value(sender); 0497 if (!windowIds.isEmpty()) { 0498 windowIds.removeAll(windowId); 0499 if (windowIds.isEmpty()) { 0500 m_serviceWatcher->removeWatchedService(sender); 0501 m_windowIdList.remove(sender); 0502 } else { 0503 m_windowIdList.insert(sender, windowIds); 0504 } 0505 } 0506 0507 for (KDEDModule *module : std::as_const(m_modules)) { 0508 qCDebug(KDED) << module->moduleName(); 0509 Q_EMIT module->windowUnregistered(windowId); 0510 } 0511 } 0512 0513 static void sighandler(int /*sig*/) 0514 { 0515 if (qApp) { 0516 qApp->quit(); 0517 } 0518 } 0519 0520 KUpdateD::KUpdateD() 0521 { 0522 m_pDirWatch = new KDirWatch(this); 0523 m_pTimer = new QTimer(this); 0524 m_pTimer->setSingleShot(true); 0525 connect(m_pTimer, &QTimer::timeout, this, &KUpdateD::runKonfUpdate); 0526 QObject::connect(m_pDirWatch, &KDirWatch::dirty, this, &KUpdateD::slotNewUpdateFile); 0527 0528 QStringList dirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("kconf_update"), QStandardPaths::LocateDirectory); 0529 for (auto &path : dirs) { 0530 Q_ASSERT(path != QDir::homePath()); 0531 if (!path.endsWith(QLatin1Char('/'))) { 0532 path += QLatin1Char('/'); 0533 } 0534 0535 if (!m_pDirWatch->contains(path)) { 0536 m_pDirWatch->addDir(path, KDirWatch::WatchFiles); 0537 } 0538 } 0539 } 0540 0541 KUpdateD::~KUpdateD() 0542 { 0543 } 0544 0545 void KUpdateD::runKonfUpdate() 0546 { 0547 ::runKonfUpdate(); 0548 } 0549 0550 void KUpdateD::slotNewUpdateFile(const QString &dirty) 0551 { 0552 Q_UNUSED(dirty); 0553 qCDebug(KDED) << dirty; 0554 m_pTimer->start(500); 0555 } 0556 0557 static void setupAppInfo(QApplication *app) 0558 { 0559 app->setApplicationName(QStringLiteral("kded6")); 0560 app->setOrganizationDomain(QStringLiteral("kde.org")); 0561 app->setApplicationVersion(QStringLiteral(KDED_VERSION_STRING)); 0562 } 0563 0564 static bool detectPlatform(int argc, char **argv) 0565 { 0566 if (qEnvironmentVariableIsSet("QT_QPA_PLATFORM")) { 0567 return false; 0568 } 0569 for (int i = 0; i < argc; i++) { 0570 /* clang-format off */ 0571 if (qstrcmp(argv[i], "-platform") == 0 0572 || qstrcmp(argv[i], "--platform") == 0 0573 || QByteArrayView(argv[i]).startsWith("-platform=") 0574 || QByteArrayView(argv[i]).startsWith("--platform=")) { /* clang-format on */ 0575 return false; 0576 } 0577 } 0578 const QByteArray sessionType = qgetenv("XDG_SESSION_TYPE"); 0579 if (sessionType.isEmpty()) { 0580 return false; 0581 } 0582 if (qstrcmp(sessionType.data(), "wayland") == 0) { 0583 qputenv("QT_QPA_PLATFORM", "wayland"); 0584 return true; 0585 } else if (qstrcmp(sessionType.data(), "x11") == 0) { 0586 qputenv("QT_QPA_PLATFORM", "xcb"); 0587 return true; 0588 } 0589 return false; 0590 } 0591 0592 int main(int argc, char *argv[]) 0593 { 0594 // options.add("check", qi18n("Check Sycoca database only once")); 0595 0596 // WABA: Make sure not to enable session management. 0597 qunsetenv("SESSION_MANAGER"); 0598 0599 const bool unsetQpa = detectPlatform(argc, argv); 0600 0601 // In older versions, QApplication creation was postponed until after 0602 // testing for --check, in which case, only a QCoreApplication was created. 0603 // Since that option is no longer used at startup, we removed that speed 0604 // optimization for code clarity and easier support of standard parameters. 0605 0606 QApplication app(argc, argv); 0607 if (unsetQpa) { 0608 qunsetenv("QT_QPA_PLATFORM"); 0609 } 0610 setupAppInfo(&app); 0611 app.setQuitOnLastWindowClosed(false); 0612 app.setQuitLockEnabled(false); 0613 0614 QCommandLineParser parser; 0615 parser.addHelpOption(); 0616 parser.addVersionOption(); 0617 parser.addOption(QCommandLineOption(QStringLiteral("check"), QStringLiteral("Check cache validity"))); 0618 QCommandLineOption replaceOption({QStringLiteral("replace")}, QStringLiteral("Replace an existing instance")); 0619 parser.addOption(replaceOption); 0620 parser.process(app); 0621 0622 // Parse command line before checking D-Bus 0623 if (parser.isSet(QStringLiteral("check"))) { 0624 // KDBusService not wanted here. 0625 KSycoca::self()->ensureCacheValid(); 0626 runKonfUpdate(); 0627 return 0; 0628 } 0629 0630 // Qt now has DBus in another thread, so we need to handle any messages 0631 // between the service registration and our paths existing 0632 // This means adding the spy now, so any received message gets 0633 // posted to the main thread 0634 qDBusAddSpyHook(Kded::messageFilter); 0635 0636 QDBusConnectionInterface *bus = QDBusConnection::sessionBus().interface(); 0637 // Also register as all the names we should respond to (org.kde.kcookiejar, org.kde.khotkeys etc.) 0638 // so that the calling code is independent from the physical "location" of the service. 0639 const QList<KPluginMetaData> plugins = KPluginMetaData::findPlugins(QStringLiteral("kf6/kded")); 0640 for (const KPluginMetaData &metaData : plugins) { 0641 const QString serviceName = metaData.value(QStringLiteral("X-KDE-DBus-ServiceName")); 0642 if (serviceName.isEmpty()) { 0643 continue; 0644 } 0645 // register them queued as an old kded could be running at this point 0646 if (!bus->registerService(serviceName, QDBusConnectionInterface::QueueService)) { 0647 qCWarning(KDED) << "Couldn't register name" << serviceName << "with DBUS - another process owns it already!"; 0648 } 0649 } 0650 KDBusService service(KDBusService::Unique | KDBusService::StartupOption(parser.isSet(replaceOption) ? KDBusService::Replace : 0)); 0651 0652 KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("kded5rc")); 0653 KConfigGroup cg(config, QStringLiteral("General")); 0654 0655 bCheckSycoca = cg.readEntry("CheckSycoca", true); 0656 bCheckUpdates = cg.readEntry("CheckUpdates", true); 0657 delayedCheck = cg.readEntry("DelayedCheck", false); 0658 0659 signal(SIGTERM, sighandler); 0660 signal(SIGHUP, sighandler); 0661 0662 KCrash::setFlags(KCrash::AutoRestart); 0663 0664 std::unique_ptr<Kded> kded = std::make_unique<Kded>(); 0665 0666 kded->recreate(true); // initial 0667 0668 if (bCheckUpdates) { 0669 (void)new KUpdateD; // Watch for updates 0670 } 0671 0672 runKonfUpdate(); // Run it once. 0673 0674 return app.exec(); // keep running 0675 } 0676 0677 #include "moc_kded.cpp"