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 ULTIMA_SHARED_ENGINE_EVENTS_H
#define ULTIMA_SHARED_ENGINE_EVENTS_H

#include "common/scummsys.h"
#include "common/events.h"
#include "common/stack.h"
#include "gui/debugger.h"
#include "graphics/screen.h"
#include "ultima/shared/core/rect.h"

namespace Ultima {
namespace Shared {

#define GAME_FRAME_RATE (1000 / 50)
#define GAME_FRAME_TIME 50
#define SCREEN_UPDATE_TIME 10
#define BUTTON_MASK(MB) (1 << ((int)(MB) - 1))
#define DOUBLE_CLICK_TIME 100

enum MouseButton {
    BUTTON_NONE = 0,
    BUTTON_LEFT = 1,
    BUTTON_RIGHT = 2,
    BUTTON_MIDDLE = 3,
    MOUSE_LAST
};

enum SpecialButtons {
    MK_LBUTTON = 1, MK_RBUTTON = 2, MK_MBUTTON = 4, MK_SHIFT = 8, MK_CONTROL = 0x10
};

class EventTarget {
public:
    virtual ~EventTarget() {
    }

    virtual void onIdle() {
    }

    virtual void mouseMove(const Common::Point &mousePos) {
    }
    virtual void leftButtonDown(const Common::Point &mousePos) {
    }
    virtual void leftButtonUp(const Common::Point &mousePos) {
    }
    virtual void leftButtonDoubleClick(const Common::Point &mousePos) {
    }
    virtual void middleButtonDown(const Common::Point &mousePos) {
    }
    virtual void middleButtonUp(const Common::Point &mousePos) {
    }
    virtual void middleButtonDoubleClick(const Common::Point &mousePos) {
    }
    virtual void rightButtonDown(const Common::Point &mousePos) {
    }
    virtual void rightButtonUp(const Common::Point &mousePos) {
    }
    virtual void mouseWheel(const Common::Point &mousePos, bool wheelUp) {
    }
    virtual void keyDown(Common::KeyState keyState) {
    }
    virtual void keyUp(Common::KeyState keyState) {
    }
};

class CPressTarget : public EventTarget {
public:
    bool _pressed;
public:
    CPressTarget() : _pressed(false) {
    }
    ~CPressTarget() override {
    }
    void leftButtonDown(const Common::Point &mousePos) override {
        _pressed = true;
    }
    void middleButtonDown(const Common::Point &mousePos) override {
        _pressed = true;
    }
    void rightButtonDown(const Common::Point &mousePos) override {
        _pressed = true;
    }
    void keyDown(Common::KeyState keyState) override {
        _pressed = true;
    }
};

class EventsCallback {
public:
    virtual ~EventsCallback() {}

    virtual Graphics::Screen *getScreen() const {
        return nullptr;
    }
};

class EventsManager {
private:
    EventsCallback *_callback;
    Common::Stack<EventTarget *> _eventTargets;
    uint32 _frameCounter;
    uint32 _priorFrameTime;
    uint32 _priorFrameCounterTime;
    uint32 _gameCounter;
    uint32 _playTime;
    Point _mousePos;
    uint _specialButtons;
    uint8  _buttonsDown;

    bool checkForNextFrameCounter();

    EventTarget *eventTarget() const {
        return _eventTargets.top();
    }

    void handleKbdSpecial(Common::KeyState keyState);

    void setButtonDown(MouseButton button, bool isDown);
protected:
    virtual void nextFrame();
public:
    EventsManager(EventsCallback *callback);
    virtual ~EventsManager() {}

    void addTarget(EventTarget *target) {
        _eventTargets.push(target);
    }

    void removeTarget() {
        _eventTargets.pop();
    }

    virtual bool pollEvent(Common::Event &event);

    void pollEvents();

    void pollEventsAndWait();

    uint32 getFrameCounter() const {
        return _frameCounter;
    }

    uint32 getTicksCount() const;

    void sleep(uint time);

    bool waitForPress(uint expiry);

    void setMousePos(const Point &pt);

    /*
     * Return whether a given special key is currently pressed
     */
    bool isSpecialPressed(SpecialButtons btn) const {
        return (_specialButtons & btn) != 0;
    }

    uint getSpecialButtons() const {
        return _specialButtons;
    }

    /*
     * Set the cursor
     */
    virtual void setCursor(int cursorId) {
    }

    void showCursor();

    void hideCursor();

    bool isCursorVisible();

    uint32 getTicks() {
        return _frameCounter;
    }

    uint32 playTime() const {
        return _playTime;
    }

    void setPlayTime(uint32 time) {
        _playTime = time;
    }

    inline bool isButtonDown(MouseButton button) const {
        return (_buttonsDown & BUTTON_MASK(button)) != 0;
    }

    bool isButtonDown() const {
        return isButtonDown(BUTTON_LEFT) || isButtonDown(BUTTON_RIGHT) || isButtonDown(BUTTON_MIDDLE);
    }

    byte getButtonState() const {
        return _buttonsDown;
    }

    Common::Point getMousePos() const {
        return _mousePos;
    }
};

extern bool isMouseDownEvent(Common::EventType type);

extern bool isMouseUpEvent(Common::EventType type);

extern MouseButton whichButton(Common::EventType type);

} // End of namespace Shared
} // End of namespace Ultima

#endif