root/lang/cplusplus/i3/src/mol/include/mol/windows/GuiModule.h @ 14345

#pragma once
#include "Mol.h"
#include "../Module.h"
#include "WindowProcedureRedirector.h"

namespace mol
{
const UINT WM_MOL_GUIMODULE = WM_APP+100;

template <typename Child>
class GuiModule : public boost::noncopyable {
    Child& getChild() {
        return *static_cast<Child*>(this);
    }

    class EventBase : boost::noncopyable
    {
    public:
        void (*execute)(void* list, void* target);
    };

    template <typename T>
    class Event : public EventBase
    {
    public:
        T data;
    };

    template <typename Data, typename Target>
    static void dispatcher(void* event_, void* target_)
    {
        Event<Data>* event = static_cast<Event<Data>*>(event_);
        Target* target = static_cast<Target*>(target_);

        // �C�����C�����ŏ���򂪏���邩��
        if (target->getChild().execute(event->data)) {
            // �폜
            boost::singleton_pool<char, PoolSizeSelector<Event<Data> >::SIZE>::free(event);
        } else {
            // �����g��.
            PostMessage(target->getWindow(), WM_MOL_GUIMODULE,
                        0, reinterpret_cast<LPARAM>(event));
        }
    }
protected:
    HWND hWnd;
    HWND getWindow() const {
        return hWnd;
    }

    mol::WindowProcedureRedirector<Child> wndproc;
    void loop() {
        MSG msg = {};

        for (BOOL result = 0; (result = GetMessage(&msg, NULL, 0, 0)), result;) {
            if (result == -1) {
                // error
                mol_abort << msg.message;
                break;
            }

            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
public:
    GuiModule(): hWnd(NULL), wndproc(getChild()) {
    }
    template <typename T>
    void post(const T& event)
    {
        void* p = boost::singleton_pool<char, PoolSizeSelector<Event<T> >::SIZE>::malloc();
        if (p == NULL) {
            // XXX
            return;
        }
        Event<T>* e = new(p) Event<T>;
        e->data = event;
        e->execute = dispatcher<T, Child>;

        assert(getWindow()); // XXX hWnd initialized ???
        PostMessage(getWindow(), WM_MOL_GUIMODULE,
                    0, reinterpret_cast<LPARAM>(e));
    }

    LRESULT MessageMap(UINT msg, WPARAM wParam, LPARAM lParam, bool& handled) {
        handled = false;
        if (msg == mol::WM_MOL_GUIMODULE)
        {
            BOOST_STATIC_ASSERT(sizeof(void*) == sizeof(lParam));
            EventBase* e = reinterpret_cast<EventBase*>(lParam);
            e->execute(e, &getChild());
            handled = true;
            return 0;
        } else if (msg == WM_DESTROY) {
            PostQuitMessage(0);
        }
        return 0;
    }

    LRESULT WindowProcedure(UINT msg, WPARAM wParam, LPARAM lParam)
    {
        bool handled = false;
        LRESULT result = MessageMap(msg, wParam, lParam, handled);
        if (handled) {
            return result;
        }
        return DefWindowProc(hWnd, msg, wParam, lParam);
    }
};

}