#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