Differential D20265 Diff 56056 libnotificationmanager/notificationgroupcollapsingproxymodel.cpp

Changeset View

Standalone View

libnotificationmanager/notificationgroupcollapsingproxymodel.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 "notificationgroupcollapsingproxymodel_p.h"
22
23		#include "notifications.h"
24
25		#include "debug.h"
26
27		using namespace NotificationManager;
28
29		NotificationGroupCollapsingProxyModel::NotificationGroupCollapsingProxyModel(QObject *parent)
30		: QSortFilterProxyModel(parent)
31		{
32
33		}
34
35		NotificationGroupCollapsingProxyModel::~NotificationGroupCollapsingProxyModel() = default;
36
37		void NotificationGroupCollapsingProxyModel::setSourceModel(QAbstractItemModel *source)
38		{
39		if (sourceModel()) {
40		disconnect(sourceModel(), nullptr, this, nullptr);
41		}
42
43		QSortFilterProxyModel::setSourceModel(source);
44
45		if (source) {
46		connect(source, &QAbstractItemModel::rowsInserted, this, &NotificationGroupCollapsingProxyModel::invalidateFilter);
47		connect(source, &QAbstractItemModel::rowsRemoved, this, &NotificationGroupCollapsingProxyModel::invalidateFilter);
48
49		// When a group is removed, there is no item that's being removed, instead the item morphs back into a single notification
50		connect(source, &QAbstractItemModel::dataChanged, this, [this](const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles) {
51		Q_UNUSED(bottomRight); // what about it?
52		Q_UNUSED(roles);
	heinUnsubmitted Done Not actually unused. `bottomRight`: You sure the source model will emit for single cells? Otherwise you need to loop over the range. hein: Not actually unused. `bottomRight`: You sure the source model will emit for single cells?
53
54		if (roles.isEmpty() \|\| roles.contains(Notifications::IsGroupRole)) {
55		if (!topLeft.data(Notifications::IsGroupRole).toBool()) {
56		if (m_expandedGroups.contains(topLeft)) {
57		setGroupExpanded(topLeft, false);
58		}
59		}
60		}
61		});
62		}
63		}
64
65		QVariant NotificationGroupCollapsingProxyModel::data(const QModelIndex &index, int role) const
66		{
67		switch (role) {
68		case NotificationManager::Notifications::IsGroupExpandedRole: {
69		if (m_limit > 0) {
70		// so each item in a group knows whether the group is expanded
71		const QModelIndex sourceIdx = mapToSource(index);
72		return m_expandedGroups.contains(sourceIdx.parent().isValid() ? sourceIdx.parent() : sourceIdx);
73		}
74		return true;
75		}
76		case NotificationManager::Notifications::ExpandedGroupChildrenCountRole:
77		return rowCount(index.parent().isValid() ? index.parent() : index);
78		}
79
80		return QSortFilterProxyModel::data(index, role);
81		}
82
83		bool NotificationGroupCollapsingProxyModel::setData(const QModelIndex &index, const QVariant &value, int role)
84		{
85		if (role == Notifications::IsGroupExpandedRole && m_limit > 0) {
86		QModelIndex groupIdx = index;
87		// so an item inside a group can expand/collapse the group
88		if (groupIdx.parent().isValid()) {
89		groupIdx = groupIdx.parent();
90		}
91
92		const bool expanded = value.toBool();
93		if (!groupIdx.data(Notifications::IsGroupRole).toBool()) {
94		qCWarning(NOTIFICATIONMANAGER) << "Cannot" << (expanded ? "expand" : "collapse") << "an item isn't a group or inside of one";
95		return false;
96		}
97
98		return setGroupExpanded(groupIdx, expanded);
99		}
100
101		return QSortFilterProxyModel::setData(index, value, role);
102		}
103
104		int NotificationGroupCollapsingProxyModel::limit() const
105		{
106		return m_limit;
107		}
108
109		void NotificationGroupCollapsingProxyModel::setLimit(int limit)
110		{
111		if (m_limit != limit) {
112		m_limit = limit;
113		invalidateFilter();
114		invalidateGroupRoles();
115		emit limitChanged();
116		}
117		}
118
119		QDateTime NotificationGroupCollapsingProxyModel::lastRead() const
120		{
121		return m_lastRead;
122		}
123
124		void NotificationGroupCollapsingProxyModel::setLastRead(const QDateTime &lastRead)
125		{
126		if (m_lastRead != lastRead) {
127		m_lastRead = lastRead;
	davidedmundsonUnsubmitted Done It seems safer to take the pesistent index from the sourceModel We're invalidating this layer repeatedly which could invalidate our persistent index davidedmundson: It seems safer to take the pesistent index from the sourceModel We're invalidating this layer…
128		invalidateFilter();
129		invalidateGroupRoles();
130		emit lastReadChanged();
131		}
132		}
133
134		bool NotificationGroupCollapsingProxyModel::expandUnread() const
	davidedmundsonUnsubmitted Not Done you shouldn't need this, the data is changing so it'll get re-evaluated davidedmundson: you shouldn't need this, the data is changing so it'll get re-evaluated
	broulikAuthorUnsubmitted Not Done `filterAcceptsRow` doesn't actually read `IsGroupExpanded` since `filterAcceptsRow` evaluates the source row, not our own broulik: `filterAcceptsRow` doesn't actually read `IsGroupExpanded` since `filterAcceptsRow` evaluates…
