root/lang/objective-cplusplus/i3/trunk/src/mil/include/mil/gui-windows/GuiModule.h @ 34065

#pragma once
#include "../Mil.h"
#include "../ModuleCommon.h"
#include "../Module.h"
#include "../ModuleExecuteProxy.h"
#include "WindowProcedureRedirector.h"

#ifdef _MSC_VER
// XXX
#pragma warning (disable: 4100)
#endif

namespace mil
{

const UINT WM_MIL_GUIMODULE = WM_APP+100;

/**
 * public should be thread safe
 */
template <typename Child>
class GuiModule : public ModuleCommon<GuiModule<Child> >
{
    class EventBase : boost::noncopyable
    {
    public:
        //void (*execute)(void* event, void* target);
    };

    template <typename T>
    class Event : public EventBase
    {
    public:
        typedef T DataType;
        int owner_id;
        T data;
    };

    atomic<HWND> hSharedWnd;

    //LONG_PTR breakLoopRequest;
    PVOID breakLoopRequest;
    //DWORD_PTR destroyed;
    atomic<PVOID> destroyed;

    bool repost;
    bool handled;
    LRESULT handled_result;

protected:
    HWND hLocalWnd;

public:
    Tls tls;

    GuiModule() :
            hSharedWnd(NULL),
            breakLoopRequest(false),
            destroyed(0),
            repost(false),
            handled(true),
            handled_result(0),
            hLocalWnd(NULL),
            tls(this->thread_id),
            wndproc(getChild())
    {
        set_auto_join(this);
    }

    void requestExit(void* event_memory)
    {
        ExitEvent e;
        post(e, exitNotifier, event_memory, exitNotifier.tls.thread_id);
        //destroyed.store((PVOID)1);
        //this->join();
    }

    ~GuiModule()
    {
        do_auto_join();
        HWND w = getWindow();
        if (IsWindow(w))
        {
            if (DestroyWindow(w) == 0)
            {
                // error
                //DebugBreak();
            }
        }
        this->join();
    }

    template <typename Data, typename Sender>
    static void dispatch(void* event_, void* target_)
    {
        typedef Child Target;
        Target& target = *static_cast<Target*>(target_);
        target.repost = false;

        if (sizeof(Data) <= sizeof(LPARAM))
        {
            Data data;
            memcpy(&data, &event_, sizeof(data));
            mil::ModuleExecuteProxy<Data, Target>::execute(data, target);
            if (!target.repost)
            {
                return;
            }
            LPARAM l = 0;
            memcpy(&l, &data, sizeof(l));
            void (*func)(void*, void*) = dispatch<Data, Child>;
            PostMessage(target.hLocalWnd /* write operation should be done */ , WM_MIL_GUIMODULE,
                        reinterpret_cast<WPARAM>(func), l);
            return;
        }

        Event<Data>& event = *static_cast<Event<Data>*>(event_);
        mil::ModuleExecuteProxy<Data, Target>::execute(event.data, target);
        if (target.repost)
        {
            void (*func)(void*, void*) = dispatch<Data, Child>;
            PostMessage(target.hLocalWnd /* write operation should be done */ , WM_MIL_GUIMODULE,
                        reinterpret_cast<WPARAM>(func) ,
                        reinterpret_cast<LPARAM>(&event));
            return;
        }

        freeEvent<Sender>(event, target);
    }

protected:
    void setWindow(HWND hWnd_)
    {
        hLocalWnd = hWnd_;
        hSharedWnd.store(hWnd_);
    }

public:
    HWND getWindow()
    {
        return hSharedWnd.load();
    }

    Child& getChild()
    {
        return *static_cast<Child*>(this);
    }

    void destroy()   //XXX thread safe
    {
        //PostQuitMessage(0);
        breakLoopRequest = (PVOID)1;
        destroyed.store((PVOID)1);
        if (IsWindow(hLocalWnd))
        {
            if (DestroyWindow(hLocalWnd) == 0)
            {
                // error
                //DebugBreak();
            }
        }
        wndproc.inactivate();
    }

