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.


Related Docs

Win32 Tree View Control Documentation

Win32 List View Control Documentation

Carbon Tree Control API Documentation (Data Browser)


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


 template <typename T>
 class sequence_model
     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);


 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);


 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);