sequence_mvc_muldex.hpp

Go to the documentation of this file.

/*
    Copyright 2008 Adobe Systems Incorporated
    Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
    or a copy at http://stlab.adobe.com/licenses.html)
*/

/******************************************************************************/

#ifndef ADOBE_SEQUENCE_MVC_MULDEX
#define ADOBE_SEQUENCE_MVC_MULDEX

/******************************************************************************/

#include <boost/static_assert.hpp>

#include <adobe/function_pack.hpp>
#include <adobe/sheet_hooks.hpp>
#include <adobe/selection.hpp>
#include <adobe/sequence_model.hpp>
#include <adobe/zuid.hpp>

/******************************************************************************/

namespace adobe {
f
/******************************************************************************/
/******************************************************************************/
#if 0
#pragma mark -
#endif
/******************************************************************************/
template <typename T>
struct sequence_view_multiplexer
{
    typedef T                                            value_type;
    typedef sequence_model<T>                            sequence_model_type;
    typedef typename sequence_model_type::key_type       key_type;
    typedef typename sequence_model_type::cow_value_type cow_value_type;
    typedef dictionary_t                                 model_type;
    typedef boost::function<void (const model_type&)>    proc_type;

    void refresh(key_type key, cow_value_type value)
    {
        if (proc_m == false)
            return;

        dictionary_t command;

        command[static_name_t("command")] = any_regular_t(static_name_t("refresh"));
        command[static_name_t("key")] = any_regular_t(key);
        command[static_name_t("value")] = any_regular_t(value);

        send(command);
    }

    void extend(key_type before, key_type key, cow_value_type value)
    {
        if (proc_m == false)
            return;

        dictionary_t command;

        command[static_name_t("command")] = any_regular_t(static_name_t("extend"));
        command[static_name_t("before")] = any_regular_t(before);
        command[static_name_t("key")] = any_regular_t(key);
        command[static_name_t("value")] = any_regular_t(value);

        send(command);
    }

    void extend_set(key_type before, const vector<key_type>& key_set)
    {
        if (proc_m == false)
            return;

        dictionary_t command;

        command[static_name_t("command")] = any_regular_t(static_name_t("extend_set"));
        command[static_name_t("before")] = any_regular_t(before);
        command[static_name_t("key_set")] = any_regular_t(key_set);

        send(command);
    }

    void erase(const vector<key_type>& key_set)
    {
        if (proc_m == false)
            return;

        dictionary_t command;

        command[static_name_t("command")] = any_regular_t(static_name_t("erase"));
        command[static_name_t("key_set")] = any_regular_t(key_set);

        send(command);
    }

    void clear()
    {
        if (proc_m == false)
            return;

        dictionary_t command;

        command[static_name_t("command")] = any_regular_t(static_name_t("clear"));

        send(command);
    }

    void monitor(const proc_type& proc)
    { proc_m = proc; }

    void enable(bool) { }

private:
    void send(const adobe::dictionary_t& command)
    {
        // first we send the command
        proc_m(command);

        // then we send an empty dictionary to clear the line
        proc_m(dictionary_t());
    }

    proc_type proc_m;
};

/******************************************************************************/
struct sequence_view_demultiplexer_t
{
    typedef dictionary_t model_type;

    template <typename T>
    explicit sequence_view_demultiplexer_t(T& sequence_view)
    {
        typedef typename T::key_type key_type;

        funnel_m.register_function(static_name_t("refresh"),
                                   boost::function<void (key_type, typename T::cow_value_type)>(boost::bind(&T::refresh, boost::ref(sequence_view), _1, _2)),
                                   static_name_t("key"),
                                   static_name_t("value"));

        funnel_m.register_function(static_name_t("extend"),
                                   boost::function<void (key_type, key_type, typename T::cow_value_type)>(boost::bind(&T::extend, boost::ref(sequence_view), _1, _2, _3)),
                                   static_name_t("before"),
                                   static_name_t("key"),
                                   static_name_t("value"));

        funnel_m.register_function(static_name_t("extend_set"),
                                   boost::function<void (key_type, const vector<key_type>&)>(boost::bind(&T::extend_set, boost::ref(sequence_view), _1, _2)),
                                   static_name_t("before"),
                                   static_name_t("key_set"));

        funnel_m.register_function(static_name_t("erase"),
                                   boost::function<void (const vector<key_type>&)>(boost::bind(&T::erase, boost::ref(sequence_view), _1)),
                                   static_name_t("key_set"));

        funnel_m.register_named0_function(static_name_t("clear"),
                                   boost::function<void ()>(boost::bind(&T::clear, boost::ref(sequence_view))));
    }

