events.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef COMMON_EVENTS_H
#define COMMON_EVENTS_H
 
#include "common/keyboard.h"
#include "common/path.h"
#include "common/queue.h"
#include "common/rect.h"
#include "common/noncopyable.h"
 
#include "common/list.h"
#include "common/singleton.h"
 
namespace Common {
 
enum EventType {
    EVENT_INVALID = 0,
    EVENT_KEYDOWN = 1,
    EVENT_KEYUP = 2,
    EVENT_MOUSEMOVE = 3,
    EVENT_LBUTTONDOWN = 4,
    EVENT_LBUTTONUP = 5,
    EVENT_RBUTTONDOWN = 6,
    EVENT_RBUTTONUP = 7,
    EVENT_WHEELUP = 8,
    EVENT_WHEELDOWN = 9,
    EVENT_MBUTTONDOWN = 13,
    EVENT_MBUTTONUP = 14,
 
    EVENT_MAINMENU = 15,
    EVENT_RETURN_TO_LAUNCHER = 16,
    EVENT_MUTE = 17,
 
    EVENT_QUIT = 10,
    EVENT_SCREEN_CHANGED = 11,
 
    EVENT_INPUT_CHANGED  = 35,
 
    EVENT_PREDICTIVE_DIALOG = 12,
 
    EVENT_CUSTOM_BACKEND_ACTION_START = 18,
    EVENT_CUSTOM_BACKEND_ACTION_END   = 19,
    EVENT_CUSTOM_BACKEND_ACTION_AXIS  = 34,
    EVENT_CUSTOM_ENGINE_ACTION_START  = 20,
    EVENT_CUSTOM_ENGINE_ACTION_END    = 21,
 
    EVENT_VIRTUAL_KEYBOARD = 22,
 
    EVENT_DROP_FILE = 23,
 
    EVENT_JOYAXIS_MOTION = 24,
    EVENT_JOYBUTTON_DOWN = 25,
    EVENT_JOYBUTTON_UP = 26,
 
    EVENT_CLIPBOARD_UPDATE = 27,
 
    EVENT_CUSTOM_BACKEND_HARDWARE = 28,
    EVENT_DEBUGGER = 29,
 
    EVENT_X1BUTTONDOWN = 30,
    EVENT_X1BUTTONUP = 31,
    EVENT_X2BUTTONDOWN = 32,
    EVENT_X2BUTTONUP = 33,
 
    EVENT_FOCUS_GAINED = 36,
    EVENT_FOCUS_LOST = 37,
 
    EVENT_HOTSPOTS_SHOW = 38,
    EVENT_HOTSPOTS_HIDE = 39,
 
    EVENT_USER_FIRST_AVAILABLE = 1000,
    EVENT_USER_LAST_AVAILABLE = 9999
};
 
const int16 JOYAXIS_MIN = -32768;
const int16 JOYAXIS_MAX = 32767;
 
struct JoystickState {
    byte axis;
    int16 position;
    uint8 button;
 
    JoystickState() : axis(0), position(0), button(0) {}
};
 
enum JoystickButton {
    JOYSTICK_BUTTON_INVALID,
    JOYSTICK_BUTTON_A,
    JOYSTICK_BUTTON_B,
    JOYSTICK_BUTTON_X,
    JOYSTICK_BUTTON_Y,
    JOYSTICK_BUTTON_BACK,
    JOYSTICK_BUTTON_GUIDE,
    JOYSTICK_BUTTON_START,
    JOYSTICK_BUTTON_LEFT_STICK,
    JOYSTICK_BUTTON_RIGHT_STICK,
    JOYSTICK_BUTTON_LEFT_SHOULDER,
    JOYSTICK_BUTTON_RIGHT_SHOULDER,
    JOYSTICK_BUTTON_DPAD_UP,
    JOYSTICK_BUTTON_DPAD_DOWN,
    JOYSTICK_BUTTON_DPAD_LEFT,
    JOYSTICK_BUTTON_DPAD_RIGHT,
    JOYSTICK_BUTTON_DPAD_CENTER
};
 
enum JoystickAxis {
    JOYSTICK_AXIS_LEFT_STICK_X,
    JOYSTICK_AXIS_LEFT_STICK_Y,
    JOYSTICK_AXIS_RIGHT_STICK_X,
    JOYSTICK_AXIS_RIGHT_STICK_Y,
    JOYSTICK_AXIS_LEFT_TRIGGER,
    JOYSTICK_AXIS_RIGHT_TRIGGER,
    JOYSTICK_AXIS_HAT_X,
    JOYSTICK_AXIS_HAT_Y
};
 
enum MouseButton {
    MOUSE_BUTTON_LEFT   = 0,
    MOUSE_BUTTON_RIGHT  = 1,
    MOUSE_BUTTON_MIDDLE = 2,
    MOUSE_WHEEL_UP      = 3,
    MOUSE_WHEEL_DOWN    = 4,
    MOUSE_BUTTON_X1     = 5,
    MOUSE_BUTTON_X2     = 6
};
typedef uint32 CustomEventType;
 
struct Event {
 
