console.h

Go to the documentation of this file.

#pragma once
#include "console_cancel_event_handler.h"
#include "console_color.h"
#include "console_key_info.h"
#include "console_special_key.h"
#include "event.h"
#include "static.h"
#include "types.h"
#include "ustring.h"
 
namespace xtd {
  class console final static_ {
  public:
    static std::ostream error;
    static std::istream in;
    static std::ostream out;
    
    static event<console, console_cancel_event_handler> cancel_key_press;
    
    static console_color background_color();
    static void background_color(console_color color);
    
    static void beep();
    static void beep(uint32_t frequency, uint32_t duration);
    
    static int32_t buffer_height();
    static void buffer_height(int32_t height);
    
    static int32_t buffer_width();
    static void buffer_width(int32_t width);
    
    static bool caps_lock();
    
    static void clear();
    
    static int32_t cursor_left();
    static void cursor_left(int32_t left);
    
    static int32_t cursor_size();
    static void cursor_size(int32_t size);
    
    static int32_t cursor_top();
    static void cursor_top(int32_t 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_t input_code_page();
    static bool input_code_page(int32_t code_page);
    
    static bool is_error_redirected();
    static bool is_in_redirected();
    static bool is_out_redirected();
    
    static bool key_available();
    
    static int32_t largest_window_height();
    static int32_t largest_window_width();
    
    static bool number_lock();
    
    static std::ostream open_standard_error();
    static std::istream open_standard_input();
    static std::ostream open_standard_output();
    
    static int32_t output_code_page();
    static bool output_code_page(int32_t code_page);
    
    static xtd::ustring read_line();
    static console_key_info read_key();
    static console_key_info read_key(bool intercept);
    
    static bool reset_color();
    
    static void set_cursor_position(int32_t left, int32_t 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 xtd::ustring title();
    static void title(const xtd::ustring& title);
    
    static bool treat_control_c_as_input();
    static void treat_control_c_as_input(bool treat_control_c_as_input);
    
    static int32_t window_height();
    static void window_height(int32_t height);
    
    static int32_t window_left();
    static void window_left(int32_t left);
    
    static int32_t window_top();
    static void window_top(int32_t top);
    
    static int32_t window_width();
    static void window_width(int32 width);
    
    template<typename arg_t>
    static void write(arg_t&& value) {write_(xtd::ustring::format("{}",  value));}
    
    template<typename type_t>
    static void write(std::initializer_list<type_t>&& il) {write_(xtd::ustring::format("{}", il));}
    
    template<typename ... args_t>
    static void write(const xtd::ustring& fmt, args_t&& ... values) {write_(xtd::ustring::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::ustring::format("{}", value));}
    
    template<typename type_t>
    static void write_line(const std::initializer_list<type_t>& il) {write_line_(xtd::ustring::format("{}", il));}
    
    template<typename ... args_t>
    static void write_line(const xtd::ustring& fmt, args_t&& ... values) {write_line_(xtd::ustring::format(fmt, std::forward<args_t>(values)...));}
 
    static void __internal_cancel_key_press__(xtd::console_cancel_event_args& e);
  private:
    static void write_(const ustring& value);
    static void write_line_(const ustring& value);
  };
}