events.h

Go to the documentation of this file.

/*! \file
  \brief  The standard Mouse and keyboard events and event structures
 
  \par Copyright Information
 
  Copyright (c) 2015 by The DiSTI Corporation.<br />
  11301 Corporate Blvd., Suite 100<br />
  Orlando, FL 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. Use, distribution,
duplication, or disclosure by the U. S. Government is subject to
"Restricted Rights" as set forth in DFARS 252.227-7014(c)(1)(ii).
*/
#ifndef INCLUDED_DISTI_EVENTS_H
#define INCLUDED_DISTI_EVENTS_H
 
#include "component_base.h"
#include "display.h"
#include "gls_include.h"
#include "group.h"
#include "timer.h"
#include <string>
 
#ifdef __VXWORKS__
#    include <cctype> //tolower
#endif
 
namespace disti
{
/** Enumeration for event types */
typedef enum
{
    EVENT_MOUSE,      /**< A Mouse (or touch screen) event */
    EVENT_KEYBOARD,   /**< A Keyboard event */
    EVENT_TIMER,      /**< Unused */
    EVENT_OBJECT,     /**< An event emitted by an object */
    EVENT_KEYBOARD_UP /**< A Keyboard up event (uses KeyboardEvent class) */
} EventType_e;
 
/** Enumeration for mouse event types */
typedef enum
{
    MOUSE_DOWN,               /**< A Mouse button was pushed down */
    MOUSE_UP,                 /**< A Mouse button was released */
    MOUSE_MOVE,               /**< The mouse moved */
    MOUSE_DRAG,               /**< The mouse moved while a button was held down */
    MOUSE_LEAVE,              /**< The mouse exited the object */
    MOUSE_ENTER,              /**< The mouse entered the object */
    MOUSE_WHEEL_MINUS,        /**< The mouse wheel was turned in the negative direction */
    MOUSE_WHEEL_PLUS,         /**< The mouse wheel was turned in the positive direction */
    MOUSE_RECEIVE_MULTITOUCH, /**< Handle this event to receive input from multiple touches at the same time */
    MOUSE_CANCEL,             /**< Handle this event to interrupt the current mouse event */
    MOUSE_DOUBLE              /**< A Mouse button was pushed down twice */
} MouseEventType_e;
 
/** Enumeration for mouse buttons */
typedef enum
{
    MOUSE_LBUTTON    = 1, /**< Mask that matches only left mouse button */
    MOUSE_MBUTTON    = 2, /**< Mask that matches only middle mouse button */
    MOUSE_RBUTTON    = 4, /**< Mask that matches only right mouse button */
    MOUSE_BUTTON_ANY = 7  /**< Mask that matches any mouse button */
} MouseButtonType_e;
 
/** Enumeration for keyboard modifiers */
typedef enum
{
    NONE_STATE        = 0,
    SHIFT_STATE       = 0x00010000,
    CAPS_LOCK_STATE   = 0x00020000,
    CTRL_STATE        = 0x00040000,
    ALT_STATE         = 0x00080000,
    NUM_LOCK_STATE    = 0x00100000,
    META_STATE        = 0x00400000,
    SCROLL_LOCK_STATE = 0x00800000,
    BUTTON1_STATE     = 0x01000000,
    BUTTON2_STATE     = 0x02000000,
    BUTTON3_STATE     = 0x04000000
} SpecialKeyState_e;
 
/** The base class for all user defined events.
  * Each new class of event is assigned an event type.
  * Each new event is assigned an event subtype
  */
class DisplayEvent
{
public:
    unsigned short eventType;    /**< Major event code. e.g., EVENT_MOUSE */
    unsigned short eventSubtype; /**< Minor event code. e.g., MOUSE_DOWN */
 
    /** Default constructor */
    DisplayEvent()
        : eventType( 0u )
        , eventSubtype( 0u )
    {
    }
 
    /// Copy constructor
    /// \param source The event to copy from.
    DisplayEvent( const DisplayEvent& source )
        : eventType( source.eventType )
        , eventSubtype( source.eventSubtype )
    {
    }
 
