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