checked_list_box.h

Go to the documentation of this file.

#pragma once
#include "item_check_event_handler.h"
#include "list_box.h"
 
namespace xtd {
  namespace forms {
    class forms_export_ checked_list_box : public list_box {
    public:
      class item : public list_box::item {
      public:
        item() = default;
        item(const xtd::ustring& value) : list_box::item(value) {}
        item(const xtd::ustring& value, bool checked) : list_box::item(value), check_state_(checked ? forms::check_state::checked : forms::check_state::unchecked) {}
        item(const xtd::ustring& value, forms::check_state check_state) : list_box::item(value), check_state_(check_state) {}
        item(const xtd::ustring& value, const std::any& tag) : list_box::item(value, tag) {}
        item(const xtd::ustring& value, bool checked, const std::any& tag) : list_box::item(value, tag), check_state_(checked ? forms::check_state::checked : forms::check_state::unchecked) {}
        item(const xtd::ustring& value, forms::check_state check_state, const std::any& tag) : list_box::item(value, tag), check_state_(check_state) {}
        
        item(const char* value) : list_box::item(value) {}
        item(const item& value) = default;
        item& operator=(const item& value) = default;
        bool operator==(const item& value) const {return list_box::item::operator==(value);}
        bool operator!=(const item& value) const {return list_box::item::operator!=(value);}
        bool operator<(const item& value) const {return list_box::item::operator<(value);}
        bool operator<=(const item& value) const {return list_box::item::operator<=(value);}
        bool operator>(const item& value) const {return list_box::item::operator>(value);}
        bool operator>=(const item& value) const {return list_box::item::operator>=(value);}
        friend std::ostream& operator<<(std::ostream& os, const item& value) {return os << value.to_string();}
 
        virtual bool checked() const {return check_state_ != forms::check_state::unchecked;}
        
        virtual forms::check_state check_state() const {return check_state_;}
        
      private:
        forms::check_state check_state_ = forms::check_state::unchecked;
      };
      
      using object_collection = layout::arranged_element_collection<item>;
 
      using checked_index_collection = std::vector<size_t>;
 
      using checked_item_collection = std::vector<item>;
 
      using selected_object_collection = std::vector<item>;
 
      checked_list_box();
    
      checked_index_collection checked_indices() const;
      
      checked_item_collection checked_items() const;
      
      object_collection& items() {return items_;}
      const object_collection& items() const {return items_;}
      const list_box& items(const object_collection& items) {
        items_ = items;
        return *this;
      }
      
      using list_box::selected_index;
      list_control& selected_index(size_t selected_index) override;
      
      std::vector<size_t> selected_indices() const override;
      
      const item& selected_item() const {return selected_item_;}
      list_box& selected_item(const item& selected_item);
 
      selected_object_collection selected_items() const;
      
      using list_box::text;
      control& text(const xtd::ustring& text) override {
        selected_item_ = {text};
        return *this;
      }
  
      void begin_update();
      void end_update();
 
      bool get_item_checked(size_t index) const;
      
      forms::check_state get_item_check_state(size_t index) const;
 
      const xtd::ustring& get_item_text(size_t index) const;
 
      void set_item_checked(size_t index, bool checked);
 
      void set_item_check_state(size_t index, forms::check_state check_state);
 
      void set_item_text(size_t index, const xtd::ustring& text);
      
      event<checked_list_box, item_check_event_handler> item_check;
 
    protected:
      bool allow_selection() override {return selection_mode_ != forms::selection_mode::none;}
 
      forms::create_params create_params() const override;
 
      void on_handle_created(const event_args& e) override;
      
      virtual void on_item_check(item_check_event_args& e) {item_check(*this, e);}
      
      void on_selected_value_changed(const event_args& e) override;
 
      void wnd_proc(message& message) override;
      
      void wm_reflect_command(message& message) override;
      
      void wm_mouse_double_click(message& message) override;
 
      void wm_mouse_down(message& message) override;
      
      void wm_mouse_up(message& message) override;
      
      object_collection items_;
      item selected_item_;
    };
  }
}