    void loop()
    {
        if (breakLoopRequest || destroyed.load() || !IsWindow(this->hLocalWnd))
        {
            return;
        }

        MSG msg = {};
        while (__builtin_expect(!breakLoopRequest, true))
        {
            BOOL result = GetMessage(&msg, NULL, 0, 0);
            if (!result)
            {
                break;
            }
            else if (result == -1)
            {
                // error
                halt << msg.message;
                break;
            }
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    template <typename Sender>
    HWND getCachedHWnd(Sender& sender) {
        HWND hWnd = sender.tls.thread[this->thread_id].hWnd;
        if (__builtin_expect(!hWnd, false))
        {
            hWnd = getWindow();
            if (!IsWindow(hWnd))
            {
                return NULL;
            }
            sender.tls.thread[this->thread_id].hWnd = hWnd;
        }
        return hWnd;
    }

    template <typename T, typename Sender>
    void post(const T& event, Sender& sender, void* memory, intptr_t owner_id)
    {
        Event<T>* e = new(memory) Event<T>;
        e->data = event;
        e->owner_id = owner_id;
        void (*func)(void*, void*) = dispatch<T, Sender>;
        HWND hWnd = getCachedHWnd(sender);
        if (PostMessage(hWnd, WM_MIL_GUIMODULE,
                        reinterpret_cast<WPARAM>(func),
                        reinterpret_cast<LPARAM>(e)) == 0)
        {
            // error
            //std::cout << "e" << std::flush;
            //debug << "foo";
            return;
        }
    }


    template <typename T, typename Sender>
    void post(const T& event, Sender& sender)
    {
        if (sizeof(T) <= sizeof(LPARAM))
        {
            HWND hWnd = getCachedHWnd(sender);
            LPARAM l = 0;
            memcpy(&l, &event, sizeof(l));
            void (*func)(void*, void*) = dispatch<T, Sender>;
            if (PostMessage(hWnd, WM_MIL_GUIMODULE,
                        reinterpret_cast<WPARAM>(func),l) == 0)
            {
               //debug << "bar";
            }
            return;
        }

        mil::pool::Producer& producer = sender.tls.producer;
        void* memory = producer.malloc<sizeof(Event<T>)>();
        if (memory == NULL)
        {
            // XXX
            return;
        }
        post(event, sender, memory, sender.tls.thread_id);
    }

    // Message Cracker Wizard for Win32 SDK Developers
    // http://www.codeproject.com/KB/winsdk/msgcrackwizard.aspx
#include "DummyMessageHandler-inl.h"

protected:
    void repostEvent()
    {
        repost = true;
    }
    void SetMsgHandled(bool handled_, LRESULT handled_result_ = 0)
    {
        handled = handled_;
        handled_result = handled_result_;
    }
    LRESULT MessageMap(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
        if (msg == mil::WM_MIL_GUIMODULE)
        {
            BOOST_STATIC_ASSERT(sizeof(EventBase*) == sizeof(lParam));
            EventBase* e = reinterpret_cast<EventBase*>(lParam);
            void (*func)(void*, void*) = reinterpret_cast<void (*)(void*, void*)>(wParam);
            func(e, &getChild());
            return 0;
        }
        else if (msg == WM_DESTROY || msg == WM_QUIT)
        {
            destroy();
        }

        // XXX will be return
        switch (msg)
        {
#include "MessageCracker-inl.h"
        default:
            SetMsgHandled(false);
            break;
        }

        return handled_result;
    }
public:
    LRESULT WindowProcedure(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
        SetMsgHandled(true);
        LRESULT result = MessageMap(hWnd, msg, wParam, lParam);
        if (handled)
        {
            return result;
        }
        return DefWindowProc(hWnd, msg, wParam, lParam);
    }

    void execute_front()
    {
        MSG msg = {};
        unsigned int loop = 10000;
        while (PeekMessage (&msg,NULL,0,0,PM_REMOVE) != 0)
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
            if (msg.message == WM_MIL_GUIMODULE)
            {
                return;
            }
            if (loop-- == 0)
            {
                return;
            }
        }
    }

    mil::WindowProcedureRedirector<
    GuiModule<Child>, &GuiModule<Child>::WindowProcedure> wndproc;
};

}