    /** Virtual deconstructor to enable RTTI */
    virtual ~DisplayEvent()
    {
    }
};
 
/** An event with location fields */
class LocationEvent : public DisplayEvent
{
public:
    /** Location of the event in window coordinates
      * x and y window coordinates in pixels.
      * z is from 0.0 -> 1.0 and represents the depth.
      * z == 0 is at the near cliping plane.
      * z == 0.5 represents half way between near
      * and far cliping planes.
      */
    Vector winLoc;
 
    /** x,y,z of event in logical design coordinates */
    Vector lCoords;
 
    /** x,y,z of event in object DCS coordinates */
    Vector oCoords;
 
    // These references are included for backwards compatibility with GL Studio 2.1.
    // They are simply references into the above vectors.  New code should not use these!
    float& x; /**< Reference to winLoc.x */
    float& y; /**< Reference to winLoc.y */
    float& z; /**< Reference to winLoc.z */
 
    float& lx; /**< Reference to lCoords.x */
    float& ly; /**< Reference to lCoords.y */
    float& lz; /**< Reference to lCoords.z */
 
    float& ox; /**< Reference to oCoords.x */
    float& oy; /**< Reference to oCoords.y */
    float& oz; /**< Reference to oCoords.z */
 
    /** Because of the use of the references, all automatically generated methods
      * must be defined to allow for copying. */
 
    /** Default constructor */
    LocationEvent()
        : DisplayEvent()
        , x( winLoc.x )
        , y( winLoc.y )
        , z( winLoc.z )
        , lx( lCoords.x )
        , ly( lCoords.y )
        , lz( lCoords.z )
        , ox( oCoords.x )
        , oy( oCoords.y )
        , oz( oCoords.z )
    {
    }
 
    /// Copy Constructor
    /// \param source The event to copy from.
    LocationEvent( const LocationEvent& source )
        : DisplayEvent( source )
        , winLoc( source.winLoc )
        , lCoords( source.lCoords )
        , oCoords( source.oCoords )
        , x( winLoc.x )
        , y( winLoc.y )
        , z( winLoc.z )
        , lx( lCoords.x )
        , ly( lCoords.y )
        , lz( lCoords.z )
        , ox( oCoords.x )
        , oy( oCoords.y )
        , oz( oCoords.z )
    {
    }
 
    /// Assignment operator
    /// \param source The event to copy from.
    /// \return The resulting event (this).
    LocationEvent operator=( const LocationEvent& source )
    {
        eventType    = source.eventType;
        eventSubtype = source.eventSubtype;
        winLoc       = source.winLoc;
        lCoords      = source.lCoords;
        oCoords      = source.oCoords;
        return *this;
    }
};
 
/** A mouse event */
class MouseEvent : public LocationEvent
{
public:
    /** Default Constructor */
    MouseEvent()
        : LocationEvent()
        , buttonMask( 0u )
        , clicks( 0u )
        , modifiers( 0 )
        , cursorID( 0u )
    {
        eventType = EVENT_MOUSE;
    }
 
    /// Copy Constructor
    /// \param source The event to copy from.
    MouseEvent( const MouseEvent& source )
        : LocationEvent( source )
        , buttonMask( source.buttonMask )
        , clicks( source.clicks )
        , modifiers( source.modifiers )
        , cursorID( source.cursorID )
    {
    }
 
    /// Copy Constructor from LocationEvent
    /// \param source The event to copy from.
    MouseEvent( const LocationEvent& source )
        : LocationEvent( source )
        , buttonMask( 0u )
        , clicks( 0u )
        , modifiers( 0 )
        , cursorID( 0u )
    {
        eventType = EVENT_MOUSE;
    }
 
    /// Assignment operator
    /// \param source The event to copy from.
    /// \return The resulting event (this).
    MouseEvent operator=( const MouseEvent& source )
    {
        LocationEvent::operator=( source );
        buttonMask             = source.buttonMask;
        clicks                 = source.clicks;
        modifiers              = source.modifiers;
        cursorID               = source.cursorID;
        return *this;
    }
 
    unsigned char buttonMask; /**< bitfield: which button was pressed for this event */
    unsigned char clicks;     /**< Number of times a button was pressed */
    int           modifiers;  /**< bitfield: which buttons or modifiers were depressed before event \sa SpecialKeyState_e */
    unsigned int  cursorID;   /**< cursor id for multi-touch support */
};
 
/** A keyboard event */
class KeyboardEvent : public LocationEvent
{
public:
    /// Default Constructor
    KeyboardEvent()
        : LocationEvent()
        , keysym( 0 )
        , event_text( 0 )
        , modifiers( 0 )
    {
    }
 
