pgLab/pglab/plugin_support/PluginModule.h

#ifndef PLUGIN_SUPPORTPLUGINMODULE_H
#define PLUGIN_SUPPORTPLUGINMODULE_H

#include "ModuleActionParameters.h"
#include "StaticAction.h"
#include "LContextAction.h"
#include "PluginRegister.h"
#include <QObject>
#include <functional>
#include <map>
#include <vector>

class QAction;
class IPluginContentWidgetContext;

class PluginModule: public QObject {
	Q_OBJECT
public:
	using StaticActionList = std::vector<StaticAction>;
	using ContextActionList = std::vector<LContextAction>;
	using ModuleAction = std::function<void(IPluginContentWidgetContext*, const ModuleActionParameters &)>;
	using ModuleActionMap = std::map<QString, ModuleAction>;

	PluginModule(QString name, QString ident);

	virtual void init() {}

	const QString& name() const { return m_name; }
	const QString& identifier() const { return m_ident; }
	const QString& displayCategory() const { return m_displayCategory; }

	void setDisplayCategory(QString category);

	/// registers an action that should always be accessible from the menu
	void registerStaticAction(StaticAction action);
	const StaticActionList& staticActions() const;

	/// "API" action that other modules can trigger by name without being linked to
	/// this module. Allows for loose coupling.
	void registerModuleAction(QString module_action, ModuleAction action);

	/// Searches for and returns a pointer to the requested module action.
	/// When the action is not found nullptr is returned.
	const ModuleAction* findModuleAction(const QString &module_action) const;

	void registerContextAction(const LContextAction &action)
	{
		m_widgetActions.push_back(action);
	}
	const ContextActionList& contextActions() const { return m_widgetActions; }
private:
	/// Name shown to end users
	QString m_name;
	/// Unique identifier
	QString m_ident;
	QString m_displayCategory;

	StaticActionList m_menuActions;
	ModuleActionMap m_moduleActions;
	ContextActionList m_widgetActions;
};


template <typename T>
std::shared_ptr<PluginModule> createPluginModule(QString name, QString ident, QString category={})
{
	auto module = std::make_shared<T>(std::move(name), std::move(ident));
	module->setDisplayCategory(category);

	PluginRegister::getInstance()->registerModule(module);
	return std::move(module);
}

#define REGISTER_PLUGIN_MODULE(module, name, ident) \
	namespace {\
		std::weak_ptr<PluginModule> register_variable = createPluginModule<module>\
			(name, ident);}

#define REGISTER_PLUGIN_MODULE_CAT(module, name, ident, category) \
	namespace {\
		std::weak_ptr<PluginModule> register_variable = createPluginModule<module>\
			(name, ident, category);}


#endif // PLUGIN_SUPPORTPLUGINMODULE_H