input_handler.h

Go to the documentation of this file.

/*! \file
  \brief  The input handler interface
 
  \par Copyright Information
 
  Copyright (c) 2016 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>
 
  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.
 
  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.
 
  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).
 
  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.
 
*/
#ifndef INCLUDED_INPUT_HANDLER_H
#define INCLUDED_INPUT_HANDLER_H
 
#include "disti_assert.h"
#include "gls_cpp_lang_support.h"
#include "weak_reference.h"
 
namespace disti
{
class DisplayObject;
class DisplayEvent;
class KeyboardEvent;
class MouseEvent;
 
/** Class used to call a callback method that takes a KeyboardEvent */
class KeyboardCallbackBase
{
public:
    /// Call the callback with the provided display event.
    /// \param ev The event to process.
    virtual void Call( KeyboardEvent* ev ) = 0;
 
    /// \return True if the callback is valid to call.
    virtual bool IsValid() const = 0;
 
    virtual ~KeyboardCallbackBase() {}
};
 
/** Interface for creating a callback from a class method.  The class must implement WeakReferenceable. 
      * Don't use this directly.  Use CreateInputHandlerCallback instead 
      */
template<class T>
class KeyboardMethodCallback : public KeyboardCallbackBase
{
public:
    typedef void ( T::*Callback )( KeyboardEvent* ev ); ///< Typedef for a function pointer accepting a keyboard event.
 
    /// Constructor
    /// \param method Function pointer to call back.
    /// \param object The object containing the function pointer.
    KeyboardMethodCallback( Callback method, T* object )
        : _method( method )
        , _object( object )
    {
        DISTI_STATIC_ASSERT_IS_CONVERTIBLE_TO( T, WeakReferenceable );
        GLS_VERIFY( NULL != method );
        GLS_VERIFY( NULL != object );
    }
 
    void Call( KeyboardEvent* ev ) DISTI_METHOD_OVERRIDE
    {
        if( IsValid() )
        {
            ( _object.Get()->*( _method ) )( ev );
        }
    }
 
    virtual bool IsValid() const DISTI_METHOD_OVERRIDE
    {
        return !_object.IsNull();
    }
 
protected:
    Callback   _method; ///< The function pointer to call back.
    WeakRef<T> _object; ///< The object containing the function pointer.
};
 
/// Helper method to create a KeyboardCallbackBase from a class method.
/// \param method A class method pointer.
/// \param obj The object to call the method on.
/// \return A pointer to a new KeyboardMethodCallback object.
template<class Class>
KeyboardCallbackBase* CreateInputHandlerCallback(
    const typename KeyboardMethodCallback<Class>::Callback method,
    Class* const                                           obj )
{
    return new KeyboardMethodCallback<Class>( method, obj );
}
 
/** Class used to call a callback method that takes a MouseEvent */
class MouseCallbackBase
{
public:
    /// Call the callback with the provided display event.
    /// \param ev The event to process.
    virtual void Call( MouseEvent* ev ) = 0;
 
    /// \return True if the callback is valid to call.
    virtual bool IsValid() const = 0;
 
    virtual ~MouseCallbackBase() {}
};
 
/** Interface for creating a callback from a class method.  The class must implement WeakReferenceable. 
      * Don't use this directly.  Use CreateInputHandlerCallback instead 
      */
template<class T>
class MouseMethodCallback : public MouseCallbackBase
{
public:
    typedef void ( T::*Callback )( MouseEvent* ev ); ///< Typedef for a function pointer accepting a mouse event.
 
    /// Constructor
    /// \param method Function pointer to call back.
    /// \param object The object containing the function pointer.
    MouseMethodCallback( Callback method, T* object )
        : _method( method )
        , _object( object )
    {
        DISTI_STATIC_ASSERT_IS_CONVERTIBLE_TO( T, WeakReferenceable );
        GLS_VERIFY( NULL != method );
        GLS_VERIFY( NULL != object );
    }
 
    void Call( MouseEvent* ev ) DISTI_METHOD_OVERRIDE
    {
        if( IsValid() )
        {
            ( _object.Get()->*( _method ) )( ev );
        }
    }
 
    virtual bool IsValid() const DISTI_METHOD_OVERRIDE
    {
        return !_object.IsNull();
    }
 
protected:
    Callback   _method; ///< The function pointer to call back.
    WeakRef<T> _object; ///< The object containing the function pointer.
};
 
/// Helper method to create a MouseCallbackBase from a class method.
/// \param method A class method pointer.
/// \param obj The object to call the method on.
/// \return A pointer to a new MouseMethodCallback object.
template<class Class>
MouseCallbackBase* CreateInputHandlerCallback(
    const typename MouseMethodCallback<Class>::Callback method,
    Class* const                                        obj )
{
    return new MouseMethodCallback<Class>( method, obj );
}
 
/** Base class implemented by all input handlers */
class InputHandler
{
public:
    /// Type for unique identifiers
    typedef unsigned int ID;
 
    /** Handle the event
          * \param ev the event to handle
          * \return the object that handled the event, or NULL if no object handled the event
          */
    virtual DisplayObject* HandleInput( DisplayEvent* ev ) = 0;
 
    /** Register a global keyboard handler.  
          * \param callback the callback to call when a keyboard event occurs.  The input handler owns the callback and will delete it.
          * \return unique ID.  Used to unregister.
          */
    virtual ID RegisterGlobalKeyboardHandler( KeyboardCallbackBase* callback ) = 0;
 
    /** Register a global mouse handler.
        * \param callback the callback to call when a mouse event occurs. The input handler owns the callback and will delete it.
        * \return unique ID. Used to unregister.
        */
    virtual ID RegisterGlobalMouseHandler( MouseCallbackBase* callback ) = 0;
 
    /** Unregister a global keyboard handler.  
          * \param id the unique identifier returned from RegisterGlobalKeyboardHandler.
          */
    virtual void UnregisterGlobalKeyboardHandler( ID id ) = 0;
 
    /** Unregister a global mouse handler.  
          * \param id the unique identifier returned from RegisterGlobalMouseHandler.
          */
    virtual void UnregisterGlobalMouseHandler( ID id ) = 0;
 
    /** destructor */
    virtual ~InputHandler() {}
};
 
} // namespace disti
 
#endif