    /// Copy Constructor
    /// \param source The event to copy from.
    KeyboardEvent( const KeyboardEvent& source )
        : LocationEvent( source )
        , keysym( source.keysym )
        , event_text( source.event_text )
        , modifiers( source.modifiers )
    {
    }
 
    /// Copy Constructor from LocationEvent
    /// \param source The event to copy from.
    KeyboardEvent( const LocationEvent& source )
        : LocationEvent( source )
        , keysym( 0 )
        , event_text( 0 )
        , modifiers( 0 )
    {
    }
 
    /// Assignment operator
    /// \param source The event to copy from.
    /// \return The resulting event (this).
    KeyboardEvent operator=( const KeyboardEvent& source )
    {
        LocationEvent::operator=( source );
        keysym                 = source.keysym;
        event_text             = source.event_text;
        modifiers              = source.modifiers;
        return *this;
    }
 
    int keysym;     /**< FLTK code for key that was pressed */
    int event_text; /**< FLTK event text code for key that was pressed */
    int modifiers;  /**< bitfield: which modifiers or buttons were pressed \sa SpecialKeyState_e */
};
 
/** The ObjectEvent class
  * This event is intended to be emitted by objects, rather than by a mouse or keyboard.
  */
class ObjectEvent : public DisplayEvent
{
    DisplayObject* _initiator; /**< The display object that initiated the event */
    char*          _eventName; /**< String event name */
    char*          _eventData; /**< Any additional data for this event.  A NULL terminated string */
 
public:
    ObjectEvent()
        : DisplayEvent()
        , _initiator( NULL )
        , _eventName( NULL )
        , _eventData( NULL )
    {
        eventType = EVENT_OBJECT;
    }
 
    /** Create an ObjectEvent, setting the initator and event name
      * \param initiator  Pointer to the object that initated the event
      * \param eventName  Name of the event
      * \param eventData  Data of the event
      */
    ObjectEvent( DisplayObject* initiator, const char* eventName, const char* eventData = NULL )
        : DisplayEvent()
        , _initiator( initiator )
        , _eventName( NULL )
        , _eventData( NULL )
    {
        int size   = (int)strlen( eventName ) + 1;
        _eventName = new char[ size ];
#if defined( _WIN32 )
        strcpy_s( _eventName, size, eventName );
#else
        strcpy( _eventName, eventName );
#endif
        if( eventData )
        {
            size       = (int)strlen( eventData ) + 1;
            _eventData = new char[ size ];
#if defined( _WIN32 )
            strcpy_s( _eventData, size, eventData );
#else
            strcpy( _eventData, eventData );
#endif
        }
 
        eventType = EVENT_OBJECT;
    }
 
    /** Create an ObjectEvent, setting the initator and event subtype
      * \param initiator Pointer to the object that initated the event
      * \param eventSubtypeArg The arbitrary event subtype
      */
    ObjectEvent( DisplayObject* initiator, unsigned short eventSubtypeArg )
        : DisplayEvent()
        , _initiator( initiator )
        , _eventName( NULL )
        , _eventData( NULL )
    {
        eventType    = EVENT_OBJECT;
        eventSubtype = eventSubtypeArg;
    }
 
    virtual ~ObjectEvent()
    {
        delete[] _eventName;
        _eventName = NULL;
 
        delete[] _eventData;
        _eventData = NULL;
    }
 
    /** \return Pointer to the object that initiated the event (may be NULL)
      */
    DisplayObject* Initiator() const { return _initiator; }
 
    /** Set which object initiated the event
      * \param initiator  Pointer to the object that initiated the event
      */
    void Initiator( DisplayObject* initiator ) { _initiator = initiator; }
 
    /** \return The name of the event
      */
    const char* EventName() const
    {
        if( _eventName )
        {
            return _eventName;
        }
        else
        {
            return "";
        }
    }
 
