File indexing completed on 2024-04-28 11:42:11

 /*
     This file is part of the KDE libraries
     SPDX-FileCopyrightText: 2016 Kai Uwe Broulik <kde@privat.broulik.de>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "openfilemanagerwindowjob.h"
 #include "openfilemanagerwindowjob_p.h"
 
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <QDBusPendingCallWatcher>
 #include <QDBusPendingReply>
 #include <QGuiApplication>
 
 #include <KJobWidgets>
 #include <KWindowSystem>
 
 #include <KIO/JobUiDelegate>
 #include <KIO/JobUiDelegateFactory>
 #include <KIO/OpenUrlJob>
 
 namespace KIO
 {
 class OpenFileManagerWindowJobPrivate
 {
 public:
     OpenFileManagerWindowJobPrivate(OpenFileManagerWindowJob *qq)
         : q(qq)
         , strategy(nullptr)
     {
     }
 
     ~OpenFileManagerWindowJobPrivate()
     {
         delete strategy;
     }
 
     AbstractOpenFileManagerWindowStrategy *createDBusStrategy()
     {
         delete strategy;
         strategy = new OpenFileManagerWindowDBusStrategy(q);
         return strategy;
     }
 
     AbstractOpenFileManagerWindowStrategy *createKRunStrategy()
     {
         delete strategy;
         strategy = new OpenFileManagerWindowKRunStrategy(q);
         return strategy;
     }
 
     OpenFileManagerWindowJob *const q;
     QList<QUrl> highlightUrls;
     QByteArray startupId;
 
     AbstractOpenFileManagerWindowStrategy *strategy;
 };
 
 OpenFileManagerWindowJob::OpenFileManagerWindowJob(QObject *parent)
     : KJob(parent)
     , d(new OpenFileManagerWindowJobPrivate(this))
 {
 #ifdef Q_OS_LINUX
     d->createDBusStrategy();
 #else
     d->createKRunStrategy();
 #endif
 }
 
 OpenFileManagerWindowJob::~OpenFileManagerWindowJob() = default;
 
 QList<QUrl> OpenFileManagerWindowJob::highlightUrls() const
 {
     return d->highlightUrls;
 }
 
 void OpenFileManagerWindowJob::setHighlightUrls(const QList<QUrl> &highlightUrls)
 {
     d->highlightUrls = highlightUrls;
 }
 
 QByteArray OpenFileManagerWindowJob::startupId() const
 {
     return d->startupId;
 }
 
 void OpenFileManagerWindowJob::setStartupId(const QByteArray &startupId)
 {
     d->startupId = startupId;
 }
 
 void OpenFileManagerWindowJob::start()
 {
     if (d->highlightUrls.isEmpty()) {
         setError(NoValidUrlsError);
         emitResult();
         return;
     }
 
     d->strategy->start(d->highlightUrls, d->startupId);
 }
 
 OpenFileManagerWindowJob *highlightInFileManager(const QList<QUrl> &urls, const QByteArray &asn)
 {
     auto *job = new OpenFileManagerWindowJob();
     job->setHighlightUrls(urls);
 
     if (asn.isNull()) {
         auto window = qGuiApp->focusWindow();
         if (!window && !qGuiApp->allWindows().isEmpty()) {
             window = qGuiApp->allWindows().constFirst();
         }
         const int launchedSerial = KWindowSystem::lastInputSerial(window);
         QObject::connect(KWindowSystem::self(), &KWindowSystem::xdgActivationTokenArrived, job, [launchedSerial, job](int serial, const QString &token) {
             QObject::disconnect(KWindowSystem::self(), &KWindowSystem::xdgActivationTokenArrived, job, nullptr);
             if (serial == launchedSerial) {
                 job->setStartupId(token.toLatin1());
                 job->start();
             }
         });
         KWindowSystem::requestXdgActivationToken(window, launchedSerial, {});
     } else {
         job->setStartupId(asn);
         job->start();
     }
 
     return job;
 }
 
 void OpenFileManagerWindowDBusStrategy::start(const QList<QUrl> &urls, const QByteArray &asn)
 {
     // see the spec at: https://www.freedesktop.org/wiki/Specifications/file-manager-interface/
 
     QDBusMessage msg = QDBusMessage::createMethodCall(QStringLiteral("org.freedesktop.FileManager1"),
                                                       QStringLiteral("/org/freedesktop/FileManager1"),
                                                       QStringLiteral("org.freedesktop.FileManager1"),
                                                       QStringLiteral("ShowItems"));
 
     msg << QUrl::toStringList(urls) << QString::fromUtf8(asn);
 
     QDBusPendingReply<void> reply = QDBusConnection::sessionBus().asyncCall(msg);
     QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(reply, m_job);
     QObject::connect(watcher, &QDBusPendingCallWatcher::finished, m_job, [=](QDBusPendingCallWatcher *watcher) {
         QDBusPendingReply<void> reply = *watcher;
         watcher->deleteLater();
 
         if (reply.isError()) {
             // Try the KRun strategy as fallback, also calls emitResult inside
             AbstractOpenFileManagerWindowStrategy *kRunStrategy = m_job->d->createKRunStrategy();
             kRunStrategy->start(urls, asn);
             return;
         }
 
         emitResultProxy();
     });
 }
 
 void OpenFileManagerWindowKRunStrategy::start(const QList<QUrl> &urls, const QByteArray &asn)
 {
     KIO::OpenUrlJob *urlJob = new KIO::OpenUrlJob(urls.at(0).adjusted(QUrl::RemoveFilename), QStringLiteral("inode/directory"));
     urlJob->setUiDelegate(KIO::createDefaultJobUiDelegate(KJobUiDelegate::AutoHandlingEnabled, KJobWidgets::window(m_job)));
     urlJob->setStartupId(asn);
     QObject::connect(urlJob, &KJob::result, m_job, [this](KJob *urlJob) {
         if (urlJob->error()) {
             emitResultProxy(OpenFileManagerWindowJob::LaunchFailedError);
         } else {
             emitResultProxy();
         }
     });
     urlJob->start();
 }
 
 } // namespace KIO
 
 #include "moc_openfilemanagerwindowjob.cpp"