irrlichtEventReceiver.cpp

#include "main.h"
#include "irrlichtEventReceiver.h"


// the maximum number of milliseconds allowed between mouse clicks for a double-click to be valid
#define IRR_DOUBLE_CLICK_TIME   300




IrrlichtEventReceiver::IrrlichtEventReceiver()
: theOneToCallOnKeyEvent(NULL),
  theOneToCallOnMouseButtonLeftEvent(NULL),
  theOneToCallOnMouseButtonLeftReleaseEvent(NULL),
  theOneToCallOnMouseButtonLeftDoubleClickEvent(NULL),
  theOneToCallOnMouseButtonRightEvent(NULL),
  theOneToCallOnMouseButtonRightReleaseEvent(NULL),
  theOneToCallOnMouseMoveEvent(NULL)
{
        logger->log( "IrrlichtEventReceiver ctor()" );
        device->setEventReceiver( this );
        
        // setup initial double click time
        if ( NULL != timer)
        {
                this->previousMouseButtonLeftClick = timer->getRealTime();
        }
}


IrrlichtEventReceiver::~IrrlichtEventReceiver()
{
        logger->log( "IrrlichtEventReceiver dtor()" );
        device->setEventReceiver( NULL );
        this->theOneToCallOnKeyEvent = NULL;
        this->theOneToCallOnMouseButtonLeftEvent = NULL;
        this->theOneToCallOnMouseButtonLeftReleaseEvent = NULL;
        this->theOneToCallOnMouseButtonLeftDoubleClickEvent = NULL;
        this->theOneToCallOnMouseButtonRightEvent = NULL;
        this->theOneToCallOnMouseMoveEvent = NULL;
}


ERR_TYPE IrrlichtEventReceiver::registerKeyEventCallback( irrlichtKeyEventCallback_TYPE anyCallBackFunction )
{
        this->theOneToCallOnKeyEvent = anyCallBackFunction;
        return ERR_OK;
}


ERR_TYPE IrrlichtEventReceiver::registerMouseButtonLeftEventCallback( irrlichtMouseButtonEventCallback_TYPE anyCallBackFunction )
{
        this->theOneToCallOnMouseButtonLeftEvent = anyCallBackFunction;
        return ERR_OK;
}


ERR_TYPE IrrlichtEventReceiver::registerMouseButtonLeftReleaseEventCallback( irrlichtMouseButtonReleaseEventCallback_TYPE anyCallBackFunction )
{
        this->theOneToCallOnMouseButtonLeftReleaseEvent = anyCallBackFunction;
        return ERR_OK;
}


ERR_TYPE IrrlichtEventReceiver::registerMouseButtonLeftDoubleClickEventCallback( irrlichtMouseButtonEventCallback_TYPE anyCallBackFunction )
{
        this->theOneToCallOnMouseButtonLeftDoubleClickEvent = anyCallBackFunction;
        return ERR_OK;
}


ERR_TYPE IrrlichtEventReceiver::registerMouseButtonRightEventCallback( irrlichtMouseButtonEventCallback_TYPE anyCallBackFunction )
{
        this->theOneToCallOnMouseButtonRightEvent = anyCallBackFunction;
        return ERR_OK;
}


ERR_TYPE IrrlichtEventReceiver::registerMouseButtonRightReleaseEventCallback( irrlichtMouseButtonReleaseEventCallback_TYPE anyCallBackFunction )
{
        this->theOneToCallOnMouseButtonRightReleaseEvent = anyCallBackFunction;
        return ERR_OK;
}


ERR_TYPE IrrlichtEventReceiver::registerMouseMoveEventCallback( irrlichtMouseMoveEventCallback_TYPE anyCallBackFunction )
{
        this->theOneToCallOnMouseMoveEvent = anyCallBackFunction;
        return ERR_OK;
}


bool IrrlichtEventReceiver::OnEvent( SEvent event )
{
        ERR_TYPE status = ERR_OK;

        // forward key event to registered function
        if ( event.EventType == EET_KEY_INPUT_EVENT && (! event.KeyInput.PressedDown) )
        {
                if ( NULL != theOneToCallOnKeyEvent )
                {
                        status = theOneToCallOnKeyEvent( event.KeyInput.Key );
                        if ( ERR_EVENT_CONSUMED == status )
                        {
                                return true;
                        }
                }
        }

        // forward mouse left button double click event to registered function
        if ( event.EventType == EET_MOUSE_INPUT_EVENT && event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP )
        {
                u32 now = timer->getRealTime();

                // a double-click is detected if the the time elapsed since the last click is within doubleClickTime
                if ( (now - this->previousMouseButtonLeftClick) <= IRR_DOUBLE_CLICK_TIME  )
                {
                        if ( NULL != theOneToCallOnMouseButtonLeftDoubleClickEvent )
                        {
                                status = theOneToCallOnMouseButtonLeftDoubleClickEvent( event.MouseInput.X, event.MouseInput.Y, event.MouseInput.Wheel );
                        }
                }
                
                // set previousClick to now so that subsequent double-clicks can be detected
                this->previousMouseButtonLeftClick = now;

                if ( ERR_EVENT_CONSUMED == status )
                {
                        return true;
                }
        }

        // forward left button down event to registered function
        if ( event.EventType == EET_MOUSE_INPUT_EVENT && event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN )
        {
                if ( NULL != theOneToCallOnMouseButtonLeftEvent )
                {
                        status = theOneToCallOnMouseButtonLeftEvent( event.MouseInput.X, event.MouseInput.Y, event.MouseInput.Wheel );
                        if ( ERR_EVENT_CONSUMED == status )
                        {
                                return true;
                        }
                }
        }

        // forward left button up event to registered function
        if ( event.EventType == EET_MOUSE_INPUT_EVENT && event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP )
        {
                if ( NULL != theOneToCallOnMouseButtonLeftReleaseEvent )
                {
                        status = theOneToCallOnMouseButtonLeftReleaseEvent();
                        if ( ERR_EVENT_CONSUMED == status )
                        {
                                return true;
                        }
                }
        }

        // forward right button down event to registered function
        if ( event.EventType == EET_MOUSE_INPUT_EVENT && event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN )
        {
                if ( NULL != theOneToCallOnMouseButtonRightEvent )
                {
                        status = theOneToCallOnMouseButtonRightEvent( event.MouseInput.X, event.MouseInput.Y, event.MouseInput.Wheel );
                        if ( ERR_EVENT_CONSUMED == status )
                        {
                                return true;
                        }
                }
        }

        // forward right button up event to registered function
        if ( event.EventType == EET_MOUSE_INPUT_EVENT && event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP )
        {
                if ( NULL != theOneToCallOnMouseButtonRightReleaseEvent )
                {
                        status = theOneToCallOnMouseButtonRightReleaseEvent();
                        if ( ERR_EVENT_CONSUMED == status )
                        {
                                return true;
                        }
                }
        }

        // forward mouse move event to registered function
        if ( event.EventType == EET_MOUSE_INPUT_EVENT )
        {
                if ( NULL != theOneToCallOnMouseMoveEvent && event.MouseInput.Event == EMIE_MOUSE_MOVED )
                {
                        status = theOneToCallOnMouseMoveEvent( event.MouseInput.X, event.MouseInput.Y );
                        if ( ERR_EVENT_CONSUMED == status )
                        {
                                return true;
                        }
                }
        }
        
        // event not consumed
        return false;
}

---