    /** Set the name of the event
      * For CRT safety, this should only be called by the constructing code
      * \param newName  The name to set
      */
    void EventName( const char* newName )
    {
        delete[] _eventName;
        _eventName = NULL;
 
        if( newName )
        {
            int size   = (int)strlen( newName ) + 1;
            _eventName = new char[ size ];
#if defined( _WIN32 )
            strcpy_s( _eventName, size, newName );
#else
            strcpy( _eventName, newName );
#endif
        }
    }
 
    /** \return The data of the event, NULL terminated
      */
    const char* EventData() const
    {
        if( _eventData )
        {
            return _eventData;
        }
        else
        {
            return "";
        }
    }
 
    /** Set the data of the event, NULL terminated.
      * For CRT safety, this should only be called by the constructing code
      * \param newData The name to set
      */
    void EventData( const char* newData )
    {
        delete[] _eventData;
        _eventData = NULL;
 
        if( newData )
        {
            int size   = (int)strlen( newData ) + 1;
            _eventData = new char[ size ];
#if defined( _WIN32 )
            strcpy_s( _eventData, size, newData );
#else
            strcpy( _eventData, newData );
#endif
        }
    }
 
    /// \param eventName The name to compare.
    /// \return True if the name of this event matches the given name.
    bool EventNameIs( const char* eventName ) const
    {
        if( !_eventName || !eventName )
        {
            return false;
        }
 
        return ( 0 == strcmp( _eventName, eventName ) );
    }
 
