Differential D20265 Diff 55470 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 <QSharedPointer>
24​
25​#include <KConcatenateRowsProxyModel>
26​#include <KDescendantsProxyModel>
27​
28​#include "notificationsmodel.h"
29​#include "notificationfilterproxymodel_p.h"
30​#include "notificationsortproxymodel_p.h"
31​#include "notificationgroupingproxymodel_p.h"
32​#include "notificationgroupcollapsingproxymodel_p.h"
33​#include "limitedrowcountproxymodel_p.h"
34​
35​#include "jobsmodel.h"
36​
37​#include "settings.h"
38​
39​#include "notification.h"
40​
41​#include "debug.h"
42​
43​#include <QDebug>
44​
45​using namespace NotificationManager;
46​
47​class Q_DECL_HIDDEN Notifications::Private
48​{
49​public:
50​ explicit Private(Notifications *q);
51​ ~Private();
52​
53​ void initModels();
54​ void updateCount();
55​
56​ bool showJobs = false;
57​
58​ Notifications::GroupMode groupMode = Notifications::GroupDisabled;
59​ int groupLimit = 0;
60​
61​ int activeNotificationsCount = 0;
62​ int expiredNotificationsCount = 0;
63​
64​ int unreadNotificationsCount = 0;
65​
66​ int activeJobsCount = 0;
67​ int jobsPercentage = 0;
68​
69​ static bool isGroup(const QModelIndex &idx);
70​ static uint notificationId(const QModelIndex &idx);
71​ static QString jobId(const QModelIndex &idx);
72​ static QModelIndex mapToModel(const QModelIndex &idx, const QAbstractItemModel *model);
73​
74​ NotificationsModel::Ptr notificationsModel;
75​ JobsModel::Ptr jobsModel;
76​ QSharedPointer<Settings> settings() const;
77​
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…
78​ KConcatenateRowsProxyModel *notificationsAndJobsModel = nullptr;
79​
80​ NotificationFilterProxyModel *filterModel = nullptr;
81​ NotificationSortProxyModel *sortModel = nullptr;
82​ NotificationGroupingProxyModel *groupingModel = nullptr;
83​ NotificationGroupCollapsingProxyModel *groupCollapsingModel = nullptr;
84​ KDescendantsProxyModel *flattenModel = nullptr;
85​
86​ LimitedRowCountProxyModel *limiterModel = nullptr;
87​
88​private:
89​ Notifications *q;
90​};
91​
92​Notifications::Private::Private(Notifications *q)
93​ : q(q)
94​{
95​
96​}
97​
98​Notifications::Private::~Private()
99​{
100​
101​}
102​
103​void Notifications::Private::initModels()
104​{
105​ /* The data flow is as follows:
106​ *
107​ * NotificationsModel JobsModel
108​ * \\ /
109​ * \\ /
110​ * KConcatenateRowsProxyModel
111​ * |||
112​ * |||
113​ * NotificationFilterProxyModel
114​ * (filters by urgency, whitelist, etc)
115​ * |
116​ * |
117​ * NotificationSortProxyModel
118​ * (sorts by urgency, date, etc)
119​ * |
120​ * --- BEGIN: Only when grouping is enabled ---
121​ * |
122​ * NotificationGroupingProxyModel
123​ * (turns list into tree grouped by app)
124​ * //\\
125​ * //\\
126​ * NotificationGroupCollapsingProxyModel
127​ * (limits number of tree leaves for expand/collapse feature)
128​ * /\
129​ * /\
130​ * KDescendantsProxyModel
131​ * (flattens tree back into a list for consumption in ListView)
132​ * |
133​ * --- END: Only when grouping is enabled ---
134​ * |
135​ * LimitedRowCountProxyModel
136​ * (limits the total number of items in the model)
137​ * |
138​ * |
139​ * \o/ <- Happy user seeing their notifications
140​ */
141​
142​ if (!notificationsModel) {
143​ notificationsModel = NotificationsModel::createNotificationsModel();
144​ connect(notificationsModel.data(), &NotificationsModel::lastReadChanged, q, [this] {
145​ updateCount();
146​ emit q->lastReadChanged();
147​ });
148​ }
149​
150​ if (!notificationsAndJobsModel) {
151​ notificationsAndJobsModel = new KConcatenateRowsProxyModel(q);
152​ notificationsAndJobsModel->addSourceModel(notificationsModel.data());
153​ }
154​
155​ if (!filterModel) {
156​ filterModel = new NotificationFilterProxyModel();
157​ connect(filterModel, &NotificationFilterProxyModel::urgenciesChanged, q, &Notifications::urgenciesChanged);
158​ connect(filterModel, &NotificationFilterProxyModel::showExpiredChanged, q, &Notifications::showExpiredChanged);
159​ connect(filterModel, &NotificationFilterProxyModel::showDismissedChanged, q, &Notifications::showDismissedChanged);
160​ connect(filterModel, &NotificationFilterProxyModel::blacklistedDesktopEntriesChanged, q, &Notifications::blacklistedDesktopEntriesChanged);
161​ connect(filterModel, &NotificationFilterProxyModel::blacklistedNotifyRcNamesChanged, q, &Notifications::blacklistedNotifyRcNamesChanged);
162​
163​ connect(filterModel, &QAbstractItemModel::rowsInserted, q, [this] {
164​ updateCount();
165​ });
166​ connect(filterModel, &QAbstractItemModel::rowsRemoved, q, [this] {
167​ updateCount();
168​ });
169​ connect(filterModel, &QAbstractItemModel::dataChanged, q, [this](const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles) {
170​ Q_UNUSED(topLeft);
171​ Q_UNUSED(bottomRight);
172​ if (roles.isEmpty()
173​ || roles.contains(Notifications::UpdatedRole)
174​ || roles.contains(Notifications::ExpiredRole)
175​ || roles.contains(Notifications::JobStateRole)
176​ || roles.contains(Notifications::PercentageRole)) {
177​ updateCount();
178​ }
179​ });
180​
181​ filterModel->setSourceModel(notificationsAndJobsModel);
182​ }
183​
184​ if (!sortModel) {
185​ sortModel = new NotificationSortProxyModel(q);
186​ connect(sortModel, &NotificationSortProxyModel::sortModeChanged, q, &Notifications::sortModeChanged);
187​ }
188​
189​ if (!limiterModel) {
190​ limiterModel = new LimitedRowCountProxyModel(q);
191​ connect(limiterModel, &LimitedRowCountProxyModel::limitChanged, q, &Notifications::limitChanged);
192​ }
193​
194​ if (groupMode == GroupApplicationsFlat) {
195​ if (!groupingModel) {
196​ groupingModel = new NotificationGroupingProxyModel(q);
197​ groupingModel->setSourceModel(filterModel);
198​ }
199​
200​ if (!groupCollapsingModel) {
201​ groupCollapsingModel = new NotificationGroupCollapsingProxyModel(q);
202​ groupCollapsingModel->setLimit(groupLimit);
203​ groupCollapsingModel->setSourceModel(groupingModel);
204​ }
205​
206​ sortModel->setSourceModel(groupCollapsingModel);
207​
208​ flattenModel = new KDescendantsProxyModel(q);
209​ flattenModel->setSourceModel(sortModel);
210​
211​ limiterModel->setSourceModel(flattenModel);
212​ } else {
213​ sortModel->setSourceModel(filterModel);
214​ limiterModel->setSourceModel(sortModel);
215​ delete flattenModel;
216​ flattenModel = nullptr;
217​ delete groupingModel;
218​ groupingModel = nullptr;
219​ }
220​
221​ q->setSourceModel(limiterModel);
222​}
223​
224​void Notifications::Private::updateCount()
225​{
226​ int active = 0;
227​ int expired = 0;
228​ int unread = 0;
229​
230​ int jobs = 0;
231​ int totalPercentage = 0;
232​
233​ // We want to get the numbers after main filtering (urgencies, whitelists, etc)
234​ // but before any limiting or group limiting, hence asking the filterModel for advice
235​ // at which point notifications and jobs also have already been merged
236​ for (int i = 0; i < filterModel->rowCount(); ++i) {
237​ const QModelIndex idx = filterModel->index(i, 0);
238​
239​ if (idx.data(Notifications::ExpiredRole).toBool()) {
240​ ++expired;
241​ } else {
242​ ++active;
243​ }
244​
245​ QDateTime date = idx.data(Notifications::UpdatedRole).toDateTime();
246​ if (!date.isValid()) {
247​ date = idx.data(Notifications::CreatedRole).toDateTime();
248​ }
249​
250​ if (date > notificationsModel->lastRead()) {
251​ ++unread;
252​ }
253​
254​ if (idx.data(Notifications::TypeRole).toInt() == Notifications::JobType) {
255​ if (idx.data(Notifications::JobStateRole).toInt() != Notifications::JobStateStopped) {
256​ ++jobs;
257​
258​ totalPercentage += idx.data(Notifications::PercentageRole).toInt();
259​ }
260​ }
261​ }
262​
263​ if (activeNotificationsCount != active) {
264​ activeNotificationsCount = active;
265​ emit q->activeNotificationsCountChanged();
266​ }
267​ if (expiredNotificationsCount != expired) {
268​ expiredNotificationsCount = expired;
269​ emit q->expiredNotificationsCountChanged();
270​ }
271​ if (unreadNotificationsCount != unread) {
272​ unreadNotificationsCount = unread;
273​ emit q->unreadNotificationsCountChanged();
274​ }
275​ if (activeJobsCount != jobs) {
276​ activeJobsCount = jobs;
277​ emit q->activeJobsCountChanged();
278​ }
279​
280​ const int percentage = (jobs > 0 ? totalPercentage / jobs : 0);
281​ if (jobsPercentage != percentage) {
282​ jobsPercentage = percentage;
283​ emit q->jobsPercentageChanged();
284​ }
285​
286​ // TODO don't emit in dataChanged
287​ emit q->countChanged();
288​}
289​
290​bool Notifications::Private::isGroup(const QModelIndex &idx)
291​{
292​ return idx.data(Notifications::IsGroupRole).toBool();
293​}
294​
295​uint Notifications::Private::notificationId(const QModelIndex &idx)
296​{
297​ return idx.data(Notifications::IdRole).toUInt();
298​}
299​
300​QString Notifications::Private::jobId(const QModelIndex &idx)
301​{
302​ return idx.data(Notifications::IdRole).toString();
303​}
304​
305​QModelIndex Notifications::Private::mapToModel(const QModelIndex &idx, const QAbstractItemModel *model)
306​{
307​ QModelIndex resolvedIdx = idx;
308​ while (resolvedIdx.isValid() && resolvedIdx.model() != model) {
309​ if (auto *proxyModel = qobject_cast<const QAbstractProxyModel *>(resolvedIdx.model())) {
310​ resolvedIdx = proxyModel->mapToSource(resolvedIdx);
311​ } else {
312​ if (resolvedIdx.model() != model) {
313​ resolvedIdx = QModelIndex(); // give up
314​ }
315​ }
316​ }
317​ return resolvedIdx;
318​}
319​
320​QSharedPointer<Settings> Notifications::Private::settings() const
321​{
322​ static QWeakPointer<Settings> s_instance;
323​ if (!s_instance) {
324​ QSharedPointer<Settings> ptr(new Settings());
325​ s_instance = ptr.toWeakRef();
326​ return ptr;
327​ }
328​ return s_instance.toStrongRef();
329​}
330​
331​Notifications::Notifications(QObject *parent)
332​ : QSortFilterProxyModel(parent)
333​ , d(new Private(this))
334​{
335​ d->initModels();
336​}
337​
338​Notifications::~Notifications() = default;
339​
340​// TODO why are we QQmlParserStatus if we don't use it?
341​void Notifications::classBegin()
342​{
343​
344​}
345​
346​void Notifications::componentComplete()
347​{
348​
349​}
350​
351​int Notifications::limit() const
352​{
353​ return d->limiterModel->limit();
354​}
355​
356​void Notifications::setLimit(int limit)
357​{
358​ d->limiterModel->setLimit(limit);
359​}
360​
361​int Notifications::groupLimit() const
362​{
363​ return d->groupLimit;
364​}
365​
366​void Notifications::setGroupLimit(int limit)
367​{
368​ if (d->groupLimit == limit) {
369​ return;
370​ }
371​
372​ d->groupLimit = limit;
373​ if (d->groupCollapsingModel) {
374​ d->groupCollapsingModel->setLimit(limit);
375​ }
376​ emit groupLimitChanged();
377​}
378​
379​bool Notifications::showExpired() const
380​{
381​ return d->filterModel->showExpired();
382​}
383​
384​void Notifications::setShowExpired(bool show)
385​{
386​ d->filterModel->setShowExpired(show);
387​}
388​
389​bool Notifications::showDismissed() const
390​{
391​ return d->filterModel->showDismissed();
392​}
393​
394​void Notifications::setShowDismissed(bool show)
395​{
396​ d->filterModel->setShowDismissed(show);
397​}
398​
399​QStringList Notifications::blacklistedDesktopEntries() const
400​{
401​ return d->filterModel->blacklistedDesktopEntries();
402​}
403​
404​void Notifications::setBlacklistedDesktopEntries(const QStringList &blacklist)
405​{
406​ d->filterModel->setBlackListedDesktopEntries(blacklist);
407​}
408​
409​QStringList Notifications::blacklistedNotifyRcNames() const
410​{
411​ return d->filterModel->blacklistedNotifyRcNames();
412​}
413​
414​void Notifications::setBlacklistedNotifyRcNames(const QStringList &blacklist)
415​{
416​ d->filterModel->setBlacklistedNotifyRcNames(blacklist);
417​}
418​
419​QStringList Notifications::whitelistedDesktopEntries() const
420​{
421​ return d->filterModel->whitelistedDesktopEntries();
422​}
423​
424​void Notifications::setWhitelistedDesktopEntries(const QStringList &whitelist)
425​{
426​ d->filterModel->setWhiteListedDesktopEntries(whitelist);
427​}
428​
429​QStringList Notifications::whitelistedNotifyRcNames() const
430​{
431​ return d->filterModel->whitelistedNotifyRcNames();
432​}
433​
434​void Notifications::setWhitelistedNotifyRcNames(const QStringList &whitelist)
435​{
436​ d->filterModel->setWhitelistedNotifyRcNames(whitelist);
437​}
438​
439​bool Notifications::showJobs() const
440​{
441​ return d->showJobs;
442​}
443​
444​void Notifications::setShowJobs(bool showJobs)
445​{
446​ if (d->showJobs == showJobs) {
447​ return;
448​ }
449​
450​ if (showJobs) {
451​ d->jobsModel = JobsModel::createJobsModel();
452​ d->notificationsAndJobsModel->addSourceModel(d->jobsModel.data());
453​ } else {
454​ d->notificationsAndJobsModel->removeSourceModel(d->jobsModel.data());
455​ d->jobsModel = nullptr;
456​ }
457​ d->showJobs = showJobs;
458​}
459​
460​Notifications::Urgencies Notifications::urgencies() const
461​{
462​ return d->filterModel->urgencies();
463​}
464​
465​void Notifications::setUrgencies(Urgencies urgencies)
466​{
467​ d->filterModel->setUrgencies(urgencies);
468​}
469​
470​Notifications::SortMode Notifications::sortMode() const
471​{
472​ return d->sortModel->sortMode();
473​}
474​
475​void Notifications::setSortMode(SortMode sortMode)
476​{
477​ d->sortModel->setSortMode(sortMode);
478​}
479​
480​Notifications::GroupMode Notifications::groupMode() const
481​{
482​ return d->groupMode;
483​}
484​
485​void Notifications::setGroupMode(GroupMode groupMode)
486​{
487​ if (d->groupMode != groupMode) {
488​ d->groupMode = groupMode;
489​ d->initModels();
490​ emit groupModeChanged();
491​ }
492​}
493​
494​int Notifications::count() const
495​{
496​ return rowCount(QModelIndex());
497​}
498​
499​int Notifications::activeNotificationsCount() const
500​{
501​ return d->activeNotificationsCount;
502​}
503​
504​int Notifications::expiredNotificationsCount() const
505​{
506​ return d->expiredNotificationsCount;
507​}
508​
509​QDateTime Notifications::lastRead() const
510​{
511​ return d->notificationsModel->lastRead();
512​}
513​
514​void Notifications::setLastRead(const QDateTime &lastRead)
515​{
516​ d->notificationsModel->setLastRead(lastRead);
517​}
518​
519​void Notifications::resetLastRead()
520​{
521​ setLastRead(QDateTime::currentDateTimeUtc());
522​}
523​
524​int Notifications::unreadNotificationsCount() const
525​{
526​ return d->unreadNotificationsCount;
527​}
528​
529​int Notifications::activeJobsCount() const
530​{
531​ return d->activeJobsCount;
532​}
533​
534​int Notifications::jobsPercentage() const
535​{
536​ return d->jobsPercentage;
537​}
538​
539​void Notifications::expire(const QModelIndex &idx)
540​{
541​ switch (static_cast<Notifications::Type>(idx.data(Notifications::TypeRole).toInt())) {
542​ case Notifications::NotificationType:
543​ d->notificationsModel->expire(Private::notificationId(idx));
544​ break;
545​ case Notifications::JobType:
546​ d->jobsModel->expire(Private::jobId(idx));
547​ break;
548​ default:
549​ Q_UNREACHABLE();
550​ }
551​}
552​
553​void Notifications::close(const QModelIndex &idx)
554​{
555​ if (idx.data(Notifications::IsGroupRole).toBool()) {
556​ const QModelIndex groupIdx = Private::mapToModel(idx, d->groupingModel);
557​ if (!groupIdx.isValid()) {
558​ qCWarning(NOTIFICATIONMANAGER) << "Failed to find group model index for this item";
559​ return;
560​ }
561​
562​ Q_ASSERT(groupIdx.model() == d->groupingModel);
563​
564​ const int childCount = d->groupingModel->rowCount(groupIdx);
565​ for (int i = childCount - 1; i >= 0; --i) {
566​ const QModelIndex childIdx = d->groupingModel->index(i, 0, groupIdx);
567​ close(childIdx);
568​ }
569​ return;
570​ }
571​
572​ if (!idx.data(Notifications::ClosableRole).toBool()) {
573​ return;
574​ }
575​
576​ switch (static_cast<Notifications::Type>(idx.data(Notifications::TypeRole).toInt())) {
577​ case Notifications::NotificationType:
578​ d->notificationsModel->close(Private::notificationId(idx));
579​ break;
580​ case Notifications::JobType:
581​ d->jobsModel->close(Private::jobId(idx));
582​ break;
583​ default:
584​ Q_UNREACHABLE();
585​ }
586​}
587​
588​void Notifications::configure(const QModelIndex &idx)
589​{
590​ // For groups just configure the application, not the individual event
591​ if (Private::isGroup(idx)) {
592​ const QString desktopEntry = idx.data(Notifications::DesktopEntryRole).toString();
593​ const QString notifyRcName = idx.data(Notifications::NotifyRcNameRole).toString();
594​
595​ d->notificationsModel->configure(desktopEntry, notifyRcName, QString() /*eventId*/);
596​ return;
597​ }
598​
599​ d->notificationsModel->configure(Private::notificationId(idx));
600​}
601​
602​void Notifications::invokeDefaultAction(const QModelIndex &idx)
603​{
604​ d->notificationsModel->invokeDefaultAction(Private::notificationId(idx));
605​}
606​
607​void Notifications::invokeAction(const QModelIndex &idx, const QString &actionId)
608​{
609​ d->notificationsModel->invokeAction(Private::notificationId(idx), actionId);
610​}
611​
612​void Notifications::startTimeout(const QModelIndex &idx)
613​{
614​ startTimeout(Private::notificationId(idx));
615​}
616​
617​void Notifications::startTimeout(uint notificationId)
618​{
619​ d->notificationsModel->startTimeout(notificationId);
620​}
621​
622​void Notifications::stopTimeout(const QModelIndex &idx)
623​{
624​ d->notificationsModel->stopTimeout(Private::notificationId(idx));
625​}
626​
627​void Notifications::suspendJob(const QModelIndex &idx)
628​{
629​ d->jobsModel->suspend(Private::jobId(idx));
630​}
631​
632​void Notifications::resumeJob(const QModelIndex &idx)
633​{
634​ d->jobsModel->resume(Private::jobId(idx));
635​}
636​
637​void Notifications::killJob(const QModelIndex &idx)
638​{
639​ d->jobsModel->kill(Private::jobId(idx));
640​}
641​
642​void Notifications::clear(ClearFlags flags)
643​{
644​ d->notificationsModel->clear(flags);
645​ d->jobsModel->clear(flags);
646​}
647​
648​QVariant Notifications::data(const QModelIndex &index, int role) const
649​{
650​ return QSortFilterProxyModel::data(index, role);
651​}
652​
653​bool Notifications::setData(const QModelIndex &index, const QVariant &value, int role)
654​{
655​ return QSortFilterProxyModel::setData(index, value, role);
656​}
657​
658​bool Notifications::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
659​{
660​ return QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);
661​}
662​
663​bool Notifications::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
664​{
665​ return QSortFilterProxyModel::lessThan(source_left, source_right);
666​}
667​
668​int Notifications::rowCount(const QModelIndex &parent) const
669​{
670​ return QSortFilterProxyModel::rowCount(parent);
671​}
672​
673​QHash<int, QByteArray> Notifications::roleNames() const
674​{
675​ return QHash<int, QByteArray> {
676​ {IdRole, QByteArrayLiteral("notificationId")}, // id is QML-reserved
677​ {IsGroupRole, QByteArrayLiteral("isGroup")},
678​ {GroupChildrenCountRole, QByteArrayLiteral("groupChildrenCount")},
679​ {IsGroupExpandedRole, QByteArrayLiteral("isGroupExpanded")},
680​ {IsInGroupRole, QByteArrayLiteral("isInGroup")},
681​ {TypeRole, QByteArrayLiteral("type")},
682​ {CreatedRole, QByteArrayLiteral("created")},
683​ {UpdatedRole, QByteArrayLiteral("updated")},
684​ {SummaryRole, QByteArrayLiteral("summary")},
685​ {BodyRole, QByteArrayLiteral("body")},
686​ {IconNameRole, QByteArrayLiteral("iconName")},
687​ {ImageRole, QByteArrayLiteral("image")},
688​ {DesktopEntryRole, QByteArrayLiteral("desktopEntry")},
689​ {NotifyRcNameRole, QByteArrayLiteral("notifyRcName")},
690​
691​ {ApplicationNameRole, QByteArrayLiteral("applicationName")},
692​ {ApplicationIconNameRole, QByteArrayLiteral("applicationIconName")},
693​ {DeviceNameRole, QByteArrayLiteral("deviceName")},
694​
695​ {ActionNamesRole, QByteArrayLiteral("actionNames")},
696​ {ActionLabelsRole, QByteArrayLiteral("actionLabels")},
697​ {HasDefaultActionRole, QByteArrayLiteral("hasDefaultAction")},
698​ {DefaultActionLabelRole, QByteArrayLiteral("defaultActionLabel")},
699​
700​ {UrlsRole, QByteArrayLiteral("urls")},
701​
702​ {UrgencyRole, QByteArrayLiteral("urgency")},
703​ {TimeoutRole, QByteArrayLiteral("timeout")},
704​
705​ {ClosableRole, QByteArrayLiteral("closable")},
706​ {ConfigurableRole, QByteArrayLiteral("configurable")},
707​ {ConfigureActionLabelRole, QByteArrayLiteral("configureActionLabel")},
708​
709​ {JobStateRole, QByteArrayLiteral("jobState")},
710​ {PercentageRole, QByteArrayLiteral("percentage")},
711​ {ErrorRole, QByteArrayLiteral("error")},
712​ {ErrorTextRole, QByteArrayLiteral("errorText")},
713​ {SuspendableRole, QByteArrayLiteral("suspendable")},
714​ {KillableRole, QByteArrayLiteral("killable")},
715​ {JobDetailsRole, QByteArrayLiteral("jobDetails")},
716​
717​ {ExpiredRole, QByteArrayLiteral("expired")},
718​ {DismissedRole, QByteArrayLiteral("dismissed")}
719​ };
720​}
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 *…