mouse.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 ULTIMA8_KERNEL_MOUSE_H
#define ULTIMA8_KERNEL_MOUSE_H

#include "common/system.h"
#include "common/rect.h"
#include "ultima/ultima8/misc/common_types.h"
#include "ultima/ultima8/misc/direction.h"

namespace Ultima {
namespace Ultima8 {

enum MouseButtonState {
    MBS_DOWN = 0x1,
    MBS_HANDLED = 0x2       // Mousedown event handled
};

struct MButton {
    uint16 _downGump;
    uint32 _lastDown;
    uint32 _curDown;
    Common::Point _downPoint;
    int _state;

    MButton() : _downGump(0), _curDown(0), _lastDown(0), _state(MBS_HANDLED)
    {
    }

    bool isState(MouseButtonState state) const {
        return _state & state;
    }
    void setState(MouseButtonState state) {
        _state |= state;
    }
    void clearState(MouseButtonState state) {
        _state &= ~state;
    }

    bool isUnhandledPastTimeout(uint32 now, uint32 timeout) {
        return !isState(MBS_HANDLED) && _curDown > 0 && (now - _curDown) > timeout;
    }

    bool isUnhandledDoubleClick(uint32 timeout) {
        return !isState(MBS_HANDLED) && _lastDown > 0 && (_curDown - _lastDown) <= timeout;
    }

};

class Gump;

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

    enum MouseCursor {
        MOUSE_NORMAL = 0,
        MOUSE_NONE = 1,
        MOUSE_TARGET = 2,
        MOUSE_WAIT = 3,
        MOUSE_HAND = 4,
        MOUSE_QUILL = 5,
        MOUSE_MAGGLASS = 6,
        MOUSE_CROSS = 7
    };

    enum DraggingState {
        DRAG_NOT = 0,
        DRAG_OK = 1,
        DRAG_INVALID = 2,
        DRAG_TEMPFAIL = 3
    };
private:
    static Mouse *_instance;
    Common::Stack<MouseCursor> _cursors;
    int _lastMouseFrame;

    uint32 _flashingCursorTime;

    // mouse input state
    MButton _mouseButton[MOUSE_LAST];

    uint16 _mouseOverGump;
    Common::Point _mousePos;
    Common::Point _draggingOffset;
    DraggingState _dragging;

    ObjId _dragging_objId;
    uint16 _draggingItem_startGump;
    uint16 _draggingItem_lastGump;

    int _walkThreshold;
    int _runThreshold;
private:
    void startDragging(int mx, int my);
    void moveDragging(int mx, int my);
    void stopDragging(int mx, int my);
    int mouseFrameForDir(Direction mousedir) const;

public:
    static Mouse *get_instance() { return _instance; }
public:
    Mouse();
    ~Mouse();

    bool buttonDown(MouseButton button);

    bool buttonUp(MouseButton button);

    int getMouseLength(int mx, int my) const;

    int getMouseLength() const {
        return getMouseLength(_mousePos.x, _mousePos.y);
    }

    Direction getMouseDirectionScreen(int mx, int my) const;

    Direction getMouseDirectionScreen() const {
        return getMouseDirectionScreen(_mousePos.x, _mousePos.y);
    }

    Direction getMouseDirectionWorld(int mx, int my) const;

    Direction getMouseDirectionWorld() const {
        return getMouseDirectionWorld(_mousePos.x, _mousePos.y);
    }

    void getMouseCoords(int32 &mx, int32 &my) const {
        mx = _mousePos.x;
        my = _mousePos.y;
    }

    void setMouseCoords(int mx, int my);

    bool isMouseDownEvent(MouseButton button) const;

    void popAllCursors();

    void setMouseCursor(MouseCursor cursor);

    void flashCrossCursor();

    void pushMouseCursor(MouseCursor cursor);

    void popMouseCursor();

    int getMouseFrame();

    DraggingState dragging() const { return _dragging; }

    void setDraggingOffset(int32 x, int32 y) {
        _draggingOffset.x = x;
        _draggingOffset.y = y;
    }
    void getDraggingOffset(int32 &x, int32 &y) {
        x = _draggingOffset.x;
        y = _draggingOffset.y;
    }

    uint32 getDoubleClickTime() const;

    void handleDelayedEvents();

    Gump *getMouseOverGump() const;
    void resetMouseOverGump() { _mouseOverGump = 0; }

    void update();
};

} // End of namespace Ultima8
} // End of namespace Ultima

#endif