Message.h

#ifndef NEO_MESSAGE_H
#define NEO_MESSAGE_H

namespace neo
{

class WindowBase;

struct Message
{
    Message()
        : hwnd(0)
        , message(0)
        , wp(0)
        , lp(0)
        , result(0)
        , resultSet(false)
        , messageHandler(0)
    {}

    void Init(HWND pHwnd, UINT pMessage, WPARAM pWP, LPARAM pLP)
    {
        hwnd = pHwnd;
        message = pMessage;
        wp = pWP;
        lp = pLP;
        result = 0;
        resultSet = false;
    }

    void Result(LRESULT res)
    {
        // warn if the result is set more than once
        assert(resultSet == false);
        result = res;
        resultSet = true;
    }

    LRESULT Default();
    void ResultDefault() { Result(Default()); }

    HWND hwnd;
    UINT message;
    WPARAM wp;
    LPARAM lp;

    LRESULT result;
    bool resultSet;
    WindowBase* messageHandler;
};

struct CaptureChangedMessage : public Message
{
    HWND WindowGainingCapture() { return (HWND)lp; }
};

struct CommandMessage : public Message
{
    WORD ID() { return LOWORD(wp); }
    WORD NotifyCode() { return HIWORD(wp); }
    HWND Control() { return reinterpret_cast<HWND>(lp); }
};

struct CreateMessage : public Message
{
    CREATESTRUCT* CreateStruct() { return reinterpret_cast<CREATESTRUCT*>(lp); }
};

struct CtlColorMessage : public Message
{
    HDC DC() { return (HDC)wp; }
    HWND Control() { return (HWND)lp; }

    void Result(HBRUSH brush) { return Message::Result(reinterpret_cast<LRESULT>(brush)); }
};

struct DropFilesMessage : public Message
{
    HDROP HandleDrop() { return reinterpret_cast<HDROP>(wp); }

    UINT NumFiles() { return DragQueryFile(HandleDrop(), 0xFFFFFFFF, 0, 0); }

    tstring GetFile(UINT i)
    {
        UINT requiredBufferSize = DragQueryFile(HandleDrop(), i, 0, 0);

        tstring dropped;
        dropped.resize(requiredBufferSize);

        DragQueryFile(HandleDrop(), i, &dropped[0], requiredBufferSize + 1);

        return dropped;
    }
};

struct EnableMessage : public Message
{
    bool Enabled() { return wp == TRUE; }
};

struct EraseBkgndMessage : public Message
{
    HDC DC() { return reinterpret_cast<HDC>(wp); }

    void Result(bool erased) { Message::Result(erased ? TRUE : FALSE); }
};

struct GetIconMessage : public Message
{
    WPARAM Type() { return wp; }

    void Result(HICON icon) { Message::Result(reinterpret_cast<LRESULT>(icon)); }
};

struct GetMinMaxInfoMessage : public Message
{
    MINMAXINFO* MinMaxInfo() { return reinterpret_cast<MINMAXINFO*>(lp); }
};

struct KeyMessage : public Message
{
    WPARAM KeyCode() { return wp; }
    SHORT Repeat()      { return LOWORD(lp); }
    BYTE ScanCode()     { return static_cast<BYTE>((lp & 0x00FF0000) >> 16); }
    bool ExtendedKey()  { return (lp & 0x01000000) > 0; }
    bool AltDown()      { return (lp & 0x20000000) > 0; }
    bool KeyWasDown()   { return (lp & 0x40000000) > 0; }
    bool KeyWasUp()     { return !KeyWasDown(); }
    bool KeyReleased()  { return (lp & 0x80000000) > 0; }
    bool KeyPressed()   { return !KeyReleased(); }
};

struct MouseMessage : public Message
{
    bool Ctrl()     { return (wp & MK_CONTROL) > 0; }
    bool Shift()    { return (wp & MK_SHIFT) > 0; }
    bool LButton()  { return (wp & MK_LBUTTON) > 0; }
    bool MButton()  { return (wp & MK_MBUTTON) > 0; }
    bool RButton()  { return (wp & MK_RBUTTON) > 0; }
    bool XButton1() { return (wp & MK_XBUTTON1) > 0; }
    bool XButton2() { return (wp & MK_XBUTTON2) > 0; }
    SHORT X() { return MAKEPOINTS(lp).x; }
    SHORT Y() { return MAKEPOINTS(lp).y; }
    Point GetPoint() { return Point(X(), Y()); }
    double WheelMoveSteps()
    {
        return static_cast<double>( static_cast<SHORT>(HIWORD(wp)) ) /
            static_cast<double>(WHEEL_DELTA);
    }
    bool FromXButton1() { return HIWORD(wp) == XBUTTON1; }
    bool FromXButton2() { return HIWORD(wp) == XBUTTON2; }
};

struct MoveMessage : public Message
{
    SHORT X() { return MAKEPOINTS(lp).x; }
    SHORT Y() { return MAKEPOINTS(lp).y; }
    Point GetPoint() { return Point(X(), Y()); }
};

struct MovingMessage : public Message
{
    RECT* Rect() { return reinterpret_cast<RECT*>(lp); }
};

struct NotifyMessage : public Message
{
    WPARAM ID() { return wp; }
    NMHDR* Header() { return reinterpret_cast<NMHDR*>(lp); }
};

struct PrintMessage : public Message
{
    HDC DC() { return reinterpret_cast<HDC>(wp); }
    LPARAM Options() { return lp; }
};

struct ScrollMessage : public Message
{
    WORD Pos() { return LOWORD(wp); }
    WORD ScrollCode() { return HIWORD(wp); }
    HWND ScrollBar() { return reinterpret_cast<HWND>(lp); }
    bool IsHorizontal() { return message == WM_HSCROLL; }
    bool IsVertical() { return message == WM_VSCROLL; }

    void UpdateScrollPos();
};

struct SizeMessage : public Message
{
    WPARAM Type() { return wp; }
    WORD Width() { return LOWORD(lp); }
    WORD Height() { return HIWORD(lp); }
    Size GetSize() { return Size(Width(), Height()); }
};

struct SizingMessage : public Message
{
    WPARAM Side() { return wp; }
    RECT* Rect() { return reinterpret_cast<RECT*>(lp); }
};

struct StyleChangedMessage : public Message
{
    bool StyleChanged() { return (wp & GWL_STYLE) > 0; }
    bool ExStyleChanged() { return (wp & GWL_EXSTYLE) > 0; }
    STYLESTRUCT* StyleStruct() { return reinterpret_cast<STYLESTRUCT*>(lp); }
};

struct TimerMessage : public Message
{
    WPARAM ID() { return wp; }
};

struct WindowPosChangeMessage : public Message
{
    WINDOWPOS* WindowPos() { return reinterpret_cast<WINDOWPOS*>(lp); }
};

} // namespace neo

#endif