console.hpp

Go to the documentation of this file.

 
#pragma once
#include "collections/generic/key_value_pair.hpp"
#include "io/stream_writer.hpp"
#include "console_cancel_event_handler.hpp"
#include "console_color.hpp"
#include "console_key_info.hpp"
#include "console_special_key.hpp"
#include "event.hpp"
#include "static.hpp"
#include "types.hpp"
#include "string.hpp"
 
namespace xtd {
  class environment;
  
  class console final static_ {
  public:
    
    static std::ostream error;
    static std::istream in;
    static std::ostream out;
    
    
    static bool auto_flush_out();
    static void auto_flush_out(bool value);
    
    static console_color background_color();
    static void background_color(console_color color);
    
    static int32 buffer_height();
    static void buffer_height(int32 height);
    
    static int32 buffer_width();
    static void buffer_width(int32 width);
    
    static bool caps_lock();
    
    static int32 cursor_left();
    static void cursor_left(int32 left);
    
    static int32 cursor_size();
    static void cursor_size(int32 size);
    
    static int32 cursor_top();
    static void cursor_top(int32 top);
    
    static bool cursor_visible();
    static void cursor_visible(bool visible);
    
    static console_color foreground_color();
    static bool foreground_color(console_color color);
    
    static int32 input_code_page();
    static void input_code_page(int32 code_page);
    
    static bool is_error_redirected();
    static bool is_input_redirected();
    static bool is_output_redirected();
    
    static bool key_available();
    
    static int32 largest_window_height();
    static int32 largest_window_width();
    
    static bool number_lock();
    
    static int32 output_code_page();
    static void output_code_page(int32 code_page);
    
    static xtd::string title();
    static void title(const xtd::string& title);
    
    static bool treat_control_c_as_input();
    static void treat_control_c_as_input(bool treat_control_c_as_input);
    
    static int32 window_height();
    static void window_height(int32 height);
    
    static int32 window_left();
    static void window_left(int32 left);
    
    static int32 window_top();
    static void window_top(int32 top);
    
    static int32 window_width();
    static void window_width(int32 width);
    
    
    static event<console, console_cancel_event_handler> cancel_key_press;
    
    
    static void beep();
    static void beep(uint32 frequency, uint32 duration);
    
    static void clear();
    
    static xtd::collections::generic::key_value_pair<int32, int32> get_cursor_position();
    
    static std::ostream open_standard_error();
    static std::istream open_standard_input();
    static std::ostream open_standard_output();
    
    static int32 read();
    
    static console_key_info read_key();
    static console_key_info read_key(bool intercept);
    
    static xtd::string read_line();
    static xtd::string read_line(bool intercept);
 
    static bool reset_color();
    
    static void set_cursor_position(int32 left, int32 top);
    
    static void set_error(const std::ostream& os);
    static void set_in(const std::istream& is);
    static void set_out(const std::ostream& os);
    
    static void set_window_position(int32 left, int32 top);
    
    static void set_window_size(int32 width, int32 height);
    
    template<typename arg_t>
    static void write(arg_t&& value) {write_(xtd::string::format("{}",  value));}
    
    template<typename type_t>
    static void write(std::initializer_list<type_t>&& il) {write_(xtd::string::format("{}", il));}
    
    template<typename ... args_t>
    static void write(const xtd::string& fmt, args_t&& ... values) {write_(xtd::string::format(fmt, std::forward<args_t>(values)...));}
    
    static void write_line();
    
    template<typename arg_t>
    static void write_line(arg_t&& value) {write_line_(xtd::string::format("{}", value));}
    
    template<typename type_t>
    static void write_line(const std::initializer_list<type_t>& il) {write_line_(xtd::string::format("{}", il));}
    
    template<typename ... args_t>
    static void write_line(const xtd::string& fmt, args_t&& ... values) {write_line_(xtd::string::format(fmt, std::forward<args_t>(values)...));}
    
  private:
    friend class xtd::environment;
    static bool on_cancel_key_press(int32 special_key);
    static void register_cancel_key_press();
    
    static void write_(const string& value);
    static void write_line_(const string& value);
  };
}