effectloader.h

Go to the documentation of this file.

/*
    KWin - the KDE window manager
    This file is part of the KDE project.
 
    SPDX-FileCopyrightText: 2014 Martin Gräßlin <mgraesslin@kde.org>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
#pragma once
#include <kwin_export.h>
// KDE
#include <KPluginMetaData>
#include <KSharedConfig>
// Qt
#include <QFlags>
#include <QMap>
#include <QObject>
#include <QPair>
#include <QQueue>
#include <QStaticPlugin>
 
namespace KWin
{
class Effect;
class EffectPluginFactory;
 
enum class LoadEffectFlag {
    Load = 1 << 0, 
    CheckDefaultFunction = 1 << 2 
};
Q_DECLARE_FLAGS(LoadEffectFlags, LoadEffectFlag)
 
 
class KWIN_EXPORT AbstractEffectLoader : public QObject
{
    Q_OBJECT
public:
    ~AbstractEffectLoader() override;
 
    virtual void setConfig(KSharedConfig::Ptr config);
 
    virtual bool hasEffect(const QString &name) const = 0;
 
    virtual QStringList listOfKnownEffects() const = 0;
 
    virtual bool loadEffect(const QString &name) = 0;
 
    virtual void queryAndLoadAll() = 0;
 
    virtual bool isEffectSupported(const QString &name) const = 0;
 
    virtual void clear() = 0;
 
Q_SIGNALS:
    void effectLoaded(KWin::Effect *effect, const QString &name);
 
protected:
    explicit AbstractEffectLoader(QObject *parent = nullptr);
    LoadEffectFlags readConfig(const QString &effectName, bool defaultValue) const;
 
private:
    KSharedConfig::Ptr m_config;
};
 
template<typename Loader, typename QueueType>
class EffectLoadQueue;
class AbstractEffectLoadQueue : public QObject
{
    Q_OBJECT
public:
    explicit AbstractEffectLoadQueue(QObject *parent = nullptr)
        : QObject(parent)
    {
    }
protected Q_SLOTS:
    virtual void dequeue() = 0;
 
private:
    template<typename Loader, typename QueueType>
    friend class EffectLoadQueue;
};
 
template<typename Loader, typename QueueType>
class EffectLoadQueue : public AbstractEffectLoadQueue
{
public:
    explicit EffectLoadQueue(Loader *parent)
        : AbstractEffectLoadQueue(parent)
        , m_effectLoader(parent)
        , m_dequeueScheduled(false)
    {
    }
    void enqueue(const QPair<QueueType, LoadEffectFlags> value)
    {
        m_queue.enqueue(value);
        scheduleDequeue();
    }
    void clear()
    {
        m_queue.clear();
        m_dequeueScheduled = false;
    }
 
protected:
    void dequeue() override
    {
        if (m_queue.isEmpty()) {
            return;
        }
        m_dequeueScheduled = false;
        const auto pair = m_queue.dequeue();
        m_effectLoader->loadEffect(pair.first, pair.second);
        scheduleDequeue();
    }
 
private:
    void scheduleDequeue()
    {
        if (m_queue.isEmpty() || m_dequeueScheduled) {
            return;
        }
        m_dequeueScheduled = true;
        QMetaObject::invokeMethod(this, &AbstractEffectLoadQueue::dequeue, Qt::QueuedConnection);
    }
    Loader *m_effectLoader;
    bool m_dequeueScheduled;
    QQueue<QPair<QueueType, LoadEffectFlags>> m_queue;
};
 
class KWIN_EXPORT ScriptedEffectLoader : public AbstractEffectLoader
{
    Q_OBJECT
public:
    explicit ScriptedEffectLoader(QObject *parent = nullptr);
    ~ScriptedEffectLoader() override;
 
    bool hasEffect(const QString &name) const override;
    bool isEffectSupported(const QString &name) const override;
    QStringList listOfKnownEffects() const override;
 
    void clear() override;
    void queryAndLoadAll() override;
    bool loadEffect(const QString &name) override;
    bool loadEffect(const KPluginMetaData &effect, LoadEffectFlags flags);
 
private:
    QList<KPluginMetaData> findAllEffects() const;
    KPluginMetaData findEffect(const QString &name) const;
    bool loadJavascriptEffect(const KPluginMetaData &effect);
    bool loadDeclarativeEffect(const KPluginMetaData &effect);
 
    QStringList m_loadedEffects;
    EffectLoadQueue<ScriptedEffectLoader, KPluginMetaData> *m_queue;
    QMetaObject::Connection m_queryConnection;
};
 
class PluginEffectLoader : public AbstractEffectLoader
{
    Q_OBJECT
public:
    explicit PluginEffectLoader(QObject *parent = nullptr);
    ~PluginEffectLoader() override;
 
    bool hasEffect(const QString &name) const override;
    bool isEffectSupported(const QString &name) const override;
    QStringList listOfKnownEffects() const override;
 
    void clear() override;
    void queryAndLoadAll() override;
    bool loadEffect(const QString &name) override;
    bool loadEffect(const KPluginMetaData &info, LoadEffectFlags flags);
 
    void setPluginSubDirectory(const QString &directory);
 
private:
    QList<KPluginMetaData> findAllEffects() const;
    KPluginMetaData findEffect(const QString &name) const;
    EffectPluginFactory *factory(const KPluginMetaData &info) const;
    QStringList m_loadedEffects;
    QString m_pluginSubDirectory;
};
 
class KWIN_EXPORT EffectLoader : public AbstractEffectLoader
{
    Q_OBJECT
public:
    explicit EffectLoader(QObject *parent = nullptr);
    ~EffectLoader() override;
    bool hasEffect(const QString &name) const override;
    bool isEffectSupported(const QString &name) const override;
    QStringList listOfKnownEffects() const override;
    bool loadEffect(const QString &name) override;
    void queryAndLoadAll() override;
    void setConfig(KSharedConfig::Ptr config) override;
    void clear() override;
 
private:
    QList<AbstractEffectLoader *> m_loaders;
};
 
}
Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::LoadEffectFlags)