Differential D20265 Diff 55470 libnotificationmanager/notificationgroupcollapsingproxymodel.cpp

Changeset View

Standalone View

View Options

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);
53​
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?
54​ if (roles.isEmpty() || roles.contains(Notifications::IsGroupRole)) {
55​ if (!topLeft.data(Notifications::IsGroupRole).toBool()) {
56​ const QModelIndex proxyIdx = mapFromSource(topLeft);
57​ if (m_expandedGroups.contains(proxyIdx)) {
58​ setGroupExpanded(proxyIdx, false);
59​ }
60​ }
61​ }
62​ });
63​ }
64​}
65​
66​QVariant NotificationGroupCollapsingProxyModel::data(const QModelIndex &index, int role) const
67​{
68​ if (role == NotificationManager::Notifications::IsGroupExpandedRole) {
69​ if (m_limit > 0) {
70​ // so each item in a group knows whether the group is expanded
71​ const QModelIndex parentIdx = index.parent();
72​ if (parentIdx.isValid()) {
73​ return m_expandedGroups.contains(parentIdx);
74​ } else {
75​ return m_expandedGroups.contains(index);
76​ }
77​ } else {
78​ return true;
79​ }
80​ }
81​
82​ return QSortFilterProxyModel::data(index, role);
83​}
84​
85​bool NotificationGroupCollapsingProxyModel::setData(const QModelIndex &index, const QVariant &value, int role)
86​{
87​ if (role == Notifications::IsGroupExpandedRole && m_limit > 0) {
88​ QModelIndex groupIdx = index;
89​ // so an item inside a group can expand/collapse the group
90​ if (groupIdx.parent().isValid()) {
91​ groupIdx = groupIdx.parent();
92​ }
93​
94​ const bool expanded = value.toBool();
95​ if (!groupIdx.data(Notifications::IsGroupRole).toBool()) {
96​ qCWarning(NOTIFICATIONMANAGER) << "Cannot" << (expanded ? "expand" : "collapse") << "an item isn't a group or inside of one";
97​ return false;
98​ }
99​
100​ return setGroupExpanded(groupIdx, expanded);
101​ }
102​
103​ return false;
104​}
105​
106​int NotificationGroupCollapsingProxyModel::limit() const
107​{
108​ return m_limit;
109​}
110​
111​void NotificationGroupCollapsingProxyModel::setLimit(int limit)
112​{
113​ if (m_limit != limit) {
114​ m_limit = limit;
115​ invalidateFilter();
116​ emit limitChanged();
117​ }
118​}
119​
120​bool NotificationGroupCollapsingProxyModel::setGroupExpanded(const QModelIndex &idx, bool expanded)
121​{
122​ if (idx.data(Notifications::IsGroupExpandedRole).toBool() == expanded) {
123​ return false;
124​ }
125​
126​ QPersistentModelIndex persistentIdx(idx);
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…
127​ if (expanded) {
128​ m_expandedGroups.append(persistentIdx);
129​ } else {
130​ m_expandedGroups.removeOne(persistentIdx);
131​ }
132​
133​ invalidateFilter();
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…
134​
135​ emit dataChanged(idx, idx, {Notifications::IsGroupExpandedRole});
136​
137​ // also signal the children
138​ emit dataChanged(idx.child(0, 0), idx.child(rowCount(idx) - 1, 0), {Notifications::IsGroupExpandedRole});
139​
140​ return true;
141​}
142​
143​bool NotificationGroupCollapsingProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
144​{
145​ if (source_parent.isValid() && m_limit > 0) {
146​ if (!m_expandedGroups.isEmpty() && m_expandedGroups.contains(mapFromSource(source_parent))) {
147​ return true;
148​ }
149​
150​ // should we raise the limit when there's just one group?
151​
152​ // FIXME why is this reversed?
153​ // grouping proxy model seems to reverse the order?
154​ return source_row >= sourceModel()->rowCount(source_parent) - m_limit;
155​ }
156​
157​ return true;
158​}
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…
heinUnsubmitted
Done

Check m_limit first for a tiny speedup.

hein: Check m_limit first for a tiny speedup.