Differential D1722 Diff 4228 libtaskmanager/taskfilterproxymodel.cpp

Changeset View

Standalone View

View Options

libtaskmanager/taskfilterproxymodel.cpp

  • This file was added.
1​/********************************************************************
2​Copyright 2016 Eike Hein <hein@kde.org>
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 "taskfilterproxymodel.h"
22​#include "abstracttasksmodel.h"
23​
24​namespace TaskManager
25​{
26​
27​class TaskFilterProxyModel::Private
28​{
29​public:
30​ Private(TaskFilterProxyModel *q);
31​
32​ AbstractTasksModelIface *sourceTasksModel = nullptr;
33​
34​ uint virtualDesktop = 0;
35​ int screen = -1;
davidedmundsonUnsubmitted
Done

Not that it will make a real difference, but shouldn't this technically default to 0?

virtual desktops start at 1 with 0 being invalid.

davidedmundson: Not that it will make a real difference, but shouldn't this technically default to 0? virtual…
heinAuthorUnsubmitted
Not Done

Makes sense -- I've changed the type to uint, the default to 0 and expanded the API docs a bit.

hein: Makes sense -- I've changed the type to uint, the default to 0 and expanded the API docs a bit.
36​ QString activity;
37​
38​ bool filterByVirtualDesktop = false;
39​ bool filterByScreen = false;
40​ bool filterByActivity = false;
41​ bool filterNotMinimized = false;
42​
43​private:
44​ TaskFilterProxyModel *q;
45​};
46​
47​TaskFilterProxyModel::Private::Private(TaskFilterProxyModel *q)
48​ : q(q)
49​{
50​}
51​
52​TaskFilterProxyModel::TaskFilterProxyModel(QObject *parent)
53​ : QSortFilterProxyModel(parent)
54​ , d(new Private(this))
55​{
56​}
57​
58​TaskFilterProxyModel::~TaskFilterProxyModel()
59​{
60​}
61​
62​void TaskFilterProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
63​{
64​ d->sourceTasksModel = dynamic_cast<AbstractTasksModelIface *>(sourceModel);
65​
66​ QSortFilterProxyModel::setSourceModel(sourceModel);
67​}
68​
69​uint TaskFilterProxyModel::virtualDesktop() const
70​{
71​ return d->virtualDesktop;
72​}
73​
74​void TaskFilterProxyModel::setVirtualDesktop(uint virtualDesktop)
75​{
76​ if (d->virtualDesktop != virtualDesktop) {
77​ d->virtualDesktop = virtualDesktop;
78​
79​ if (d->filterByVirtualDesktop) {
80​ invalidateFilter();
81​ }
82​
83​ emit virtualDesktopChanged();
84​ }
85​}
86​
87​int TaskFilterProxyModel::screen() const
88​{
89​ return d->screen;
90​}
91​
92​void TaskFilterProxyModel::setScreen(int screen)
93​{
94​ if (d->screen != screen) {
95​ d->screen = screen;
96​
97​ if (d->filterByScreen) {
98​ invalidateFilter();
99​ }
100​
101​ emit screenChanged();
102​ }
103​}
104​
105​QString TaskFilterProxyModel::activity() const
106​{
107​ return d->activity;
108​}
109​
110​void TaskFilterProxyModel::setActivity(const QString &activity)
111​{
112​ if (d->activity != activity) {
113​ d->activity = activity;
114​
115​ if (d->filterByActivity) {
116​ invalidateFilter();
117​ }
118​
119​ emit activityChanged();
120​ }
121​}
122​
123​bool TaskFilterProxyModel::filterByVirtualDesktop() const
124​{
125​ return d->filterByVirtualDesktop;
126​}
127​
128​void TaskFilterProxyModel::setFilterByVirtualDesktop(bool filter)
129​{
130​ if (d->filterByVirtualDesktop != filter) {
131​ d->filterByVirtualDesktop = filter;
132​
133​ invalidateFilter();
134​
135​ emit filterByVirtualDesktopChanged();
136​ }
137​}
138​
139​bool TaskFilterProxyModel::filterByScreen() const
140​{
141​ return d->filterByScreen;
142​}
143​
144​void TaskFilterProxyModel::setFilterByScreen(bool filter)
145​{
146​ if (d->filterByScreen != filter) {
147​ d->filterByScreen = filter;
148​
149​ invalidateFilter();
150​
151​ emit filterByScreenChanged();
152​ }
153​}
154​
155​bool TaskFilterProxyModel::filterByActivity() const
156​{
157​ return d->filterByActivity;
158​}
159​
160​void TaskFilterProxyModel::setFilterByActivity(bool filter)
161​{
162​ if (d->filterByActivity != filter) {
163​ d->filterByActivity = filter;
164​
165​ invalidateFilter();
166​
167​ emit filterByActivityChanged();
168​ }
169​}
170​
171​bool TaskFilterProxyModel::filterNotMinimized() const
172​{
173​ return d->filterNotMinimized;
174​}
175​
176​void TaskFilterProxyModel::setFilterNotMinimized(bool filter)
177​{
178​ if (d->filterNotMinimized != filter) {
179​ d->filterNotMinimized = filter;
180​
181​ invalidateFilter();
182​
183​ emit filterNotMinimizedChanged();
184​ }
185​}
186​
187​void TaskFilterProxyModel::requestActivate(const QModelIndex &index)
188​{
189​ if (d->sourceTasksModel && index.isValid() && index.model() == this) {
190​ d->sourceTasksModel->requestActivate(mapToSource(index));
191​ }
192​}
193​
194​void TaskFilterProxyModel::requestNewInstance(const QModelIndex &index)
195​{
196​ if (d->sourceTasksModel && index.isValid() && index.model() == this) {
197​ d->sourceTasksModel->requestNewInstance(mapToSource(index));
198​ }
199​}
200​
201​void TaskFilterProxyModel::requestClose(const QModelIndex &index)
202​{
203​ if (d->sourceTasksModel && index.isValid() && index.model() == this) {
204​ d->sourceTasksModel->requestClose(mapToSource(index));
205​ }
206​}
207​
208​void TaskFilterProxyModel::requestMove(const QModelIndex &index)
209​{
210​ if (d->sourceTasksModel && index.isValid() && index.model() == this) {
211​ d->sourceTasksModel->requestMove(mapToSource(index));
212​ }
213​}
214​
215​void TaskFilterProxyModel::requestResize(const QModelIndex &index)
216​{
217​ if (d->sourceTasksModel && index.isValid() && index.model() == this) {
218​ d->sourceTasksModel->requestResize(mapToSource(index));
219​ }
220​}
221​
222​void TaskFilterProxyModel::requestToggleMinimized(const QModelIndex &index)
223​{
224​ if (d->sourceTasksModel && index.isValid() && index.model() == this) {
225​ d->sourceTasksModel->requestToggleMinimized(mapToSource(index));
226​ }
227​}
228​
229​void TaskFilterProxyModel::requestToggleMaximized(const QModelIndex &index)
230​{
231​ if (d->sourceTasksModel && index.isValid() && index.model() == this) {
232​ d->sourceTasksModel->requestToggleMaximized(mapToSource(index));
233​ }
234​}
235​
236​void TaskFilterProxyModel::requestToggleKeepAbove(const QModelIndex &index)
237​{
238​ if (d->sourceTasksModel && index.isValid() && index.model() == this) {
239​ d->sourceTasksModel->requestToggleKeepAbove(mapToSource(index));
240​ }
241​}
242​
243​void TaskFilterProxyModel::requestToggleKeepBelow(const QModelIndex &index)
244​{
245​ if (d->sourceTasksModel && index.isValid() && index.model() == this) {
246​ d->sourceTasksModel->requestToggleKeepBelow(mapToSource(index));
247​ }
248​}
249​
250​void TaskFilterProxyModel::requestToggleFullScreen(const QModelIndex &index)
251​{
252​ if (d->sourceTasksModel && index.isValid() && index.model() == this) {
253​ d->sourceTasksModel->requestToggleFullScreen(mapToSource(index));
254​ }
255​}
256​
257​void TaskFilterProxyModel::requestToggleShaded(const QModelIndex &index)
258​{
259​ if (d->sourceTasksModel && index.isValid() && index.model() == this) {
260​ d->sourceTasksModel->requestToggleShaded(mapToSource(index));
261​ }
262​}
263​
264​void TaskFilterProxyModel::requestVirtualDesktop(const QModelIndex &index, qint32 desktop)
265​{
266​ if (d->sourceTasksModel && index.isValid() && index.model() == this) {
267​ d->sourceTasksModel->requestVirtualDesktop(mapToSource(index), desktop);
268​ }
269​}
270​
271​void TaskFilterProxyModel::requestPublishDelegateGeometry(const QModelIndex &index, const QRect &geometry, QObject *delegate)
272​{
273​ if (index.isValid() && index.model() == this) {
274​ d->sourceTasksModel->requestPublishDelegateGeometry(mapToSource(index), geometry, delegate);
275​ }
276​}
277​
278​bool TaskFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
279​{
280​ Q_UNUSED(sourceParent)
281​
282​ const QModelIndex &sourceIdx = sourceModel()->index(sourceRow, 0);
283​
284​ // Filter tasks that are not to be shown on the task bar.
285​ if (sourceIdx.data(AbstractTasksModel::SkipTaskbar).toBool()) {
286​ return false;
287​ }
288​
289​ // Filter by virtual desktop.
290​ if (d->filterByVirtualDesktop && d->virtualDesktop != 0) {
291​ if (!sourceIdx.data(AbstractTasksModel::IsOnAllVirtualDesktops).toBool()) {
292​ const QVariant &virtualDesktop = sourceIdx.data(AbstractTasksModel::VirtualDesktop);
293​
294​ if (!virtualDesktop.isNull()) {
295​ bool ok = false;
296​ const uint i = virtualDesktop.toUInt(&ok);
297​
298​ if (ok && i != d->virtualDesktop) {
299​ return false;
davidedmundsonUnsubmitted
Done

There was a bug that Kai found recently where some other bit of code randomly set the virtual desktop to 0 if you only had 1 virtual desktop.

(I don't know if that was in a bit of code we've replaced or not).

davidedmundson: There was a bug that Kai found recently where some other bit of code randomly set the virtual…
heinAuthorUnsubmitted
Not Done

I've dropped the 0 check.

hein: I've dropped the 0 check.
300​ }
301​ }
302​ }
303​ }
304​
305​ // Filter by screen.
306​ if (d->filterByScreen && d->screen != -1) {
307​ const QVariant &screen = sourceIdx.data(AbstractTasksModel::Screen);
308​
309​ if (!screen.isNull()) {
310​ bool ok = false;
311​ const int i = screen.toInt(&ok);
312​
313​ if (ok && i != -1 && i != d->screen) {
314​ return false;
315​ }
316​ }
317​ }
318​
319​ // Filter by activity.
320​ if (d->filterByActivity && !d->activity.isEmpty()) {
321​ const QVariant &activities = sourceIdx.data(AbstractTasksModel::Activities);
322​
323​ if (!activities.isNull()) {
324​ const QStringList l = activities.toStringList();
325​
326​ if (!l.isEmpty() && !l.contains(d->activity)) {
327​ return false;
328​ }
329​ }
330​ }
331​
332​ // Filter not minimized.
333​ if (d->filterNotMinimized) {
334​ bool isMinimized = sourceIdx.data(AbstractTasksModel::IsMinimized).toBool();
335​
336​ if (!isMinimized) {
337​ return false;
338​ }
339​ }
340​
341​ return true;
342​}
343​
344​}