Differential D20265 Diff 56056 libnotificationmanager/notifications.cpp

Changeset View

Standalone View

View Options

libnotificationmanager/notifications.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 "notifications.h"
22​
23​#include <QDebug>
24​#include <QSharedPointer>
25​
26​#include <KConcatenateRowsProxyModel>
27​#include <KDescendantsProxyModel>
28​
29​#include "notificationsmodel.h"
30​#include "notificationfilterproxymodel_p.h"
31​#include "notificationsortproxymodel_p.h"
32​#include "notificationgroupingproxymodel_p.h"
33​#include "notificationgroupcollapsingproxymodel_p.h"
34​#include "limitedrowcountproxymodel_p.h"
35​
36​#include "jobsmodel.h"
37​
38​#include "settings.h"
39​
40​#include "notification.h"
41​
42​#include "utils_p.h"
43​
44​#include "debug.h"
45​
46​using namespace NotificationManager;
47​
48​class Q_DECL_HIDDEN Notifications::Private
49​{
50​public:
51​ explicit Private(Notifications *q);
52​ ~Private();
53​
54​ void initSourceModels();
55​ void initProxyModels();
56​
57​ void updateCount();
58​
59​ bool showNotifications = true;
60​ bool showJobs = false;
61​
62​ Notifications::GroupMode groupMode = Notifications::GroupDisabled;
63​ int groupLimit = 0;
64​ bool expandUnread = false;
65​
66​ int activeNotificationsCount = 0;
67​ int expiredNotificationsCount = 0;
68​
69​ int unreadNotificationsCount = 0;
70​
71​ int activeJobsCount = 0;
72​ int jobsPercentage = 0;
73​
74​ static bool isGroup(const QModelIndex &idx);
75​ static uint notificationId(const QModelIndex &idx);
76​ QModelIndex mapFromModel(const QModelIndex &idx) const;
heinUnsubmitted
Not Done

Have you considered using KModelIndexProxyMapper from KF5::ItemModels?

hein: Have you considered using `KModelIndexProxyMapper` from KF5::ItemModels?
broulikAuthorUnsubmitted
Not Done

I have, it doesn't work for this usecase. It can only map a tree via a single model, we have it the other way round, we have a single proxy chain diverging into two. Also, KConcatenateRowsProxyModel isn't a proper proxy model, so it completely breaks KModelIndexProxyMapper

broulik: I have, it doesn't work for this usecase. It can only map a tree via a single model, we have it…
77​
78​ // NOTE when you add or re-arrange models make sure to update mapFromModel()!
79​ NotificationsModel::Ptr notificationsModel;
80​ JobsModel::Ptr jobsModel;
81​ QSharedPointer<Settings> settings() const;
82​
83​ KConcatenateRowsProxyModel *notificationsAndJobsModel = nullptr;
84​
85​ NotificationFilterProxyModel *filterModel = nullptr;
86​ NotificationSortProxyModel *sortModel = nullptr;
87​ NotificationGroupingProxyModel *groupingModel = nullptr;
88​ NotificationGroupCollapsingProxyModel *groupCollapsingModel = nullptr;
89​ KDescendantsProxyModel *flattenModel = nullptr;
90​
91​ LimitedRowCountProxyModel *limiterModel = nullptr;
92​
93​private:
94​ Notifications *q;
95​};
96​
97​Notifications::Private::Private(Notifications *q)
98​ : q(q)
99​{
100​
101​}
102​
103​Notifications::Private::~Private()
104​{
105​
106​}
107​
108​void Notifications::Private::initSourceModels()
109​{
110​ Q_ASSERT(notificationsAndJobsModel); // initProxyModels must be called before initSourceModels
111​
112​ if (showNotifications && !notificationsModel) {
113​ notificationsModel = NotificationsModel::createNotificationsModel();
114​ connect(notificationsModel.data(), &NotificationsModel::lastReadChanged, q, [this] {
115​ updateCount();
116​ emit q->lastReadChanged();
117​ });
118​ notificationsAndJobsModel->addSourceModel(notificationsModel.data());
119​ } else if (!showNotifications && notificationsModel) {
120​ notificationsAndJobsModel->removeSourceModel(notificationsModel.data());
121​ disconnect(notificationsModel.data(), nullptr, q, nullptr); // disconnect all
122​ notificationsModel = nullptr;
123​ }
124​
125​ if (showJobs && !jobsModel) {
126​ jobsModel = JobsModel::createJobsModel();
127​ notificationsAndJobsModel->addSourceModel(jobsModel.data());
128​ jobsModel->init();
129​ } else if (!showJobs && jobsModel) {
130​ notificationsAndJobsModel->removeSourceModel(jobsModel.data());
131​ jobsModel = nullptr;
132​ }
133​}
134​
135​void Notifications::Private::initProxyModels()
136​{
137​ /* The data flow is as follows:
138​ * NOTE when you add or re-arrange models make sure to update mapFromModel()!
139​ *
140​ * NotificationsModel JobsModel
141​ * \\ /
142​ * \\ /
143​ * KConcatenateRowsProxyModel
144​ * |||
145​ * |||
146​ * NotificationFilterProxyModel
147​ * (filters by urgency, whitelist, etc)
148​ * |
149​ * |
150​ * NotificationSortProxyModel
151​ * (sorts by urgency, date, etc)
152​ * |
153​ * --- BEGIN: Only when grouping is enabled ---
154​ * |
155​ * NotificationGroupingProxyModel
156​ * (turns list into tree grouped by app)
157​ * //\\
158​ * //\\
159​ * NotificationGroupCollapsingProxyModel
160​ * (limits number of tree leaves for expand/collapse feature)
161​ * /\
162​ * /\
163​ * KDescendantsProxyModel
164​ * (flattens tree back into a list for consumption in ListView)
165​ * |
166​ * --- END: Only when grouping is enabled ---
167​ * |
168​ * LimitedRowCountProxyModel
169​ * (limits the total number of items in the model)
170​ * |
171​ * |
172​ * \o/ <- Happy user seeing their notifications
173​ */
174​
175​ if (!notificationsAndJobsModel) {
176​ notificationsAndJobsModel = new KConcatenateRowsProxyModel(q);
177​ }
178​
179​ if (!filterModel) {
180​ filterModel = new NotificationFilterProxyModel();
181​ connect(filterModel, &NotificationFilterProxyModel::urgenciesChanged, q, &Notifications::urgenciesChanged);
182​ connect(filterModel, &NotificationFilterProxyModel::showExpiredChanged, q, &Notifications::showExpiredChanged);
183​ connect(filterModel, &NotificationFilterProxyModel::showDismissedChanged, q, &Notifications::showDismissedChanged);
184​ connect(filterModel, &NotificationFilterProxyModel::blacklistedDesktopEntriesChanged, q, &Notifications::blacklistedDesktopEntriesChanged);
185​ connect(filterModel, &NotificationFilterProxyModel::blacklistedNotifyRcNamesChanged, q, &Notifications::blacklistedNotifyRcNamesChanged);
186​
187​ connect(filterModel, &QAbstractItemModel::rowsInserted, q, [this] {
188​ updateCount();
189​ });
190​ connect(filterModel, &QAbstractItemModel::rowsRemoved, q, [this] {
191​ updateCount();
192​ });
193​ connect(filterModel, &QAbstractItemModel::dataChanged, q, [this](const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles) {
194​ Q_UNUSED(topLeft);
195​ Q_UNUSED(bottomRight);
196​ if (roles.isEmpty()
197​ || roles.contains(Notifications::UpdatedRole)
198​ || roles.contains(Notifications::ExpiredRole)
199​ || roles.contains(Notifications::JobStateRole)
200​ || roles.contains(Notifications::PercentageRole)) {
201​ updateCount();
202​ }
203​ });
204​
205​ filterModel->setSourceModel(notificationsAndJobsModel);
206​ }
207​
208​ if (!sortModel) {
209​ sortModel = new NotificationSortProxyModel(q);
210​ connect(sortModel, &NotificationSortProxyModel::sortModeChanged, q, &Notifications::sortModeChanged);
211​ }
212​
213​ if (!limiterModel) {
214​ limiterModel = new LimitedRowCountProxyModel(q);
215​ connect(limiterModel, &LimitedRowCountProxyModel::limitChanged, q, &Notifications::limitChanged);
216​ }
217​
218​ if (groupMode == GroupApplicationsFlat) {
219​ if (!groupingModel) {
220​ groupingModel = new NotificationGroupingProxyModel(q);
221​ groupingModel->setSourceModel(filterModel);
222​ }
223​
224​ if (!groupCollapsingModel) {
225​ groupCollapsingModel = new NotificationGroupCollapsingProxyModel(q);
226​ groupCollapsingModel->setLimit(groupLimit);
227​ groupCollapsingModel->setExpandUnread(expandUnread);
228​ groupCollapsingModel->setLastRead(q->lastRead());
229​ groupCollapsingModel->setSourceModel(groupingModel);
230​ }
231​
232​ sortModel->setSourceModel(groupCollapsingModel);
233​
234​ flattenModel = new KDescendantsProxyModel(q);
235​ flattenModel->setSourceModel(sortModel);
236​
237​ limiterModel->setSourceModel(flattenModel);
238​ } else {
239​ sortModel->setSourceModel(filterModel);
240​ limiterModel->setSourceModel(sortModel);
241​ delete flattenModel;
242​ flattenModel = nullptr;
243​ delete groupingModel;
244​ groupingModel = nullptr;
245​ }
246​
247​ q->setSourceModel(limiterModel);
248​}
249​
250​void Notifications::Private::updateCount()
251​{
252​ int active = 0;
253​ int expired = 0;
254​ int unread = 0;
255​
256​ int jobs = 0;
257​ int totalPercentage = 0;
258​
259​ // We want to get the numbers after main filtering (urgencies, whitelists, etc)
260​ // but before any limiting or group limiting, hence asking the filterModel for advice
261​ // at which point notifications and jobs also have already been merged
262​ for (int i = 0; i < filterModel->rowCount(); ++i) {
263​ const QModelIndex idx = filterModel->index(i, 0);
264​
265​ if (idx.data(Notifications::ExpiredRole).toBool()) {
266​ ++expired;
267​ } else {
268​ ++active;
269​ }
270​
271​ QDateTime date = idx.data(Notifications::UpdatedRole).toDateTime();
272​ if (!date.isValid()) {
273​ date = idx.data(Notifications::CreatedRole).toDateTime();
274​ }
275​
276​ // TODO Jobs could also be unread?
277​ if (notificationsModel) {
278​ if (date > notificationsModel->lastRead()) {
279​ ++unread;
280​ }
281​ }
282​
283​ if (idx.data(Notifications::TypeRole).toInt() == Notifications::JobType) {
284​ if (idx.data(Notifications::JobStateRole).toInt() != Notifications::JobStateStopped) {
285​ ++jobs;
286​
287​ totalPercentage += idx.data(Notifications::PercentageRole).toInt();
288​ }
289​ }
290​ }
291​
292​ if (activeNotificationsCount != active) {
293​ activeNotificationsCount = active;
294​ emit q->activeNotificationsCountChanged();
295​ }
296​ if (expiredNotificationsCount != expired) {
297​ expiredNotificationsCount = expired;
298​ emit q->expiredNotificationsCountChanged();
299​ }
300​ if (unreadNotificationsCount != unread) {
301​ unreadNotificationsCount = unread;
302​ emit q->unreadNotificationsCountChanged();
303​ }
304​ if (activeJobsCount != jobs) {
305​ activeJobsCount = jobs;
306​ emit q->activeJobsCountChanged();
307​ }
308​
309​ const int percentage = (jobs > 0 ? totalPercentage / jobs : 0);
310​ if (jobsPercentage != percentage) {
311​ jobsPercentage = percentage;
312​ emit q->jobsPercentageChanged();
313​ }
314​
315​ // TODO don't emit in dataChanged
316​ emit q->countChanged();
317​}
318​
319​bool Notifications::Private::isGroup(const QModelIndex &idx)
320​{
321​ return idx.data(Notifications::IsGroupRole).toBool();
322​}
323​
324​// FIXME remove once we just map to the source model
325​uint Notifications::Private::notificationId(const QModelIndex &idx)
326​{
327​ return idx.data(Notifications::IdRole).toUInt();
328​}
329​
330​QModelIndex Notifications::Private::mapFromModel(const QModelIndex &idx) const
331​{
332​ QModelIndex resolvedIdx = idx;
333​
334​ QAbstractItemModel *models[] = {
335​ notificationsAndJobsModel,
336​ filterModel,
337​ sortModel,
338​ groupingModel,
339​ groupCollapsingModel,
340​ flattenModel,
341​ limiterModel,
342​ };
343​
344​ // TODO can we do this with a generic loop like mapFromModel
345​ while (resolvedIdx.isValid() && resolvedIdx.model() != q) {
346​ const auto *idxModel = resolvedIdx.model();
347​
348​ // HACK try to find the model that uses the index' model as source
349​ bool found = false;
350​ for (QAbstractItemModel *model : models) {
351​ if (!model) {
352​ continue;
353​ }
354​
355​ if (auto *proxyModel = qobject_cast<QAbstractProxyModel *>(model)) {
356​ if (proxyModel->sourceModel() == idxModel) {
357​ resolvedIdx = proxyModel->mapFromSource(resolvedIdx);
358​ found = true;
359​ break;
360​ }
361​ } else if (auto *concatenateModel = qobject_cast<KConcatenateRowsProxyModel *>(model)) {
362​ // There's no "sourceModels()" on KConcatenateRowsProxyModel
363​ if (idxModel == notificationsModel.data() || idxModel == jobsModel.data()) {
364​ resolvedIdx = concatenateModel->mapFromSource(resolvedIdx);
365​ found = true;
366​ break;
367​ }
368​ }
369​ }
370​
371​ if (!found) {
372​ break;
373​ }
374​ }
375​ return resolvedIdx;
376​}
377​
378​QSharedPointer<Settings> Notifications::Private::settings() const
379​{
380​ static QWeakPointer<Settings> s_instance;
381​ if (!s_instance) {
382​ QSharedPointer<Settings> ptr(new Settings());
383​ s_instance = ptr.toWeakRef();
384​ return ptr;
385​ }
386​ return s_instance.toStrongRef();
387​}
388​
389​Notifications::Notifications(QObject *parent)
390​ : QSortFilterProxyModel(parent)
391​ , d(new Private(this))
392​{
393​ // The proxy models are always the same, just with different
394​ // properties set whereas we want to avoid loading a source model
395​ // e.g. notifications or jobs when we're not actually using them
396​ d->initProxyModels();
397​
398​ // init source models when used from C++
399​ QMetaObject::invokeMethod(this, [this] {
400​ d->initSourceModels();
401​ }, Qt::QueuedConnection);
402​}
403​
404​Notifications::~Notifications() = default;
405​
406​void Notifications::classBegin()
407​{
408​
409​}
410​
411​void Notifications::componentComplete()
412​{
413​ // init source models when used from QML
414​ d->initSourceModels();
415​}
416​
417​int Notifications::limit() const
418​{
419​ return d->limiterModel->limit();
420​}
421​
422​void Notifications::setLimit(int limit)
423​{
424​ d->limiterModel->setLimit(limit);
425​}
426​
427​int Notifications::groupLimit() const
428​{
429​ return d->groupLimit;
430​}
431​
432​void Notifications::setGroupLimit(int limit)
433​{
434​ if (d->groupLimit == limit) {
435​ return;
436​ }
437​
438​ d->groupLimit = limit;
439​ if (d->groupCollapsingModel) {
440​ d->groupCollapsingModel->setLimit(limit);
441​ }
442​ emit groupLimitChanged();
443​}
444​
445​bool Notifications::expandUnread() const
446​{
447​ return d->expandUnread;
448​}
449​
450​void Notifications::setExpandUnread(bool expand)
451​{
452​ if (d->expandUnread == expand) {
453​ return;
454​ }
455​
456​ d->expandUnread = expand;
457​ if (d->groupCollapsingModel) {
458​ d->groupCollapsingModel->setExpandUnread(expand);
459​ }
460​ emit expandUnreadChanged();
461​}
462​
463​bool Notifications::showExpired() const
464​{
465​ return d->filterModel->showExpired();
466​}
467​
468​void Notifications::setShowExpired(bool show)
469​{
470​ d->filterModel->setShowExpired(show);
471​}
472​
473​bool Notifications::showDismissed() const
474​{
475​ return d->filterModel->showDismissed();
476​}
477​
478​void Notifications::setShowDismissed(bool show)
479​{
480​ d->filterModel->setShowDismissed(show);
481​}
482​
483​QStringList Notifications::blacklistedDesktopEntries() const
484​{
485​ return d->filterModel->blacklistedDesktopEntries();
486​}
487​
488​void Notifications::setBlacklistedDesktopEntries(const QStringList &blacklist)
489​{
490​ d->filterModel->setBlackListedDesktopEntries(blacklist);
491​}
492​
493​QStringList Notifications::blacklistedNotifyRcNames() const
494​{
495​ return d->filterModel->blacklistedNotifyRcNames();
496​}
497​
498​void Notifications::setBlacklistedNotifyRcNames(const QStringList &blacklist)
499​{
500​ d->filterModel->setBlacklistedNotifyRcNames(blacklist);
501​}
502​
503​QStringList Notifications::whitelistedDesktopEntries() const
504​{
505​ return d->filterModel->whitelistedDesktopEntries();
506​}
507​
508​void Notifications::setWhitelistedDesktopEntries(const QStringList &whitelist)
509​{
510​ d->filterModel->setWhiteListedDesktopEntries(whitelist);
511​}
512​
513​QStringList Notifications::whitelistedNotifyRcNames() const
514​{
515​ return d->filterModel->whitelistedNotifyRcNames();
516​}
517​
518​void Notifications::setWhitelistedNotifyRcNames(const QStringList &whitelist)
519​{
520​ d->filterModel->setWhitelistedNotifyRcNames(whitelist);
521​}
522​
523​bool Notifications::showNotifications() const
524​{
525​ return d->showNotifications;
526​}
527​
528​void Notifications::setShowNotifications(bool show)
529​{
530​ if (d->showNotifications == show) {
531​ return;
532​ }
533​
534​ d->showNotifications = show;
535​ d->initSourceModels();
536​ emit showNotificationsChanged();
537​}
538​
539​bool Notifications::showJobs() const
540​{
541​ return d->showJobs;
542​}
543​
544​void Notifications::setShowJobs(bool show)
545​{
546​ if (d->showJobs == show) {
547​ return;
548​ }
549​
550​ d->showJobs = show;
551​ d->initSourceModels();
552​ emit showJobsChanged();
553​}
554​
555​Notifications::Urgencies Notifications::urgencies() const
556​{
557​ return d->filterModel->urgencies();
558​}
559​
560​void Notifications::setUrgencies(Urgencies urgencies)
561​{
562​ d->filterModel->setUrgencies(urgencies);
563​}
564​
565​Notifications::SortMode Notifications::sortMode() const
566​{
567​ return d->sortModel->sortMode();
568​}
569​
570​void Notifications::setSortMode(SortMode sortMode)
571​{
572​ d->sortModel->setSortMode(sortMode);
573​}
574​
575​Notifications::GroupMode Notifications::groupMode() const
576​{
577​ return d->groupMode;
578​}
579​
580​void Notifications::setGroupMode(GroupMode groupMode)
581​{
582​ if (d->groupMode != groupMode) {
583​ d->groupMode = groupMode;
584​ d->initProxyModels();
585​ emit groupModeChanged();
586​ }
587​}
588​
589​int Notifications::count() const
590​{
591​ return rowCount(QModelIndex());
592​}
593​
594​int Notifications::activeNotificationsCount() const
595​{
596​ return d->activeNotificationsCount;
597​}
598​
599​int Notifications::expiredNotificationsCount() const
600​{
601​ return d->expiredNotificationsCount;
602​}
603​
604​QDateTime Notifications::lastRead() const
605​{
606​ if (d->notificationsModel) {
607​ return d->notificationsModel->lastRead();
608​ }
609​ return QDateTime();
610​}
611​
612​void Notifications::setLastRead(const QDateTime &lastRead)
613​{
614​ // TODO jobs could also be unread?
615​ if (d->notificationsModel) {
616​ d->notificationsModel->setLastRead(lastRead);
617​ }
618​ if (d->groupCollapsingModel) {
619​ d->groupCollapsingModel->setLastRead(lastRead);
620​ }
621​}
622​
623​void Notifications::resetLastRead()
624​{
625​ setLastRead(QDateTime::currentDateTimeUtc());
626​}
627​
628​int Notifications::unreadNotificationsCount() const
629​{
630​ return d->unreadNotificationsCount;
631​}
632​
633​int Notifications::activeJobsCount() const
634​{
635​ return d->activeJobsCount;
636​}
637​
638​int Notifications::jobsPercentage() const
639​{
640​ return d->jobsPercentage;
641​}
642​
643​QPersistentModelIndex Notifications::makePersistentModelIndex(const QModelIndex &idx) const
644​{
645​ return QPersistentModelIndex(idx);
646​}
647​
648​void Notifications::expire(const QModelIndex &idx)
649​{
650​ switch (static_cast<Notifications::Type>(idx.data(Notifications::TypeRole).toInt())) {
651​ case Notifications::NotificationType:
652​ d->notificationsModel->expire(Private::notificationId(idx));
653​ break;
654​ case Notifications::JobType:
655​ d->jobsModel->expire(Utils::mapToModel(idx, d->jobsModel.data()));
656​ break;
657​ default:
658​ Q_UNREACHABLE();
659​ }
660​}
661​
662​void Notifications::close(const QModelIndex &idx)
663​{
664​ if (idx.data(Notifications::IsGroupRole).toBool()) {
665​ const QModelIndex groupIdx = Utils::mapToModel(idx, d->groupingModel);
666​ if (!groupIdx.isValid()) {
667​ qCWarning(NOTIFICATIONMANAGER) << "Failed to find group model index for this item";
668​ return;
669​ }
670​
671​ Q_ASSERT(groupIdx.model() == d->groupingModel);
672​
673​ const int childCount = d->groupingModel->rowCount(groupIdx);
674​ for (int i = childCount - 1; i >= 0; --i) {
675​ const QModelIndex childIdx = d->groupingModel->index(i, 0, groupIdx);
676​ close(childIdx);
677​ }
678​ return;
679​ }
680​
681​ if (!idx.data(Notifications::ClosableRole).toBool()) {
682​ return;
683​ }
684​
685​ switch (static_cast<Notifications::Type>(idx.data(Notifications::TypeRole).toInt())) {
686​ case Notifications::NotificationType:
687​ d->notificationsModel->close(Private::notificationId(idx));
688​ break;
689​ case Notifications::JobType:
690​ d->jobsModel->close(Utils::mapToModel(idx, d->jobsModel.data()));
691​ break;
692​ default:
693​ Q_UNREACHABLE();
694​ }
695​}
696​
697​void Notifications::configure(const QModelIndex &idx)
698​{
699​ if (!d->notificationsModel) {
700​ return;
701​ }
702​
703​ // For groups just configure the application, not the individual event
704​ if (Private::isGroup(idx)) {
705​ const QString desktopEntry = idx.data(Notifications::DesktopEntryRole).toString();
706​ const QString notifyRcName = idx.data(Notifications::NotifyRcNameRole).toString();
707​
708​ d->notificationsModel->configure(desktopEntry, notifyRcName, QString() /*eventId*/);
709​ return;
710​ }
711​
712​ d->notificationsModel->configure(Private::notificationId(idx));
713​}
714​
715​void Notifications::invokeDefaultAction(const QModelIndex &idx)
716​{
717​ if (d->notificationsModel) {
718​ d->notificationsModel->invokeDefaultAction(Private::notificationId(idx));
719​ }
720​}
721​
722​void Notifications::invokeAction(const QModelIndex &idx, const QString &actionId)
723​{
724​ if (d->notificationsModel) {
725​ d->notificationsModel->invokeAction(Private::notificationId(idx), actionId);
726​ }
727​}
728​
729​void Notifications::startTimeout(const QModelIndex &idx)
730​{
731​ startTimeout(Private::notificationId(idx));
732​}
733​
734​void Notifications::startTimeout(uint notificationId)
735​{
736​ if (d->notificationsModel) {
737​ d->notificationsModel->startTimeout(notificationId);
738​ }
739​}
740​
741​void Notifications::stopTimeout(const QModelIndex &idx)
742​{
743​ if (d->notificationsModel) {
744​ d->notificationsModel->stopTimeout(Private::notificationId(idx));
745​ }
746​}
747​
748​void Notifications::suspendJob(const QModelIndex &idx)
749​{
750​ if (d->jobsModel) {
751​ d->jobsModel->suspend(Utils::mapToModel(idx, d->jobsModel.data()));
752​ }
753​}
754​
755​void Notifications::resumeJob(const QModelIndex &idx)
756​{
757​ if (d->jobsModel) {
758​ d->jobsModel->resume(Utils::mapToModel(idx, d->jobsModel.data()));
759​ }
760​}
761​
762​void Notifications::killJob(const QModelIndex &idx)
763​{
764​ if (d->jobsModel) {
765​ d->jobsModel->kill(Utils::mapToModel(idx, d->jobsModel.data()));
766​ }
767​}
768​
769​void Notifications::clear(ClearFlags flags)
770​{
771​ if (d->notificationsModel) {
772​ d->notificationsModel->clear(flags);
773​ }
774​ if (d->jobsModel) {
775​ d->jobsModel->clear(flags);
776​ }
777​}
778​
779​QModelIndex Notifications::groupIndex(const QModelIndex &idx) const
780​{
781​ if (idx.data(Notifications::IsGroupRole).toBool()) {
782​ return idx;
783​ }
784​
785​ if (idx.data(Notifications::IsInGroupRole).toBool()) {
786​ QModelIndex groupingIdx = Utils::mapToModel(idx, d->groupingModel);
787​ return d->mapFromModel(groupingIdx.parent());
788​ }
789​
790​ qCWarning(NOTIFICATIONMANAGER) << "Cannot get group index for item that isn't a group or inside one";
791​ return QModelIndex();
792​}
793​
794​void Notifications::collapseAllGroups()
795​{
796​ if (d->groupCollapsingModel) {
797​ d->groupCollapsingModel->collapseAll();
798​ }
799​}
800​
801​QVariant Notifications::data(const QModelIndex &index, int role) const
802​{
803​ return QSortFilterProxyModel::data(index, role);
804​}
805​
806​bool Notifications::setData(const QModelIndex &index, const QVariant &value, int role)
807​{
808​ return QSortFilterProxyModel::setData(index, value, role);
809​}
810​
811​bool Notifications::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
812​{
813​ return QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);
814​}
815​
816​bool Notifications::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
817​{
818​ return QSortFilterProxyModel::lessThan(source_left, source_right);
819​}
820​
821​int Notifications::rowCount(const QModelIndex &parent) const
822​{
823​ return QSortFilterProxyModel::rowCount(parent);
824​}
825​
826​QHash<int, QByteArray> Notifications::roleNames() const
827​{
828​ return QHash<int, QByteArray> {
heinUnsubmitted
Done

While this isn't an objection, I usually use QMetaEnum to compute this from the enum instead of having a block of stuff that needs to be synced.

hein: While this isn't an objection, I usually use QMetaEnum to compute this from the enum instead of…
broulikAuthorUnsubmitted
Done

There's a gazillion places that need to be synced when we add something:

  • add enum in header
  • add new field to struct that holds the actual data
  • let data() return the new role

as well as actually forwarding it in a bunch of places in QML, so I don't think automating this particular part really reduces the workload for that. I can give it a shot, though.

broulik: There's a gazillion places that need to be synced when we add something: * add enum in header *…
829​ {IdRole, QByteArrayLiteral("notificationId")}, // id is QML-reserved
830​ {IsGroupRole, QByteArrayLiteral("isGroup")},
831​ {GroupChildrenCountRole, QByteArrayLiteral("groupChildrenCount")},
832​ {ExpandedGroupChildrenCountRole, QByteArrayLiteral("expandedGroupChildrenCount")},
833​ {IsGroupExpandedRole, QByteArrayLiteral("isGroupExpanded")},
834​ {IsInGroupRole, QByteArrayLiteral("isInGroup")},
835​ {TypeRole, QByteArrayLiteral("type")},
836​ {CreatedRole, QByteArrayLiteral("created")},
837​ {UpdatedRole, QByteArrayLiteral("updated")},
838​ {SummaryRole, QByteArrayLiteral("summary")},
839​ {BodyRole, QByteArrayLiteral("body")},
840​ {IconNameRole, QByteArrayLiteral("iconName")},
841​ {ImageRole, QByteArrayLiteral("image")},
842​ {DesktopEntryRole, QByteArrayLiteral("desktopEntry")},
843​ {NotifyRcNameRole, QByteArrayLiteral("notifyRcName")},
844​
845​ {ApplicationNameRole, QByteArrayLiteral("applicationName")},
846​ {ApplicationIconNameRole, QByteArrayLiteral("applicationIconName")},
847​ {DeviceNameRole, QByteArrayLiteral("deviceName")},
848​
849​ {ActionNamesRole, QByteArrayLiteral("actionNames")},
850​ {ActionLabelsRole, QByteArrayLiteral("actionLabels")},
851​ {HasDefaultActionRole, QByteArrayLiteral("hasDefaultAction")},
852​ {DefaultActionLabelRole, QByteArrayLiteral("defaultActionLabel")},
853​
854​ {UrlsRole, QByteArrayLiteral("urls")},
855​
856​ {UrgencyRole, QByteArrayLiteral("urgency")},
857​ {TimeoutRole, QByteArrayLiteral("timeout")},
858​
859​ {ClosableRole, QByteArrayLiteral("closable")},
860​ {ConfigurableRole, QByteArrayLiteral("configurable")},
861​ {ConfigureActionLabelRole, QByteArrayLiteral("configureActionLabel")},
862​
863​ {JobStateRole, QByteArrayLiteral("jobState")},
864​ {PercentageRole, QByteArrayLiteral("percentage")},
865​ {JobErrorRole, QByteArrayLiteral("jobError")},
866​ {SuspendableRole, QByteArrayLiteral("suspendable")},
867​ {KillableRole, QByteArrayLiteral("killable")},
868​ {JobDetailsRole, QByteArrayLiteral("jobDetails")},
869​
870​ {ExpiredRole, QByteArrayLiteral("expired")},
871​ {DismissedRole, QByteArrayLiteral("dismissed")}
872​ };
873​}