text_box_base.h

Go to the documentation of this file.

 
#pragma once
#include "control.h"
#include <xtd/bit_converter.h>
#include <xtd/argument_out_of_range_exception.h>
 
namespace xtd {
  namespace forms {
    class text_box_base : public control {
    public:
      virtual bool accepts_tab() const {return accepts_tab_;}
      virtual text_box_base& accepts_tab(bool value) {
        if (accepts_tab_ != value) {
          accepts_tab_ = value;
          recreate_handle();
          on_accepts_tab_changed(event_args::empty);
        }
        return *this;
      }
      
      virtual forms::border_style border_style() const {return border_style_;}
      virtual text_box_base& border_style(forms::border_style border_style) {
        if (border_style_ != border_style) {
          border_style_ = border_style;
          recreate_handle();
          on_border_style_changed(event_args::empty);
        }
        return *this;
      }
 
 
      forms::cursor default_cursor() const override {return forms::cursors::ibeam();}
 
      std::vector<xtd::ustring> lines() const {
        return text().split({'\n'});
      }
      text_box_base& lines(const std::vector<xtd::ustring>& lines) {
        text(xtd::ustring::join("\n", lines));
        return *this;
      }
      
      virtual bool multiline() const {return multiline_;}
      virtual text_box_base& multiline(bool value) {
        if (multiline_ != value) {
          multiline_ = value;
          recreate_handle();
          on_multiline_changed(event_args::empty);
        }
        return *this;
      }
      
      virtual bool read_only() const {return read_only_;}
      virtual text_box_base& read_only(bool value) {
        if (read_only_ != value) {
          read_only_ = value;
          recreate_handle();
          on_read_only_changed(event_args::empty);
        }
        return *this;
      }
 
      virtual size_t selection_length() const {return selection_length_;}
      virtual text_box_base& selection_length(size_t value) {
        select(selection_start_, value);
        return *this;
      }
      
      virtual size_t selection_start() const {return selection_start_;}
      virtual text_box_base& selection_start(size_t value) {
        select(value, selection_length_);
        return *this;
      }
      
      virtual bool word_wrap() const {return word_wrap_;}
      virtual text_box_base& word_wrap(bool value) {
        if (word_wrap_ != value) {
          word_wrap_ = value;
          recreate_handle();
        }
        return *this;
      }
 
      virtual void append_text(const xtd::ustring& value) {
        suspend_layout();
        text(text() + value);
        select(text().size(), 0);
        resume_layout();
      }
      
      void clear() {
        text("");
      }
      
      virtual void select(size_t start, size_t length) {
        if (selection_start_ != start || length != selection_length_) {
          if (start > text().size()) throw argument_out_of_range_exception("start greater than text size"_t, current_stack_frame_);
          if (start + length > text().size()) throw argument_out_of_range_exception("start + length greater than text size"_t, current_stack_frame_);
          selection_start_ = start;
          selection_length_ = length;
        }
      }
      
      void select_all() {
        select(0, text().size());
      }
      
      event<text_box_base, event_handler> accepts_tab_changed;
      
      event<text_box_base, event_handler> border_style_changed;
      
      event<text_box_base, event_handler> multiline_changed;
      
      event<text_box_base, event_handler> read_only_changed;
 
    protected:
      text_box_base() = default;
 
      virtual void on_accepts_tab_changed(const event_args& e) {
        if (can_raise_events()) accepts_tab_changed(*this, e);
      }
      
      virtual void on_border_style_changed(const event_args& e) {
        if (can_raise_events()) border_style_changed(*this, e);
      }
      
      virtual void on_multiline_changed(const event_args& e) {
        if (can_raise_events()) multiline_changed(*this, e);
      }
 
      virtual void on_read_only_changed(const event_args& e) {
        if (can_raise_events()) read_only_changed(*this, e);
      }
 
      bool accepts_tab_ = false;
      xtd::forms::border_style border_style_ = xtd::forms::border_style::fixed_single;
      bool multiline_ = false;
      bool read_only_ = false;
      bool word_wrap_ = true;
      mutable size_t selection_start_ = 0;
      mutable size_t selection_length_ = 0;
    };
  }
}