app.h

// SPDX-FileCopyrightText: 2025 Manuel Schneider
// SPDX-License-Identifier: MIT
 
 
 
 
 
 
 
 
 
 
 
#pragma once
#include <QObject>
#include <QString>
#include <albert/export.h>
#include <filesystem>
#include <map>
#include <memory>
class QNetworkAccessManager;
class QSettings;
class QUrl;
 
namespace albert
{
class Extension;
class UsageScoring;
 
class ALBERT_EXPORT App : public QObject
{
    Q_OBJECT
public:
    static App &instance();
 
 
 
    virtual void show(const QString &input_text = {}) = 0;
 
    virtual void showSettings(QString plugin_id = {}) = 0;
 
 
 
    virtual const std::map<QString,Extension*> &extensions() const = 0;
 
    template<typename T>
    std::map<QString, T*> extensions() const
    {
        std::map<QString, T*> results;
        for (auto &[id, extension] : extensions())
            if (T *t = dynamic_cast<T*>(extension))
                results.emplace(id, t);
        return results;
    }
 
    template<typename T>
    T* extension(const QString &id) const
    {
        try {
            return dynamic_cast<T*>(extensions().at(id));
        } catch (const std::out_of_range &) {
            return nullptr;
        }
    }
 
 
 
    static void restart();
 
    static void quit();
 
 
 
    static std::unique_ptr<QSettings> settings();
 
    static std::unique_ptr<QSettings> state();
 
    static const std::filesystem::path &configLocation();
 
    static const std::filesystem::path &cacheLocation();
 
    static const std::filesystem::path &dataLocation();
 
 
signals:
 
    void added(albert::Extension*);
 
    void removed(albert::Extension*);
 
protected:
 
    App();
    virtual ~App();
 
};
 
} // namespace albert