xrb_event.hpp

// ///////////////////////////////////////////////////////////////////////////
// xrb_event.hpp by Victor Dods, created 2004/09/11
// ///////////////////////////////////////////////////////////////////////////
// Unless a different license was explicitly granted in writing by the
// copyright holder (Victor Dods), this software is freely distributable under
// the terms of the GNU General Public License, version 2.  Any works deriving
// from this work must also be released under the GNU GPL.  See the included
// file LICENSE for details.
// ///////////////////////////////////////////////////////////////////////////

#if !defined(_XRB_EVENT_HPP_)
#define _XRB_EVENT_HPP_

#include "xrb.hpp"

#include "xrb_key.hpp"
#include "xrb_screencoord.hpp"

namespace Xrb
{

class Event
{
public:

    enum EventType
    {
        DUMMY = 0,
        KEYDOWN,
        KEYUP,
        KEYREPEAT,
        MOUSEBUTTONDOWN,
        MOUSEBUTTONUP,
        MOUSEWHEEL,
        MOUSEMOTION,
        JOYAXIS,
        JOYBALL,
        JOYBUTTONDOWN,
        JOYBUTTONUP,
        JOYHAT,
        FOCUS,
        MOUSEOVER,
        DELETE_CHILD_WIDGET,
        QUIT,
        STATE_MACHINE_INPUT,
        ENGINE2_DELETE_ENTITY,
        ENGINE2_REMOVE_ENTITY_FROM_WORLD,
        CUSTOM
    }; // end of enum Event::EventType

    inline Event (Float time, EventType event_type)
    {
        ASSERT1(time >= 0.0);
        m_time = time;
        m_event_type = event_type;
        m_id = 0;
        m_is_scheduled_for_deletion = false;
    }
    virtual ~Event () = 0;

    static std::string const &Name (EventType event_type);
    inline Float Time () const { return m_time; }
    inline EventType GetEventType () const { return m_event_type; }
    inline Uint32 ID () const { return m_id; }
    inline bool IsScheduledForDeletion () const { return m_is_scheduled_for_deletion; }
    virtual bool IsInputEvent () const { return false; }
    virtual bool IsKeyEvent () const { return false; }
    virtual bool IsMouseEvent () const { return false; }
    virtual bool IsMouseButtonEvent () const { return false; }
    virtual bool IsMouseMotionEvent () const { return false; }
    virtual bool IsJoyEvent () const { return false; }

private:

    inline void SetID (Uint32 id) const { m_id = id; }

    inline void ScheduleForDeletion () const { m_is_scheduled_for_deletion = true; }

    Float m_time;
    EventType m_event_type;
    mutable Uint32 m_id;
    mutable bool m_is_scheduled_for_deletion;

    friend class EventQueue;
}; // end of class Event

class EventStateMachineInput : public Event
{
public:

    EventStateMachineInput (StateMachineInput input, Float time)
        :
        Event(time, STATE_MACHINE_INPUT),
        m_input(input)
    { }

    inline StateMachineInput GetInput () const { return m_input; }

private:

    StateMachineInput const m_input;
}; // end of class EventStateMachineInput

class EventCustom : public Event
{
public:

    typedef Uint16 CustomType;

    EventCustom (CustomType custom_type, Float time)
        :
        Event(time, CUSTOM),
        m_custom_type(custom_type)
    { }
    virtual ~EventCustom () = 0;

    inline CustomType GetCustomType () const { return m_custom_type; }

private:

    CustomType const m_custom_type;
}; // end of class EventCustom

// skip documenting this class
class EventDummy : public Event
{
private:

    EventDummy (Float time) : Event(time, DUMMY) { }
    ~EventDummy () { }

    friend class EventQueue;
}; // end of class EventDummy

// ///////////////////////////////////////////////////////////////////////////
// event-matching functions for use in EventQueue
// ///////////////////////////////////////////////////////////////////////////

bool MatchEventType (Event const *event, Event::EventType event_type);
bool MatchCustomType (Event const *event, EventCustom::CustomType custom_type);

} // end of namespace Xrb

#endif // !defined(_XRB_EVENT_HPP_)

---