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

#pragma once

#include "../Memory.h"
#include "../ModuleCommon.h"
#include "WindowProcedureRedirector.h"

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

namespace mil {

/**
* public should be thread safe
*/
template <typename Child>
class GuiModule : public ModuleCommon<GuiModule<Child> > {
public:
    MIL_CRTP_CLASS_MEMBERS;

private:
    class EventBase : public boost::noncopyable {
    public:
        thread::id_t getThreadId() {
            return pool::MemoryHeader::get((void*)this).getThreadId();
        }
        void (*execute)(void* event, void* target);
        EventBase* next;
    };

    class EventList : public boost::noncopyable {
        EventBase* head;
        EventBase* tail;
        Mutex mutex;
    public:
        EventList() {
            head = NULL;
            tail = NULL;
        }

        bool push(EventBase& e) {
            synchronized (mutex) {
                e.next = NULL;
                if (head == NULL) { // tail == NULL
                    head = &e;
                    tail = &e;
                    return true;
                }
                tail->next = &e;
                tail = &e;
            }
            return false;
        }

        EventBase* pop() {
            EventBase* result = NULL;
            synchronized (mutex) {
                if (!head) {
                    return NULL;
                }
                result = head;
                head = head->next;
            }
            return result;
        }

        void clear() {
            synchronized (mutex) {
                head = NULL;
                tail = NULL;
            }
        }
    };
protected:
    template <typename T>
    class Event : public EventBase {
    public:
        typedef T DataType;
        T data;
    };

private:
    EventList list;
    Semaphore semaphore;
    bool repost;
    bool handled;
    LRESULT handled_result;
protected:
    bool break_loop_request;
public:
    atomic<HWND> window;
    atomic<bool> break_loop_request_shared;
protected:
    HWND local_window;

public:
    GuiModule() :
            window(NULL),
            break_loop_request(false),
            break_loop_request_shared(false),
            repost(false),
            handled(true),
            handled_result(0),
            local_window(NULL),
            wndproc(getChild()) {
    }

    void requestExit(void* event_memory) {
        list.clear();
        break_loop_request_shared.store(true);
        exitNotifier.tls.flush();
        ExitEvent e;
        post(e, exitNotifier, event_memory);
    }

    ~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 dispatcher(void* event_, void* target_) {
        typedef Child Target;

        // XXX type safety??
        Target& target = *static_cast<Target*>(target_);
        Event<Data>& event = *static_cast<Event<Data>*>(event_);
        //target.list.pop();
        target.repost = false;
        ModuleExecuteProxy::execute<Data, Target>(event.data, target);
        if (target.repost) {
            target.list.push(event);
            return;
        }

        dispatcher_free_event<Event<Data>, Target, Sender>(event, target);
    }

    template <typename T, typename Sender>
    void post(const T& event, Sender&, void* memory) {
        Event<T>* e = new(memory) Event<T>;
        e->data = event;
        e->execute = dispatcher<T, Sender>;

        if (list.push(*e)) {
            semaphore.passeren();
        }
    }

    template <typename T, typename Sender>
    void post(const T& event, Sender& sender) {
        pool::Producer& producer = sender.tls.producer;
        void* memory = producer.allocate(sizeof(Event<T>));
        if (unlikely(memory == NULL)) {
            halt << "can't allocate event memory";
            return;
        }

        post(event, sender, memory);
    }

protected:
    void setWindow(HWND hWnd_) {
        local_window = hWnd_;
        window.store(hWnd_);
        wndproc.set(hWnd_);
    }

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

    void destroy() { //XXX thread safe
        //PostQuitMessage(0);
        break_loop_request = true;
        break_loop_request_shared.store(true);

        // DestroyWindow -> dtor

        //if (IsWindow(local_window))
        //{
        //    if (DestroyWindow(local_window) == 0)
        //    {
        //        // error
        //        //DebugBreak();
        //    }
        //}
        wndproc.inactivate();
    }

    void createUI() { // XXX UI or Gui
    }

    void run() {
        MIL_MODULE_GET_SUPER_CHILD(*this).createGui();
        MIL_MODULE_GET_SUPER_CHILD(*this).loop();
    }

    void loop() {
        if (break_loop_request || break_loop_request_shared.load() || !IsWindow(this->local_window)) {
            return;
        }

        assert(GetWindowThreadProcessId(this->local_window, NULL) == GetCurrentThreadId());

        MSG msg = {};

        for (;;) {
            DWORD wakeup = MsgWaitForMultipleObjects(1, &(semaphore.handle), false, INFINITE, QS_ALLINPUT);
            if (wakeup == WAIT_OBJECT_0) {
                execute_front();
            }

            MSG msg;            
            bool b = false;
            while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
                // dirty if-condition is for most expected branch
                if (msg.message != WM_QUIT) {
                    TranslateMessage(&msg);
                    DispatchMessage(&msg);
                    if (likely(!break_loop_request)) {
                        continue;
                    } else {
                        b = true;
                        break;
                    }
                } else {
                    return;      
                }
            }
            if (likely(!b)) {
                continue;
            } else {
                break;
            }
        }
    }

    template <typename Sender>
    HWND getCachedWindow(Sender& sender, bool flush = false) {
        // XXX must compare no cached
        if (!flush) {
            HWND window = sender.tls.getData(this->thread_id).window_cache;
            if (window) {
                return window;
            }
        }

        HWND window = getWindow();
        if (!IsWindow(window)) {
            return NULL;
        }
        sender.tls.getData(this->thread_id).window_cache = window;
        return window;
    }

    // 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 == 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);
    }

    bool execute_front() {
        EventBase* e = list.pop();
        if (!e) {
            return false;
        }
        e->execute((void*)e, (void*)this);
        return true;
    }

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

}