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

#pragma once

#include "../ModuleCommon.h"

namespace mil {

/**
 * public members should be thread safe
 */
template <typename Child>
class UIModule : public ModuleCommon<UIModule<Child>, thread::Cocoa> {
public:
    Tls tls;
    MIL_CRTP_CLASS_MEMBERS;

public:
    template <typename T>
    class Event : boost::noncopyable {
    public:
        thread::id_t getThreadId() {
            return pool::MemoryHeader::get((void*)this).getThreadId();
        }
        typedef T DataType;
        T data;
        void (*execute)(void* event, void* target);
    };

private:
    bool repost;

protected:
    NSWindow *window;

public:
    NSWindow* getWindow() {
        return window;
    }

    void setWindow(NSWindow* window_) {
        window = window_;
    }

    void requestExit(void* event_memory) {
        exitNotifier.tls.flush();
        ExitEvent e;
        post(e, exitNotifier, event_memory);
    }

    UIModule() : tls(this->thread_id), repost(false), window(NULL) {
    }

    void createGui() {
    }

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

protected:
    void repostEvent() {
        repost = true;
    }

    template <typename Data, typename Sender>
    static void dispatcher(void* event_, void* target_) {
        typedef Child Target;
        Target& target = *static_cast<Target*>(target_);
        Event<Data>& event = *static_cast<Event<Data>*>(event_);
        target.repost = false;
        ModuleExecuteProxy::execute<Data, Target>(event.data, target);
        if (target.repost) {
            target.post(event.data, target);
            return;
        }
    }

public:
    void requestExit() {
        ExitEvent e;
        post(e, *this);
    }

    template <typename Sender>
    NSWindow* getCachedWindow(Sender& sender, bool flush = false) {
        NSWindow* window = NULL;

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

    template <typename T, typename Sender>
    void post(const T& event, Sender& sender, void* memory = NULL) {
        NSWindow* window = getCachedWindow(sender);
        Event<T> e;
        e.data = event;
        e.execute = dispatcher<T, Sender>;
    }
public:
    void destroy() {
    }

    ~UIModule() {
        do_auto_join();
        if (!window) {
            return;
        }
        [window dealloc];
        window = NULL;
    }

    bool execute_front() {
        return false;
    }

    void mouseDown(NSEvent*) {
    }
protected:
    void loop() {
        [[NSRunLoop currentRunLoop] run];
    }
};

}