135		{
136		return m_expandUnread;
137		}
138
139		void NotificationGroupCollapsingProxyModel::setExpandUnread(bool expand)
140		{
141		if (m_expandUnread != expand) {
142		m_expandUnread = expand;
143		invalidateFilter();
144		invalidateGroupRoles();
145		emit expandUnreadChanged();
146		}
147		}
148
149		void NotificationGroupCollapsingProxyModel::collapseAll()
150		{
151		m_expandedGroups.clear();
152
153		invalidateFilter();
154		invalidateGroupRoles();
155		}
156
157		bool NotificationGroupCollapsingProxyModel::setGroupExpanded(const QModelIndex &idx, bool expanded)
158		{
159		if (idx.data(Notifications::IsGroupExpandedRole).toBool() == expanded) {
160		return false;
161		}
162
163		QPersistentModelIndex persistentIdx(mapToSource(idx));
164		if (expanded) {
165		m_expandedGroups.append(persistentIdx);
166		} else {
167		m_expandedGroups.removeOne(persistentIdx);
168		}
169
170		invalidateFilter();
171
172		const QVector<int> dirtyRoles = {Notifications::ExpandedGroupChildrenCountRole, Notifications::IsGroupExpandedRole};
173
174		emit dataChanged(idx, idx, dirtyRoles);
175		emit dataChanged(idx.child(0, 0), idx.child(rowCount(idx) - 1, 0), dirtyRoles);
	heinUnsubmitted Done I know this really sucks, and I'm not going to be pushy on this because you've been waiting on this review forever. But: Qt 5.13 has deprecated `QModelIndex::child` (they want us to use `QAIM::index` now always), leading to noisy builds. For new code it'd be amazing to avoid it. hein: I know this really sucks, and I'm not going to be pushy on this because you've been waiting on…
176
177		return true;
178		}
179
180		void NotificationGroupCollapsingProxyModel::invalidateGroupRoles()
181		{
182		const QVector<int> dirtyRoles = {Notifications::ExpandedGroupChildrenCountRole, Notifications::IsGroupExpandedRole};
183
184		emit dataChanged(index(0, 0), index(rowCount() - 1, 0), dirtyRoles);
185
186		for (int row = 0; row < rowCount(); ++row) {
187		const QModelIndex groupIdx = index(row, 0);
188		emit dataChanged(groupIdx.child(0, 0), groupIdx.child(rowCount(groupIdx) - 1, 0), dirtyRoles);
189		}
190		}
191
192		bool NotificationGroupCollapsingProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
193		{
194		if (source_parent.isValid() && m_limit > 0) {
	heinUnsubmitted Done Check m_limit first for a tiny speedup. hein: Check m_limit first for a tiny speedup.
195		if (!m_expandedGroups.isEmpty() && m_expandedGroups.contains(source_parent)) {
196		return true;
197		}
198
199		if (m_expandUnread && m_lastRead.isValid()) {
200		const QModelIndex sourceIdx = sourceModel()->index(source_row, 0, source_parent);
201		QDateTime time = sourceIdx.data(Notifications::UpdatedRole).toDateTime();
202		if (!time.isValid()) {
203		time = sourceIdx.data(Notifications::CreatedRole).toDateTime();
204		}
205
206		if (time.isValid() && m_lastRead < time) {
207		return true;
208		}
209		}
210
211		// should we raise the limit when there's just one group?
212
213		// FIXME why is this reversed?
214		// grouping proxy model seems to reverse the order?
215		return source_row >= sourceModel()->rowCount(source_parent) - m_limit;
216		}
217
218		return true;
219		}