List/Tree Widget

From Adobe Open Source Wiki
Revision as of 23:36, 31 January 2007 by FosterBrereton (Talk | contribs)

Jump to: navigation, search

(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.

Contents

Related Docs

Win32 Tree View Control Documentation

Win32 List View Control Documentation

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

 template <typename T>
 class sequence_model
 {
 public:
     sequence_model(std::size_t count = 0);
 
     typedef T                                          value_type;
     typedef dirty_value<T>                             dirty_type;
     typedef std::vector<dirty_type>                    model_type;
     typedef typename model_type::iterator              iterator;
     typedef typename model_type::const_iterator        const_iterator;
     typedef boost::signals::connection                 connection_type;
     typedef typename model_type::size_type             size_type;
     typedef boost::function<void (iterator, iterator)> inplace_operation_proc_t;
 
     typedef boost::function<void (size_type pos, const T* first, const T* last)> monitor_insert_proc_t;
     typedef boost::function<void (size_type index, const T& value)>              monitor_set_proc_t;
 
     static const size_type npos;
 
     const_iterator begin() const;
     const_iterator end() const;
 
     size_type size() const;
     size_type max_size() const;
 
     bool empty() const;
 
     const T& at(size_type n) const;
     const T& operator[](size_type n);
 
     void push_back(const value_type& x);
 
     void set(size_type pos, const value_type& x);
 
     template <typename I>
     void insert(size_type pos, I first, I last);
 
     void inplace_operation(const inplace_operation_proc_t& proc,
                            size_type                       pos = 0,
                            size_type                       n = sequence_model::npos);
 
     connection_type monitor_insert(const monitor_insert_proc_t& proc);
     connection_type monitor_set(const monitor_set_proc_t& proc);
 };

View

 struct list_view_t
 {
   typedef model_type::value_type value_type;
   typedef model_type::size_type  size_type;
 
   void set(size_type index, const value_type& value);
 
   void insert(size_type pos, const value_type* first, const value_type* last);
 };

Controller

 struct list_controller_t
 {
   typedef model_type::inplace_operation_proc_t inplace_operation_proc_t;
   typedef boost::function<void (size_type, const value_type&)> monitor_set_callback_t;
   typedef boost::function<void (size_type, const value_type*, const value_type*)> monitor_insert_callback_t;
   typedef boost::function<void (const inplace_operation_proc_t& proc, size_type, size_type)> monitor_inplace_operation_callback_t;
 
   void enable(bool make_enabled);
   
   void monitor_set(const monitor_set_callback_t& how);
   
   void monitor_insert(const monitor_insert_callback_t& how);
   
   void monitor_inplace_operation(const monitor_inplace_operation_callback_t& how);
 };