#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