KoPluginLoader Class Reference

#include <KoPluginLoader.h>

Inheritance diagram for KoPluginLoader:

Classes
struct	PluginsConfig

Public Member Functions
	KoPluginLoader ()
	DO NOT USE! Use instance() instead.
void	load (const QString &serviceType, const PluginsConfig &config=PluginsConfig(), QObject *owner=0, bool cache=true)
KPluginFactory *	loadSinglePlugin (const QString &id, const QString &serviceType)
KPluginFactory *	loadSinglePlugin (const std::pair< QString, QString > &predicates, const QString &serviceType)
KPluginFactory *	loadSinglePlugin (const std::vector< std::pair< QString, QString > > &predicates, const QString &serviceType)
	~KoPluginLoader () override

Static Public Member Functions
static KoPluginLoader *	instance ()

Public Attributes
QStringList	loadedServiceTypes

Private Member Functions
	KoPluginLoader (const KoPluginLoader &)
KoPluginLoader	operator= (const KoPluginLoader &)
Private Member Functions inherited from Private
	Private (KisCanvas2 *c)

Private Attributes
Private *const	d
Private Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Detailed Description

The pluginloader singleton is responsible for loading the plugins that it's asked to load. It keeps track of which servicetypes it has seen and doesn't reload them. The plugins need to inherit a QObject with a default constructor. Inside the default constructor you can create whatever object you want and add it to whatever registry you prefer. After having been constructed, your plugin will be deleted, so do all you need in the constructor. Things like adding a factory to a registry make sense there. Example header file;

#include <QObject>
 
class MyPlugin : public QObject {
    Q_OBJECT
public:
    MyPlugin(QObject *parent, const QVariantList & );
    ~MyPlugin() {}
};

Example cpp file;

#include "MyPlugin.h"
#include <kpluginfactory.h>
 
K_PLUGIN_FACTORY_WITH_JSON(MyPluginFactory, "myplugin.json", registerPlugin<MyPlugin>();)
 
MyPlugin::MyPlugin( QObject *parent, const QVariantList& ) : QObject(parent) {
    // do stuff like creating a factory and adding it to the
    // registry instance.
}
#include <MyPlugin.moc>

Definition at line 60 of file KoPluginLoader.cpp.

Constructor & Destructor Documentation

~KoPluginLoader()

KoPluginLoader::~KoPluginLoader ( )

override

Definition at line 71 of file KoPluginLoader.cpp.

{
    delete d;
}

References d.

KoPluginLoader() [1/2]

KoPluginLoader::KoPluginLoader

(

)

DO NOT USE! Use instance() instead.

Definition at line 66 of file KoPluginLoader.cpp.

        : d(new Private())
{
}

KoPluginLoader() [2/2]

KoPluginLoader::KoPluginLoader ( const KoPluginLoader & )

private

Member Function Documentation

instance()

KoPluginLoader * KoPluginLoader::instance ( )

static

Return an instance of the KoPluginLoader Creates an instance if that has never happened before and returns the singleton instance.

Definition at line 78 of file KoPluginLoader.cpp.

{
    return pluginLoaderInstance();
}

load()

void KoPluginLoader::load	(	const QString &	serviceType,
		const PluginsConfig &	config = PluginsConfig(),
		QObject *	owner = 0,
		bool	cache = true )

Load all plugins that conform to the versiontype, for instance: KoPluginLoader::instance()->load("Krita/Flake"); This method allows you to optionally limit the plugins that are loaded by version, but also using a user configurable set of config options. If you pass a PluginsConfig struct only those plugins are loaded that are specified in the application config file. New plugins found since last start will be automatically loaded.

Parameters

serviceType	The string used to identify the plugins.
config	when passing a valid config only the wanted plugins are actually loaded #param owner if 0, the plugin will be deleted after instantiation, if not, the given qobject will own the plugin in its qobject hierarchy
cache	if true, the plugin will only be loaded once

Returns

a list of services (by library name) that were not know in the config

First, remove all the duplicated plugins and keep only the ones with the highest version number

Erasing an element in QList in Qt5 may invalidate the existing iterator, so we should derive the new position from the iterator returned by erase() method

Then remove all the blacklisted plugins if necessary

Now "load" all the plugins. If "owner" object is not provided, we just create the plugin object and immediately destroy it. Usually the constructor of this plugin will just populate some registry, so the object is not necessary anymore.

Definition at line 83 of file KoPluginLoader.cpp.

