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