Differential D22735 Diff 62540 lib/runnerresultsmodel.cpp

Changeset View

Standalone View

View Options

lib/runnerresultsmodel.cpp

  • This file was added.
1​/*
2​ * This file is part of the KDE Milou Project
3​ * Copyright (C) 2019 Kai Uwe Broulik <kde@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​
23​#include "runnerresultsmodel.h"
24​
25​#include <QAction>
26​#include <QSet>
27​
28​#include <KRunner/RunnerManager>
29​
30​#include "resultsmodel.h"
31​
32​using namespace Milou;
33​using namespace Plasma;
34​
35​RunnerResultsModel::RunnerResultsModel(QObject *parent)
36​ : QAbstractItemModel(parent)
37​ , m_manager(new RunnerManager(this))
38​{
39​ connect(m_manager, &RunnerManager::matchesChanged, this, &RunnerResultsModel::onMatchesChanged);
40​ connect(m_manager, &RunnerManager::queryFinished, this, [this] {
41​ setQuerying(false);
42​ });
43​
44​ m_resetTimer.setSingleShot(true);
45​ m_resetTimer.setInterval(500);
46​ connect(&m_resetTimer, &QTimer::timeout, this, [this] {
47​ // Clear the old matches if any
48​ if (!m_hasMatches) {
49​ clear();
50​ }
51​ });
52​}
53​
54​RunnerResultsModel::~RunnerResultsModel() = default;
55​
56​Plasma::QueryMatch RunnerResultsModel::fetchMatch(const QModelIndex &idx) const
57​{
58​ const QString category = m_categories.value(idx.internalId() - 1);
59​ return m_matches.value(category).value(idx.row());
60​}
61​
62​void RunnerResultsModel::onMatchesChanged(const QList<Plasma::QueryMatch> &matches)
63​{
64​ // We clear the model ourselves in the reset timer, ignore any empty matchset
65​ if (matches.isEmpty() && m_resetTimer.isActive() && !m_hasMatches) {
66​ return;
67​ }
68​
69​ // Build the list of new categories and matches
70​ QSet<QString> newCategories;
71​ // here we use QString as key since at this point we don't care about the order
72​ // of categories but just what matches we have for each one.
73​ // Below when we populate the actual m_matches we'll make sure to keep the order
74​ // of existing categories to avoid pointless model changes.
75​ QHash<QString /*category*/, QVector<Plasma::QueryMatch>> newMatches;
76​ for (const auto &match : matches) {
77​ const QString category = match.matchCategory();
78​ newCategories.insert(category);
79​ newMatches[category].append(match);
80​ }
81​
82​ // Get rid of all categories that are no longer present
83​ auto it = m_categories.begin();
84​ while (it != m_categories.end()) {
85​ const int categoryNumber = std::distance(m_categories.begin(), it);
86​
87​ if (!newCategories.contains(*it)) {
88​ beginRemoveRows(QModelIndex(), categoryNumber, categoryNumber);
89​ m_matches.remove(*it);
90​ it = m_categories.erase(it);
91​ endRemoveRows();
92​ } else {
93​ ++it;
94​ }
95​ }
96​
97​ // Update the existing categories by adding/removing new/removed rows and
98​ // updating changed ones
99​ for (auto it = m_categories.constBegin(), end = m_categories.constEnd(); it != end; ++it) {
100​ Q_ASSERT(newCategories.contains(*it));
101​
102​ const int categoryNumber = std::distance(m_categories.constBegin(), it);
103​ const QModelIndex categoryIdx = index(categoryNumber, 0);
104​
105​ // don't use operator[] as to not insert an empty list
106​ // TODO why? shouldn't m_categories and m_matches be in sync?
107​ auto oldCategoryIt = m_matches.find(*it);
108​ Q_ASSERT(oldCategoryIt != m_matches.end());
109​
110​ auto &oldMatchesInCategory = *oldCategoryIt;
111​ const auto newMatchesInCategory = newMatches.value(*it);
112​
113​ Q_ASSERT(!oldMatchesInCategory.isEmpty());
114​ Q_ASSERT(!newMatches.isEmpty());
115​
116​ // Emit a change for all existing matches if any of them changed
117​ // TODO only emit a change for the ones that changed
118​ bool emitDataChanged = false;
119​
120​ const int oldCount = oldMatchesInCategory.count();
121​ const int newCount = newMatchesInCategory.count();
122​
123​ const int countCeiling = qMin(oldCount, newCount);
124​
125​ for (int i = 0; i < countCeiling; ++i) {
126​ auto &oldMatch = oldMatchesInCategory[i];
127​ if (oldMatch != newMatchesInCategory.at(i)) {
128​ oldMatch = newMatchesInCategory.at(i);
129​ emitDataChanged = true;
130​ }
131​ }
132​
133​ // Now that the source data has been updated, emit the data changes we noted down earlier
134​ if (emitDataChanged) {
135​ emit dataChanged(index(0, 0, categoryIdx), index(countCeiling - 1, 0, categoryIdx));
136​ }
137​
138​ // Signal insertions for any new items
139​ if (newCount > oldCount) {
140​ beginInsertRows(categoryIdx, oldCount, newCount - 1);
141​ oldMatchesInCategory = newMatchesInCategory;
142​ endInsertRows();
143​ } else if (newCount < oldCount) {
144​ beginRemoveRows(categoryIdx, newCount, oldCount - 1);
145​ oldMatchesInCategory = newMatchesInCategory;
146​ endRemoveRows();
147​ }
148​
149​ // Remove it from the "new" categories so in the next step we can add all genuinely new categories in one go
davidedmundsonUnsubmitted
Not Done

Urgh, we've done this style before and it resulted in obscure QtQuick crashes.

For QtQuick we need to insert new rows for new rows, not just insert/remove the difference and emit changed on everything, otherwise we mess up the delegates.

See 9371a7c96d4722b93b49b18df7b21780f2a9ad38 in p-d

Sorry.

davidedmundson: Urgh, we've done this style before and it resulted in obscure QtQuick crashes. For QtQuick we…
150​ newCategories.remove(*it);
151​ }
152​
153​ // Finally add all the new categories
154​ if (!newCategories.isEmpty()) {
155​ beginInsertRows(QModelIndex(), m_categories.count(), m_categories.count() + newCategories.count() - 1);
156​
157​ for (const QString &newCategory : newCategories) {
158​ const auto matchesInNewCategory = newMatches.value(newCategory);
159​
160​ m_matches[newCategory] = matchesInNewCategory;
161​ m_categories.append(newCategory);
162​ }
163​
164​ endInsertRows();
165​ }
166​
167​ Q_ASSERT(m_categories.count() == m_matches.count());
168​
169​ m_hasMatches = !m_matches.isEmpty();
170​}
171​
172​QString RunnerResultsModel::queryString() const
173​{
174​ return m_queryString;
175​}
176​
177​void RunnerResultsModel::setQueryString(const QString &queryString)
178​{
179​ if (m_queryString.trimmed() == queryString.trimmed()) {
180​ return;
181​ }
182​
183​ m_queryString = queryString;
184​ m_hasMatches = false;
185​ if (queryString.isEmpty()) {
186​ clear();
187​ } else {
188​ m_resetTimer.start();
189​ m_manager->launchQuery(queryString);
190​ setQuerying(true);
191​ }
192​ emit queryStringChanged();
193​}
194​
195​bool RunnerResultsModel::querying() const
196​{
197​ return m_querying;
198​}
199​
200​void RunnerResultsModel::setQuerying(bool querying)
201​{
202​ if (m_querying != querying) {
203​ m_querying = querying;
204​ emit queryingChanged();
205​ }
206​}
207​
208​QString RunnerResultsModel::runner() const
209​{
210​ return m_runner;
211​}
212​
213​void RunnerResultsModel::setRunner(const QString &runner)
214​{
215​ if (m_runner == runner) {
216​ return;
217​ }
218​
219​ m_runner = runner;
220​ m_manager->setSingleModeRunnerId(runner);
221​ m_manager->setSingleMode(!runner.isEmpty());
222​ emit runnerChanged();
223​}
224​
225​QString RunnerResultsModel::runnerName() const
226​{
227​ if (auto *singleRunner = m_manager->singleModeRunner()) {
228​ return singleRunner->name();
229​ }
230​ return QString();
231​}
232​
233​QIcon RunnerResultsModel::runnerIcon() const
234​{
235​ if (auto *singleRunner = m_manager->singleModeRunner()) {
236​ return singleRunner->icon();
237​ }
238​ return QIcon();
239​}
240​
241​void RunnerResultsModel::clear()
242​{
243​ setQuerying(false);
244​
245​ beginResetModel();
246​ m_hasMatches = false;
247​ m_categories.clear();
248​ m_matches.clear();
249​ m_manager->reset();
250​ m_manager->matchSessionComplete();
251​ endResetModel();
252​}
253​
254​bool RunnerResultsModel::run(const QModelIndex &idx)
255​{
256​ Plasma::QueryMatch match = fetchMatch(idx);
257​ if (!match.isValid()) {
258​ return false;
259​ }
260​
261​ if (match.type() == Plasma::QueryMatch::InformationalMatch) {
262​ QString info = match.data().toString();
263​ int editPos = info.length();
264​
265​ if (!info.isEmpty()) {
266​ // FIXME: pretty lame way to decide if this is a query prototype
267​ // Copied from kde4 krunner interface.cpp
268​ if (!match.runner()) {
269​ // lame way of checking to see if this is a Help Button generated match!
270​ int index = info.indexOf(QStringLiteral(":q:"));
271​
272​ if (index != -1) {
273​ editPos = index;
274​ info.replace(QStringLiteral(":q:"), QString());
275​ }
276​ }
277​
278​ emit queryStringChangeRequested(info, editPos);
279​ return false;
280​ }
281​ }
282​
283​ m_manager->run(match);
284​ return true;
285​}
286​
287​bool RunnerResultsModel::runAction(const QModelIndex &idx, int actionNumber)
288​{
289​ Plasma::QueryMatch match = fetchMatch(idx);
290​ if (!match.isValid()) {
291​ return false;
292​ }
293​
294​ const auto actions = m_manager->actionsForMatch(match);
295​ if (actionNumber < 0 || actionNumber >= actions.count()) {
296​ return false;
297​ }
298​
299​ QAction *action = actions.at(actionNumber);
300​ match.setSelectedAction(action);
301​ m_manager->run(match);
302​ return true;
303​}
304​
305​int RunnerResultsModel::columnCount(const QModelIndex &parent) const
306​{
307​ Q_UNUSED(parent);
308​ return 1;
309​}
310​
311​int RunnerResultsModel::rowCount(const QModelIndex &parent) const
312​{
313​ if (parent.column() > 0) {
314​ return 0;
315​ }
316​
317​ if (!parent.isValid()) { // root level
318​ return m_categories.count();
319​ }
320​
321​ if (parent.internalId()) {
322​ return 0;
323​ }
324​
325​ const QString category = m_categories.value(parent.row());
326​ return m_matches.value(category).count();
327​}
328​
329​QVariant RunnerResultsModel::data(const QModelIndex &index, int role) const
330​{
331​ if (!index.isValid()) {
332​ return QVariant();
333​ }
334​
335​ if (index.internalId()) { // runner match
336​ if (int(index.internalId() - 1) >= m_categories.count()) {
337​ return QVariant();
338​ }
339​
340​ Plasma::QueryMatch match = fetchMatch(index);
341​ if (!match.isValid()) {
342​ return QVariant();
343​ }
344​
345​ switch (role) {
346​ case Qt::DisplayRole:
347​ return match.text();
348​ case Qt::DecorationRole:
349​ if (!match.iconName().isEmpty()) {
350​ return match.iconName();
351​ }
352​ return match.icon();
353​ case ResultsModel::TypeRole:
354​ return match.type();
355​ case ResultsModel::RelevanceRole:
356​ return match.relevance();
357​ case ResultsModel::IdRole:
358​ return match.id();
359​ case ResultsModel::EnabledRole:
360​ return match.isEnabled();
361​ case ResultsModel::CategoryRole:
362​ return match.matchCategory();
363​ case ResultsModel::SubtextRole:
364​ return match.subtext();
365​ case ResultsModel::ActionsRole: {
366​ const auto actions = m_manager->actionsForMatch(match);
367​ if (actions.isEmpty()) {
368​ return QVariantList();
369​ }
370​
371​ QVariantList actionsList;
372​ actionsList.reserve(actions.size());
373​
374​ for (QAction *action : actions) {
375​ actionsList.append(QVariant::fromValue(action));
376​ }
377​
378​ return actionsList;
379​ }
380​
381​ }
382​
383​ return QVariant();
384​ }
385​
386​ // category
387​ if (index.row() >= m_categories.count()) {
388​ return QVariant();
389​ }
390​
391​ switch (role) {
392​ case Qt::DisplayRole:
393​ return m_categories.at(index.row());
394​
395​ // Returns the highest type/role within the group
396​ case ResultsModel::TypeRole: {
397​ int highestType = 0;
398​ for (int i = 0; i < rowCount(index); ++i) {
399​ const int type = this->index(i, 0, index).data(ResultsModel::TypeRole).toInt();
400​ if (type > highestType) {
401​ highestType = type;
402​ }
403​ }
404​ return highestType;
405​ }
406​ case ResultsModel::RelevanceRole: {
407​ qreal highestRelevance = 0.0;
408​ for (int i = 0; i < rowCount(index); ++i) {
409​ const qreal relevance = this->index(i, 0, index).data(ResultsModel::RelevanceRole).toReal();
410​ if (relevance > highestRelevance) {
411​ highestRelevance = relevance;
412​ }
413​ }
414​ return highestRelevance;
415​ }
416​
417​ }
418​
419​ return QVariant();
420​}
421​
422​QModelIndex RunnerResultsModel::index(int row, int column, const QModelIndex &parent) const
423​{
424​ if (row < 0 || column != 0) {
425​ return QModelIndex();
426​ }
427​
428​ if (parent.isValid()) {
429​ const QString category = m_categories.value(parent.row());
430​ const auto matches = m_matches.value(category);
431​ if (row < matches.count()) {
432​ return createIndex(row, column, parent.row() + 1);
433​ }
434​
435​ return QModelIndex();
436​ }
437​
438​ if (row < m_categories.count()) {
439​ return createIndex(row, column, nullptr);
440​ }
441​
442​ return QModelIndex();
443​}
444​
445​QModelIndex RunnerResultsModel::parent(const QModelIndex &child) const
446​{
447​ if (child.internalId()) {
448​ return createIndex(child.internalId() - 1, 0, nullptr);
449​ }
450​
451​ return QModelIndex();
452​}
453​
454​QMimeData *RunnerResultsModel::mimeData(const QModelIndexList &indexes) const
455​{
456​ if (indexes.isEmpty()) {
457​ return nullptr;
458​ }
459​
460​ Plasma::QueryMatch match = fetchMatch(indexes.first());
461​ if (!match.isValid()) {
462​ return nullptr;
463​ }
464​
465​ return m_manager->mimeDataForMatch(match);
466​ return nullptr;
467​}