    /// \param eventData The name to compare.
    /// \return True if the name of this event matches the given name.
    bool EventDataIs( const char* eventData ) const
    {
        if( !_eventData || !eventData )
        {
            return false;
        }
 
        return ( 0 == strcmp( _eventData, eventData ) );
    }
};
 
/// Emits the specfied ObjectEvent.
/// \param self The object emitting the event.
/// \param event A complete ObjectEvent object to emit.
inline void EmitObjectEvent( DisplayObject* self, ObjectEvent* event )
{
    if( self->ParentGroup() )
    {
        self->ParentGroup()->handle( event );
    }
    else if( dynamic_cast<ComponentBase*>( self ) )
    {
        // Called when our ParentGroup is NULL and we are wrapped by an RSO Interface.
        self->handle( event );
    }
}
 
/// Creates an ObjectEvent from the given NULL terminated strings and emits it.
/// \param self The object emitting the event.
/// \param eventName The name of the event e.g. "StateChanged".
/// \param eventData Optional additional user data.
inline void EmitObjectEvent( DisplayObject* self, const char* eventName, const char* eventData = NULL )
{
    ObjectEvent temp( self, eventName, eventData );
    EmitObjectEvent( self, &temp );
}
 
/** \return true if the given DisplayEvent is an ObjectEvent and it's event name matches the given string.
  * \param event  The event to check
  * \param eventName  The eventName to compare
  * \param eventData optional eventData to compare, if NULL, it will not be checked, otherwise, it will.
  */
inline bool ObjectEventIs( DisplayEvent* event, const char* eventName, const char* eventData = NULL )
{
    ObjectEvent* objEvent = dynamic_cast<ObjectEvent*>( event );
    bool         is       = ( objEvent && objEvent->EventNameIs( eventName ) );
    if( is && eventData )
    {
        is = objEvent->EventDataIs( eventData );
    }
    return is;
}
 
/** Basic on event test, given the event and subevent enums. */
#define ON( event, subevent ) if( ( ev->eventType == ( event ) ) && ( ev->eventSubtype == ( subevent ) ) )
 
/** On mouse button up event test, given the mouse button enum. */
#define ON_MOUSE_UP( btnMask ) if( ( ev->eventType == EVENT_MOUSE ) && ( ev->eventSubtype == MOUSE_UP ) && ( (btnMask)&mev->buttonMask ) )
 
/** On mouse button down event test, given the mouse button enum. */
#define ON_MOUSE_DOWN( btnMask ) if( ( ev->eventType == EVENT_MOUSE ) && ( ev->eventSubtype == MOUSE_DOWN ) && ( (btnMask)&mev->buttonMask ) )
 
/** On mouse button held during a drag event test, given the mouse button enum. */
#define ON_MOUSE_DRAG( btnMask ) if( ( ev->eventType == EVENT_MOUSE ) && ( ev->eventSubtype == MOUSE_DRAG ) && ( (btnMask)&mev->buttonMask ) )
 
/** On keyboard key down event test, given the alpha numeric key to test. */
#define ON_KEY_DOWN( testKey ) if( ( ev->eventType == EVENT_KEYBOARD ) && OnKeyEvent( kev, true, int( testKey ) ) )
 
/** On keyboard key up event test, given the alpha numeric key to test. */
#define ON_KEY_UP( testKey ) if( ( ev->eventType == EVENT_KEYBOARD_UP ) && OnKeyEvent( kev, true, int( testKey ) ) )
 
/** On keyboard key down with modifiers event test, given the alpha numeric key and modifiers to test. */
#define ON_KEY_DOWN_WITH_MODIFIER( testKey, modifierMask ) if( ( ev->eventType == EVENT_KEYBOARD ) && OnKeyEvent( kev, true, int( testKey ), modifierMask ) )
 
/** On keyboard key up with modifiers event test, given the alpha numeric key and modifiers to test. */
#define ON_KEY_UP_WITH_MODIFIER( testKey, modifierMask ) if( ( ev->eventType == EVENT_KEYBOARD_UP ) && OnKeyEvent( kev, true, int( testKey ), modifierMask ) )
 
/** On keyboard key down event test, given the special key to test. */
#define ON_SPECIAL_KEY_DOWN( keySym ) if( ( ev->eventType == EVENT_KEYBOARD ) && OnKeyEvent( kev, false, int( keySym ) ) )
 
/** On keyboard key up event test, given the special key to test. */
#define ON_SPECIAL_KEY_UP( keySym ) if( ( ev->eventType == EVENT_KEYBOARD_UP ) && OnKeyEvent( kev, false, int( keySym ) ) )
 
/** On keyboard key down with modifiers event test, given the special key and modifiers to test. */
#define ON_SPECIAL_KEY_DOWN_WITH_MODIFIER( keySym, modifierMask ) if( ( ev->eventType == EVENT_KEYBOARD ) && OnKeyEvent( kev, false, int( keySym ), modifierMask ) )
 
/** On keyboard key up with modifiers event test, given the special key and modifiers to test. */
#define ON_SPECIAL_KEY_UP_WITH_MODIFIER( keySym, modifierMask ) if( ( ev->eventType == EVENT_KEYBOARD_UP ) && OnKeyEvent( kev, false, int( keySym ), modifierMask ) )
 
/** On keyboard key down event test. */
#define ON_ANY_KEY_DOWN() if( ( ev->eventType == EVENT_KEYBOARD ) )
 
/** On keyboard key up event test. */
#define ON_ANY_KEY_UP() if( ( ev->eventType == EVENT_KEYBOARD_UP ) )
 
/** Examples:
  *     ON( EVENT_MOUSE, MOUSE_DOWN )
  *     {
  *     }
  *     ON_MOUSE_DOWN( MOUSE_LBUTTON )
  *     {
  *     }
  *     ON_KEY_DOWN( 'a' )
  *     {
  *     }
  *     ON_KEY_DOWN_WITH_MODIFIER( 'B', FL_SHIFT )
  *     {
  *     }
  *     ON_KEY_DOWN_WITH_MODIFIER( 'c', FL_SHIFT | FL_CTRL )
  *     {
  *     }
  *     ON_SPECIAL_KEY_DOWN( FL_KP+'1' )
  *     {
  *     }
  *     ON_SPECIAL_KEY_DOWN_WITH_MODIFIER( FL_F+1, FL_CTRL )
  *     {
  *     }
  *     For a comprehensive list of keys and modifiers refer to Enumerations.H.
  */
 
/// A convenience function to compare a KeyboardEvent against a particular keyboard key / modifier combo.
/// \param kev The KeyboardEvent to check.
/// \param alphaNumeric Whether or not to try to compare to kev->event_text versus kev->keysym.
/// \param key The key to look for in the event.
/// \param modifierMask Any modifiers to look for in the event.
/// \return True if the incoming key event matches the other incoming parameters.
inline bool OnKeyEvent( KeyboardEvent* kev, bool alphaNumeric, int key, int modifierMask = 0 )
{
    bool keySuccess = false;
 
    if( alphaNumeric )
    {
        /** If CTRL is expected we need to look at keysym instead.
          * Because CTRL changes the output of the key press to something unexpected
          * we need to check against the key press action instead. 
          */
        if( CTRL_STATE & modifierMask )
        {
            /** keysym is always lowercase */
            key        = std::tolower( key );
            keySuccess = ( key == kev->keysym );
        }
        else
        {
            keySuccess = ( key == kev->event_text );
        }
    }
    else
    {
        keySuccess = ( key == kev->keysym );
    }
 
    /** Compare to zero to avoid performance warnings. 
      * Did we find the modifiers we're looking for (modifierMask) in the modifiers currently pressed (kev->modifiers)?
      * OR Are we not looking for any modifiers AND none of the modifiers are currently pressed?
      * (ignoring the lock state and mouse button modifiers)
      */
    bool modSuccess = ( 0 != ( modifierMask & kev->modifiers ) || ( 0 == modifierMask && 0 == ( int( SHIFT_STATE | CTRL_STATE | ALT_STATE | META_STATE ) & kev->modifiers ) ) );
 
    return ( keySuccess && modSuccess );
}
 
template<class T>
/** Event Compressor */
class EventCompressor
{
public:
    typedef DisplayObject* ( T::*EventSenderCbType )( DisplayEvent* ev ); ///< Typedef for a event callback function pointer.
 
protected:
    MouseEvent        _lastCompressedEvent;    ///< The result of event compression, i.e. what all the other events boiled down to.
    bool              _lastEventWasCompressed; ///< If true, the event we're passing along was compressed.
    EventSenderCbType _handleCb;               ///< The callback function that will process this event.
    T*                _objectPtr;              ///< The object containing the callback function.
    bool              _sendingCompressed;      ///< Flag set to avoid compressing an already compressed event (infinite loop).
    bool              _active;                 ///< If active, events will be compressed, i.e. multiple MOUSE_DRAG will be boiled down to one equivalent MOUSE_DRAG.
 
public:
    /// Set the current active state for event compression.
    /// \param val The new active state to set.
    void Active( bool val ) { _active = val; }
 
