messages.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_MESSAGES_H
#define ULTIMA_SHARED_ENGINE_MESSAGES_H

#include "common/keyboard.h"
#include "common/events.h"
#include "ultima/shared/core/rect.h"
#include "ultima/shared/core/base_object.h"
#include "ultima/shared/core/tree_item.h"

namespace Ultima {
namespace Shared {

enum MessageFlag {
    MSGFLAG_SCAN = 1,
    MSGFLAG_BREAK_IF_HANDLED = 2,
    MSGFLAG_CLASS_DEF = 4
};

class CMessage;
namespace Gfx {
class VisualItem;
class TextInput;
class Popup;
}

#define MESSAGEDEF(theClass) \
    static ClassDef type() { return ClassDef(#theClass, &CMessage::type); } \
    virtual ClassDef getType() const { return type(); }
#define MESSAGEDEFP(theClass, baseClass) \
    static ClassDef type() { return ClassDef(#theClass, &baseClass::type); } \
    virtual ClassDef getType() const { return type(); }

#define MESSAGE0(NAME) \
    class NAME: public CMessage { \
    public: NAME() : CMessage() {} \
    MESSAGEDEF(NAME); \
    }
#define MESSAGE1(NAME, F1, N1, V1) \
    class NAME: public CMessage { \
    public: F1 _##N1; \
    NAME(F1 N1 = V1) : CMessage(), _##N1(N1) {} \
    MESSAGEDEF(NAME); \
    }
#define MESSAGE2(NAME, F1, N1, V1, F2, N2, V2) \
    class NAME: public CMessage { \
    public: F1 _##N1; F2 _##N2; \
    NAME(F1 N1 = V1, F2 N2 = V2) : CMessage(), _##N1(N1), _##N2(N2) {} \
    MESSAGEDEF(NAME); \
    }
#define MESSAGE3(NAME, F1, N1, V1, F2, N2, V2, F3, N3, V3) \
    class NAME: public CMessage { \
    public: F1 _##N1; F2 _##N2; F3 _##N3; \
    NAME(F1 N1 = V1, F2 N2 = V2, F3 N3 = V3) : CMessage(), _##N1(N1), _##N2(N2), _##N3(N3) {} \
    MESSAGEDEF(NAME); \
    }
#define MESSAGE4(NAME, F1, N1, V1, F2, N2, V2, F3, N3, V3, F4, N4, V4) \
    class NAME: public CMessage { \
    public: F1 _##N1; F2 _##N2; F3 _##N3; F4 _##N4; \
    NAME(F1 N1 = V1, F2 N2 = V2, F3 N3 = V3, F4 N4 = V4) : CMessage(), _##N1(N1), _##N2(N2), _##N3(N3), _##N4(N4) {} \
    MESSAGEDEF(NAME); \
    }

class CMessage : public BaseObject {
private:
    static const MSGMAP_ENTRY *findMapEntry(const TreeItem *treeItem, const ClassDef &classDef);
public:
    MESSAGEDEFP(CMessage, BaseObject);
    CMessage();

    bool execute(TreeItem *target, const ClassDef *classDef = nullptr,
        int flags = MSGFLAG_SCAN | MSGFLAG_BREAK_IF_HANDLED);

    bool execute(const Common::String &target, const ClassDef *classDef = nullptr,
        int flags = MSGFLAG_SCAN | MSGFLAG_BREAK_IF_HANDLED);

    virtual bool perform(TreeItem *treeItem);

    static bool supports(const TreeItem *treeItem, const ClassDef &classDef);

    virtual bool isMouseMsg() const;
    virtual bool isButtonDownMsg() const;
    virtual bool isButtonUpMsg() const;
    virtual bool isMouseMoveMsg() const;
    virtual bool isDoubleClickMsg() const;
};


enum CMouseButton {
    MB_LEFT = 1, MB_MIDDLE = 2, MB_RIGHT = 4
};

class CMouseMsg : public CMessage {
public:
    int _buttons;
    Point _mousePos;
public:
    MESSAGEDEF(CMouseMsg);

    CMouseMsg() : _buttons(0) {}
    CMouseMsg(const Point &pt, int buttons) :
        _mousePos(pt), _buttons(buttons) {}
};

class CMouseMoveMsg : public CMouseMsg {
public:
    MESSAGEDEFP(CMouseMoveMsg, CMouseMsg);
    CMouseMoveMsg() : CMouseMsg() {}
    CMouseMoveMsg(const Point &pt, int buttons) : CMouseMsg(pt, buttons) {}
};

class CMouseDragMsg : public CMouseMoveMsg {
public:
    MESSAGEDEFP(CMouseDragMsg, CMouseMoveMsg);
    CMouseDragMsg() : CMouseMoveMsg() {}
    CMouseDragMsg(const Point &pt, int buttons) : CMouseMoveMsg(pt, buttons) {}
};

class CMouseButtonMsg : public CMouseMsg {
public:
    MESSAGEDEFP(CMouseButtonMsg, CMouseMsg);
    CMouseButtonMsg() : CMouseMsg() {}
    CMouseButtonMsg(const Point &pt, int buttons) : CMouseMsg(pt, buttons) {}
};

class CMouseButtonDownMsg : public CMouseButtonMsg {
public:
    MESSAGEDEFP(CMouseButtonDownMsg, CMouseButtonMsg);
    CMouseButtonDownMsg() : CMouseButtonMsg() {}
    CMouseButtonDownMsg(const Point &pt, int buttons) : CMouseButtonMsg(pt, buttons) {}
};

class CMouseButtonUpMsg : public CMouseButtonMsg {
public:
    MESSAGEDEFP(CMouseButtonUpMsg, CMouseButtonMsg);
    CMouseButtonUpMsg() : CMouseButtonMsg() {}
    CMouseButtonUpMsg(const Point &pt, int buttons) : CMouseButtonMsg(pt, buttons) {}
};

class CMouseWheelMsg : public CMouseMsg {
public:
    bool _wheelUp;
public:
    MESSAGEDEFP(CMouseWheelMsg, CMouseMsg);
    CMouseWheelMsg() : CMouseMsg(), _wheelUp(false) {}
    CMouseWheelMsg(const Point &pt, bool wheelUp) :
        CMouseMsg(pt, 0), _wheelUp(wheelUp) {}
};

class CMouseDoubleClickMsg : public CMouseButtonMsg {
public:
    MESSAGEDEFP(CMouseDuobleClickMsg, CMouseButtonMsg);
    CMouseDoubleClickMsg() : CMouseButtonMsg() {}
    CMouseDoubleClickMsg(const Point &pt, int buttons) : CMouseButtonMsg(pt, buttons) {}
};

MESSAGE1(CFrameMsg, uint, ticks, 0);

MESSAGE2(CHideMsg, Gfx::VisualItem *, view, (Gfx::VisualItem *)nullptr, bool, fadeOut, false);

MESSAGE1(CInfoGetCommandKeypress, TreeItem *, responder, (TreeItem *)nullptr);

MESSAGE1(CInfoGetKeypress, TreeItem *, responder, (TreeItem *)nullptr);

MESSAGE3(CInfoGetInput, TreeItem *, responder, (TreeItem *)nullptr, bool, isNumeric, false, size_t, maxCharacters, 10);

MESSAGE3(CInfoMsg, Common::String, text, "", bool, newLine, true, bool, replaceLine, false);

MESSAGE0(CHuhMsg);

MESSAGE1(CKeyCharMsg, int, key, 32);

MESSAGE1(CKeypressMsg, Common::KeyState, keyState, Common::KeyState());

MESSAGE1(CPopupShownMsg, Gfx::Popup *, view, (Gfx::Popup *)nullptr);

MESSAGE1(CPopupHiddenMsg, Gfx::Popup *, view, (Gfx::Popup *)nullptr);

MESSAGE2(CShowMsg, Gfx::VisualItem *, view, (Gfx::VisualItem *)nullptr, bool, fadeIn, false);

MESSAGE2(CTextInputMsg, Common::String, text, "", bool, escaped, false);

MESSAGE1(CCharacterInputMsg, Common::KeyState, keyState, Common::KeyState());

/*-------------------------------------------------------------------*/

MESSAGE1(CMoveMsg, int, direction, 0);

MESSAGE1(CAttackMsg, int, direction, 0);

MESSAGE0(CBoardMsg);

MESSAGE0(CCastMsg);

MESSAGE0(CClimbMsg);

MESSAGE0(CDropMsg);

MESSAGE0(CEnterMsg);

MESSAGE0(CExitTransportMsg);

MESSAGE0(CFireMsg);

MESSAGE0(CGetMsg);

MESSAGE0(CHyperJumpMsg);

MESSAGE0(CInformMsg);

MESSAGE0(COpenMsg);

MESSAGE0(CPassMsg);

MESSAGE0(CQuitMsg);

MESSAGE0(CReadyMsg);

MESSAGE0(CStatsMsg);

MESSAGE0(CStealMsg);

MESSAGE0(CTransactMsg);

MESSAGE0(CUnlockMsg);

MESSAGE0(CViewChangeMsg);

MESSAGE0(CEndOfTurnMsg);

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

#endif