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

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

namespace mil
{

/**
 * public members should be thread safe
 */
template <typename Child>
class GuiModule : public Thread<GuiModule<Child> >
{
public:
    Tls tls;
private:
    class EventBase : public boost::intrusive::slist_base_hook<>, public boost::noncopyable
    {
    public:
        void (*execute)(void* event, void* target);
        intptr_t owner_id;
    };

    class EventList : public boost::noncopyable
    {
        boost::intrusive::slist<EventBase, boost::intrusive::constant_time_size<false>, boost::intrusive::cache_last<true> > l;
        boost::details::pool::default_mutex m;
        typedef boost::details::pool::guard<boost::details::pool::default_mutex> guard;
    public:
        void push(EventBase& e)
        {
            guard g(m);
            l.push_back(e);
        }

        void pop()
        {
            guard g(m);
            l.pop_front();
        }

        EventBase* top()
        {
            guard g(m);
            if (l.size() == 0)
            {
                return NULL;
            }
            return &l.front();
        }
    };

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

    friend class Module_test;

private:
    EventList list;
    Conditional c;
    bool repost;
    mil::atomic<bool> isWaiting;
protected:
    NSWindow *window;

public:
    GuiModule() : tls(this->thread_id), repost(false), isWaiting(false), window(NULL)
    {
    }

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

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


    template <typename Data, typename Sender>
    static void dispatcher(void* event_, void* target_)
    {
        typedef Child  Target;

        if (!event_ || !target_)
        {
            return;
        }

        // XXX type safety??
        Target& target = *static_cast<Target*>(target_);
        Event<Data>& event = *static_cast<Event<Data>*>(event_);
        target.list.pop();
        target.repost = false;
        ModuleExecuteProxy<Data, Target>::execute(event.data, target);
        if (target.repost) {
            target.list.push(event);
            return;
        }
        if (event.owner_id == target.thread_id) {
            mil::pool::ReturnMemoryProxy<Data>::free(&event, target.tls.producer, mil::pool::Blocks<Event<Data> >::value);
            return;
        }
        void* mem = NULL;
        pool::MemoryList* m = NULL;
        boost::tie(mem, m) = target.tls.consumer.work(&event);
        if (!m) {
            return;
        }
        pool::ReturnMemoryEvent<pool::Blocks<Event<Data> >::value> e;
        e.memory = m;
        void* t = threads[event.owner_id].load();
        if (!t) {
            return;
        }
        (reinterpret_cast<Sender*>(t))->post(e, target, mem, event.owner_id);
    }
public:
    template <typename T, typename Sender>
    void post(const T& event, Sender& sender, void* memory = NULL, intptr_t owner_id = 0)
    {
        void* p = NULL;
        if (memory) {
            p = memory;
        } else {
            mil::pool::Producer& producer = sender.tls.producer;
            p = producer.malloc<sizeof(Event<T>)>();
        }

        if (p == NULL)
        {
            // XXX
            return;
        }

        Event<T>* e = new(p) Event<T>;
        e->data = event;
        e->execute = dispatcher<T, Sender>;
        if (memory) {
            e->owner_id = owner_id;
        } else {
            e->owner_id = sender.tls.thread_id;
        }

        list.push(*e);
        if (isWaiting.load()) {
            c.signal();
        }
    }
public:
    void destroy()
    {
        if (!window)
        {
            return;
        }
        [window dealloc];
        window = NULL;
    }

    ~GuiModule() {
        ExitEvent e;
        post(e, *this);
        //destroy();
        this->join();
    }

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

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

}