#ifndef _PANE_EVENT
#define _PANE_EVENT

#include <vector>

namespace	Pane
{
	/*
	** EventHandler class (4 parameters)
	*/
	template<typename Return, typename Param1 = void, typename Param2 = void, typename Param3 = void, typename Param4 = void>
	class	EventHandler
	{
		public:
			class	EventClass
			{
				public:
					virtual			~EventClass ()
					{
					}

					virtual Return	operator () (Param1, Param2, Param3, Param4) = 0;
			};

			template<typename Sender = void>
			class	Event : public EventClass
			{
				public:
					typedef Return	(Sender::*Method) (Param1, Param2, Param3, Param4);

					/**/	Event (Sender* sender, Method method) :
						method (method),
						sender (sender)
					{
					}

					virtual Return	operator () (Param1 param1, Param2 param2, Param3 param3, Param4 param4)
					{
						return (this->sender->*method) (param1, param2, param3, param4);
					}

				private:
					Method	method;
					Sender*	sender;
			};

			/**/	~EventHandler ();

			void	operator += (EventClass*);
			bool	operator () (Param1, Param2, Param3, Param4);

		private:
			typedef std::vector<EventClass*>	Events;

			Events	events;
	};

	/*
	** EventHandler class (3 parameters)
	*/
	template<typename Return, typename Param1, typename Param2, typename Param3>
	class	EventHandler<Return, Param1, Param2, Param3>
	{
		public:
			class	EventClass
			{
				public:
					virtual			~EventClass ()
					{
					}

					virtual Return	operator () (Param1, Param2, Param3) = 0;
			};

			template<typename Sender = void>
			class	Event : public EventClass
			{
				public:
					typedef Return	(Sender::*Method) (Param1, Param2, Param3);

					/**/	Event (Sender* sender, Method method) :
						method (method),
						sender (sender)
					{
					}

					virtual Return	operator () (Param1 param1, Param2 param2, Param3 param3)
					{
						return (this->sender->*method) (param1, param2, param3);
					}

				private:
					Method	method;
					Sender*	sender;
			};

			/**/	~EventHandler ();

			void	operator += (EventClass*);
			bool	operator () (Param1, Param2, Param3);

		private:
			typedef std::vector<EventClass*>	Events;

			Events	events;
	};

	/*
	** EventHandler class (2 parameters)
	*/
	template<typename Return, typename Param1, typename Param2>
	class	EventHandler<Return, Param1, Param2>
	{
		public:
			class	EventClass
			{
				public:
					virtual			~EventClass ()
					{
					}

					virtual Return	operator () (Param1, Param2) = 0;
			};

			template<typename Sender = void>
			class	Event : public EventClass
			{
				public:
					typedef Return	(Sender::*Method) (Param1, Param2);

					/**/	Event (Sender* sender, Method method) :
						method (method),
						sender (sender)
					{
					}

					virtual Return	operator () (Param1 param1, Param2 param2)
					{
						return (this->sender->*method) (param1, param2);
					}

				private:
					Method	method;
					Sender*	sender;
			};

			/**/	~EventHandler ();

			void	operator += (EventClass*);
			bool	operator () (Param1, Param2);

		private:
			typedef std::vector<EventClass*>	Events;

			Events	events;
	};

	/*
	** EventHandler class (1 parameter)
	*/
	template<typename Return, typename Param1>
	class	EventHandler<Return, Param1>
	{
		public:
			class	EventClass
			{
				public:
					virtual			~EventClass ()
					{
					}

					virtual Return	operator () (Param1) = 0;
			};

			template<typename Sender = void>
			class	Event : public EventClass
			{
				public:
					typedef Return	(Sender::*Method) (Param1);

					/**/	Event (Sender* sender, Method method) :
						method (method),
						sender (sender)
					{
					}

					virtual Return	operator () (Param1 param1)
					{
						return (this->sender->*method) (param1);
					}

				private:
					Method	method;
					Sender*	sender;
			};

			/**/	~EventHandler ();

			void	operator += (EventClass*);
			bool	operator () (Param1);

		private:
			typedef std::vector<EventClass*>	Events;

			Events	events;
	};

	/*
	** EventHandler class (0 parameter)
	*/
	template<typename Return>
	class	EventHandler<Return>
	{
		public:
			class	EventClass
			{
				public:
					virtual			~EventClass ()
					{
					}

					virtual Return	operator () () = 0;
			};

			template<typename Sender = void>
			class	Event : public EventClass
			{
				public:
					typedef Return	(Sender::*Method) ();

					/**/	Event (Sender* sender, Method method) :
						method (method),
						sender (sender)
					{
					}

					virtual Return	operator () ()
					{
						return (this->sender->*method) ();
					}

				private:
					Method	method;
					Sender*	sender;
			};

			/**/	~EventHandler ();

			void	operator += (EventClass*);
			bool	operator () ();

		private:
			typedef std::vector<EventClass*>	Events;

			Events	events;
	};
}

#include "eventHandler.hxx"

#endif // _PANE_EVENT