{
    // Don't load the same plugins again
    if (cache && d->loadedServiceTypes.contains(serviceType)) {
        return;
    }
    d->loadedServiceTypes << serviceType;
 
    QList<KoJsonTrader::Plugin> plugins = KoJsonTrader::instance()->query(serviceType, QString());
 
    {
        std::sort(plugins.begin(), plugins.end(), &sortByIdAndReversedVersion);
        auto it = plugins.begin();
        while ((it = std::adjacent_find(it, plugins.end(), &idCompareEqual)) != plugins.end()) {
            warnPlugins << "Skipping duplicated plugin, id:" << idFromPlugin(*it)
                        << "version:" << versionFromPlugin(*it) << "filename:" << it->fileName();
            it = std::prev(plugins.erase(std::next(it)));
        }
    }
 
    if (config.isValid()) {
        KConfigGroup configGroup(KSharedConfig::openConfig(), config.group);
        QStringList blackList = configGroup.readEntry(config.blacklist, QStringList());
 
        auto it = plugins.begin();
        while (it != plugins.end()) {
            if (blackList.contains(idFromPlugin(*it))) {
                it = plugins.erase(it);
            } else {
                ++it;
            }
        }
    }
 
    for (KoJsonTrader::Plugin &plugin : plugins) {
        const QString pluginName = idFromPlugin(plugin);
        dbgPlugins << "loading" << pluginName;
 
        QObject *object = 0;
 
        KPluginFactory *factory = qobject_cast<KPluginFactory *>(plugin.instance());
        if (factory) {
            object = factory->create<QObject>(owner ? owner : this, QVariantList());
        }
 
        if (object) {
            dbgPlugins << "\tLoaded plugin" << plugin.fileName() << "owner:" << owner;
            if (!owner) {
                delete object;
            }
        } else {
            qWarning() << "\tLoading plugin" << plugin.fileName() << "failed, " << plugin.errorString();
        }
    }
}

References KoPluginLoader::PluginsConfig::blacklist, d, dbgPlugins, KoJsonTrader::Plugin::errorString(), KoJsonTrader::Plugin::fileName(), KoPluginLoader::PluginsConfig::group, KoJsonTrader::instance(), KoJsonTrader::Plugin::instance(), KoPluginLoader::PluginsConfig::isValid(), KoJsonTrader::query(), and warnPlugins.

loadSinglePlugin() [1/3]

KPluginFactory * KoPluginLoader::loadSinglePlugin	(	const QString &	id,
		const QString &	serviceType )

Definition at line 189 of file KoPluginLoader.cpp.

{
    return loadSinglePlugin({"Id", id}, serviceType);
}

References loadSinglePlugin().

loadSinglePlugin() [2/3]

KPluginFactory * KoPluginLoader::loadSinglePlugin	(	const std::pair< QString, QString > &	predicates,
		const QString &	serviceType )

Definition at line 184 of file KoPluginLoader.cpp.

{
    return loadSinglePlugin(std::vector<std::pair<QString, QString>>{predicates}, serviceType);
}

References loadSinglePlugin().

loadSinglePlugin() [3/3]

KPluginFactory * KoPluginLoader::loadSinglePlugin	(	const std::vector< std::pair< QString, QString > > &	predicates,
		const QString &	serviceType )

Load a single plugin from the plugins directory

One can pass a set of predicates that should be satisfied for the plugin to be selected. The loader will compare metadata of the plugin against those predicates and choose only the one satisfying all of them.

If multiple plugins are found, then the one with highest version number is used. If two plugins with the same maximum version number exist, then a random one is selected.

Usage:

KPluginFactory *factory = KoPluginLoader::instance()->loadSinglePlugin(
    std::make_pair("X-Krita-PlatformId", QGuiApplication::platformName()),
    "Krita/PlatformPlugin");
 
if (factory) {
    interface = factory->create<KisExtendedModifiersMapperPluginInterface>();
}

Definition at line 157 of file KoPluginLoader.cpp.

{
    QList<KoJsonTrader::Plugin> offers = KoJsonTrader::instance()->query(serviceType, QString());
 
    offers.erase(std::remove_if(offers.begin(),
                                offers.end(),
                                [&](const KoJsonTrader::Plugin &plugin) {
                                    QJsonObject json = plugin.metaData().value("MetaData").toObject();
                                    Q_FOREACH(const auto &predicate, predicates) {
                                        if (json.value(predicate.first).toString() != predicate.second) {
                                            return true;
                                        }
                                    }
                                    return false;
                                }),
                 offers.end());
 
    auto it = std::max_element(offers.begin(), offers.end(), versionCompareLess);
 
    if (it != offers.end()) {
        KPluginFactory *factory = qobject_cast<KPluginFactory *>(it->instance());
        return factory;
    }
 
    return nullptr;
}

References KoJsonTrader::instance(), and KoJsonTrader::query().

operator=()

KoPluginLoader KoPluginLoader::operator= ( const KoPluginLoader & )

private

Member Data Documentation

d

Private* const KoPluginLoader::d

private

Definition at line 152 of file KoPluginLoader.h.

loadedServiceTypes

QStringList KoPluginLoader::loadedServiceTypes

Definition at line 63 of file KoPluginLoader.cpp.

---

The documentation for this class was generated from the following files:

• libs/koplugin/KoPluginLoader.cpp
• libs/koplugin/KoPluginLoader.h