source: orxonox.OLD/orxonox/trunk/src/util/event/event_handler.cc @ 4386

/* 
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   ### File Specific:
   main-programmer: Patrick Boenzli
   co-programmer: 

   This code is inspired by Christian Meyers CommandNode code (in Orxonox v0.2.3)
*/

#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_EVENT

#include "event_handler.h"
#include "event_listener.h"
#include "event.h"

#include "compiler.h"
#include "debug.h"

using namespace std;


/**
   \brief standard constructor
*/
EventHandler::EventHandler () 
{
  this->setClassID(CL_EVENT_HANDLER, "EventHandler"); 

  this->listeners = new EventListener**[ES_NUMBER];
  for(int i = 0; i < ES_NUMBER; ++i)
    this->listeners[i] = new EventListener*[EV_NUMBER];

  /* now initialize them all to zero */
  for(int i = 0; i < ES_NUMBER; ++i)
    {
      for(int j = 0; j < SDLK_LAST; ++j)
        {
          this->listeners[i][j] = NULL;
        }
    }
}

/**
   \brief the singleton reference to this class
*/
EventHandler* EventHandler::singletonRef = NULL;

/**
   \returns a Pointer to this Class
*/
EventHandler* EventHandler::getInstance(void)
{
  if (!EventHandler::singletonRef)
    EventHandler::singletonRef = new EventHandler();
  return EventHandler::singletonRef;
}

/**
   \brief standard deconstructor

*/
EventHandler::~EventHandler () 
{
  EventHandler::singletonRef = NULL;
}



void EventHandler::setState(elState state)
{
  this->state = state;
}

void EventHandler::subscribeListener(EventListener* el, elState state, int eventType)
{
  if( likely(this->listeners[state][eventType] == NULL))
    this->listeners[state][eventType] = el;
  else
    PRINTF(0)("Someone tried to subscribe to event %i @ state %i but this event has already been subscribed\n", eventType, state);
}


void EventHandler::unsubscribeListener(int eventType, elState state)
{
  this->listeners[state][eventType] = NULL;
}

void EventHandler::flush(elState state)
{
  if( state == ES_ALL)
    {
      for(int i = 0; i < ES_NUMBER; ++i)
        {
          for(int j = 0; j < SDLK_LAST; ++j)
            {
              this->listeners[i][j] = NULL;
            }
        }
    }
  else
    {
      for(int j = 0; j < SDLK_LAST; ++j)
        {
          this->listeners[state][j] = NULL;
        }
    }
}



void EventHandler::process()
{
  SDL_Event event;
  Event ev;
  EventListener* listener;
  while( SDL_PollEvent (&event))
    {
      switch( event.type)
        {
        case SDL_KEYDOWN:
          ev.bPressed = true;
          ev.type = event.key.keysym.sym;
          break;
        case SDL_KEYUP:
          ev.bPressed = false;
          ev.type = event.key.keysym.sym;
          break;
        case SDL_MOUSEMOTION:
          ev.bPressed = false;
          ev.type = EV_MOUSE_MOTION;
          ev.x = event.motion.x;
          ev.y = event.motion.y;
          ev.xRel = event.motion.xrel;
          ev.yRel = event.motion.yrel;
          break;
        case SDL_MOUSEBUTTONUP:
          ev.bPressed = false;
          ev.type = EV_MOUSE_BUTTON;
          break;
        case SDL_MOUSEBUTTONDOWN:
          ev.bPressed = true;
          ev.type = EV_MOUSE_BUTTON;
          break;
        case SDL_JOYAXISMOTION:
          ev.bPressed = false;
          ev.type = EV_JOY_AXIS_MOTION;
          break;
        case SDL_JOYBALLMOTION:
          ev.bPressed = false;
          ev.type = EV_JOY_BALL_MOTION;
          break;
        case SDL_JOYHATMOTION:
          ev.bPressed = false;
          ev.type = EV_JOY_HAT_MOTION;
          break;
        case SDL_JOYBUTTONDOWN:
          ev.bPressed = true;
          ev.type = EV_JOY_BUTTON;
          break;
        case SDL_JOYBUTTONUP:
          ev.bPressed = true;
          ev.type = EV_JOY_BUTTON;
          break;
        default:
          break;
        }

      /* small debug routine: shows alle events dispatched by the event handler */
      PRINT(0)("\n==========================| EventHandler::process () |===\n");
      PRINT(0)("=  Got Event nr%i\n, for state %i", event.type, this->state);  
      
      listener = this->listeners[this->state][event.key.keysym.sym];
      if( listener != NULL)
        {
          listener->process(ev);
          PRINTF(0)("=  Event dispatcher msg: This event has been consumed\n");
        }
      else
        {
          PRINTF(0)("=  Event dispatcher msg: This event has NOT been consumed\n");
        }

      PRINT(0)("=======================================================\n");      
    }
}