    /// \return The current active state of event compression.
    bool Active() { return _active; }
 
    /// Construct a new EventCompressor object to compress events for the given object.
    /// \param objectPtr The object to receive compressed events, contains the callback function.
    /// \param cb The callback function to receive compressed events.
    EventCompressor( T* objectPtr, EventSenderCbType cb )
        : _lastEventWasCompressed( false )
        , _handleCb( cb )
        , _objectPtr( objectPtr )
        , _sendingCompressed( false )
        , _active( true )
    {
    }
 
    /// Caller should stop processing this event if returns true
    /// Caller *MUST* call SendAnyCompressedEvents() before
    /// drawing to make sure any saved events are processed.
    /// \param ev The event to compress.
    /// \return True if event was compressed.
    bool CompressEvent( const DisplayEvent& ev )
    {
        if( !_active || _sendingCompressed )
        {
            return false;
        }
 
        bool compressed = false;
        if( EVENT_MOUSE == ev.eventType && ( MOUSE_MOVE == ev.eventSubtype || MOUSE_DRAG == ev.eventSubtype ) )
        {
            MouseEvent* mev = (MouseEvent*)&ev;
 
            if( !_lastEventWasCompressed || ( _lastEventWasCompressed && _lastCompressedEvent.eventType == ev.eventType && _lastCompressedEvent.eventSubtype == ev.eventSubtype && _lastCompressedEvent.cursorID == mev->cursorID ) )
            {
                // Replace with this event, and don't send
                _lastCompressedEvent    = *mev;
                _lastEventWasCompressed = true;
                compressed              = true;
            }
        }
 
        // If we did not compress the event, send any pending ones.
        if( !compressed )
        {
            SendAnyCompressedEvents();
        }
        return compressed;
    }
 
    /// Passes along the resulting compressed event to the target object's callback function.
    void SendAnyCompressedEvents()
    {
        // Avoids infinite loop
        if( _sendingCompressed )
        {
            return;
        }
 
        if( _lastEventWasCompressed )
        {
            _sendingCompressed = true;
            // Call the callback
            ( _objectPtr->*( _handleCb ) )( &_lastCompressedEvent );
            // The event is no longer valid
            _sendingCompressed = false;
 
            _lastEventWasCompressed = false;
        }
    }
};
 
} // namespace disti
 
#endif // INCLUDED_DISTI_EVENTS_H