    void display(const model_type& value)
    {
        if (value == model_type())
            return;

        funnel_m(value);
    }

private:
    function_pack_t funnel_m;
};

/******************************************************************************/
template <typename SequenceView, typename Sheet>
void attach_sequence_view_to_model(assemblage_t& assemblage,
                                   Sheet&        model,
                                   name_t        cell,
                                   SequenceView& sequence_view)
{
    // This line asserts that sequence_view does in fact model a SequenceView concept.
    boost::function_requires<SequenceViewConcept<SequenceView> >();

    sequence_view_demultiplexer_t* demux(new sequence_view_demultiplexer_t(sequence_view));

    assemblage_cleanup_ptr(assemblage, demux);

    attach_view_to_model(assemblage, model, cell, *demux);
}

/******************************************************************************/
template <typename SequenceModel, typename Sheet>
void attach_sequence_model_view_to_model(assemblage_t&  assemblage,
                                         Sheet&         model,
                                         name_t         cell,
                                         SequenceModel& sequence_model)
{
    typedef typename SequenceModel::value_type                   value_type;
    typedef typename poly_sequence_view<value_type>::type poly_sequence_view_type;

    sequence_view_multiplexer<value_type>* mux(new sequence_view_multiplexer<value_type>());

    assemblage_cleanup_ptr(assemblage, mux);

    attach_controller_to_model(assemblage, model, cell, *mux);

    poly_sequence_view_type* poly_sequence_view(new poly_sequence_view_type(boost::ref(*mux)));

    assemblage_cleanup_ptr(assemblage, poly_sequence_view);

    sequence_model.attach_view(*poly_sequence_view);

    assemblage.cleanup(boost::bind(&SequenceModel::detach_view,
                                   boost::ref(sequence_model),
                                   boost::ref(*poly_sequence_view)));
}

/******************************************************************************/
template <typename SequenceModel, typename SequenceView, typename Sheet>
void attach_sequence_view_muldex(SequenceModel&       sequence_model,
                                 SequenceView&        sequence_view,
                                 Sheet&               model,
                                 name_t        cell,
                                 assemblage_t& assemblage)
{
    attach_sequence_view_to_model(assemblage,
                                  model,
                                  cell,
                                  sequence_view);

    attach_sequence_model_view_to_model(assemblage,
                                        model,
                                        cell,
                                        sequence_model);
}

/******************************************************************************/
#if 0
#pragma mark -
#endif
/******************************************************************************/
template <typename T>
struct sequence_model_multiplexer
{
    typedef T                                         value_type;
    typedef adobe::sequence_key<T>                    key_type;
    typedef dictionary_t                              model_type;
    typedef boost::function<void (const model_type&)> proc_type;

    template <typename SequenceController>
    sequence_model_multiplexer(SequenceController& controller)
    {
        BOOST_STATIC_ASSERT((boost::is_same<T, typename sequence_controller_value_type<SequenceController>::type>::value));

        poly_m.reset(new typename poly_sequence_model<T>::type(boost::ref(*this)));

        controller.monitor_sequence(*poly_m);
    }

    /*
        The following are sequence_controller routines.
    */
    
    void push_back(const value_type& value)
    {
        if (proc_m == false)
            return;

        dictionary_t command;

        command[static_name_t("command")] = any_regular_t(static_name_t("push_back"));
        command[static_name_t("value")] = any_regular_t(value);

        send(command);
    }

