MessageId.h

#ifndef NEO_MESSAGE_ID_H
#define NEO_MESSAGE_ID_H

namespace neo
{

class MessageId
{
public:
    MessageId(UINT message);

    bool EqualOrSpecializationOf(const MessageId& rhs) const;
    bool operator==(const MessageId& rhs) const;
    bool operator<(const MessageId& rhs) const;

    void SetParam1(UINT_PTR param) { paramMask |= 0x1; p1 = param; }
    void SetParam2(UINT_PTR param) { paramMask |= 0x2; p2 = param; }
    void SetParam3(UINT_PTR param) { paramMask |= 0x4; p3 = param; }

    UINT message;
    UINT paramMask; //<! which parameters are in use
    UINT_PTR p1;
    UINT_PTR p2;
    UINT_PTR p3;
};

class CommandMessageId : public MessageId
{
public:
    CommandMessageId();
    CommandMessageId(UINT notifyCode, HWND control);
    CommandMessageId(UINT notifyCode, UINT_PTR idOfControl);
    CommandMessageId(UINT notifyCode, UINT_PTR idOfControl, HWND control);
    
    CommandMessageId& NotifyCode(UINT code) { SetParam1(code); return *this; }
    CommandMessageId& ControlId(UINT_PTR id) { SetParam2(id); return *this; }
    CommandMessageId& Control(HWND control) { SetParam3(reinterpret_cast<UINT_PTR>(control)); return *this; }
};

class ButtonMessageId : public CommandMessageId
{
public:
    ButtonMessageId();
    ButtonMessageId(HWND control);
    ButtonMessageId(UINT idOfControl);
};

class NotifyMessageId : public CommandMessageId
{
public:
    NotifyMessageId();
    NotifyMessageId(UINT notifyCode, HWND control);
    NotifyMessageId(UINT notifyCode, UINT_PTR idOfControl);
    NotifyMessageId(UINT notifyCode, UINT_PTR idOfControl, HWND control);
};

class ScrollMessageId : public MessageId
{
public:
    ScrollMessageId(UINT message, HWND scrollbar);
};

class WindowScrollMessageId : public ScrollMessageId
{
public:
    WindowScrollMessageId(UINT message) : ScrollMessageId(message, 0) {}
};

//-----------------------------------------------------------------------------

inline MessageId::MessageId(UINT pMessage)
{
    message = pMessage;
    paramMask = 0;
    p1 = 0;
    p2 = 0;
    p3 = 0;
}

/*
tricky: this function also returns true if rhs is a generalization of this
e.g.
CommandMessageId id1(EN_UPDATE, edit);
MessageId id2(WM_COMMAND);

id1.EqualOrSpecializationOf(id1) -> true
id2.EqualOrSpecializationOf(id2) -> true
id1.EqualOrSpecializationOf(id2) -> true
id2.EqualOrSpecializationOf(id1) -> false
*/
inline bool MessageId::EqualOrSpecializationOf(const MessageId& rhs) const
{
    UINT combinedMask = paramMask & rhs.paramMask;

    return message == rhs.message
        && combinedMask == rhs.paramMask
        && ((combinedMask & 0x1) ? p1 == rhs.p1 : true)
        && ((combinedMask & 0x2) ? p2 == rhs.p2 : true)
        && ((combinedMask & 0x4) ? p3 == rhs.p3 : true);
}

inline bool MessageId::operator==(const MessageId& rhs) const
{
    return message == rhs.message
        && paramMask == rhs.paramMask
        && p1 == rhs.p1
        && p2 == rhs.p2
        && p3 == rhs.p3;
}

inline bool MessageId::operator<(const MessageId& rhs) const
{
    if(message != rhs.message)
        return message < rhs.message;

    if(paramMask != rhs.paramMask)
        return paramMask > rhs.paramMask; // reverse order, means special masks are before general masks

    if(p1 != rhs.p1)
        return p1 < rhs.p1;
    if(p2 != rhs.p2)
        return p2 < rhs.p2;
    if(p3 != rhs.p3)
        return p3 < rhs.p3;
    return false;
}

//-----------------------------------------------------------------------------

inline CommandMessageId::CommandMessageId()
    : MessageId(WM_COMMAND)
{
}

inline CommandMessageId::CommandMessageId(UINT notifyCode, HWND control)
    : MessageId(WM_COMMAND)
{
    NotifyCode(notifyCode);
    Control(control);
}

inline CommandMessageId::CommandMessageId(UINT notifyCode, UINT_PTR idOfControl)
    : MessageId(WM_COMMAND)
{
    NotifyCode(notifyCode);
    ControlId(idOfControl);
}

inline CommandMessageId::CommandMessageId(UINT notifyCode, UINT_PTR idOfControl, HWND control)
    : MessageId(WM_COMMAND)
{
    NotifyCode(notifyCode);
    ControlId(idOfControl);
    Control(control);
}

//-----------------------------------------------------------------------------

inline ButtonMessageId::ButtonMessageId()
    : CommandMessageId()
{
    NotifyCode(BN_CLICKED);
}

inline ButtonMessageId::ButtonMessageId(HWND control)
    : CommandMessageId(BN_CLICKED, control)
{}

inline ButtonMessageId::ButtonMessageId(UINT idOfControl)
    : CommandMessageId(BN_CLICKED, idOfControl)
{}

//-----------------------------------------------------------------------------

inline NotifyMessageId::NotifyMessageId()
    : CommandMessageId()
{
    message = WM_NOTIFY;
}

inline NotifyMessageId::NotifyMessageId(UINT notifyCode, HWND control)
    : CommandMessageId(notifyCode, control)
{
    message = WM_NOTIFY;
}

inline NotifyMessageId::NotifyMessageId(UINT notifyCode, UINT_PTR idOfControl)
    : CommandMessageId(notifyCode, idOfControl)
{
    message = WM_NOTIFY;
}

inline NotifyMessageId::NotifyMessageId(UINT notifyCode, UINT_PTR idOfControl, HWND control)
    : CommandMessageId(notifyCode, idOfControl, control)
{
    message = WM_NOTIFY;
}

//-----------------------------------------------------------------------------

inline ScrollMessageId::ScrollMessageId(UINT pMessage, HWND scrollbar)
    : MessageId(pMessage)
{
    assert(message == WM_HSCROLL || message == WM_VSCROLL);
    SetParam1(reinterpret_cast<UINT_PTR>(scrollbar));
}

} // namespace neo

#endif