#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