List/Tree Widget

(For the time being the focus will be on lists, not heirarchical trees.)

The tricky part of a list controller/view is that you have a controller/view on a sequence. You need to figure out:

1. How to communicate requests for changes to the sequence
2. What those requests are
3. How to communicate a change in the visible portion of the sequence to the view

We assume the sequences in a list are disjoint.

Related Docs

Win32 Tree View Control Documentation

Win32 List View Control Documentation (List View)

Carbon Tree Control API Documentation (Data Browser)

API

This API set will be updated piecemeal as I am able to further the implementation

Assume for the time being that the model_type is a simple string for now...

Model

 class list_model_t
 {
 public:
   typedef std::string                   value_type;
   typedef std::list<value_type>         model_type;
   typedef model_type::const_iterator    iterator;
   typedef std::pair<iterator, iterator> range_type;
   typedef std::vector<range_type>       selection_type;
   typedef boost::signals::connection    connection_type;
 
   typedef boost::function<void (iterator, const selection_type&)> monitor_splice_callback_t;
   typedef boost::function<void (iterator)>                        monitor_value_callback_t;
 
   void push_front(const value_type& value);
   void push_back(const value_type& value);
 
   void splice(iterator before, const selection_type& value);
 
   void set(iterator who, const value_type& value);
 
   connection_type monitor_splice(const monitor_splice_callback_t& how);
   connection_type monitor_value(const monitor_value_callback_t& how);
 
 private:
   typedef boost::signal<void (iterator, const selection_type&)> splice_callback_set_t;
   typedef boost::signal<void (iterator)>                        value_callback_set_t;
 
   model_type            model_m;
   splice_callback_set_t splice_callback_set_m;
   value_callback_set_t  value_callback_set_m;
 };

View

 struct list_view_t
 {
   typedef model_type::const_iterator    iterator;
   typedef std::vector<range_type>       selection_type;
 
   void set(iterator who);
 
   void splice(iterator before, const selection_type& value);
 };

Controller

 struct list_controller_t
 {
   typedef adobe::list_model_t::monitor_splice_callback_t          monitor_splice_callback_t;
   typedef boost::function<void (const value_type&)>               monitor_push_back_callback_t;
   typedef boost::function<void (const value_type&)>               monitor_push_front_callback_t;
   typedef boost::function<void (iterator who, const value_type&)> monitor_value_callback_t;
 
   void enable(bool make_enabled);
 
   void monitor_value(const monitor_value_callback_t& how);
 
   void monitor_splice(const monitor_splice_callback_t& how);
 
   void monitor_push_front(const monitor_push_front_callback_t& how);
 
   void monitor_push_back(const monitor_push_back_callback_t& how);
 };