File indexing completed on 2024-05-12 05:35:38

 /*
     SPDX-FileCopyrightText: 2022 Méven Car <meven@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "applicationmodel.h"
 
 #include <KApplicationTrader>
 #include <KLocalizedString>
 #include <KService>
 
 #include <optional>
 
 #include "componentchooser.h"
 
 ApplicationModel::ApplicationModel(QObject *parent)
     : QAbstractItemModel(parent)
 {
 }
 
 void ApplicationModel::addApplication(const QString &name, const QString &iconName, const QString &storageId, bool isSelected, const QString &execLine)
 {
     QVariantMap application;
     application[QStringLiteral("name")] = name;
     application[QStringLiteral("icon")] = iconName;
     application[QStringLiteral("storageId")] = storageId;
     application[QStringLiteral("isSelected")] = isSelected;
     application[QStringLiteral("execLine")] = execLine;
     m_applications += application;
 }
 
 void ApplicationModel::load(const QString &mimeType,
                             const QString &applicationCategory,
                             const QString &defaultApplication,
                             const KService::Ptr preferredService)
 {
     beginResetModel();
 
     m_applications.clear();
 
     if (preferredService) {
         addApplication(preferredService->name(), preferredService->icon(), preferredService->storageId(), true, preferredService->exec());
         if (preferredService->storageId() == defaultApplication) {
             m_defaultIndex = 0;
         }
     }
 
     KApplicationTrader::query([preferredService, applicationCategory, mimeType, defaultApplication, this](const KService::Ptr &service) {
         if (service->exec().isEmpty() || (!applicationCategory.isEmpty() && !service->categories().contains(applicationCategory))
             || (!mimeType.isEmpty() && !ComponentChooser::serviceSupportsMimeType(service, mimeType))
             || (preferredService && preferredService->storageId() == service->storageId())) {
             return false;
         }
 
         const auto icon = service->icon().isEmpty() ? QStringLiteral("application-x-shellscript") : service->icon();
         bool isDefault = service->storageId() == defaultApplication;
 
         addApplication(service->name(), icon, service->storageId(), false, service->exec());
 
         if (isDefault) {
             m_defaultIndex = m_applications.length() - 1;
         }
         return false;
     });
 
     addApplication(i18n("Other…"), QStringLiteral("application-x-shellscript"), QString(), false, QString());
 
     endResetModel();
 }
 
 int ApplicationModel::currentIndex() const
 {
     int index = 0;
     for (const auto &application : std::as_const(m_applications)) {
         if (application["isSelected"].toBool()) {
             return index;
         }
         ++index;
     }
 
     if (m_defaultIndex != -1) {
         return m_defaultIndex;
     }
 
     return 0;
 }
 
 std::optional<int> ApplicationModel::defaultIndex() const
 {
     if (m_defaultIndex == -1)
         return {};
     else {
         return m_defaultIndex;
     }
 }
 
 int ApplicationModel::addApplicationBeforeLast(const KServicePtr service)
 {
     // the application will grow by 1, we want to add the new application at the before
     // last position taking into account the future new size of m_applications
     int newRowIndex = rowCount() - 1;
     beginInsertRows(QModelIndex(), newRowIndex, newRowIndex);
 
     addApplication(service->name(), service->icon(), service->storageId(), false, service->exec());
     // addApplication adds at the end of of the list
     // swaps the last and before last applications
     m_applications.swapItemsAt(rowCount() - 2, rowCount() - 1);
 
     endInsertRows();
 
     return newRowIndex;
 }
 
 QVariant ApplicationModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     Q_UNUSED(section)
     Q_UNUSED(orientation)
     Q_UNUSED(role)
 
     return QVariant();
 }
 
 QModelIndex ApplicationModel::index(int row, int column, const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
 
     if (row >= 0 && row < m_applications.length()) {
         return createIndex(row, column);
     }
     return QModelIndex();
 }
 
 QModelIndex ApplicationModel::parent(const QModelIndex &index) const
 {
     Q_UNUSED(index)
     return QModelIndex();
 }
 
 int ApplicationModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
     return m_applications.length();
 }
 
 int ApplicationModel::columnCount(const QModelIndex &parent) const
 {
     if (!parent.isValid())
         return 0;
 
     return 1;
 }
 
 QVariant ApplicationModel::data(const QModelIndex &index, int role) const
 {
     if (!isValid(index))
         return QVariant();
 
     int row = index.row();
     const auto map = m_applications.at(row);
     switch (role) {
     case Qt::DisplayRole:
         return map["name"];
     case Icon:
         return map["icon"];
     case StorageId:
         return map["storageId"];
     case Selected:
         return map["isSelected"];
     case ExecLine:
         return map["execLine"];
     }
 
     return QVariant();
 }
 
 QVariant ApplicationModel::data(const int &row, int role) const
 {
     return data(index(row, 0), role);
 }
 
 bool ApplicationModel::isValid(const QModelIndex &index) const
 {
     return index.column() == 0 && index.row() >= 0 && index.row() < m_applications.length();
 }
 
 bool ApplicationModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (role != Selected) {
         return false;
     }
     if (!isValid(index)) {
         return false;
     }
     if (!value.canConvert(QMetaType(QMetaType::Type::Bool)) && !value.toBool()) {
         return false;
     }
 
     for (auto &application : m_applications) {
         application["isSelected"] = false;
     }
 
     const auto row = index.row();
 
     // auto map = m_applications[row].toMap();
     m_applications[row]["isSelected"] = true;
     // m_applications[row] = map;
 
     Q_EMIT dataChanged(index, index, {role});
 
     return true;
 }
 
 QModelIndex ApplicationModel::findByStorageId(const QString &storageId) const
 {
     int i = 0;
     for (const auto &application : std::as_const(m_applications)) {
         if (application["storageId"] == storageId) {
             return index(i, 0);
         }
         ++i;
     }
     return QModelIndex();
 }
 
 QHash<int, QByteArray> ApplicationModel::roleNames() const
 {
     return {
         {Qt::DisplayRole, "name"},
         {Icon, "icon"},
         {StorageId, "storageId"},
         {Selected, "isSelected"},
         {ExecLine, "execLine"},
     };
 }