Differential D20265 Diff 57643 libnotificationmanager/settings.cpp

Changeset View

Standalone View

libnotificationmanager/settings.cpp

This file was added.

		1		/*
		2		* Copyright 2019 Kai Uwe Broulik <kde@privat.broulik.de>
		3		*
		4		* This library is free software; you can redistribute it and/or
		5		* modify it under the terms of the GNU Lesser General Public
		6		* License as published by the Free Software Foundation; either
		7		* version 2.1 of the License, or (at your option) version 3, or any
		8		* later version accepted by the membership of KDE e.V. (or its
		9		* successor approved by the membership of KDE e.V.), which shall
		10		* act as a proxy defined in Section 6 of version 3 of the license.
		11		*
		12		* This library is distributed in the hope that it will be useful,
		13		* but WITHOUT ANY WARRANTY; without even the implied warranty of
		14		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		15		* Lesser General Public License for more details.
		16		*
		17		* You should have received a copy of the GNU Lesser General Public
		18		* License along with this library. If not, see <http://www.gnu.org/licenses/>.
		19		*/
		20
		21		#include "settings.h"
		22
		23		#include <QDebug>
		24
		25		#include <KConfigWatcher>
		26		#include <KService>
		27
		28		#include "server.h"
		29		#include "debug.h"
		30
		31		// Settings
		32		#include "donotdisturbsettings.h"
		33		#include "notificationsettings.h"
		34		#include "jobsettings.h"
		35		#include "badgesettings.h"
		36
		37		using namespace NotificationManager;
		38
		39		class Q_DECL_HIDDEN Settings::Private
		40		{
		41		public:
		42		explicit Private(Settings *q);
		43		~Private();
		44
		45		void setDirty(bool dirty);
		46
		47		Settings::NotificationBehaviors groupBehavior(const KConfigGroup &group) const;
		48		void setGroupBehavior(KConfigGroup &group, const Settings::NotificationBehaviors &behavior);
		49
		50		KConfigGroup servicesGroup() const;
		51		KConfigGroup applicationsGroup() const;
		52
		53		QStringList behaviorMatchesList(const KConfigGroup &group, Settings::NotificationBehavior behavior, bool on) const;
		54
		55		Settings *q;
		56
		57		KSharedConfig::Ptr config;
		58
		59		KConfigWatcher::Ptr watcher;
		60		QMetaObject::Connection watcherConnection;
		61
		62		bool live = false; // set to true initially in constructor
		63		bool dirty = false;
		64
		65		};
		66
		67		Settings::Private::Private(Settings *q)
		68		: q(q)
		69		{
		70
		71		}
		72
		73		Settings::Private::~Private() = default;
		74
		75		void Settings::Private::setDirty(bool dirty)
		76		{
		77		if (this->dirty != dirty) {
		78		this->dirty = dirty;
		79		emit q->dirtyChanged();
		80		}
		81		}
		82
		83		Settings::NotificationBehaviors Settings::Private::groupBehavior(const KConfigGroup &group) const
		84		{
		85		Settings::NotificationBehaviors behaviors;
		86		behaviors.setFlag(Settings::ShowPopups, group.readEntry("ShowPopups", true));
		87		// show popups in dnd mode implies the show popups
		88		behaviors.setFlag(Settings::ShowPopupsInDoNotDisturbMode, behaviors.testFlag(Settings::ShowPopups) && group.readEntry("ShowPopupsInDndMode", false));
		89		behaviors.setFlag(Settings::ShowInHistory, group.readEntry("ShowInHistory", true));
		90		behaviors.setFlag(Settings::ShowBadges, group.readEntry("ShowBadges", true));
		91		return behaviors;
		92		}
		93
		94		void Settings::Private::setGroupBehavior(KConfigGroup &group, const Settings::NotificationBehaviors &behavior)
		95		{
		96		if (groupBehavior(group) == behavior) {
		97		return;
		98		}
		99
		100		const bool showPopups = behavior.testFlag(Settings::ShowPopups);
		101		if (showPopups && !group.hasDefault("ShowPopups")) {
		102		group.revertToDefault("ShowPopups", KConfigBase::Notify);
		103		} else {
		104		group.writeEntry("ShowPopups", showPopups, KConfigBase::Notify);
		105		}
		106
		107		const bool showPopupsInDndMode = behavior.testFlag(Settings::ShowPopupsInDoNotDisturbMode);
		108		if (!showPopupsInDndMode && !group.hasDefault("ShowPopups")) {
		109		group.revertToDefault("ShowPopupsInDndMode", KConfigBase::Notify);
		110		} else {
		111		group.writeEntry("ShowPopupsInDndMode", showPopupsInDndMode, KConfigBase::Notify);
		112		}
		113
		114		const bool showInHistory = behavior.testFlag(Settings::ShowInHistory);
		115		if (showInHistory && !group.hasDefault("ShowInHistory")) {
		116		group.revertToDefault("ShowInHistory", KConfig::Notify);
		117		} else {
		118		group.writeEntry("ShowInHistory", showInHistory, KConfigBase::Notify);
		119		}
		120
		121		const bool showBadges = behavior.testFlag(Settings::ShowBadges);
		122		if (showBadges && !group.hasDefault("ShowBadges")) {
		123		group.revertToDefault("ShowBadges", KConfigBase::Notify);
		124		} else {
		125		group.writeEntry("ShowBadges", showBadges, KConfigBase::Notify);
		126		}
		127
		128		setDirty(true);
		129		}
		130
		131		KConfigGroup Settings::Private::servicesGroup() const
		132		{
		133		return config->group("Services");
		134		}
		135
		136		KConfigGroup Settings::Private::applicationsGroup() const
		137		{
		138		return config->group("Applications");
		139		}
		140
		141		QStringList Settings::Private::behaviorMatchesList(const KConfigGroup &group, Settings::NotificationBehavior behavior, bool on) const
		142		{
		143		QStringList matches;
		144
		145		const QStringList apps = group.groupList();
		146		for (const QString &app : apps) {
		147		if (groupBehavior(group.group(app)).testFlag(behavior) == on) {
		148		matches.append(app);
		149		}
		150		}
		151
		152		return matches;
		153		}
		154
		155		Settings::Settings(QObject *parent)
		156		// FIXME static thing for config file name
		157		: Settings(KSharedConfig::openConfig(QStringLiteral("plasmanotifyrc")), parent)
		158		{
		159
		160		}
		161
		162		Settings::Settings(const KSharedConfig::Ptr &config, QObject *parent)
		163		: QObject(parent)
		164		, d(new Private(this))
		165		{
		166		d->config = config;
		167
		168		static bool s_settingsInited = false;
		169		if (!s_settingsInited) {
		170		DoNotDisturbSettings::instance(config);
		171		NotificationSettings::instance(config);
		172		JobSettings::instance(config);
		173		BadgeSettings::instance(config);
		174		s_settingsInited = true;
		175		}
		176
		177		setLive(true);
		178
		179		connect(&Server::self(), &Server::inhibitedChanged,
		180		this, &Settings::notificationsInhibitedByApplicationChanged);
		181		connect(&Server::self(), &Server::inhibitionApplicationsChanged,
		182		this, &Settings::notificationInhibitionApplicationsChanged);
		183		}
		184
		185		Settings::~Settings()
		186		{
		187		d->config->markAsClean();
		188		}
		189
		190		Settings::NotificationBehaviors Settings::applicationBehavior(const QString &desktopEntry) const
		191		{
		192		return d->groupBehavior(d->applicationsGroup().group(desktopEntry));
		193		}
		194
		195		void Settings::setApplicationBehavior(const QString &desktopEntry, NotificationBehaviors behaviors)
		196		{
		197		KConfigGroup group(d->applicationsGroup().group(desktopEntry));
		198		d->setGroupBehavior(group, behaviors);
		199		}
		200
		201		Settings::NotificationBehaviors Settings::serviceBehavior(const QString &notifyRcName) const
		202		{
		203		return d->groupBehavior(d->servicesGroup().group(notifyRcName));
		204		}
		205
		206		void Settings::setServiceBehavior(const QString &notifyRcName, NotificationBehaviors behaviors)
		207		{
		208		KConfigGroup group(d->servicesGroup().group(notifyRcName));
		209		d->setGroupBehavior(group, behaviors);
		210		}
		211
		212		void Settings::registerKnownApplication(const QString &desktopEntry)
		213		{
		214		KService::Ptr service = KService::serviceByDesktopName(desktopEntry);
		215		if (!service) {
		216		qCDebug(NOTIFICATIONMANAGER) << "Application" << desktopEntry << "cannot be registered as seen application since there is no service for it";
		217		return;
		218		}
		219
		220		if (service->noDisplay()) {
		221		qCDebug(NOTIFICATIONMANAGER) << "Application" << desktopEntry << "will not be registered as seen application since it's marked as NoDisplay";
		222		return;
		223		}
		224
		225		if (knownApplications().contains(desktopEntry)) {
		226		return;
		227		}
		228
		229		d->applicationsGroup().group(desktopEntry).writeEntry("Seen", true);
		230
		231		emit knownApplicationsChanged();
		232		}
		233
		234		void Settings::forgetKnownApplication(const QString &desktopEntry)
		235		{
		236		if (!knownApplications().contains(desktopEntry)) {
		237		return;
		238		}
		239
		240		// Only remove applications that were added through registerKnownApplication
		241		if (!d->applicationsGroup().group(desktopEntry).readEntry("Seen", false)) {
		242		qCDebug(NOTIFICATIONMANAGER) << "Application" << desktopEntry << "will not be removed from seen applications since it wasn't one.";
		243		return;
		244		}
		245
		246		d->applicationsGroup().deleteGroup(desktopEntry);
		247
		248		emit knownApplicationsChanged();
		249		}
		250
		251		void Settings::load()
		252		{
		253		d->config->markAsClean();
		254		d->config->reparseConfiguration();
		255		DoNotDisturbSettings::self()->load();
		256		NotificationSettings::self()->load();
		257		JobSettings::self()->load();
		258		BadgeSettings::self()->load();
		259		emit settingsChanged();
		260		d->setDirty(false);
		261		}
		262
		263		void Settings::save()
		264		{
		265		DoNotDisturbSettings::self()->save();
		266		NotificationSettings::self()->save();
		267		JobSettings::self()->save();
		268		BadgeSettings::self()->save();
		269
		270		d->config->sync();
		271		d->setDirty(false);
		272		}
		273
		274		void Settings::defaults()
		275		{
		276		DoNotDisturbSettings::self()->setDefaults();
		277		NotificationSettings::self()->setDefaults();
		278		JobSettings::self()->setDefaults();
		279		BadgeSettings::self()->setDefaults();
		280		}
		281
		282		bool Settings::live() const
		283		{
		284		return d->live;
		285		}
		286
		287		void Settings::setLive(bool live)
		288		{
		289		if (live == d->live) {
		290		return;
		291		}
		292
		293		d->live = live;
		294
		295		if (live) {
		296		d->watcher = KConfigWatcher::create(d->config);
		297		d->watcherConnection = connect(d->watcher.data(), &KConfigWatcher::configChanged, this,
		298		[this](const KConfigGroup &group, const QByteArrayList &names) {
		299		Q_UNUSED(names);
		300
		301		if (group.name() == QLatin1String("DoNotDisturb")) {
		302		DoNotDisturbSettings::self()->load();
		303		} else if (group.name() == QLatin1String("Notifications")) {
		304		NotificationSettings::self()->load();
		305		} else if (group.name() == QLatin1String("Jobs")) {
		306		JobSettings::self()->load();
		307		} else if (group.name() == QLatin1String("Badges")) {
		308		BadgeSettings::self()->load();
		309		}
		310
		311		emit settingsChanged();
		312		});
		313		} else {
		314		disconnect(d->watcherConnection);
		315		d->watcherConnection = QMetaObject::Connection();
		316		d->watcher.reset();
		317		}
		318
		319		emit liveChanged();
		320		}
		321
		322		bool Settings::dirty() const
		323		{
		324		// KConfigSkeleton doesn't write into the KConfig until calling save()
		325		// so we need to track d->config->isDirty() manually
		326		return d->dirty;
		327		}
		328
		329		bool Settings::keepCriticalAlwaysOnTop() const
		330		{
		331		return NotificationSettings::criticalAlwaysOnTop();
		332		}
		333
		334		void Settings::setKeepCriticalAlwaysOnTop(bool enable)
		335		{
		336		if (this->keepCriticalAlwaysOnTop() == enable) {
		337		return;
		338		}
		339		NotificationSettings::setCriticalAlwaysOnTop(enable);
		340		d->setDirty(true);
		341		}
		342
		343		bool Settings::criticalPopupsInDoNotDisturbMode() const
		344		{
		345		return NotificationSettings::criticalInDndMode();
		346		}
		347
		348		void Settings::setCriticalPopupsInDoNotDisturbMode(bool enable)
		349		{
		350		if (this->criticalPopupsInDoNotDisturbMode() == enable) {
		351		return;
		352		}
		353		NotificationSettings::setCriticalInDndMode(enable);
		354		d->setDirty(true);
		355		}
		356
		357		bool Settings::lowPriorityPopups() const
		358		{
		359		return NotificationSettings::lowPriorityPopups();
		360		}
		361
		362		void Settings::setLowPriorityPopups(bool enable)
		363		{
		364		if (this->lowPriorityPopups() == enable) {
		365		return;
		366		}
		367		NotificationSettings::setLowPriorityPopups(enable);
		368		d->setDirty(true);
		369		}
		370
		371		bool Settings::lowPriorityHistory() const
		372		{
		373		return NotificationSettings::lowPriorityHistory();
		374		}
		375
		376		void Settings::setLowPriorityHistory(bool enable)
		377		{
		378		if (this->lowPriorityHistory() == enable) {
		379		return;
		380		}
		381		NotificationSettings::setLowPriorityHistory(enable);
		382		d->setDirty(true);
		383		}
		384
		385		Settings::PopupPosition Settings::popupPosition() const
		386		{
		387		return NotificationSettings::popupPosition();
		388		}
		389
		390		void Settings::setPopupPosition(Settings::PopupPosition position)
		391		{
		392		if (this->popupPosition() == position) {
		393		return;
		394		}
		395		NotificationSettings::setPopupPosition(position);
		396		d->setDirty(true);
		397		}
		398
		399		int Settings::popupTimeout() const
		400		{
		401		return NotificationSettings::popupTimeout();
		402		}
		403
		404		void Settings::setPopupTimeout(int timeout)
		405		{
		406		if (this->popupTimeout() == timeout) {
		407		return;
		408		}
		409		NotificationSettings::setPopupTimeout(timeout);
		410		d->setDirty(true);
		411		}
		412
		413		void Settings::resetPopupTimeout()
		414		{
		415		setPopupTimeout(NotificationSettings::defaultPopupTimeoutValue());
		416		}
		417
		418		bool Settings::jobsInTaskManager() const
		419		{
		420		return JobSettings::inTaskManager();
		421		}
		422
		423		void Settings::setJobsInTaskManager(bool enable)
		424		{
		425		if (jobsInTaskManager() == enable) {
		426		return;
		427		}
		428		JobSettings::setInTaskManager(enable);
		429		d->setDirty(true);
		430		}
		431
		432		bool Settings::jobsInNotifications() const
		433		{
		434		return JobSettings::inNotifications();
		435		}
		436		void Settings::setJobsInNotifications(bool enable)
		437		{
		438		if (jobsInNotifications() == enable) {
		439		return;
		440		}
		441		JobSettings::setInNotifications(enable);
		442		d->setDirty(true);
		443		}
		444
		445		bool Settings::permanentJobPopups() const
		446		{
		447		return JobSettings::permanentPopups();
		448		}
		449
		450		void Settings::setPermanentJobPopups(bool enable)
		451		{
		452		if (permanentJobPopups() == enable) {
		453		return;
		454		}
		455		JobSettings::setPermanentPopups(enable);
		456		d->setDirty(true);
		457		}
		458
		459		bool Settings::badgesInTaskManager() const
		460		{
		461		return BadgeSettings::inTaskManager();
		462		}
		463
		464		void Settings::setBadgesInTaskManager(bool enable)
		465		{
		466		if (badgesInTaskManager() == enable) {
		467		return;
		468		}
		469		BadgeSettings::setInTaskManager(enable);
		470		d->setDirty(true);
		471		}
		472
		473		QStringList Settings::knownApplications() const
		474		{
		475		return d->applicationsGroup().groupList();
		476		}
		477
		478		QStringList Settings::popupBlacklistedApplications() const
		479		{
		480		return d->behaviorMatchesList(d->applicationsGroup(), ShowPopups, false);
		481		}
		482
		483		QStringList Settings::popupBlacklistedServices() const
		484		{
		485		return d->behaviorMatchesList(d->servicesGroup(), ShowPopups, false);
		486		}
		487
		488		QStringList Settings::doNotDisturbPopupWhitelistedApplications() const
		489		{
		490		return d->behaviorMatchesList(d->applicationsGroup(), ShowPopupsInDoNotDisturbMode, true);
		491		}
		492
		493		QStringList Settings::doNotDisturbPopupWhitelistedServices() const
		494		{
		495		return d->behaviorMatchesList(d->servicesGroup(), ShowPopupsInDoNotDisturbMode, true);
		496		}
		497
		498		QStringList Settings::historyBlacklistedApplications() const
		499		{
		500		return d->behaviorMatchesList(d->applicationsGroup(), ShowInHistory, false);
		501		}
		502
		503		QStringList Settings::historyBlacklistedServices() const
		504		{
		505		return d->behaviorMatchesList(d->servicesGroup(), ShowInHistory, false);
		506		}
		507
		508		QDateTime Settings::notificationsInhibitedUntil() const
		509		{
		510		return DoNotDisturbSettings::until();
		511		}
		512
		513		void Settings::setNotificationsInhibitedUntil(const QDateTime &time)
		514		{
		515		DoNotDisturbSettings::setUntil(time);
		516		d->setDirty(true);
		517		}
		518
		519		void Settings::resetNotificationsInhibitedUntil()
		520		{
		521		setNotificationsInhibitedUntil(QDateTime());// FIXME DoNotDisturbSettings::defaultUntilValue());
		522		}
		523
		524		bool Settings::notificationsInhibitedByApplication() const
		525		{
		526		return Server::self().inhibited();
		527		}
		528
		529		QStringList Settings::notificationInhibitionApplications() const
		530		{
		531		return Server::self().inhibitionApplications();
		532		}
		533
		534		QStringList Settings::notificationInhibitionReasons() const
		535		{
		536		return Server::self().inhibitionReasons();
		537		}
		538
		539		void Settings::revokeApplicationInhibitions()
		540		{
		541		Server::self().clearInhibitions();
		542		}
		543
		544		bool Settings::notificationSoundsInhibited() const
		545		{
		546		return DoNotDisturbSettings::notificationSoundsMuted();
		547		}
		548
		549		void Settings::setNotificationSoundsInhibited(bool inhibited)
		550		{
		551		if (inhibited == notificationSoundsInhibited()) {
		552		return;
		553		}
		554
		555		DoNotDisturbSettings::setNotificationSoundsMuted(inhibited);
		556		d->setDirty(true);
		557		}