xrb_input_events.hpp

// ///////////////////////////////////////////////////////////////////////////
// xrb_input_events.hpp by Victor Dods, created 2005/11/06
// ///////////////////////////////////////////////////////////////////////////
// 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_INPUT_EVENTS_HPP_)
#define _XRB_INPUT_EVENTS_HPP_

#include "xrb.hpp"

#include "xrb_event.hpp"

namespace Xrb
{

class EventInput : public Event
{
public:

    EventInput (Float time, EventType event_type)
        :
        Event(time, event_type)
    { }
    virtual ~EventInput () = 0;

    virtual bool IsInputEvent () const { return true; }
};

class EventKey : public EventInput
{
public:

    EventKey (Key::Code code, Key::Modifier modifier, Float time, EventType event_type);
    virtual ~EventKey () = 0;

    virtual bool IsKeyEvent () const { return true; }
    Key::Code KeyCode () const { return m_code; }
    Key::Modifier KeyModifier () const { return m_modifier; }
    inline bool IsEitherAltKeyPressed () const
    {
        return (m_modifier & Key::MOD_ALT) != 0;
    }
    inline bool IsEitherControlKeyPressed () const
    {
        return (m_modifier & Key::MOD_CTRL) != 0;
    }
    inline bool IsEitherShiftKeyPressed () const
    {
        return (m_modifier & Key::MOD_SHIFT) != 0;
    }
    char ModifiedAscii () const { return m_modified_ascii; }
    virtual bool IsKeyDownEvent () const { return false; }
    virtual bool IsKeyUpEvent () const { return false; }
    virtual bool IsKeyRepeatEvent () const { return false; }

private:

    // the keycode (e.g. A, NUMLOCK, CTRL)
    Key::Code m_code;
    // the key modifier (e.g. left-alt)
    Key::Modifier m_modifier;
    // the ascii code of the keypress modified by caps and num lock
    char m_modified_ascii;
}; // end of class EventKey

class EventKeyDown : public EventKey
{
public:

    EventKeyDown (
        Key::Code code,
        Key::Modifier modifier,
        Float time)
        :
        EventKey(code, modifier, time, KEYDOWN)
    { }
    virtual ~EventKeyDown () { }

    virtual bool IsKeyDownEvent () const { return true; }
}; // end of class EventKeyDown

class EventKeyUp : public EventKey
{
public:

    EventKeyUp (
        Key::Code code,
        Key::Modifier modifier,
        Float time)
        :
        EventKey(code, modifier, time, KEYUP)
    { }
    virtual ~EventKeyUp () { }

    virtual bool IsKeyUpEvent () const { return true; }
}; // end of class EventKeyUp

class EventKeyRepeat : public EventKey
{
public:

    EventKeyRepeat (
        Key::Code code,
        Key::Modifier modifier,
        Float const time)
        :
        EventKey(code, modifier, time, KEYREPEAT)
    { }
    virtual ~EventKeyRepeat () { }

    virtual bool IsKeyRepeatEvent () const { return true; }
}; // end of class EventKeyRepeat

class EventMouse : public EventInput
{
public:

    EventMouse (
        ScreenCoordVector2 const &position,
        Key::Modifier modifier,
        Float time,
        EventType event_type);
    virtual ~EventMouse () = 0;

    virtual bool IsMouseEvent () const { return true; }
    ScreenCoordVector2 const &Position () const { return m_position; }
    inline bool IsEitherAltKeyPressed () const
    {
        return (m_modifier & Key::MOD_ALT) != 0;
    }
    inline bool IsEitherControlKeyPressed () const
    {
        return (m_modifier & Key::MOD_CTRL) != 0;
    }
    inline bool IsEitherShiftKeyPressed () const
    {
        return (m_modifier & Key::MOD_SHIFT) != 0;
    }
    inline bool IsCapsLockOn () const
    {
        return (m_modifier & Key::MOD_CAPS) != 0;
    }
    inline bool IsNumLockOn () const
    {
        return (m_modifier & Key::MOD_NUM) != 0;
    }

private:

