omni::PluginLoader Class Reference

PluginLoader singleton to load plugins from multiple directories Plugins have the extension omnix. More...

#include <PluginLoader.h>

Collaboration diagram for omni::PluginLoader:

Public Member Functions
	PluginLoader (std::vector< QDir >const &_paths=std::vector< QDir >(), bool _defaultPaths=true)

Static Public Member Functions
static void	load (std::vector< QDir >const &_paths)
	Load plugins from list of paths. More...
static void	load (QDir const &_path)
	Load plugins from single path. More...
static std::vector< QDir >	defaultPaths ()
	Return default plugin path. More...
static std::vector< PluginInfo > const &	loadedPlugins ()
	Return list of information about loaded plugins. More...

Static Private Member Functions
static void	loadPlugin (QString const &_file)
	Load a single plugin from file. More...

Static Private Attributes
static std::vector< PluginInfo >	loadedPlugins_
	Kept list of loaded plugins. More...

Detailed Description

PluginLoader singleton to load plugins from multiple directories Plugins have the extension omnix.

Constructor & Destructor Documentation

omni::PluginLoader::PluginLoader	(	std::vector< QDir >const &	_paths = std::vector<QDir>(),
		bool	_defaultPaths = true
	)

                            {
        load(_paths);
        if (_defaultPaths) {
            load(defaultPaths());
        }
    }

Member Function Documentation

std::vector< QDir > omni::PluginLoader::defaultPaths ( )

static

Return default plugin path.

                                               {
        std::vector<QDir> _pluginDirs;
        _pluginDirs.push_back(QCoreApplication::applicationDirPath());
        #if defined(Q_OS_MAC)
        {
            QDir _appDir(QCoreApplication::applicationDirPath());
            if (_appDir.dirName() == "MacOS") {
                // omnidome.app/Contents/MacOS
                QDir _dir = _appDir;
                _dir.cdUp();
                _dir.cdUp();
                _dir.cdUp();
                _pluginDirs.push_back(_dir);

                // omnidome.app/Contents/PlugIns
                _dir = _appDir;
                _dir.cdUp();
                _dir.cd("PlugIns");
                _pluginDirs.push_back(_dir);
            } else {
                QDir _dir = _appDir;
                _dir.cd("omnidome.app");
                _dir.cd("Contents");
                _dir.cd("PlugIns");
                _pluginDirs.push_back(_dir);
            }
        }
        #endif
  #if defined(Q_OS_LINUX)
        _pluginDirs.push_back(QDir("/usr/share/Omnidome/plugins"));
        _pluginDirs.push_back(QDir(QDir::homePath() + "/.local/Omnidome/plugins"));
  #endif 
        return _pluginDirs;
    }

void omni::PluginLoader::load ( std::vector< QDir >const &  _paths )

static

Load plugins from list of paths.

                                                         {
        for (auto& _path : _paths) {
            qDebug() << "Plugin Path: " << _path.absolutePath();
            load(_path);
        }
    }

void omni::PluginLoader::load ( QDir const &  _path )

static

Load plugins from single path.

                                             {
        QDirIterator dirIt(_path);
        while (dirIt.hasNext()) {
            dirIt.next();
            auto _path = dirIt.filePath();
            if (!QFileInfo(_path).isFile()) continue;

            if (QFileInfo(_path).suffix() == "omnix") {
                loadPlugin(_path);
            }
        }
    }

std::vector< PluginInfo > const & omni::PluginLoader::loadedPlugins ( )

static

Return list of information about loaded plugins.

                                                             {
        return loadedPlugins_;
    }

void omni::PluginLoader::loadPlugin ( QString const &  _file )

staticprivate

Load a single plugin from file.

                                                      {
        QPluginLoader _pluginLoader(_path);
        qDebug() << "Loading plugin: " << _path;
        QObject *plugin = _pluginLoader.instance();
        if (plugin) {
            loadedPlugins_.push_back(PluginInfo::make(_path,plugin));

            auto* _inputInterface = qobject_cast<input::Interface*>(plugin);
            if (_inputInterface) {
                qDebug() << "Loaded input plugin: " << _inputInterface->getTypeId();
                _inputInterface->registerInFactory();
            }
            auto* _mappingInterface = qobject_cast<mapping::Interface*>(plugin);
            if (_mappingInterface) {
                qDebug() << "Loaded mapping plugin: " << _mappingInterface->getTypeId();
                _mappingInterface->registerInFactory();
            }
            auto* _canvasInterface = qobject_cast<canvas::Interface*>(plugin);
            if (_canvasInterface) {
                qDebug() << "Loaded canvas plugin: " << _canvasInterface->getTypeId();
                _canvasInterface->registerInFactory();
            }

            auto* _patchInterface = qobject_cast<patch::Interface*>(plugin);
            if (_patchInterface) {
                qDebug() << "Loaded patch plugin: " << _patchInterface->getTypeId();
                _patchInterface->registerInFactory();
            }
            delete plugin;
        } else {
            qDebug() << "Error loading plugin: " << _pluginLoader.errorString();
        }
    }

Field Documentation

std::vector< PluginInfo > omni::PluginLoader::loadedPlugins_

staticprivate

Kept list of loaded plugins.

---

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

• include/omni/PluginLoader.h
• src/lib/PluginLoader.cpp