Differential D20265 Diff 55470 libnotificationmanager/notificationgroupingproxymodel.cpp

Changeset View

Standalone View

libnotificationmanager/notificationgroupingproxymodel.cpp

This file was added.

1		/*
2		* Copyright 2016 Eike Hein <hein@kde.org>
3		* Copyright 2018-2019 Kai Uwe Broulik <kde@privat.broulik.de>
4		*
5		* This library is free software; you can redistribute it and/or
6		* modify it under the terms of the GNU Lesser General Public
7		* License as published by the Free Software Foundation; either
8		* version 2.1 of the License, or (at your option) version 3, or any
9		* later version accepted by the membership of KDE e.V. (or its
10		* successor approved by the membership of KDE e.V.), which shall
11		* act as a proxy defined in Section 6 of version 3 of the license.
12		*
13		* This library is distributed in the hope that it will be useful,
14		* but WITHOUT ANY WARRANTY; without even the implied warranty of
15		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16		* Lesser General Public License for more details.
17		*
18		* You should have received a copy of the GNU Lesser General Public
19		* License along with this library. If not, see <http://www.gnu.org/licenses/>.
20		*/
21
22		#include "notificationgroupingproxymodel_p.h"
23
24		#include <QDateTime>
25
26		#include "notifications.h"
27
28		using namespace NotificationManager;
29
30		NotificationGroupingProxyModel::NotificationGroupingProxyModel(QObject *parent)
31		: QAbstractProxyModel(parent)
32		{
33
34		}
35
36		NotificationGroupingProxyModel::~NotificationGroupingProxyModel() = default;
37
38		bool NotificationGroupingProxyModel::appsMatch(const QModelIndex &a, const QModelIndex &b) const
39		{
	heinUnsubmitted Done Careful there - these will match when both are empty, which is why the libtm version tests for that. Are you sure this data cannot ever be missing? hein: Careful there - these will match when both are empty, which is why the libtm version tests for…
	broulikAuthorUnsubmitted Done I'm pretty sure it can never be empty as if all else fails I use the binary name of the process that sent the notification dbus message (which might fail after all?), I'll add a check nonetheless. broulik: I'm pretty sure it can never be empty as if all else fails I use the binary name of the process…
40		const QString aName = a.data(Notifications::ApplicationNameRole).toString();
41		const QString bName = b.data(Notifications::ApplicationNameRole).toString();
42
43		const QString aDesktopEntry = a.data(Notifications::DesktopEntryRole).toString();
44		const QString bDesktopEntry = b.data(Notifications::DesktopEntryRole).toString();
45
46		return aName == bName && aDesktopEntry == bDesktopEntry;
47		}
48
49		bool NotificationGroupingProxyModel::isGroup(int row) const
50		{
51		if (row < 0 \|\| row >= rowMap.count()) {
52		return false;
53		}
54
55		return (rowMap.at(row)->count() > 1);
56		}
57
58		bool NotificationGroupingProxyModel::tryToGroup(const QModelIndex &sourceIndex, bool silent)
59		{
60		// Meat of the matter: Try to add this source row to a sub-list with source rows
61		// associated with the same application.
62		for (int i = 0; i < rowMap.count(); ++i) {
63		const QModelIndex &groupRep = sourceModel()->index(rowMap.at(i)->constFirst(), 0);
64
65		// Don't match a row with itself.
66		if (sourceIndex == groupRep) {
67		continue;
68		}
69
70		if (appsMatch(sourceIndex, groupRep)) {
71		const QModelIndex parent = index(i, 0);
72
73		if (!silent) {
74		const int newIndex = rowMap.at(i)->count();
75
76		if (newIndex == 1) {
77		beginInsertRows(parent, 0, 1);
78		} else {
79		beginInsertRows(parent, newIndex, newIndex);
80		}
81		}
82
83		rowMap[i]->append(sourceIndex.row());
84
85		if (!silent) {
86		endInsertRows();
87
88		dataChanged(parent, parent);
89		}
90
91		return true;
92		}
93		}
94
95		return false;
96		}
97
98		void NotificationGroupingProxyModel::adjustMap(int anchor, int delta)
99		{
100		for (int i = 0; i < rowMap.count(); ++i) {
101		QVector<int> *sourceRows = rowMap.at(i);
102		QMutableVectorIterator<int> it(*sourceRows);
103
104		while (it.hasNext()) {
105		it.next();
106
107		if (it.value() >= anchor) {
108		it.setValue(it.value() + delta);
109		}
110		}
111		}
112		}
113
114		void NotificationGroupingProxyModel::rebuildMap()
115		{
116		qDeleteAll(rowMap);
117		rowMap.clear();
118
119		const int rows = sourceModel()->rowCount();
120
121		rowMap.reserve(rows);
122
123		for (int i = 0; i < rows; ++i) {
124		rowMap.append(new QVector<int>{i});
125		}
126
127		checkGrouping(true /* silent */);
128		}
129
130		void NotificationGroupingProxyModel::checkGrouping(bool silent)
131		{
132		for (int i = (rowMap.count()) - 1; i >= 0; --i) {
133		if (isGroup(i)) {
134		continue;
135		}
136
137		// FIXME support skip grouping hint, maybe?
138		// The new grouping keeps every notification separate, still, so perhaps we don't need to
139
140		if (tryToGroup(sourceModel()->index(rowMap.at(i)->constFirst(), 0), silent)) {
141		beginRemoveRows(QModelIndex(), i, i);
142		delete rowMap.takeAt(i); // Safe since we're iterating backwards.
143		endRemoveRows();
144		}
145		}
146		}
147
148		void NotificationGroupingProxyModel::formGroupFor(const QModelIndex &index)
149		{
150		// Already in group or a group.
151		if (index.parent().isValid() \|\| isGroup(index.row())) {
152		return;
153		}
154
155		// We need to grab a source index as we may invalidate the index passed
156		// in through grouping.
157		const QModelIndex &sourceTarget = mapToSource(index);
158
159		for (int i = (rowMap.count() - 1); i >= 0; --i) {
160		const QModelIndex &sourceIndex = sourceModel()->index(rowMap.at(i)->constFirst(), 0);
161
162		if (!appsMatch(sourceTarget, sourceIndex)) {
163		continue;
164		}
165
166		if (tryToGroup(sourceIndex)) {
167		beginRemoveRows(QModelIndex(), i, i);
168		delete rowMap.takeAt(i); // Safe since we're iterating backwards.
169		endRemoveRows();
170		}
171		}
172		}
173
174		void NotificationGroupingProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
175		{
176		if (sourceModel == QAbstractProxyModel::sourceModel()) {
177		return;
178		}
179
180		beginResetModel();
181
182		if (QAbstractProxyModel::sourceModel()) {
183		QAbstractProxyModel::sourceModel()->disconnect(this);
184		}
185
186		QAbstractProxyModel::setSourceModel(sourceModel);
187
188		if (sourceModel) {
189		rebuildMap();
190
191		// FIXME move this stuff into separate slot methods
192
193		connect(sourceModel, &QAbstractItemModel::rowsInserted, this, [this](const QModelIndex &parent, int start, int end) {
194		if (parent.isValid()) {
195		return;
196		}
197
198		adjustMap(start, (end - start) + 1);
199
200		for (int i = start; i <= end; ++i) {
201		if (!tryToGroup(this->sourceModel()->index(i, 0))) {
202		beginInsertRows(QModelIndex(), rowMap.count(), rowMap.count());
203		rowMap.append(new QVector<int>{i});
204		endInsertRows();
205		}
206		}
207
208		checkGrouping();
209		});
210
211		connect(sourceModel, &QAbstractItemModel::rowsAboutToBeRemoved, this, [this](const QModelIndex &parent, int first, int last) {
212		if (parent.isValid()) {
213		return;
214		}
215
216		for (int i = first; i <= last; ++i) {
217		for (int j = 0; j < rowMap.count(); ++j) {
218		const QVector<int> *sourceRows = rowMap.at(j);
219		const int mapIndex = sourceRows->indexOf(i);
220
221		if (mapIndex != -1) {
222		// Remove top-level item.
223		if (sourceRows->count() == 1) {
224		beginRemoveRows(QModelIndex(), j, j);
225		delete rowMap.takeAt(j);
226		endRemoveRows();
227		// Dissolve group.
228		} else if (sourceRows->count() == 2) {
229		const QModelIndex parent = index(j, 0);
230		beginRemoveRows(parent, 0, 1);
231		rowMap[j]->remove(mapIndex);
232		endRemoveRows();
233
234		// We're no longer a group parent.
235		dataChanged(parent, parent);
236		// Remove group member.
237		} else {
238		const QModelIndex parent = index(j, 0);
239		beginRemoveRows(parent, mapIndex, mapIndex);
240		rowMap[j]->remove(mapIndex);
241		endRemoveRows();
242
243		// Various roles of the parent evaluate child data, and the
244		// child list has changed.
245		dataChanged(parent, parent);
246
247		// Signal children count change for all other items in the group.
248		emit dataChanged(index(0, 0, parent), index(rowMap.count() - 1, 0, parent), {Notifications::GroupChildrenCountRole});
249		}
250
251		break;
252		}
253		}
254		}
255		});
256
257		connect(sourceModel, &QAbstractItemModel::rowsRemoved, this, [this](const QModelIndex &parent, int start, int end) {
258		if (parent.isValid()) {
259		return;
260		}
261
262		adjustMap(start + 1, -((end - start) + 1));
263
264		checkGrouping();
265		});
266
267
268		connect(sourceModel, &QAbstractItemModel::modelAboutToBeReset, this, &NotificationGroupingProxyModel::beginResetModel);
269		connect(sourceModel, &QAbstractItemModel::modelReset, this, [this] {
270		rebuildMap();
271		endResetModel();
272		});
273
274		connect(sourceModel, &QAbstractItemModel::dataChanged, this, [this](const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles) {
275		for (int i = topLeft.row(); i <= bottomRight.row(); ++i) {
276		const QModelIndex &sourceIndex = this->sourceModel()->index(i, 0);
277		QModelIndex proxyIndex = mapFromSource(sourceIndex);
278
279		if (!proxyIndex.isValid()) {
280		return;
281		}
282
283		const QModelIndex parent = proxyIndex.parent();
284
285		// If a child item changes, its parent may need an update as well as many of
286		// the data roles evaluate child data. See data().
287		// TODO: Some roles do not need to bubble up as they fall through to the first
288		// child in data(); it _might_ be worth adding constraints here later.
289		if (parent.isValid()) {
290		dataChanged(parent, parent, roles);
291		}
292
293		dataChanged(proxyIndex, proxyIndex, roles);
294		}
295		});
296		}
297
298		endResetModel();
299		}
300
301		QModelIndex NotificationGroupingProxyModel::index(int row, int column, const QModelIndex &parent) const
302		{
303		if (row < 0 \|\| column != 0) {
304		return QModelIndex();
305		}
306
307		if (parent.isValid() && row < rowMap.at(parent.row())->count()) {
308		return createIndex(row, column, rowMap.at(parent.row()));
309		}
310
311		if (row < rowMap.count()) {
312		return createIndex(row, column, nullptr);
313		}
314
315		return QModelIndex();
316		}
317
318		QModelIndex NotificationGroupingProxyModel::parent(const QModelIndex &child) const
319		{
320		if (child.internalPointer() == nullptr) {
321		return QModelIndex();
322		} else {
323		const int parentRow = rowMap.indexOf(static_cast<QVector<int> *>(child.internalPointer()));
324
325		if (parentRow != -1) {
326		return index(parentRow, 0);
327		}
328
329		// If we were asked to find the parent for an internalPointer we can't
330		// locate, we have corrupted data: This should not happen.
331		Q_ASSERT(parentRow != -1);
332		}
333
334		return QModelIndex();
335		}
336
337		QModelIndex NotificationGroupingProxyModel::mapFromSource(const QModelIndex &sourceIndex) const
338		{
339		if (!sourceIndex.isValid() \|\| sourceIndex.model() != sourceModel()) {
340		return QModelIndex();
341		}
342
343		for (int i = 0; i < rowMap.count(); ++i) {
344		const QVector<int> *sourceRows = rowMap.at(i);
345		const int childIndex = sourceRows->indexOf(sourceIndex.row());
346		const QModelIndex parent = index(i, 0);
347
348		if (childIndex == 0) {
349		// If the sub-list we found the source row in is larger than 1 (i.e. part
350		// of a group, map to the logical child item instead of the parent item
351		// the source row also stands in for. The parent is therefore unreachable
352		// from mapToSource().
353		if (isGroup(i)) {
354		return index(0, 0, parent);
355		// Otherwise map to the top-level item.
356		} else {
357		return parent;
358		}
359		} else if (childIndex != -1) {
360		return index(childIndex, 0, parent);
361		}
362		}
363
364		return QModelIndex();
365		}
366
367		QModelIndex NotificationGroupingProxyModel::mapToSource(const QModelIndex &proxyIndex) const
368		{
369		if (!proxyIndex.isValid() \|\| proxyIndex.model() != this \|\| !sourceModel()) {
370		return QModelIndex();
371		}
372
373		const QModelIndex &parent = proxyIndex.parent();
374
375		if (parent.isValid()) {
376		if (parent.row() < 0 \|\| parent.row() >= rowMap.count()) {
377		return QModelIndex();
378		}
379
380		return sourceModel()->index(rowMap.at(parent.row())->at(proxyIndex.row()), 0);
381		} else {
382		// Group parents items therefore equate to the first child item; the source
383		// row logically appears twice in the proxy.
384		// mapFromSource() is not required to handle this well (consider proxies can
385		// filter out rows, too) and opts to map to the child item, as the group parent
386		// has its Qt::DisplayRole mangled by data(), and it's more useful for trans-
387		// lating dataChanged() from the source model.
388		// NOTE we changed that to be last
389		if (rowMap.isEmpty()) { // FIXME
390		// How can this happen? (happens when closing a group)
391		return QModelIndex();
392		}
393		return sourceModel()->index(rowMap.at(proxyIndex.row())->constLast(), 0);
394		}
395
396		return QModelIndex();
397		}
398
399		int NotificationGroupingProxyModel::rowCount(const QModelIndex &parent) const
400		{
401		if (!sourceModel()) {
402		return 0;
403		}
404
405		if (parent.isValid() && parent.model() == this) {
406		// Don't return row count for top-level item at child row: Group members
407		// never have further children of their own.
408		if (parent.parent().isValid()) {
409		return 0;
410		}
411
412		if (parent.row() < 0 \|\| parent.row() >= rowMap.count()) {
413		return 0;
414		}
415
416		const int rowCount = rowMap.at(parent.row())->count();
417
418		// If this sub-list in the map only has one entry, it's a plain item, not
419		// parent to a group.
420		if (rowCount == 1) {
421		return 0;
422		} else {
423		return rowCount;
424		}
425		}
426
427		return rowMap.count();
428		}
429
430		bool NotificationGroupingProxyModel::hasChildren(const QModelIndex &parent) const
431		{
432		if ((parent.model() && parent.model() != this) \|\| !sourceModel()) {
433		return false;
434		}
435
436		return rowCount(parent);
437		}
438
439		int NotificationGroupingProxyModel::columnCount(const QModelIndex &parent) const
440		{
441		Q_UNUSED(parent)
442
443		return 1;
444		}
445
446		QVariant NotificationGroupingProxyModel::data(const QModelIndex &proxyIndex, int role) const
447		{
448		if (!proxyIndex.isValid() \|\| proxyIndex.model() != this \|\| !sourceModel()) {
449		return QVariant();
450		}
451
452		const QModelIndex &parent = proxyIndex.parent();
453		const bool isGroup = (!parent.isValid() && this->isGroup(proxyIndex.row()));
454
455		// For group parent items, this will map to the last child task.
456		const QModelIndex &sourceIndex = mapToSource(proxyIndex);
457
458		if (!sourceIndex.isValid()) {
459		return QVariant();
460		}
461
462		if (isGroup) {
463		// For group parent items, DisplayRole is mapped to AppName of the first child.
464		switch (role) {
465		case Notifications::IsGroupRole:
466		return true;
467		case Notifications::GroupChildrenCountRole:
468		return rowCount(proxyIndex);
469		case Notifications::IsInGroupRole:
470		return false;
471
472		case Notifications::DesktopEntryRole:
473		for (int i = 0; i < rowCount(proxyIndex); ++i) {
474		const QString desktopEntry = proxyIndex.child(i, 0).data(Notifications::DesktopEntryRole).toString();
475		if (!desktopEntry.isEmpty()) {
476		return desktopEntry;
477		}
478		}
479		return QString();
480		case Notifications::NotifyRcNameRole:
481		for (int i = 0; i < rowCount(proxyIndex); ++i) {
482		const QString notifyRcName = proxyIndex.child(i, 0).data(Notifications::NotifyRcNameRole).toString();
483		if (!notifyRcName.isEmpty()) {
484		return notifyRcName;
485		}
486		}
487		return QString();
488
489
490		case Notifications::ConfigurableRole: // if there is any configurable child item
491		for (int i = 0; i < rowCount(proxyIndex); ++i) {
492		if (proxyIndex.child(i, 0).data(Notifications::ConfigurableRole).toBool()) {
493		return true;
494		}
495		}
496		return false;
497
498		case Notifications::ClosableRole: // if there is any closable child item
499		for (int i = 0; i < rowCount(proxyIndex); ++i) {
500		if (proxyIndex.child(i, 0).data(Notifications::ClosableRole).toBool()) {
501		return true;
502		}
503		}
504		return false;
505
506		}
507		} else {
508		switch (role) {
509		case Notifications::IsGroupRole:
510		return false;
511		// So a notification knows with how many other items it is in a group
512		case Notifications::GroupChildrenCountRole:
513		if (proxyIndex.parent().isValid()) {
514		return rowCount(proxyIndex.parent());
515		}
516		break;
517		case Notifications::IsInGroupRole:
518		return parent.isValid();
519		}
520		}
521
522		return sourceIndex.data(role);
523		}