    // the mouse button position in screen coordinates
    ScreenCoordVector2 m_position;
    // the metakey modifier flags for this event
    Key::Modifier m_modifier;
}; // end of class EventMouse

class EventMouseButton : public EventMouse
{
public:

    EventMouseButton (
        Key::Code button_code,
        ScreenCoordVector2 const &position,
        Key::Modifier modifier,
        Float time,
        EventType event_type);
    virtual ~EventMouseButton () = 0;

    Key::Code ButtonCode () const { return m_button_code; }
    virtual bool IsMouseButtonEvent () const { return true; }
    virtual bool IsMouseButtonDownEvent () const { return false; }
    virtual bool IsMouseButtonUpEvent () const { return false; }

private:

    Key::Code m_button_code;
}; // end of class EventMouseButton

class EventMouseButtonDown : public EventMouseButton
{
public:

    EventMouseButtonDown (
        Key::Code button_code,
        ScreenCoordVector2 const &position,
        Key::Modifier modifier,
        Float time)
        :
        EventMouseButton(button_code, position, modifier, time, MOUSEBUTTONDOWN)
    { }
    virtual ~EventMouseButtonDown () { }

    virtual bool IsMouseButtonDownEvent () const { return true; }
}; // end of class EventMouseButtonDown

class EventMouseButtonUp : public EventMouseButton
{
public:

    EventMouseButtonUp (
        Key::Code button_code,
        ScreenCoordVector2 const &position,
        Key::Modifier modifier,
        Float time)
        :
        EventMouseButton(button_code, position, modifier, time, MOUSEBUTTONUP)
    { }
    virtual ~EventMouseButtonUp () { }

    virtual bool IsMouseButtonUpEvent () const { return true; }
}; // end of class EventMouseButtonUp

class EventMouseWheel : public EventMouseButton
{
public:

    EventMouseWheel (
        Key::Code button_code,
        ScreenCoordVector2 const &position,
        Key::Modifier modifier,
        Float time)
        :
        EventMouseButton(button_code, position, modifier, time, MOUSEWHEEL)
    { }
    virtual ~EventMouseWheel () { }
};

class EventMouseMotion : public EventMouse
{
public:

    EventMouseMotion (
        bool is_left_mouse_button_pressed,
        bool is_middle_mouse_button_pressed,
        bool is_right_mouse_button_pressed,
        ScreenCoordVector2 const &position,
        ScreenCoordVector2 const &delta,
        Key::Modifier modifier,
        Float time);
    virtual ~EventMouseMotion () { }

    virtual bool IsMouseMotionEvent () const { return true; }
    ScreenCoordVector2 const &Delta () const { return m_delta; }
    bool IsLeftMouseButtonPressed () const { return m_is_left_mouse_button_pressed; }
    bool IsMiddleMouseButtonPressed () const { return m_is_middle_mouse_button_pressed; }
    bool IsRightMouseButtonPressed () const { return m_is_right_mouse_button_pressed; }

private:

    bool m_is_left_mouse_button_pressed;
    bool m_is_middle_mouse_button_pressed;
    bool m_is_right_mouse_button_pressed;
    // the mouse motion delta in screen coordinates
    ScreenCoordVector2 m_delta;
}; // end of class EventMouseMotion

class EventJoy : public EventInput
{
public:

    EventJoy (Float time, EventType event_type) : EventInput(time, event_type) { }
    virtual ~EventJoy () = 0;

    virtual bool IsJoyEvent () const { return true; }
}; // end of class EventJoy

class EventQuit : public Event
{
public:

    EventQuit (Float time) : Event(time, QUIT) { }
}; // end of class EventQuit

} // end of namespace Xrb

#endif // !defined(_XRB_INPUT_EVENTS_HPP_)

---