winix/core/plugin.h

/*
 * This file is a part of Winix
 * and is not publicly distributed
 * 
 * Copyright (c) 2008-2012, Tomasz Sowa
 * All rights reserved.
 * 
 */
 

#ifndef headerfile_winix_core_plugin
#define headerfile_winix_core_plugin

#include <vector>
#include <string>
#include <map>
#include "pluginmsg.h"
#include "log.h"
#include "plugindata.h"
#include "config.h"
#include "request.h"
#include "system.h"
#include "sessionmanager.h"
#include "synchro.h"
#include "functions/functions.h"
#include "templates/templates.h"


/*
	all your plugin functions can have signature either:
	void my_function(PluginInfo & info); or
	void my_function();

	only the main Init should have:
	extern "C" void Init(PluginFunction & info);

	in the Init you can add your own functions by using plugin.Assign() method
	and you can set the name of the plugin by setting info.p1 pointer 
	to a string buffer (const char *)
	(this buffer will not be copied so it should not be destroyed after Init finishes)
	also in Init you can only use logger (log) info.config and info.db objects
	(the rest winix objects are not initialized yet)
*/




struct PluginInfo
{
	// these variables are used for some purposes
	// depending on a hook in which they are used
	void * p1;
	void * p2;
	long l1;
	long l2;

	// unique plugin identifier
	int plugin_id;
	
	// objects from winix which are accessible from a plugin
	Db        * db;
	Config    * config;
	Cur       * cur;
	System    * system;
	Functions * functions;
	Templates * templates;
	Synchro   * synchro;
	SessionManager * session_manager;

	// a session
	// some messages are sent in a session's context e.g. logging a user
	// this pointer in not always the same as cur->session, it is preferred
	// to use this pointer instead of cur->session
	// (cur->session can point at a temporary object)
	// this pointer can be null
	Session * session;

	// pointer to the plugin session (can be null if not set by the plugin or if session is null)
	// this is taken from session->plugin_data.Get()
	// you should use WINIX_SESSION_CREATED and WINIX_PLUGIN_SESSION_DATA_REMOVE
	// to create your plugin's session data
	PluginDataBase * plugin_data_base; // !! zmienic nazwe na plugin_session_base ? a moze session_base; a moze plugin_session?

	// function return status
	// default: false (if not set by the plugin)
	bool res;
	
	
	void Clear()
	{
		// pointers to winix objects are not cleared here

		p1 = 0;
		p2 = 0;
		l1 = 0;
		l2 = 0;

		plugin_id			= -1;
		session				= 0;
		plugin_data_base	= 0;

		res = false;
	}
};


/*
	this structure tells how many plugins returned true and false
*/
struct PluginRes
{
	int res_false;
	int res_true;

	PluginRes()
	{
		res_false = 0;
		res_true  = 0;
	}
};



class Plugin
{
public:	

	// index of a plugin which is called by Call() method
	// normally: -1
	int current_plugin;

	// Fun is a type of a function you should provide in your plugin
	typedef void (*Fun1)(PluginInfo &);
	typedef void (*Fun2)(void);


	struct Slot
	{
		Fun1 fun1;
		Fun2 fun2;
		int index; // plugin index (which plugin has inserted the slot)
		bool is_running;

		Slot()
		{
			fun1  = 0;
			fun2  = 0;
			index = -1;
			is_running = false;
		}
	};

	struct PluginsItem
	{
		void * handle;
		const wchar_t * plugin_name; // plugin name (can be null if was not set by the plugin)
	};

	typedef std::vector<PluginsItem> Plugins;


	Plugin();
	~Plugin();

	void SetDb(Db * pdb);
	void SetConfig(Config * pconfig);
	void SetCur(Cur * pcur);
	void SetSystem(System * psystem);
	void SetFunctions(Functions * pfunctions);
	void SetTemplates(Templates * ptemplates);
	void SetSynchro(Synchro * psynchro);
	void SetSessionManager(SessionManager * psession_manager);

	void LoadPlugin(const char * filename);
	void LoadPlugin(const std::string & filename);
	void LoadPlugin(const wchar_t * filename);
	void LoadPlugin(const std::wstring & filename);

	void LoadPlugins(const std::wstring & plugins_dir, const std::vector<std::wstring> & plugins);
	void UnloadPlugins();
	
	bool HasPlugin(const wchar_t * name);
	bool HasPlugin(const std::wstring & name);

	bool HasMessage(int message);

	PluginRes Call(int message);
	PluginRes Call(int message, void * p1_);
	PluginRes Call(int message, void * p1_, void * p2_);
	PluginRes Call(int message, long l1_);
	PluginRes Call(int message, long l1_, long l2_);
	PluginRes Call(int message, void * p1_, long l1_);
	PluginRes Call(int message, void * p1_, long l1_, long l2_);
	PluginRes Call(int message, void * p1_, void * p2_, long l1_);
	PluginRes Call(Session * ses, int message, void * p1_, void * p2_, long l1_, long l2_);
	
	PluginRes Call(Session * ses, int message);
	PluginRes Call(Session * ses, int message, void * p1_);
	PluginRes Call(Session * ses, int message, void * p1_, void * p2_);
	PluginRes Call(Session * ses, int message, long l1_);
	PluginRes Call(Session * ses, int message, long l1_, long l2_);
	PluginRes Call(Session * ses, int message, void * p1_, long l1_);
	PluginRes Call(Session * ses, int message, void * p1_, long l1_, long l2_);
	PluginRes Call(Session * ses, int message, void * p1_, void * p2_, long l1_);

	// how many plugins there are
	size_t Size();

	// assign a function to a message
	// you can assign more than one function to a specific message
	void Assign(int message, Fun1);
	void Assign(int message, Fun2);

	// return a const pointer to the plugin tab
	const Plugins * GetPlugins();

private:	

	Db        * db;
	Config    * config;
	Cur       * cur;
	System    * system;
	Functions * functions;
	Templates * templates;
	Synchro   * synchro;
	SessionManager * session_manager;

	std::wstring temp_path;

	Plugins plugins;
	
	typedef std::multimap<int, Slot> Slots;
	Slots slots;
	
	std::string afilename;

	void * LoadInitFun(const char * filename, Fun1 & fun_init);
	void Call(Session * ses, int message, Slots::iterator & slot, PluginInfo & info);

	bool SetPointers(PluginInfo & info);
};




extern Plugin plugin;

#endif