Warning, file /frameworks/krunner/src/model/resultsmodel.cpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 /*
  * This file is part of the KDE Milou Project
  * SPDX-FileCopyrightText: 2019 Kai Uwe Broulik <kde@broulik.de>
  * SPDX-FileCopyrightText: 2023 Alexander Lohnau <alexander.lohnau@gmx.de>
  *
  * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
  *
  */
 
 #include "resultsmodel.h"
 
 #include "runnerresultsmodel_p.h"
 
 #include <QIdentityProxyModel>
 #include <QPointer>
 
 #include <KConfigGroup>
 #include <KDescendantsProxyModel>
 #include <KModelIndexProxyMapper>
 #include <KRunner/AbstractRunner>
 #include <QTimer>
 #include <cmath>
 
 using namespace KRunner;
 
 /**
  * Sorts the matches and categories by their type and relevance
  *
  * A category gets type and relevance of the highest
  * scoring match within.
  */
 class SortProxyModel : public QSortFilterProxyModel
 {
     Q_OBJECT
 
 public:
     SortProxyModel(QObject *parent)
         : QSortFilterProxyModel(parent)
     {
         setDynamicSortFilter(true);
         sort(0, Qt::DescendingOrder);
     }
 
     void setQueryString(const QString &queryString)
     {
         const QStringList words = queryString.split(QLatin1Char(' '), Qt::SkipEmptyParts);
         if (m_words != words) {
             m_words = words;
             invalidate();
         }
     }
 
 protected:
     bool lessThan(const QModelIndex &sourceA, const QModelIndex &sourceB) const override
     {
         bool isCategoryComparison = !sourceA.internalId() && !sourceB.internalId();
         Q_ASSERT((bool)sourceA.internalId() == (bool)sourceB.internalId());
         // Only check the favorite index if we compare categories. For individual matches, they will always be the same
         if (isCategoryComparison) {
             const int favoriteA = sourceA.data(ResultsModel::FavoriteIndexRole).toInt();
             const int favoriteB = sourceB.data(ResultsModel::FavoriteIndexRole).toInt();
             if (favoriteA != favoriteB) {
                 return favoriteA > favoriteB;
             }
 
             const int typeA = sourceA.data(ResultsModel::CategoryRelevanceRole).toReal();
             const int typeB = sourceB.data(ResultsModel::CategoryRelevanceRole).toReal();
             return typeA < typeB;
         }
 
         const qreal relevanceA = sourceA.data(ResultsModel::RelevanceRole).toReal();
         const qreal relevanceB = sourceB.data(ResultsModel::RelevanceRole).toReal();
 
         if (!qFuzzyCompare(relevanceA, relevanceB)) {
             return relevanceA < relevanceB;
         }
 
         return QSortFilterProxyModel::lessThan(sourceA, sourceB);
     }
 
 public:
     QStringList m_words;
 };
 
 /**
  * Distributes the number of matches shown per category
  *
  * Each category may occupy a maximum of 1/(n+1) of the given @c limit,
  * this means the further down you get, the less matches there are.
  * There is at least one match shown per category.
  *
  * This model assumes the results to already be sorted
  * descending by their relevance/score.
  */
 class CategoryDistributionProxyModel : public QSortFilterProxyModel
 {
     Q_OBJECT
 
 public:
     CategoryDistributionProxyModel(QObject *parent)
         : QSortFilterProxyModel(parent)
     {
     }
     void setSourceModel(QAbstractItemModel *sourceModel) override
     {
         if (this->sourceModel()) {
             disconnect(this->sourceModel(), nullptr, this, nullptr);
         }
 
         QSortFilterProxyModel::setSourceModel(sourceModel);
 
         if (sourceModel) {
             connect(sourceModel, &QAbstractItemModel::rowsInserted, this, &CategoryDistributionProxyModel::invalidateFilter);
             connect(sourceModel, &QAbstractItemModel::rowsMoved, this, &CategoryDistributionProxyModel::invalidateFilter);
             connect(sourceModel, &QAbstractItemModel::rowsRemoved, this, &CategoryDistributionProxyModel::invalidateFilter);
         }
     }
 
     int limit() const
     {
         return m_limit;
     }
 
     void setLimit(int limit)
     {
         if (m_limit == limit) {
             return;
         }
         m_limit = limit;
         invalidateFilter();
         Q_EMIT limitChanged();
     }
 
 Q_SIGNALS:
     void limitChanged();
 
 protected:
     bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override
     {
         if (m_limit <= 0) {
             return true;
         }
 
         if (!sourceParent.isValid()) {
             return true;
         }
 
         const int categoryCount = sourceModel()->rowCount();
 
         int maxItemsInCategory = m_limit;
 
         if (categoryCount > 1) {
             int itemsBefore = 0;
             for (int i = 0; i <= sourceParent.row(); ++i) {
                 const int itemsInCategory = sourceModel()->rowCount(sourceModel()->index(i, 0));
 
                 // Take into account that every category gets at least one item shown
                 const int availableSpace = m_limit - itemsBefore - std::ceil(m_limit / qreal(categoryCount));
 
                 // The further down the category is the less relevant it is and the less space it my occupy
                 // First category gets max half the total limit, second category a third, etc
                 maxItemsInCategory = std::min(availableSpace, int(std::ceil(m_limit / qreal(i + 2))));
 
                 // At least show one item per category
                 maxItemsInCategory = std::max(1, maxItemsInCategory);
 
                 itemsBefore += std::min(itemsInCategory, maxItemsInCategory);
             }
         }
 
         if (sourceRow >= maxItemsInCategory) {
             return false;
         }
 
         return true;
     }
 
 private:
     // if you change this, update the default in resetLimit()
     int m_limit = 0;
 };
 
 /**
  * This model hides the root items of data originally in a tree structure
  *
  * KDescendantsProxyModel collapses the items but keeps all items in tact.
  * The root items of the RunnerMatchesModel represent the individual cateories
  * which we don't want in the resulting flat list.
  * This model maps the items back to the given @c treeModel and filters
  * out any item with an invalid parent, i.e. "on the root level"
  */
 class HideRootLevelProxyModel : public QSortFilterProxyModel
 {
     Q_OBJECT
 
 public:
     HideRootLevelProxyModel(QObject *parent)
         : QSortFilterProxyModel(parent)
     {
     }
 
     QAbstractItemModel *treeModel() const
     {
         return m_treeModel;
     }
     void setTreeModel(QAbstractItemModel *treeModel)
     {
         m_treeModel = treeModel;
         invalidateFilter();
     }
 
 protected:
     bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override
     {
         KModelIndexProxyMapper mapper(sourceModel(), m_treeModel);
         const QModelIndex treeIdx = mapper.mapLeftToRight(sourceModel()->index(sourceRow, 0, sourceParent));
         return treeIdx.parent().isValid();
     }
 
 private:
     QAbstractItemModel *m_treeModel = nullptr;
 };
 
 class KRunner::ResultsModelPrivate
 {
 public:
     ResultsModelPrivate(const KConfigGroup &configGroup, KConfigGroup stateConfigGroup, ResultsModel *q)
         : q(q)
         , resultsModel(new RunnerResultsModel(configGroup, stateConfigGroup, q))
     {
     }
 
     ResultsModel *q;
 
     QPointer<KRunner::AbstractRunner> runner = nullptr;
 
     RunnerResultsModel *const resultsModel;
     SortProxyModel *const sortModel = new SortProxyModel(q);
     CategoryDistributionProxyModel *const distributionModel = new CategoryDistributionProxyModel(q);
     KDescendantsProxyModel *const flattenModel = new KDescendantsProxyModel(q);
     HideRootLevelProxyModel *const hideRootModel = new HideRootLevelProxyModel(q);
     const KModelIndexProxyMapper mapper{q, resultsModel};
 };
 
 ResultsModel::ResultsModel(QObject *parent)
     : ResultsModel(KConfigGroup(), KConfigGroup(), parent)
 {
 }
 ResultsModel::ResultsModel(const KConfigGroup &configGroup, KConfigGroup stateConfigGroup, QObject *parent)
     : QSortFilterProxyModel(parent)
     , d(new ResultsModelPrivate(configGroup, stateConfigGroup, this))
 {
     connect(d->resultsModel, &RunnerResultsModel::queryStringChanged, this, &ResultsModel::queryStringChanged);
     connect(d->resultsModel, &RunnerResultsModel::queryingChanged, this, &ResultsModel::queryingChanged);
     connect(d->resultsModel, &RunnerResultsModel::queryStringChangeRequested, this, &ResultsModel::queryStringChangeRequested);
 
     // The matches for the old query string remain on display until the first set of matches arrive for the new query string.
     // Therefore we must not update the query string inside RunnerResultsModel exactly when the query string changes, otherwise it would
     // re-sort the old query string matches based on the new query string.
     // So we only make it aware of the query string change at the time when we receive the first set of matches for the new query string.
     connect(d->resultsModel, &RunnerResultsModel::matchesChanged, this, [this]() {
         d->sortModel->setQueryString(queryString());
     });
 
     connect(d->distributionModel, &CategoryDistributionProxyModel::limitChanged, this, &ResultsModel::limitChanged);
 
     // The data flows as follows:
     // - RunnerResultsModel
     //   - SortProxyModel
     //     - CategoryDistributionProxyModel
     //       - KDescendantsProxyModel
     //         - HideRootLevelProxyModel
 
     d->sortModel->setSourceModel(d->resultsModel);
 
     d->distributionModel->setSourceModel(d->sortModel);
 
     d->flattenModel->setSourceModel(d->distributionModel);
 
     d->hideRootModel->setSourceModel(d->flattenModel);
     d->hideRootModel->setTreeModel(d->resultsModel);
 
     setSourceModel(d->hideRootModel);
 
     // Initialize the runners, this will speed the first query up.
     // While there were lots of optimizations, instantiating plugins, creating threads and AbstractRunner::init is still heavy work
     QTimer::singleShot(0, this, [this]() {
         runnerManager()->runners();
     });
 }
 
 ResultsModel::~ResultsModel() = default;
 
 void ResultsModel::setFavoriteIds(const QStringList &ids)
 {
     d->resultsModel->m_favoriteIds = ids;
     Q_EMIT favoriteIdsChanged();
 }
 
 QStringList ResultsModel::favoriteIds() const
 {
     return d->resultsModel->m_favoriteIds;
 }
 
 QString ResultsModel::queryString() const
 {
     return d->resultsModel->queryString();
 }
 
 void ResultsModel::setQueryString(const QString &queryString)
 {
     d->resultsModel->setQueryString(queryString, singleRunner());
 }
 
 int ResultsModel::limit() const
 {
     return d->distributionModel->limit();
 }
 
 void ResultsModel::setLimit(int limit)
 {
     d->distributionModel->setLimit(limit);
 }
 
 void ResultsModel::resetLimit()
 {
     setLimit(0);
 }
 
 bool ResultsModel::querying() const
 {
     return d->resultsModel->querying();
 }
 
 QString ResultsModel::singleRunner() const
 {
     return d->runner ? d->runner->id() : QString();
 }
 
 void ResultsModel::setSingleRunner(const QString &runnerId)
 {
     if (runnerId == singleRunner()) {
         return;
     }
     if (runnerId.isEmpty()) {
         d->runner = nullptr;
     } else {
         d->runner = runnerManager()->runner(runnerId);
     }
     Q_EMIT singleRunnerChanged();
 }
 
 KPluginMetaData ResultsModel::singleRunnerMetaData() const
 {
     return d->runner ? d->runner->metadata() : KPluginMetaData();
 }
 
 QHash<int, QByteArray> ResultsModel::roleNames() const
 {
     auto names = QAbstractItemModel::roleNames();
     names[IdRole] = QByteArrayLiteral("matchId"); // "id" is QML-reserved
     names[EnabledRole] = QByteArrayLiteral("enabled");
     names[CategoryRole] = QByteArrayLiteral("category");
     names[SubtextRole] = QByteArrayLiteral("subtext");
     names[UrlsRole] = QByteArrayLiteral("urls");
     names[ActionsRole] = QByteArrayLiteral("actions");
     names[MultiLineRole] = QByteArrayLiteral("multiLine");
     return names;
 }
 
 void ResultsModel::clear()
 {
     d->resultsModel->clear();
 }
 
 bool ResultsModel::run(const QModelIndex &idx)
 {
     KModelIndexProxyMapper mapper(this, d->resultsModel);
     const QModelIndex resultsIdx = mapper.mapLeftToRight(idx);
     if (!resultsIdx.isValid()) {
         return false;
     }
     return d->resultsModel->run(resultsIdx);
 }
 
 bool ResultsModel::runAction(const QModelIndex &idx, int actionNumber)
 {
     KModelIndexProxyMapper mapper(this, d->resultsModel);
     const QModelIndex resultsIdx = mapper.mapLeftToRight(idx);
     if (!resultsIdx.isValid()) {
         return false;
     }
     return d->resultsModel->runAction(resultsIdx, actionNumber);
 }
 
 QMimeData *ResultsModel::getMimeData(const QModelIndex &idx) const
 {
     if (auto resultIdx = d->mapper.mapLeftToRight(idx); resultIdx.isValid()) {
         return runnerManager()->mimeDataForMatch(d->resultsModel->fetchMatch(resultIdx));
     }
     return nullptr;
 }
 
 KRunner::RunnerManager *ResultsModel::runnerManager() const
 {
     return d->resultsModel->runnerManager();
 }
 
 KRunner::QueryMatch ResultsModel::getQueryMatch(const QModelIndex &idx) const
 {
     const QModelIndex resultIdx = d->mapper.mapLeftToRight(idx);
     return resultIdx.isValid() ? d->resultsModel->fetchMatch(resultIdx) : QueryMatch();
 }
 
 #include "moc_resultsmodel.cpp"
 #include "resultsmodel.moc"