L>>Кстати, lboss-овскую неявную карту сообщений прикрутить не захотел? Я использую уже.

MsgOut<This,WM_USER,__COUNTER__> onMsg(Msg<WM_USER>&);
MsgOut<This,WM_USER,__COUNTER__> onMsg(Msg<WM_USER>&);//в каком порядке будут сконструированы MsgOut?

L>>Очень гибкая схема получается. Вот только проблема всех гибкостей — найти применение.

MultiMsgOut<This,WM_USER,1> onMsg(MultiMsg<WM_USER,1>&);
MultiMsgOut<This,WM_USER,2> onMsg(MultiMsg<WM_USER,2>&);

L>MultiMsgOut<This,WM_USER,1> onMsg(MultiMsg<WM_USER,1>&);
L>MultiMsgOut<This,WM_USER,2> onMsg(MultiMsg<WM_USER,2>&);
L>

#define MESSAGE__(class, id, id2)\
MultiMsgOut<class,id,id2> onMsg(MultiMsg<id,id2>& msg);
#define MESSAGE_(class, id, id2)MESSAGE__(class, id, id2)
#define MESSAGE(id)MESSAGE_(CUR_CLASS, id, __COUNTER__)

class Test
{
    #define CUR_CLASS Test
    MESSAGE(WM_PAINT)
    {
        return false;
    }
    MESSAGE(WM_PAINT)
    {
        return false;
    }
    #undef CUR_CLASS
};

 OnMessage<WM_CLOSE>  onMsg(Msg<WM_CLOSE> & msg);
 OnCommand<IDOK>  onMsg(Msg<WM_COMMAND> & msg);

OnMessage<WM_PAINT>  onMsg(Msg<WM_PAINT> & msg)
{
  return myFirstPaint(msg) || mySecondPaint(msg);
}

L> OnMessage<WM_CLOSE>  onMsg(Msg<WM_CLOSE> & msg);
L> OnCommand<IDOK>  onMsg(Msg<WM_COMMAND> & msg);

L>> OnMessage<WM_CLOSE>  onMsg(Msg<WM_CLOSE> & msg);
L>> OnCommand<IDOK>  onMsg(Msg<WM_COMMAND> & msg);
L>

#define VMessageMap(ThisClassName, BaseClassName)\
    typedef ThisClassName ThisClass;\
    virtual    bool    processMessage(MsgData & msg)\
    {\
        return MsgProcessor<ThisClass>::getInstance().processMessage(this, msg) || BaseClassName::processMessage(msg);\
    }

#define VOnMessage(MessageId)\
    OnMessage<ThisClass, MessageId> onMsg(Msg<MessageId> & msg)

#define VOnCommand(CommandId)\
    OnCommand<ThisClass, CommandId> onMsg(CommandMsg<CommandId> & msg)

class Test1 : public    Wnd
{
public:
    VMessageMap(Test1, Wnd);
        VOnMessage(WM_PAINT)
        {
            puts("VOnMessage(WM_PAINT)");
            return true;
        }
        VOnCommand(IDOK)
        {
            EndDialog(IDOK);
            return true;
        }

};

L>#define VOnCommand(CommandId)\
L>    OnCommand<ThisClass, CommandId> onMsg(CommandMsg<CommandId> & msg)

template <class T>
// базовый класс
struct WndBase {

    void msg_handle( UINT id, WPARAM w, LPARAM l ) {
        T *p = static_cast<T*>( this );
        switch ( id ) {
            case WM_PAINT: p->wm_paint(); break;
            case WM_MOVE: p->wm_move(LOWORD(l),HIWORD(l)); break;
            case WM_CREATE: p->wm_create(*(CREATESTRUCT*)l); break;
            // .... все виндовые сообщения
        }
    }

    void wm_paint() {}
    void wm_create( CREATESTRUCT&) {}
    void wm_move(int x, int y) {}
    // .... все виндовые сообщения
};

// производный
struct MyWnd : public WndBase<MyWnd> {
    void wm_move( int x, int y ) {
        // ....
    }
};

struct WindowBase {
    void wm_paint()        { assert(0); } // не для вызова
    void wm_ncpaint()    { assert(0); }
    void wm_create()    { assert(0); }
    void wm_nccreate()    { assert(0); }
    void wm_size()        { assert(0); }
    void wm_move()        { assert(0); }
    // добавить все остальные сообщения
    void def_handler() {
        printf("def_handler\n");
    }

    virtual void msg_handle( UINT msg )    = 0;
};

typedef void (WindowBase::*XMFn)();

#define XANDLER_CHK( xfn, id ) if ( (XMFn)&T::xfn != (XMFn)&WindowBase::xfn ) { mmp[id] = (XMFn)&T::xfn; }

template <class T>
class Window : public WindowBase {
    typedef std::map<UINT,XMFn>    mp_id2xf;
public:

    void msg_handle( UINT msg ) {
        static mp_id2xf mmp;
        static bool init = true;
        if ( init ) {
            init = false;
            XANDLER_CHK( wm_paint, WM_PAINT );
            XANDLER_CHK( wm_ncpaint, WM_NCPAINT );
            XANDLER_CHK( wm_create, WM_CREATE );
            XANDLER_CHK( wm_nccreate, WM_NCCREATE );
            XANDLER_CHK( wm_size, WM_SIZE );
            XANDLER_CHK( wm_move, WM_MOVE );
        // добавить все остальные сообщения
        }
        mp_id2xf::iterator x = mmp.find( msg );
        if ( mmp.end() == x ) {
            def_handler();
        }
        else {
            WindowBase &p = *this;
            (p.*x->second)();
        }
            
    }

};

struct MyWnd : Window<MyWnd> {
    void wm_paint() {
        printf("paint\n");
    }
    void wm_move() {
        printf("move\n");
    }

};

void test() {
    MyWnd wnd;
    wnd.msg_handle( WM_PAINT ); // MyWnd::wm_paint
    wnd.msg_handle( WM_MOVE );  // MyWnd::wm_move 
    wnd.msg_handle( WM_CREATE );// WindowBase::def_handler
}

void wm_crak_size( WPARAM, LPARAM l ) {
    T *p = static_cast<T*>(this);
    p->wm_size( LOWORD(l), HIWORD(l) );
}