    void set(key_type key, const value_type& value)
    {
        if (proc_m == false)
            return;

        dictionary_t command;

        command[static_name_t("command")] = any_regular_t(static_name_t("set"));
        command[static_name_t("key")] = any_regular_t(key);
        command[static_name_t("value")] = any_regular_t(value);

        send(command);
    }

    void insert(key_type before, const value_type& value)
    {
        if (proc_m == false)
            return;

        dictionary_t command;

        command[static_name_t("command")] = any_regular_t(static_name_t("insert"));
        command[static_name_t("before")] = any_regular_t(before);
        command[static_name_t("value")] = any_regular_t(value);

        send(command);
    }

    void insert_set(key_type before, const vector<value_type>& value_set)
    {
        if (proc_m == false)
            return;

        dictionary_t command;

        command[static_name_t("command")] = any_regular_t(static_name_t("insert_set"));
        command[static_name_t("before")] = any_regular_t(before);
        command[static_name_t("value_set")] = any_regular_t(value_set);

        send(command);
    }

    void erase(const vector<key_type>& key_set)
    {
        if (proc_m == false)
            return;

        dictionary_t command;

        command[static_name_t("command")] = any_regular_t(static_name_t("erase"));
        command[static_name_t("key_set")] = any_regular_t(key_set);

        send(command);
    }

    void clear()
    {
        if (proc_m == false)
            return;

        dictionary_t command;

        command[static_name_t("command")] = any_regular_t(static_name_t("clear"));

        send(command);
    }

    /*
        The following are property_model_controller routines.
    */
    
    void monitor(const proc_type& proc)
    { proc_m = proc; }

    void enable(bool) { }

private:
    void send(const adobe::dictionary_t& command)
    {
        // first we send the command
        proc_m(command);

        // then we send an empty dictionary to clear the line
        proc_m(dictionary_t());
    }

    proc_type                                       proc_m;
    auto_ptr<typename poly_sequence_model<T>::type> poly_m;
};

/******************************************************************************/
template <typename T>
struct sequence_model_demultiplexer
{
    typedef T                      value_type;
    typedef adobe::sequence_key<T> key_type;
    typedef dictionary_t           model_type;

    sequence_model_demultiplexer() :
        sequence_m(0)
    { }

    void display(const model_type& value)
    {
        if (value == model_type())
            return;

        funnel_m(value);
    }

