event_handler.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 ULTIMA4_EVENTS_EVENT_HANDLER_H
#define ULTIMA4_EVENTS_EVENT_HANDLER_H

#include "ultima/ultima4/events/timed_event_mgr.h"
#include "ultima/ultima4/controllers/key_handler_controller.h"
#include "ultima/ultima4/core/types.h"
#include "ultima/ultima4/gfx/screen.h"
#include "ultima/shared/std/containers.h"
#include "common/events.h"
#include "common/list.h"
#include "common/rect.h"
#include "common/str.h"

namespace Ultima {
namespace Ultima4 {

#define eventHandler (EventHandler::getInstance())

#if defined(IOS_ULTIMA4)
#ifndef __OBJC__
typedef void *TimedManagerHelper;
typedef void *UIEvent;
#else
@class TimedManagerHelper;
@class UIEvent;
#endif
#endif

typedef void(*updateScreenCallback)();

class WalkTrigger {
private:
    int _ticksCtr, _ticksPerWalk;
    KeybindingAction _action;
public:
    WalkTrigger() : _ticksCtr(0), _ticksPerWalk(0), _action(KEYBIND_NONE) {
    }

    void reset();

    void setDelta(Direction dir, int distance);

    KeybindingAction getAction();
};


class EventHandler {
    typedef Common::List<const MouseArea *> MouseAreaList;
private:
    static EventHandler *_instance;
    WalkTrigger _walk;
    bool _isRightButtonDown;
private:
    void handleMouseMotionEvent(const Common::Event &event);
    void handleMouseButtonDownEvent(const Common::Event &event, Controller *controller, updateScreenCallback updateScreen);
    void handleMouseButtonUpEvent(const Common::Event &event, Controller *controller, updateScreenCallback updateScreen);
    void handleKeyDownEvent(const Common::Event &event, Controller *controller, updateScreenCallback updateScreen);
protected:
    static bool _controllerDone;
    static bool _ended;
    TimedEventMgr _timer;
    Std::vector<Controller *> _controllers;
    MouseAreaList _mouseAreaSets;
    updateScreenCallback _updateScreen;
public:
    EventHandler();

    /* Static functions */
    static EventHandler *getInstance();

    static void sleep(uint usec);

    static void wait_msecs(uint msecs);

    static void wait_cycles(uint cycles);

    static void setControllerDone(bool exit = true);

    static bool getControllerDone();
    static void end();

    /* Member functions */
    TimedEventMgr *getTimer();

    /* Event functions */
    void run();
    void setScreenUpdate(void (*updateScreen)(void));
#if defined(IOS_ULTIMA4)
    void handleEvent(UIEvent *);
    static void controllerStopped_helper();
    updateScreenCallback screenCallback() {
        return updateScreen;
    }
#endif

    /* Controller functions */
    Controller *pushController(Controller *c);
    Controller *popController();
    Controller *getController() const;
    void setController(Controller *c);

    /* Key handler functions */
    void pushKeyHandler(KeyHandler kh);

    void popKeyHandler();

    KeyHandler *getKeyHandler() const;

    void setKeyHandler(KeyHandler kh);

    /* Mouse area functions */
    void pushMouseAreaSet(const MouseArea *mouseAreas);
    void popMouseAreaSet();

    const MouseArea *getMouseAreaSet() const;

    const MouseArea *mouseAreaForPoint(int x, int y);

    KeybindingAction getAction() {
        return _isRightButtonDown ? _walk.getAction() : KEYBIND_NONE;
    }
};

} // End of namespace Ultima4
} // End of namespace Ultima

#endif