    EventType type;
 
    bool kbdRepeat;
 
    KeyState kbd;
 
    Point mouse;
 
    CustomEventType customType;
 
    Common::Path path;
 
    Common::Point relMouse;
 
    JoystickState joystick;
 
    Event() : type(EVENT_INVALID), kbdRepeat(false), customType(0) {
    }
};
 
bool isMouseEvent(const Event &event);
 
class EventSource {
public:
    virtual ~EventSource();
 
    virtual bool pollEvent(Event &event) = 0;
 
    virtual bool allowMapping() const { return true; }
};
 
class ArtificialEventSource : public EventSource {
protected:
    Queue<Event> _artificialEventQueue;
public:
    void addEvent(const Event &ev) {
        _artificialEventQueue.push(ev);
    }
 
    bool pollEvent(Event &ev) override {
        if (!_artificialEventQueue.empty()) {
            ev = _artificialEventQueue.pop();
            return true;
        } else {
            return false;
        }
    }
 
    bool allowMapping() const override { return false; }
};
 
class EventObserver {
public:
    virtual ~EventObserver();
 
    virtual bool notifyEvent(const Event &event) = 0;
 
    virtual void notifyPoll() { }
};
 
class EventMapper {
public:
    virtual ~EventMapper();
 
    virtual bool mapEvent(const Event &ev, List<Event> &mappedEvents) = 0;
};
 
class EventDispatcher {
public:
    EventDispatcher();
    ~EventDispatcher();
 
    void dispatch();
 
    void clearEvents();
 
    void registerMapper(EventMapper *mapper, bool autoFree);
 
    void unregisterMapper(EventMapper *mapper);
 
    void registerSource(EventSource *source, bool autoFree);
 
    void unregisterSource(EventSource *source);
 
    void ignoreSources(bool ignore);
 
    void registerObserver(EventObserver *obs, uint priority, bool autoFree, bool listenPolls = false);
 
    void unregisterObserver(EventObserver *obs);
private:
    struct Entry {
        bool autoFree;
        bool ignore;
    };
 
    struct MapperEntry : public Entry {
        EventMapper *mapper;
    };
 
    List<MapperEntry> _mappers;
 
    struct SourceEntry : public Entry {
        EventSource *source;
    };
 
    List<SourceEntry> _sources;
 
    struct ObserverEntry : public Entry {
        uint priority;
        EventObserver *observer;
        bool poll;
    };
 
    List<ObserverEntry> _observers;
 
    void dispatchEvent(const Event &event);
    void dispatchPoll();
};
 
class Keymap;
class Keymapper;
 
class EventManager : NonCopyable {
public:
    virtual ~EventManager();
 
    enum {
        LBUTTON = 1 << MOUSE_BUTTON_LEFT,
        RBUTTON = 1 << MOUSE_BUTTON_RIGHT
    };
 
 
    virtual void init() {}
 
    virtual bool pollEvent(Event &event) = 0;
 
    virtual void pushEvent(const Event &event) = 0;
 
    virtual void purgeMouseEvents() = 0;
 
    virtual void purgeKeyboardEvents() = 0;
 
    virtual Point getMousePos() const = 0;
 
    virtual int getButtonState() const = 0;
 
    virtual int getModifierState() const = 0;
 
    virtual int shouldQuit() const = 0;
 
    virtual int shouldReturnToLauncher() const = 0;
 
    virtual void resetReturnToLauncher() = 0;
    virtual void resetQuit() = 0;
    // Optional: check whether a given key is currently pressed ????
    //virtual bool isKeyPressed(int keycode) = 0;
 
    // TODO: Keyboard repeat support?
 
    // TODO: Consider removing OSystem::getScreenChangeID and
    // replacing it by a generic getScreenChangeID method here
    virtual Keymapper *getKeymapper() = 0;
    virtual Keymap *getGlobalKeymap() = 0;
 
    enum {
        kEventManPriority = 0,
        kEventRecorderPriority = 1,
        kEventRemapperPriority = 999
    };
 
    EventDispatcher *getEventDispatcher() { return &_dispatcher; }
 
protected:
    EventDispatcher _dispatcher;
};
 
EventSource *makeKeyboardRepeatingEventSource(EventSource *eventSource);
 
} // End of namespace Common
 
#endif