    void monitor_sequence(typename poly_sequence_model<T>::type& sequence)
    {
        sequence_m = &sequence;

        funnel_m.register_function(static_name_t("push_back"),
                                   boost::function<void (const value_type&)>(boost::bind(&poly_sequence_model<T>::type::push_back, boost::ref(*sequence_m), _1)),
                                   static_name_t("value"));

        funnel_m.register_function(static_name_t("set"),
                                   boost::function<void (key_type pos, const value_type&)>(boost::bind(&poly_sequence_model<T>::type::set, boost::ref(*sequence_m), _1, _2)),
                                   static_name_t("key"),
                                   static_name_t("value"));

        funnel_m.register_function(static_name_t("insert"),
                                   boost::function<void (key_type pos, const value_type&)>(boost::bind(&poly_sequence_model<T>::type::insert, boost::ref(*sequence_m), _1, _2)),
                                   static_name_t("before"),
                                   static_name_t("value"));

        funnel_m.register_function(static_name_t("insert_set"),
                                   boost::function<void (key_type pos, const vector<value_type>&)>(boost::bind(&poly_sequence_model<T>::type::insert_set, boost::ref(*sequence_m), _1, _2)),
                                   static_name_t("before"),
                                   static_name_t("value_set"));

        funnel_m.register_function(static_name_t("erase"),
                                   boost::function<void (const vector<key_type>& selection)>(boost::bind(&poly_sequence_model<T>::type::erase, boost::ref(*sequence_m), _1)),
                                   static_name_t("key_set"));

        funnel_m.register_named0_function(static_name_t("clear"),
                                   boost::function<void ()>(boost::bind(&poly_sequence_model<T>::type::clear, boost::ref(*sequence_m))));
    }

private:
    typename poly_sequence_model<T>::type* sequence_m;
    function_pack_t                        funnel_m;
};

/******************************************************************************/
template <typename SequenceController, typename Sheet>
void attach_sequence_controller_to_model(assemblage_t&       assemblage,
                                         Sheet&              model,
                                         name_t              cell,
                                         SequenceController& sequence_controller)
{
    // This line asserts that sequence_controller does in fact model a SequenceController concept.
    boost::function_requires<SequenceControllerConcept<SequenceController> >();

    typedef typename sequence_controller_value_type<SequenceController>::type value_type;
    typedef typename poly_sequence_controller<value_type>::type               poly_sequence_controller_type;

    sequence_model_multiplexer<value_type>* mux(new sequence_model_multiplexer<value_type>(sequence_controller));

    assemblage_cleanup_ptr(assemblage, mux);

    attach_controller_to_model(assemblage, model, cell, *mux);
}

/******************************************************************************/
template <typename SequenceModel, typename Sheet>
void attach_sequence_model_controller_to_model(assemblage_t&  assemblage,
                                               Sheet&         model,
                                               name_t         cell,
                                               SequenceModel& sequence_model)
{
    typedef typename SequenceModel::value_type                  value_type;
    typedef typename poly_sequence_controller<value_type>::type poly_sequence_controller_type;

    sequence_model_demultiplexer<value_type>* demux(new sequence_model_demultiplexer<value_type>());

    assemblage_cleanup_ptr(assemblage, demux);

    poly_sequence_controller_type* poly_sequence_controller(new poly_sequence_controller_type(boost::ref(*demux)));

    assemblage_cleanup_ptr(assemblage, poly_sequence_controller);

    sequence_model.attach_controller(*poly_sequence_controller);

    assemblage.cleanup(boost::bind(&SequenceModel::detach_controller,
                                   boost::ref(sequence_model),
                                   boost::ref(*poly_sequence_controller)));

    attach_view_to_model(assemblage, model, cell, *demux);
}

/******************************************************************************/
template <typename SequenceModel, typename SequenceController, typename Sheet>
void attach_sequence_controller_muldex(SequenceModel&      sequence_model,
                                       SequenceController& sequence_controller,
                                       Sheet&              model,
                                       name_t              cell,
                                       assemblage_t&       assemblage)
{
    attach_sequence_controller_to_model(assemblage,
                                        model,
                                        cell,
                                        sequence_controller);

    attach_sequence_model_controller_to_model(assemblage,
                                              model,
                                              cell,
                                              sequence_model);
}

/******************************************************************************/
template <typename SequenceModel, typename Sheet>
void attach_sequence_model_to_property_model(SequenceModel& sequence_model,
                                             Sheet&         model,
                                             name_t         view_line_cell,
                                             name_t         controller_line_cell,
                                             assemblage_t&  assemblage)
{
    attach_sequence_model_controller_to_model(assemblage,
                                              model,
                                              controller_line_cell,
                                              sequence_model);

    attach_sequence_model_view_to_model(assemblage,
                                        model,
                                        view_line_cell,
                                        sequence_model);
}

/******************************************************************************/
template <typename SequenceWidget, typename Sheet>
void attach_sequence_widget_to_property_model(SequenceWidget& sequence_widget,
                                              Sheet&          model,
                                              name_t          view_line_cell,
                                              name_t          controller_line_cell,
                                              assemblage_t&   assemblage)
{
    attach_sequence_controller_to_model(assemblage,
                                        model,
                                        controller_line_cell,
                                        sequence_widget);

    attach_sequence_view_to_model(assemblage,
                                  model,
                                  view_line_cell,
                                  sequence_widget);
}

/******************************************************************************/

} // namespace adobe

/******************************************************************************/
// ADOBE_SEQUENCE_MVC_MULDEX
#endif
/******************************************************************************/