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

 /*
     SPDX-FileCopyrightText: 2002 Joseph Wenninger <jowenn@kde.org>
     SPDX-FileCopyrightText: 2020 Méven Car <meven.car@kdemail.net>
     SPDX-FileCopyrightText: 2020 Tobias Fella <fella@posteo.de>
     SPDX-FileCopyrightText: 2022 Méven Car <meven@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "componentchooser.h"
 
 #include <QApplication>
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <QMimeDatabase>
 
 #include <KApplicationTrader>
 #include <KBuildSycocaProgressDialog>
 #include <KConfigGroup>
 #include <KOpenWithDialog>
 #include <KQuickConfigModule>
 #include <KService>
 #include <KSharedConfig>
 
 extern KSERVICE_EXPORT int ksycoca_ms_between_checks;
 
 ComponentChooser::ComponentChooser(QObject *parent,
                                    const QString &mimeType,
                                    const QString &applicationCategory,
                                    const QString &defaultApplication,
                                    const QString &dialogText)
     : QObject(parent)
     , m_mimeType(mimeType)
     , m_applicationCategory(applicationCategory)
     , m_defaultApplication(defaultApplication)
     , m_dialogText(dialogText)
 {
     qRegisterMetaType<QList<PairQml>>("QList<PairQml>");
 
     m_model = new ApplicationModel(this);
     connect(m_model, &QAbstractItemModel::modelReset, this, &ComponentChooser::modelChanged);
 }
 
 void ComponentChooser::defaults()
 {
     const auto defaultIndex = m_model->defaultIndex();
     if (defaultIndex) {
         select(*defaultIndex);
     }
 }
 
 void ComponentChooser::load()
 {
     m_model->load(m_mimeType, m_applicationCategory, m_defaultApplication, KApplicationTrader::preferredService(m_mimeType));
 
     m_index = m_model->currentIndex();
 
     m_currentApplication = currentStorageId();
 
     Q_EMIT indexChanged();
     Q_EMIT isDefaultsChanged();
 }
 
 void ComponentChooser::select(int index)
 {
     // Other selection
     if (index == m_model->rowCount() - 1) {
         KOpenWithDialog *dialog = new KOpenWithDialog(QList<QUrl>(), m_mimeType, m_dialogText, QString(), QApplication::activeWindow());
         dialog->setSaveNewApplications(true);
         dialog->setAttribute(Qt::WA_DeleteOnClose);
         connect(dialog, &KOpenWithDialog::finished, this, [this, dialog](int result) {
             if (result == QDialog::Rejected) {
                 Q_EMIT indexChanged();
                 Q_EMIT isDefaultsChanged();
                 return;
             }
 
             const auto serviceStorageId = dialog->service()->storageId();
 
             // Check if the selected application is already in the list
             QModelIndex modelIndex = m_model->findByStorageId(serviceStorageId);
             if (modelIndex.isValid()) {
                 select(modelIndex.row());
                 return;
             }
 
             auto newIndex = m_model->addApplicationBeforeLast(dialog->service());
             select(newIndex);
         });
         dialog->open();
     } else {
         m_index = index;
 
         const auto selectedIndex = m_model->index(index, 0);
         m_model->setData(selectedIndex, true, ApplicationModel::Selected);
 
         Q_EMIT indexChanged();
         Q_EMIT isDefaultsChanged();
     }
 }
 
 void ComponentChooser::saveMimeTypeAssociations(const QString &storageId, const QStringList &mimeTypes, bool forceUnsupportedMimeType)
 {
     if (storageId.isEmpty()) {
         return;
     }
 
     // This grabs the configuration from mimeapps.list, which is DE agnostic and part of the XDG standard.
     KSharedConfig::Ptr mimeAppsList = KSharedConfig::openConfig(QStringLiteral("mimeapps.list"), KConfig::NoGlobals, QStandardPaths::GenericConfigLocation);
 
     if (mimeAppsList->isConfigWritable(true)) {
         const auto appService = KService::serviceByStorageId(storageId);
 
         for (const QString &mimeType : mimeTypes) {
             if (!forceUnsupportedMimeType && appService && !serviceSupportsMimeType(appService, mimeType)) {
                 // skip mimetype association if the app does not support it at all
                 continue;
             }
 
             KApplicationTrader::setPreferredService(mimeType, appService);
         }
 
         m_currentApplication = storageId;
     }
 }
 
 void ComponentChooser::onSaved()
 {
     Q_EMIT indexChanged();
     Q_EMIT isDefaultsChanged();
 }
 
 QStringList ComponentChooser::unsupportedMimeTypes() const
 {
     const auto preferredApp = currentStorageId();
 
     if (preferredApp.isEmpty()) {
         return QStringList{};
     }
 
     const auto db = QMimeDatabase();
 
     QStringList unsupportedMimeTypes;
 
     const auto appService = KService::serviceByStorageId(preferredApp);
     const auto componentMimeTypes = mimeTypes();
     for (const QString &mimeType : componentMimeTypes) {
         if (!serviceSupportsMimeType(appService, mimeType)) {
             const auto preferredService = KApplicationTrader::preferredService(mimeType);
             if (!preferredService || (preferredService->storageId() != appService->storageId())) {
                 unsupportedMimeTypes << mimeType;
             }
         }
     }
 
     return unsupportedMimeTypes;
 }
 
 void ComponentChooser::saveAssociationUnsuportedMimeTypes()
 {
     const auto storageId = currentStorageId();
 
     saveMimeTypeAssociations(storageId, unsupportedMimeTypes(), true);
     forceReloadServiceCache();
     load();
 }
 
 QList<PairQml> ComponentChooser::mimeTypesNotAssociated() const
 {
     auto ret = QList<PairQml>();
 
     const auto db = QMimeDatabase();
     const auto storageId = m_currentApplication;
 
     const auto appService = KService::serviceByStorageId(storageId);
 
     if (!appService) {
         return ret;
     }
 
     const auto mimes = mimeTypes();
 
     for (const QString &mimeType : mimes) {
         const auto service = KApplicationTrader::preferredService(mimeType);
 
         if (service && service->storageId() != storageId &&
             // only explicitly supported mimetype
             serviceSupportsMimeType(appService, mimeType)) {
             ret.append(PairQml(service->name(), mimeType));
         }
     }
 
     return ret;
 }
 
 void ComponentChooser::saveMimeTypesNotAssociated()
 {
     const auto mimeTypeNotAssociated = mimeTypesNotAssociated();
 
     auto mimeTypeList = QList<QString>();
     for (const auto &pair : mimeTypeNotAssociated) {
         mimeTypeList.append(pair.second.toString());
     }
 
     const auto storageId = currentStorageId();
     saveMimeTypeAssociations(storageId, mimeTypeList);
 
     forceReloadServiceCache();
     load();
 }
 
 QString ComponentChooser::currentStorageId() const
 {
     return m_model->data(m_index, ApplicationModel::StorageId).toString();
 }
 
 QString ComponentChooser::applicationName() const
 {
     return m_model->data(m_index, Qt::DisplayRole).toString();
 }
 
 QString ComponentChooser::applicationIcon() const
 {
     return m_model->data(m_index, ApplicationModel::Icon).toString();
 }
 
 QStringList ComponentChooser::mimeTypes() const
 {
     return QStringList{};
 }
 
 void ComponentChooser::forceReloadServiceCache()
 {
     KBuildSycocaProgressDialog::rebuildKSycoca(QApplication::activeWindow());
 
     // HACK to ensure mime cache is updated right away
     int previous_delay = ksycoca_ms_between_checks;
     ksycoca_ms_between_checks = 0;
     KService::allServices();
     ksycoca_ms_between_checks = previous_delay;
 }
 
 void ComponentChooser::save()
 {
     // default impl for simple application kinds
     const auto storageId = currentStorageId();
 
     saveMimeTypeAssociations(storageId, mimeTypes());
 }
 
 bool ComponentChooser::isDefaults() const
 {
     const auto defaultIndex = m_model->defaultIndex();
     return !defaultIndex.has_value() || *defaultIndex == m_index;
 }
 
 bool ComponentChooser::isSaveNeeded() const
 {
     const auto storageId = currentStorageId();
     return m_model->rowCount() > 1 && (m_currentApplication != storageId) && storageId != "";
 }
 
 bool ComponentChooser::serviceSupportsMimeType(KService::Ptr service, const QString &targetMimeType)
 {
     static QMimeDatabase db;
     const QStringList mimeTypes = service->mimeTypes();
     for (const QString &supportedMimeType : mimeTypes) {
         if (supportedMimeType == targetMimeType) {
             return true;
         }
 
         if (db.mimeTypeForName(targetMimeType).inherits(supportedMimeType)) {
             return true;
         }
     }
 
     if (targetMimeType.startsWith(QLatin1String("x-scheme-handler/")) && service->schemeHandlers().contains(targetMimeType.mid(17))) {
         return true;
     }
 
     return false;
 }