input_dialog.h

Go to the documentation of this file.

#pragma once
#include <string>
#include <xtd/delegate.h>
#include "dialog_style.h"
#include "character_casing.h"
#include "common_dialog.h"
 
namespace xtd {
  namespace forms {
    class forms_export_ input_dialog : public common_dialog {
    public:
      input_dialog() = default;
 
      xtd::forms::character_casing character_casing() const {return character_casing_;}
      input_dialog& character_casing(xtd::forms::character_casing character_casing) {
        if (character_casing_ != character_casing) {
          character_casing_ = character_casing;
          switch (character_casing_) {
            case xtd::forms::character_casing::upper: value_ = value_.to_upper(); break;
            case xtd::forms::character_casing::lower: value_ = value_.to_lower(); break;
            default: break;
          }
        }
        return *this;
      }
      
      xtd::forms::dialog_style dialog_style() const {return dialog_style_;}
      input_dialog& dialog_style(xtd::forms::dialog_style dialog_style) {
        if (dialog_style_ != dialog_style)
          dialog_style_ = dialog_style;
        return *this;
      }
      
      bool multiline() const {return multiline_;}
      input_dialog& multiline(bool multiline) {
        if (multiline_ != multiline)
          multiline_ = multiline;
        return *this;
      }
 
      xtd::ustring message() const {return message_;}
      input_dialog& message(const xtd::ustring& message) {
        if (message_ != message)
          message_ = message;
        return *this;
      }
      
      xtd::ustring text() const {return text_;}
      input_dialog& text(const xtd::ustring& text) {
        if (text_ != text)
          text_ = text;
        return *this;
      }
 
      bool use_system_password_char() const {return use_system_password_char_;}
      input_dialog&  use_system_password_char(bool use_system_password_char) {
        use_system_password_char_ = use_system_password_char;
        return *this;
      }
      
      xtd::ustring value() const {return value_;}
      input_dialog& value(const xtd::ustring& value) {
        if (value != value_) {
          switch (character_casing_) {
            case xtd::forms::character_casing::normal: value_ = value; break;
            case xtd::forms::character_casing::upper: value_ = value.to_upper(); break;
            case xtd::forms::character_casing::lower: value_ = value.to_lower(); break;
          }
        }
        return *this;
      }
 
      bool word_wrap() const {return word_wrap_;}
      input_dialog& word_wrap(bool word_wrap) {
        if (word_wrap_ != word_wrap)
          word_wrap_ = word_wrap;
        return *this;
      }
      
      void reset() override;
 
    protected:
      bool run_dialog(intptr_t owner) override;
      void run_sheet(intptr_t owner) override;
 
      xtd::forms::character_casing character_casing_ = xtd::forms::character_casing::normal;
      xtd::forms::dialog_style dialog_style_ = xtd::forms::dialog_style::standard;
      bool multiline_ = false;
      xtd::ustring message_;
      xtd::ustring text_;
      bool use_system_password_char_ = false;
      xtd::ustring value_;
      bool word_wrap_ = true;
    };
  }
}