Inheritance diagram for xtd::console:

Definition

Represents the standard input, output, and error streams for console applications.

Header: #include <xtd/console>

Namespace: xtd

Library: xtd.core

Examples: The following example demonstrates how to read data from, and write data to, the standard input and output streams. Note that these streams can be redirected by using the set_in and set_out methods.
#include <xtd/xtd>

auto main() -> int {

console::write("Hello ");

console::write_line("World!");

console::write("Enter your name: ");

string name = console::read_line();

console::write("Good day, ");

console::write(name);

console::write_line("!");

}

// This code produces the following output :

//

// Hello World!

// Enter your name: James

// Good day, James!

xtd::console::read_line
static auto read_line() -> xtd::string
Reads the next line of characters from the standard input stream.

xtd::console::write
static auto write(arg_t &&value) -> void
Writes the text representation of the specified value to the standard output stream.
Definition console.hpp:490

xtd::console::write_line
static auto write_line() -> void
Writes the current line terminator to the standard output stream using the specified format informati...

#include <xtd/xtd>

auto main() -> int {

auto& is = console::in;

auto& os = console::out;

os << "Ola Mundo!" << environment::new_line;

os << "What is your name: ";

auto name = string::empty_string;

is >> name;

os << "Buenos Dias, " << name << environment::new_line;

}

// This code produces the following output :

//

// Ola Mundo!

// What is your name: James

// Buenos Dias, James!

xtd::basic_string< char >::empty_string
static const basic_string empty_string
Definition basic_string.hpp:119

xtd::console::in
static std::istream in
Gets the standard input stream. A std::basic_istream<char_t> that represents the standard input strea...
Definition console.hpp:48

xtd::console::out
static std::ostream out
Gets the standard output stream. A std::basic_ostream<char_t> that represents the standard output str...
Definition console.hpp:53

xtd::environment::new_line
static auto new_line() noexcept -> xtd::string
Gets the newline string defined for this environment.

xtd::is
auto is(xtd::any value) -> bool
Checks if the result of an expression is compatible with a given type.
Definition is.hpp:485

Public Fields
static std::ostream	error
	Gets the error output stream. A std::basic_ostream<char_t> that represents the error output stream.
static std::istream	in
	Gets the standard input stream. A std::basic_istream<char_t> that represents the standard input stream.
static std::ostream	out
	Gets the standard output stream. A std::basic_ostream<char_t> that represents the standard output stream.

Public Static Events
static event< console, console_cancel_event_handler >	cancel_key_press
	Occurs when the Control modifier key (Ctrl) and either the ConsoleKey.C console key (C) or the Break key are pressed simultaneously (Ctrl+C or Ctrl+Break).

Public Static Properties
static auto	auto_flush_out () -> bool
	Gets a value indicating whether the xtd::console::out will flush its buffer to the underlying stream after every call to xtd::console::write and xtd::console::write_line.
static auto	auto_flush_out (bool value) -> void
	Sets a value indicating whether the xtd::console::out will flush its buffer to the underlying stream after every call to xtd::console::write and xtd::console::write_line.
static auto	background_color () -> console_color
	Gets the background color of the console.
static auto	background_color (console_color color) -> void
	Sets the background color of the console.
static auto	buffer_height () -> int32
	Gets the height of the buffer area.
static auto	buffer_height (int32 height) -> void
	Sets or sets the height of the buffer area.
static auto	buffer_width () -> int32
	Gets the width of the buffer area.
static auto	buffer_width (int32 width) -> void
	Sets the width of the buffer area.
static auto	caps_lock () -> bool
	Gets a value indicating whether the CAPS LOCK keyboard toggle is turned on or turned off.
static auto	cursor_left () -> int32
	Gets the column position of the cursor within the buffer area.
static auto	cursor_left (int32 left) -> void
	Sets the column position of the cursor within the buffer area.
static auto	cursor_size () -> int32
	Gets or sets the height of the cursor within a character cell.
static auto	cursor_size (int32 size) -> void
	Sets the height of the cursor within a character cell.
static auto	cursor_top () -> int32
	Gets the row position of the cursor within the buffer area.
static auto	cursor_top (int32 top) -> void
	Sets the row position of the cursor within the buffer area.
static auto	cursor_visible () -> bool
	Gets a value indicating whether the cursor is visible.
static auto	cursor_visible (bool visible) -> void
	Sets a value indicating whether the cursor is visible.
static auto	foreground_color () -> console_color
	Gets the foreground color of the console.
static auto	foreground_color (console_color color) -> bool
	Sets the foreground color of the console.
static auto	input_code_page () -> int32
	Gets the code page the console uses to read input.
static auto	input_code_page (int32 code_page) -> void
	Sets the code page the console uses to read input.
static auto	is_error_redirected () -> bool
	Gets a value that indicates whether the error output stream has been redirected from the standard error stream.
static auto	is_input_redirected () -> bool
	Gets a value that indicates whether the input stream has been redirected from the standard input stream.
static auto	is_output_redirected () -> bool
	Gets a value that indicates whether the output stream has been redirected from the standard output stream.
static auto	key_available () -> bool
	Gets a value indicating whether a key press is available in the input stream.
static auto	largest_window_height () -> int32
	Gets the largest possible number of console window rows, based on the current font and screen resolution.
static auto	largest_window_width () -> int32
	Gets the largest possible number of console window columns, based on the current font and screen resolution.
static auto	number_lock () -> bool
	Gets a value indicating whether the NUM LOCK keyboard toggle is turned on or turned off.
static auto	output_code_page () -> int32
	Gets the code page the console uses to write output.
static auto	output_code_page (int32 code_page) -> void
	Sets the code page the console uses to write output.
static auto	title () -> xtd::string
	Gets the title to display in the console title bar.
static auto	title (const xtd::string &title) -> void
	Sets the title to display in the console title bar.
static auto	treat_control_c_as_input () -> bool
	Gets a value indicating whether the combination of the Control modifier key and C console key (Ctrl+C) is treated as ordinary input or as an interruption that is handled by the operating system.
static auto	treat_control_c_as_input (bool treat_control_c_as_input) -> void
	Sets a value indicating whether the combination of the Control modifier key and C console key (Ctrl+C) is treated as ordinary input or as an interruption that is handled by the operating system.
static auto	window_height () -> int32
	Gets the height of the console window area.
static auto	window_height (int32 height) -> void
	Sets the height of the console window area.
static auto	window_left () -> int32
	Gets the left of the console window area.
static auto	window_left (int32 left) -> void
	Sets the left of the console window area.
static auto	window_top () -> int32
	Gets the top of the console window area.
static auto	window_top (int32 top) -> void
	Sets the top of the console window area.
static auto	window_width () -> int32
	Gets the width of the console window area.
static auto	window_width (int32 width) -> void
	Sets the width of the console window area.

Public Static Methods
static auto	beep () -> void
	Plays the sound of a beep through the console speaker.
static auto	beep (uint32 frequency, uint32 duration) -> void
	Plays the sound of a beep of a specified frequency and duration through the console speaker.
static auto	clear () -> void
	Clears the console buffer and corresponding console window of display information.
static auto	get_cursor_position () -> xtd::collections::generic::key_value_pair< int32, int32 >
	Gets the position of the cursor.
static auto	open_standard_error () -> std::ostream
	Acquires the standard error stream.
static auto	open_standard_input () -> std::istream
	Acquires the standard input stream.
static auto	open_standard_output () -> std::ostream
	Acquires the standard output stream.
static auto	read () -> int32
	Reads the next character from the standard input stream.
static auto	read_key () -> console_key_info
	Obtains the next character or function key pressed by the user. The pressed key is displayed in the console window.
static auto	read_key (bool intercept) -> console_key_info
	Obtains the next character or function key pressed by the user. The pressed key is optionally displayed in the console window.
static auto	read_key (const string &text) -> console_key_info
	Obtains the next character or function key pressed by the user. The pressed key is displayed in the console window with specified invit text.
static auto	read_key (const string &text, bool intercept) -> console_key_info
	Obtains the next character or function key pressed by the user. The pressed key is optionally displayed in the console window with specified invit text.
static auto	read_line () -> xtd::string
	Reads the next line of characters from the standard input stream.
static auto	read_line (bool intercept) -> xtd::string
	Reads the next line of characters from the standard input stream.
static auto	read_line (const string &text) -> xtd::string
	Reads the next line of characters from the standard input stream with specified invit text.
static auto	read_line (const string &text, bool intercept) -> xtd::string
	Reads the next line of characters from the standard input stream with specified invit text.
template<typename string_t>
static auto	read_line (string_t text) -> xtd::string
template<typename string_t>
static auto	read_line (string_t text, bool intercept) -> xtd::string
static auto	reset_color () -> bool
	Sets the foreground and background console colors to their defaults.
static auto	reset_terminal_mode () -> void
	Resets terminale mode to default.
static auto	set_cursor_position (int32 left, int32 top) -> void
	Sets the position of the cursor.
static auto	set_error (const std::ostream &os) -> void
	Sets the error property to the specified std::ostream object.
static auto	set_in (const std::istream &is) -> void
	Sets the int property to the specified std::istream object.
static auto	set_out (const std::ostream &os) -> void
	Sets the out property to the specified std::ostream object.
static auto	set_window_position (int32 left, int32 top) -> void
	Sets the position of the console window relative to the screen buffer.
static auto	set_window_size (int32 width, int32 height) -> void
	Sets the height and width of the console window to the specified values.
template<typename arg_t>
static auto	write (arg_t &&value) -> void
	Writes the text representation of the specified value to the standard output stream.
template<typename ... args_t>
static auto	write (const xtd::string &fmt, args_t &&... values) -> void
	Writes the text representation of the specified list of values to the standard output stream using the specified format information.
template<typename arg_t>
static auto	write (const xtd::globalization::culture_info &culture, arg_t &&value) -> void
	Writes the text representation of the specified value to the standard output stream.
template<typename ... args_t>
static auto	write (const xtd::globalization::culture_info &culture, const xtd::string &fmt, args_t &&... values) -> void
	Writes the text representation of the specified list of values to the standard output stream using the specified format information.
static auto	write_line () -> void
	Writes the current line terminator to the standard output stream using the specified format information.
template<typename arg_t>
static auto	write_line (arg_t &&value) -> void
	Writes the text representation of the specified value, followed by the current line terminator, to the standard output stream.
template<typename ... args_t>
static auto	write_line (const xtd::string &fmt, args_t &&... values) -> void
	Writes the text representation of the specified list of values, followed by the current line terminator, to the standard output stream using the specified format information.
template<typename arg_t>
static auto	write_line (const xtd::globalization::culture_info &culture, arg_t &&value) -> void
	Writes the text representation of the specified value, followed by the current line terminator, to the standard output stream.
template<typename ... args_t>
static auto	write_line (const xtd::globalization::culture_info &culture, const xtd::string &fmt, args_t &&... values) -> void
	Writes the text representation of the specified list of values, followed by the current line terminator, to the standard output stream using the specified format information.

Member Function Documentation

◆ auto_flush_out() [1/2]

auto xtd::console::auto_flush_out ( ) -> bool

staticnodiscard

Gets a value indicating whether the xtd::console::out will flush its buffer to the underlying stream after every call to xtd::console::write and xtd::console::write_line.

Returns: true to force xtd::console::out to flush its buffer; otherwise, false. The default value is true.

◆ auto_flush_out() [2/2]

auto xtd::console::auto_flush_out ( bool value ) -> void

static

Sets a value indicating whether the xtd::console::out will flush its buffer to the underlying stream after every call to xtd::console::write and xtd::console::write_line.

Parameters

value true to force xtd::console::out to flush its buffer; otherwise, false. The default value is true.

◆ background_color() [1/2]

auto xtd::console::background_color ( ) -> console_color

staticnodiscard

Gets the background color of the console.

Returns: the background xtd::console_color.

Remarks: A get operation for a Windows-based application, in which a console does not exist, returns xtd::console_color::black.

Examples: The following example saves the values of the xtd::console_color enumeration to an array and stores the current values of the xtd::console::background_color and xtd::console::foreground_color properties to variables. It then changes the foreground color to each color in the xtd::console_color enumeration except to the color that matches the current background, and it changes the background color to each color in the xtd::console_color enumeration except to the color that matches the current foreground. (If the foreground color is the same as the background color, the text isn't visible.) Finally, it calls the xtd::console::reset_color method to restore the original console colors.
#include <xtd/xtd>

auto main() -> int {

const auto logo = array {

u8"████████████████████████████████████████████████████████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░██████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░██████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████",

u8"███████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░█████████████",

u8"██████████████████████████████████████████████████████████████████████",

u8"██████████████████████████████████████████████████████████████████████",

u8"██████████████████████████▀▄▄▄▄▀███████▀▄▄▄▄▀█████████████████████████",

u8"███████████████████████████▀▀▀▀███████▀▀▀▀▀███████████████████████████",

u8"██████████████████████████ ▀████ ▀█████████████████████████",

u8"███████████ ▐ ▀▀ ▐ ██████████",

u8"█████████ ▐ ███ ▌▐ ███ ▐ █████████",

u8"█████████ ▐ █▄▄▌ ▌▐ ▐▄▄█ ▐ █████████",

u8"█████████ ▐▄ ▀▀ ▄▀ ▀▄ ▀▀ ▄▀ █████████",

u8"█████████ ▀▀▄▄▀ ▀▀▄▄▀ █████████",

u8"█████████ █████████",

u8"█████████ █▄ ▌ █████████",

u8"█████████ ▌▀▀▄ ▄██ █████████",

u8"█████████ ▐ ▀▀▄▄▄▄▄▄█▀ █▌ █████████",

u8"█████████ ▐ ▄█ █████████",

u8"█████████ █ ▄█ █████████",

u8"█████████ ▀▄ █▀ █████████",

u8"█████████ ▀▄▄▄▄██▀ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"██████████████████████████████████████████████████████████████████",

};

console::output_code_page(65001);

for (auto index = 0ul; index < logo.length(); ++index) {

console::write(index == 0 || index == logo.length() - 1 ? " " : " ");

console::background_color(console_color::white);

console::foreground_color(console_color::dark_blue);

console::write(logo[index]);

console::reset_color();

console::write_line();

}

console::foreground_color(console_color::dark_blue);

console::write_line(u8" Gammasoft ");

console::foreground_color(console_color::dark_gray);

console::write_line(u8" More than thirty years of passion for high technology especially in development");

console::write_line(u8" (c++, c#, objective-c, ...).");

console::reset_color();

}

// This code produces the following output with colors :

//

// ████████████████████████████████████████████████████████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░██████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░██████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████

// ███████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░█████████████

// ██████████████████████████████████████████████████████████████████████

// ██████████████████████████████████████████████████████████████████████

// ██████████████████████████▀▄▄▄▄▀███████▀▄▄▄▄▀█████████████████████████

// ███████████████████████████▀▀▀▀███████▀▀▀▀▀███████████████████████████

// ██████████████████████████ ▀████ ▀█████████████████████████

// ███████████ ▐ ▀▀ ▐ ██████████

// █████████ ▐ ███ ▌▐ ███ ▐ █████████

// █████████ ▐ █▄▄▌ ▌▐ ▐▄▄█ ▐ █████████

// █████████ ▐▄ ▀▀ ▄▀ ▀▄ ▀▀ ▄▀ █████████

// █████████ ▀▀▄▄▀ ▀▀▄▄▀ █████████

// █████████ █████████

// █████████ █▄ ▌ █████████

// █████████ ▌▀▀▄ ▄██ █████████

// █████████ ▐ ▀▀▄▄▄▄▄▄█▀ █▌ █████████

// █████████ ▐ ▄█ █████████

// █████████ █ ▄█ █████████

// █████████ ▀▄ █▀ █████████

// █████████ ▀▄▄▄▄██▀ █████████

// █████████ █████████

// █████████ █████████

// █████████ █████████

// █████████ █████████

// █████████ █████████

// ██████████████████████████████████████████████████████████████████

// Gammasoft

// More than thirty years of passion for high technology especially in development

// (c++, c#, objective-c, ...).

xtd::array
Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the ba...
Definition array.hpp:64

xtd::console::foreground_color
static auto foreground_color() -> console_color
Gets the foreground color of the console.

xtd::console::output_code_page
static auto output_code_page() -> int32
Gets the code page the console uses to write output.

xtd::console::background_color
static auto background_color() -> console_color
Gets the background color of the console.

xtd::console::reset_color
static auto reset_color() -> bool
Sets the foreground and background console colors to their defaults.

xtd::console_color::dark_blue
@ dark_blue
The color dark blue.
Definition console_color.hpp:26

xtd::console_color::white
@ white
The color white.
Definition console_color.hpp:54

xtd::index
Represents a type that can be used to index a collection either from the beginning or the end.
Definition index.hpp:38

◆ background_color() [2/2]

auto xtd::console::background_color ( console_color color ) -> void

static

Sets the background color of the console.

Parameters

color A xtd::console_color that specifies the background color of the console; that is, the color that appears behind each character.

Exceptions

xtd::argument_exception The color specified in a set operation is not a valid member of xtd::console_color.

Remarks: A change to the background_color method affects only output that is written to individual character cells after the background color is changed. To change the background color of the console window as a whole, set the BackgroundColor property and call the Clear method. The following example provides an illustration.

Examples: The following example saves the values of the xtd::console_color enumeration to an array and stores the current values of the xtd::console::background_color and xtd::console::foreground_color properties to variables. It then changes the foreground color to each color in the xtd::console_color enumeration except to the color that matches the current background, and it changes the background color to each color in the xtd::console_color enumeration except to the color that matches the current foreground. (If the foreground color is the same as the background color, the text isn't visible.) Finally, it calls the xtd::console::reset_color method to restore the original console colors.
#include <xtd/xtd>

auto main() -> int {

const auto logo = array {

u8"████████████████████████████████████████████████████████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░██████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░██████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████",

u8"███████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░█████████████",

u8"██████████████████████████████████████████████████████████████████████",

u8"██████████████████████████████████████████████████████████████████████",

u8"██████████████████████████▀▄▄▄▄▀███████▀▄▄▄▄▀█████████████████████████",

u8"███████████████████████████▀▀▀▀███████▀▀▀▀▀███████████████████████████",

u8"██████████████████████████ ▀████ ▀█████████████████████████",

u8"███████████ ▐ ▀▀ ▐ ██████████",

u8"█████████ ▐ ███ ▌▐ ███ ▐ █████████",

u8"█████████ ▐ █▄▄▌ ▌▐ ▐▄▄█ ▐ █████████",

u8"█████████ ▐▄ ▀▀ ▄▀ ▀▄ ▀▀ ▄▀ █████████",

u8"█████████ ▀▀▄▄▀ ▀▀▄▄▀ █████████",

u8"█████████ █████████",

u8"█████████ █▄ ▌ █████████",

u8"█████████ ▌▀▀▄ ▄██ █████████",

u8"█████████ ▐ ▀▀▄▄▄▄▄▄█▀ █▌ █████████",

u8"█████████ ▐ ▄█ █████████",

u8"█████████ █ ▄█ █████████",

u8"█████████ ▀▄ █▀ █████████",

u8"█████████ ▀▄▄▄▄██▀ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"██████████████████████████████████████████████████████████████████",

};

console::output_code_page(65001);

for (auto index = 0ul; index < logo.length(); ++index) {

console::write(index == 0 || index == logo.length() - 1 ? " " : " ");

console::background_color(console_color::white);

console::foreground_color(console_color::dark_blue);

console::write(logo[index]);

console::reset_color();

console::write_line();

}

console::foreground_color(console_color::dark_blue);

console::write_line(u8" Gammasoft ");

console::foreground_color(console_color::dark_gray);

console::write_line(u8" More than thirty years of passion for high technology especially in development");

console::write_line(u8" (c++, c#, objective-c, ...).");

console::reset_color();

}

// This code produces the following output with colors :

//

// ████████████████████████████████████████████████████████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░██████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░██████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████

// ███████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░█████████████

// ██████████████████████████████████████████████████████████████████████

// ██████████████████████████████████████████████████████████████████████

// ██████████████████████████▀▄▄▄▄▀███████▀▄▄▄▄▀█████████████████████████

// ███████████████████████████▀▀▀▀███████▀▀▀▀▀███████████████████████████

// ██████████████████████████ ▀████ ▀█████████████████████████

// ███████████ ▐ ▀▀ ▐ ██████████

// █████████ ▐ ███ ▌▐ ███ ▐ █████████

// █████████ ▐ █▄▄▌ ▌▐ ▐▄▄█ ▐ █████████

// █████████ ▐▄ ▀▀ ▄▀ ▀▄ ▀▀ ▄▀ █████████

// █████████ ▀▀▄▄▀ ▀▀▄▄▀ █████████

// █████████ █████████

// █████████ █▄ ▌ █████████

// █████████ ▌▀▀▄ ▄██ █████████

// █████████ ▐ ▀▀▄▄▄▄▄▄█▀ █▌ █████████

// █████████ ▐ ▄█ █████████

// █████████ █ ▄█ █████████

// █████████ ▀▄ █▀ █████████

// █████████ ▀▄▄▄▄██▀ █████████

// █████████ █████████

// █████████ █████████

// █████████ █████████

// █████████ █████████

// █████████ █████████

// ██████████████████████████████████████████████████████████████████

// Gammasoft

// More than thirty years of passion for high technology especially in development

// (c++, c#, objective-c, ...).

◆ buffer_height() [1/2]

auto xtd::console::buffer_height ( ) -> int32

staticnodiscard

Gets the height of the buffer area.

Returns: The current height, in rows, of the buffer area.

Examples: This example demonstrates the buffer_height and buffer_width properties. The example reports the dimensions of an operating system window set to a buffer size of 300 rows and 85 columns.
#include <xtd/xtd>

auto main() -> int {

console::write_line("The current buffer height is {} rows.", console::buffer_height());

console::write_line("The current buffer width is {} columns.", console::buffer_width());

}

// This code produces the following output :

//

// The current buffer height is 300 rows.

// The current buffer width is 85 columns.

xtd::console::buffer_height
static auto buffer_height() -> int32
Gets the height of the buffer area.

xtd::console::buffer_width
static auto buffer_width() -> int32
Gets the width of the buffer area.

◆ buffer_height() [2/2]

auto xtd::console::buffer_height ( int32 height ) -> void

static

Sets or sets the height of the buffer area.

Parameters

height The current height, in rows, of the buffer area.

Exceptions

xtd::argument_out_of_range_exception The value in a set operation is less than or equal to zero.
-or-
The value in a set operation is greater than or equal to xtd::int16_object::max_value.

Examples: This example demonstrates the buffer_height and buffer_width properties. The example reports the dimensions of an operating system window set to a buffer size of 300 rows and 85 columns.
#include <xtd/xtd>

auto main() -> int {

console::write_line("The current buffer height is {} rows.", console::buffer_height());

console::write_line("The current buffer width is {} columns.", console::buffer_width());

}

// This code produces the following output :

//

// The current buffer height is 300 rows.

// The current buffer width is 85 columns.

◆ buffer_width() [1/2]

auto xtd::console::buffer_width ( ) -> int32

staticnodiscard

Gets the width of the buffer area.

Returns: The current width, in columns, of the buffer area.

Examples: This example demonstrates the BufferHeight and buffer_width properties. The example reports the dimensions of an operating system window set to a buffer size of 300 rows and 85 columns.
#include <xtd/xtd>

auto main() -> int {

console::write_line("The current buffer height is {} rows.", console::buffer_height());

console::write_line("The current buffer width is {} columns.", console::buffer_width());

}

// This code produces the following output :

//

// The current buffer height is 300 rows.

// The current buffer width is 85 columns.

◆ buffer_width() [2/2]

auto xtd::console::buffer_width ( int32 width ) -> void

static

Sets the width of the buffer area.

Parameters

width The current width, in columns, of the buffer area.

Exceptions

xtd::argument_out_of_range_exception The value in a set operation is less than or equal to zero.
-or-
The value in a set operation is greater than or equal to xtd::int16_object::max_value.

Examples: This example demonstrates the BufferHeight and buffer_width properties. The example reports the dimensions of an operating system window set to a buffer size of 300 rows and 85 columns.
#include <xtd/xtd>

auto main() -> int {

console::write_line("The current buffer height is {} rows.", console::buffer_height());

console::write_line("The current buffer width is {} columns.", console::buffer_width());

}

// This code produces the following output :

//

// The current buffer height is 300 rows.

// The current buffer width is 85 columns.

◆ caps_lock()

auto xtd::console::caps_lock ( ) -> bool

staticnodiscard

Gets a value indicating whether the CAPS LOCK keyboard toggle is turned on or turned off.

Returns: true if CAPS LOCK is turned on; false if CAPS LOCK is turned off.

◆ cursor_left() [1/2]

auto xtd::console::cursor_left ( ) -> int32

staticnodiscard

Gets the column position of the cursor within the buffer area.

Returns: The current position, in columns, of the cursor.

Examples: This example demonstrates the cursor_left and cursor_top properties, and the set_cursor_position and clear methods. The example positions the cursor, which determines where the next write will occur, to draw a 5 character by 5 character rectangle using a combination of "+", "|", and "-" strings. Note that the rectangle could be drawn with fewer steps using a combination of other strings.
#include <xtd/xtd>

namespace console_curosr_example {

class program {

public:

// The main entry point for the application.

static auto main() {

// Clear the screen, then save the top and left coordinates.

console::clear();

orig_row = console::cursor_top();

orig_col = console::cursor_left();

// Draw the left side of a 5x5 rectangle, from top to bottom.

write_at("+", 0, 0);

write_at("|", 0, 1);

write_at("|", 0, 2);

write_at("|", 0, 3);

write_at("+", 0, 4);

// Draw the bottom side, from left to right.

write_at("-", 1, 4); // shortcut: write_at("---", 1, 4)

write_at("-", 2, 4); // ...

write_at("-", 3, 4); // ...

write_at("+", 4, 4);

// Draw the right side, from bottom to top.

write_at("|", 4, 3);

write_at("|", 4, 2);

write_at("|", 4, 1);

write_at("+", 4, 0);

// Draw the top side, from right to left.

write_at("-", 3, 0); // shortcut: write_at("---", 1, 0)

write_at("-", 2, 0); // ...

write_at("-", 1, 0); // ...

//

write_at("All done!", 0, 6);

console::write_line();

}

private:

static auto write_at(const string& s, int x, int y) noexcept -> void {

console::set_cursor_position(orig_col + x, orig_row + y);

console::write(s);

}

static inline auto orig_row = 0;

static inline auto orig_col = 0;

};

}

startup_(console_curosr_example::program::main);

// This code produces the following output :

//

// +---+

// | |

// | |

// | |

// +---+

//

// All done!

xtd::console::set_cursor_position
static auto set_cursor_position(int32 left, int32 top) -> void
Sets the position of the cursor.

xtd::console::cursor_top
static auto cursor_top() -> int32
Gets the row position of the cursor within the buffer area.

xtd::console::cursor_left
static auto cursor_left() -> int32
Gets the column position of the cursor within the buffer area.

xtd::console::clear
static auto clear() -> void
Clears the console buffer and corresponding console window of display information.

startup_
#define startup_(...)
Defines the entry point to be called when the application loads. Generally this is set either to the ...
Definition startup.hpp:152

◆ cursor_left() [2/2]

auto xtd::console::cursor_left ( int32 left ) -> void

static

Sets the column position of the cursor within the buffer area.

Parameters

left	The current position, in columns, of the cursor.

Exceptions

xtd::argument_out_of_range_exception The value in a set operation is less than zero
-or-
The value in a set operation is greater than or equal to xtd::console::buffer_width.

Examples: This example demonstrates the cursor_left and cursor_top properties, and the set_cursor_position and clear methods. The example positions the cursor, which determines where the next write will occur, to draw a 5 character by 5 character rectangle using a combination of "+", "|", and "-" strings. Note that the rectangle could be drawn with fewer steps using a combination of other strings.
#include <xtd/xtd>

namespace console_curosr_example {

class program {

public:

// The main entry point for the application.

static auto main() {

// Clear the screen, then save the top and left coordinates.

console::clear();

orig_row = console::cursor_top();

orig_col = console::cursor_left();

// Draw the left side of a 5x5 rectangle, from top to bottom.

write_at("+", 0, 0);

write_at("|", 0, 1);

write_at("|", 0, 2);

write_at("|", 0, 3);

write_at("+", 0, 4);

// Draw the bottom side, from left to right.

write_at("-", 1, 4); // shortcut: write_at("---", 1, 4)

write_at("-", 2, 4); // ...

write_at("-", 3, 4); // ...

write_at("+", 4, 4);

// Draw the right side, from bottom to top.

write_at("|", 4, 3);

write_at("|", 4, 2);

write_at("|", 4, 1);

write_at("+", 4, 0);

// Draw the top side, from right to left.

write_at("-", 3, 0); // shortcut: write_at("---", 1, 0)

write_at("-", 2, 0); // ...

write_at("-", 1, 0); // ...

//

write_at("All done!", 0, 6);

console::write_line();

}

private:

static auto write_at(const string& s, int x, int y) noexcept -> void {

console::set_cursor_position(orig_col + x, orig_row + y);

console::write(s);

}

static inline auto orig_row = 0;

static inline auto orig_col = 0;

};

}

startup_(console_curosr_example::program::main);

// This code produces the following output :

//

// +---+

// | |

// | |

// | |

// +---+

//

// All done!

◆ cursor_size() [1/2]

auto xtd::console::cursor_size ( ) -> int32

staticnodiscard

Gets or sets the height of the cursor within a character cell.

Returns: The size of the cursor expressed as a percentage of the height of a character cell. The property value ranges from 1 to 100.

Examples: This example demonstrates the cursor_size property. The example increases the size of the cursor each time any console key is pressed, then restores the cursor to its original size before terminating.
#include <xtd/xtd>

auto main() -> int {

constexpr auto m0 = "This example increments the cursor size from 1% to 100%:\n";

constexpr auto m1 = "Cursor size = {0}%. (Press any key to continue...)";

auto sizes = {1, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100};

auto save_cursor_size = console::cursor_size();

console::write_line(m0);

for (auto size : sizes) {

console::cursor_size(size);

console::write_line(m1, size);

console::read_key();

}

console::cursor_size(save_cursor_size);

}

// This code produces the following output :

//

// This example increments the cursor size from 1% to 100%:

//

// Cursor size = 1%. (Press any key to continue...)

// Cursor size = 10%. (Press any key to continue...)

// Cursor size = 20%. (Press any key to continue...)

// Cursor size = 30%. (Press any key to continue...)

// Cursor size = 40%. (Press any key to continue...)

// Cursor size = 50%. (Press any key to continue...)

// Cursor size = 60%. (Press any key to continue...)

// Cursor size = 70%. (Press any key to continue...)

// Cursor size = 80%. (Press any key to continue...)

// Cursor size = 90%. (Press any key to continue...)

// Cursor size = 100%. (Press any key to continue...)

xtd::console::cursor_size
static auto cursor_size() -> int32
Gets or sets the height of the cursor within a character cell.

xtd::console::read_key
static auto read_key() -> console_key_info
Obtains the next character or function key pressed by the user. The pressed key is displayed in the c...

xtd::size
constexpr auto size() const noexcept -> size_type
Returns the number of elements.
Definition read_only_span.hpp:213

◆ cursor_size() [2/2]

auto xtd::console::cursor_size ( int32 size ) -> void

static

Sets the height of the cursor within a character cell.

Parameters

size	The size of the cursor expressed as a percentage of the height of a character cell. The property value ranges from 1 to 100.

Exceptions

xtd::argument_out_of_range_exception The value specified in a set operation is less than 1 or greater than 100.

Examples: This example demonstrates the cursor_size property. The example increases the size of the cursor each time any console key is pressed, then restores the cursor to its original size before terminating.
#include <xtd/xtd>

auto main() -> int {

constexpr auto m0 = "This example increments the cursor size from 1% to 100%:\n";

constexpr auto m1 = "Cursor size = {0}%. (Press any key to continue...)";

auto sizes = {1, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100};

auto save_cursor_size = console::cursor_size();

console::write_line(m0);

for (auto size : sizes) {

console::cursor_size(size);

console::write_line(m1, size);

console::read_key();

}

console::cursor_size(save_cursor_size);

}

// This code produces the following output :

//

// This example increments the cursor size from 1% to 100%:

//

// Cursor size = 1%. (Press any key to continue...)

// Cursor size = 10%. (Press any key to continue...)

// Cursor size = 20%. (Press any key to continue...)

// Cursor size = 30%. (Press any key to continue...)

// Cursor size = 40%. (Press any key to continue...)

// Cursor size = 50%. (Press any key to continue...)

// Cursor size = 60%. (Press any key to continue...)

// Cursor size = 70%. (Press any key to continue...)

// Cursor size = 80%. (Press any key to continue...)

// Cursor size = 90%. (Press any key to continue...)

// Cursor size = 100%. (Press any key to continue...)

◆ cursor_top() [1/2]

auto xtd::console::cursor_top ( ) -> int32

staticnodiscard

Gets the row position of the cursor within the buffer area.

Returns: The current position, in rows, of the cursor.

Examples: This example demonstrates the cursor_left and cursor_top properties, and the set_cursor_position and clear methods. The example positions the cursor, which determines where the next write will occur, to draw a 5 character by 5 character rectangle using a combination of "+", "|", and "-" strings. Note that the rectangle could be drawn with fewer steps using a combination of other strings.
#include <xtd/xtd>

namespace console_curosr_example {

class program {

public:

// The main entry point for the application.

static auto main() {

// Clear the screen, then save the top and left coordinates.

console::clear();

orig_row = console::cursor_top();

orig_col = console::cursor_left();

// Draw the left side of a 5x5 rectangle, from top to bottom.

write_at("+", 0, 0);

write_at("|", 0, 1);

write_at("|", 0, 2);

write_at("|", 0, 3);

write_at("+", 0, 4);

// Draw the bottom side, from left to right.

write_at("-", 1, 4); // shortcut: write_at("---", 1, 4)

write_at("-", 2, 4); // ...

write_at("-", 3, 4); // ...

write_at("+", 4, 4);

// Draw the right side, from bottom to top.

write_at("|", 4, 3);

write_at("|", 4, 2);

write_at("|", 4, 1);

write_at("+", 4, 0);

// Draw the top side, from right to left.

write_at("-", 3, 0); // shortcut: write_at("---", 1, 0)

write_at("-", 2, 0); // ...

write_at("-", 1, 0); // ...

//

write_at("All done!", 0, 6);

console::write_line();

}

private:

static auto write_at(const string& s, int x, int y) noexcept -> void {

console::set_cursor_position(orig_col + x, orig_row + y);

console::write(s);

}

static inline auto orig_row = 0;

static inline auto orig_col = 0;

};

}

startup_(console_curosr_example::program::main);

// This code produces the following output :

//

// +---+

// | |

// | |

// | |

// +---+

//

// All done!

◆ cursor_top() [2/2]

auto xtd::console::cursor_top ( int32 top ) -> void

static

Sets the row position of the cursor within the buffer area.

Parameters

top	The current position, in rows, of the cursor.

Returns: true if cursor top changed; otherwise false.

Exceptions

xtd::argument_out_of_range_exception The value in a set operation is less than zero
-or-
The value in a set operation is greater than or equal to xtd::console::buffer_height.

Examples: This example demonstrates the cursor_left and cursor_top properties, and the set_cursor_position and clear methods. The example positions the cursor, which determines where the next write will occur, to draw a 5 character by 5 character rectangle using a combination of "+", "|", and "-" strings. Note that the rectangle could be drawn with fewer steps using a combination of other strings.
#include <xtd/xtd>

namespace console_curosr_example {

class program {

public:

// The main entry point for the application.

static auto main() {

// Clear the screen, then save the top and left coordinates.

console::clear();

orig_row = console::cursor_top();

orig_col = console::cursor_left();

// Draw the left side of a 5x5 rectangle, from top to bottom.

write_at("+", 0, 0);

write_at("|", 0, 1);

write_at("|", 0, 2);

write_at("|", 0, 3);

write_at("+", 0, 4);

// Draw the bottom side, from left to right.

write_at("-", 1, 4); // shortcut: write_at("---", 1, 4)

write_at("-", 2, 4); // ...

write_at("-", 3, 4); // ...

write_at("+", 4, 4);

// Draw the right side, from bottom to top.

write_at("|", 4, 3);

write_at("|", 4, 2);

write_at("|", 4, 1);

write_at("+", 4, 0);

// Draw the top side, from right to left.

write_at("-", 3, 0); // shortcut: write_at("---", 1, 0)

write_at("-", 2, 0); // ...

write_at("-", 1, 0); // ...

//

write_at("All done!", 0, 6);

console::write_line();

}

private:

static auto write_at(const string& s, int x, int y) noexcept -> void {

console::set_cursor_position(orig_col + x, orig_row + y);

console::write(s);

}

static inline auto orig_row = 0;

static inline auto orig_col = 0;

};

}

startup_(console_curosr_example::program::main);

// This code produces the following output :

//

// +---+

// | |

// | |

// | |

// +---+

//

// All done!

◆ cursor_visible() [1/2]

auto xtd::console::cursor_visible ( ) -> bool

staticnodiscard

Gets a value indicating whether the cursor is visible.

Returns: true if the cursor is visible; otherwise, false.

Examples: This example demonstrates the cursor_visible property. The example makes the cursor visible if the first column of input is a '+' character or invisible if the input is a '-' character.
#include <xtd/xtd>

auto main() -> int {

constexpr auto message = "\nThe cursor is {0}.\nType any text then press Enter. "

"Type '+' in the first column to show \n"

"the cursor, '-' to hide the cursor, "

"or lowercase 'x' to quit:";

auto save_cursor_visibile = console::cursor_visible();

auto save_cursor_size = console::cursor_size();

console::cursor_visible(true); // Initialize the cursor to visible.

console::cursor_size(100); // Emphasize the cursor.

while (true) {

console::write_line(message, ((console::cursor_visible() == true) ? "VISIBLE" : "HIDDEN"));

auto s = console::read_line();

if (string::is_empty(s)) continue;

if (s[0] == '+') console::cursor_visible(true);

else if (s[0] == '-') console::cursor_visible(false);

else if (s[0] == 'x') break;

}

console::cursor_visible(save_cursor_visibile);

console::cursor_size(save_cursor_size);

}

// This code produces the following output. Note that these results

// cannot depict cursor visibility. You must run the example to see the

// cursor behavior:

//

// The cursor is VISIBLE.

// Type any text then press Enter. Type '+' in the first column to show

// the cursor, '-' to hide the cursor, or lowercase 'x' to quit:

// The quick brown fox

//

// The cursor is VISIBLE.

// Type any text then press Enter. Type '+' in the first column to show

// the cursor, '-' to hide the cursor, or lowercase 'x' to quit:

// -

//

// The cursor is HIDDEN.

// Type any text then press Enter. Type '+' in the first column to show

// the cursor, '-' to hide the cursor, or lowercase 'x' to quit:

// jumps over

//

// The cursor is HIDDEN.

// Type any text then press Enter. Type '+' in the first column to show

// the cursor, '-' to hide the cursor, or lowercase 'x' to quit:

// +

//

// The cursor is VISIBLE.

// Type any text then press Enter. Type '+' in the first column to show

// the cursor, '-' to hide the cursor, or lowercase 'x' to quit:

// the lazy dog.

//

// The cursor is VISIBLE.

// Type any text then press Enter. Type '+' in the first column to show

// the cursor, '-' to hide the cursor, or lowercase 'x' to quit:

// x

xtd::basic_string< char >::is_empty
static auto is_empty(const xtd::basic_string< value_type, traits_type, allocator_type > &string) noexcept -> bool
Definition basic_string.hpp:1232

xtd::console::cursor_visible
static auto cursor_visible() -> bool
Gets a value indicating whether the cursor is visible.

xtd::console_key::s
@ s
The S key.
Definition console_key.hpp:124

◆ cursor_visible() [2/2]

auto xtd::console::cursor_visible ( bool visible ) -> void

static

Sets a value indicating whether the cursor is visible.

Parameters

visible true if the cursor is visible; otherwise, false.

Examples: This example demonstrates the cursor_visible property. The example makes the cursor visible if the first column of input is a '+' character or invisible if the input is a '-' character.
#include <xtd/xtd>

auto main() -> int {

constexpr auto message = "\nThe cursor is {0}.\nType any text then press Enter. "

"Type '+' in the first column to show \n"

"the cursor, '-' to hide the cursor, "

"or lowercase 'x' to quit:";

auto save_cursor_visibile = console::cursor_visible();

auto save_cursor_size = console::cursor_size();

console::cursor_visible(true); // Initialize the cursor to visible.

console::cursor_size(100); // Emphasize the cursor.

while (true) {

console::write_line(message, ((console::cursor_visible() == true) ? "VISIBLE" : "HIDDEN"));

auto s = console::read_line();

if (string::is_empty(s)) continue;

if (s[0] == '+') console::cursor_visible(true);

else if (s[0] == '-') console::cursor_visible(false);

else if (s[0] == 'x') break;

}

console::cursor_visible(save_cursor_visibile);

console::cursor_size(save_cursor_size);

}

// This code produces the following output. Note that these results

// cannot depict cursor visibility. You must run the example to see the

// cursor behavior:

//

// The cursor is VISIBLE.

// Type any text then press Enter. Type '+' in the first column to show

// the cursor, '-' to hide the cursor, or lowercase 'x' to quit:

// The quick brown fox

//

// The cursor is VISIBLE.

// Type any text then press Enter. Type '+' in the first column to show

// the cursor, '-' to hide the cursor, or lowercase 'x' to quit:

// -

//

// The cursor is HIDDEN.

// Type any text then press Enter. Type '+' in the first column to show

// the cursor, '-' to hide the cursor, or lowercase 'x' to quit:

// jumps over

//

// The cursor is HIDDEN.

// Type any text then press Enter. Type '+' in the first column to show

// the cursor, '-' to hide the cursor, or lowercase 'x' to quit:

// +

//

// The cursor is VISIBLE.

// Type any text then press Enter. Type '+' in the first column to show

// the cursor, '-' to hide the cursor, or lowercase 'x' to quit:

// the lazy dog.

//

// The cursor is VISIBLE.

// Type any text then press Enter. Type '+' in the first column to show

// the cursor, '-' to hide the cursor, or lowercase 'x' to quit:

// x

◆ foreground_color() [1/2]

auto xtd::console::foreground_color ( ) -> console_color

staticnodiscard

Gets the foreground color of the console.

Returns: A console_color that specifies the foreground color of the console; that is, the color of each character that is displayed.

Examples: The following example saves the values of the console_color enumeration to an array and stores the current values of the background_color and foreground_color properties to variables. It then changes the foreground color to each color in the ConsoleColor enumeration except to the color that matches the current background, and it changes the background color to each color in the console_color enumeration except to the color that matches the current foreground. (If the foreground color is the same as the background color, the text isn't visible.) Finally, it calls the reset_color method to restore the original console colors.
#include <xtd/xtd>

auto main() -> int {

const auto logo = array {

u8"████████████████████████████████████████████████████████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░██████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░██████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████",

u8"███████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░█████████████",

u8"██████████████████████████████████████████████████████████████████████",

u8"██████████████████████████████████████████████████████████████████████",

u8"██████████████████████████▀▄▄▄▄▀███████▀▄▄▄▄▀█████████████████████████",

u8"███████████████████████████▀▀▀▀███████▀▀▀▀▀███████████████████████████",

u8"██████████████████████████ ▀████ ▀█████████████████████████",

u8"███████████ ▐ ▀▀ ▐ ██████████",

u8"█████████ ▐ ███ ▌▐ ███ ▐ █████████",

u8"█████████ ▐ █▄▄▌ ▌▐ ▐▄▄█ ▐ █████████",

u8"█████████ ▐▄ ▀▀ ▄▀ ▀▄ ▀▀ ▄▀ █████████",

u8"█████████ ▀▀▄▄▀ ▀▀▄▄▀ █████████",

u8"█████████ █████████",

u8"█████████ █▄ ▌ █████████",

u8"█████████ ▌▀▀▄ ▄██ █████████",

u8"█████████ ▐ ▀▀▄▄▄▄▄▄█▀ █▌ █████████",

u8"█████████ ▐ ▄█ █████████",

u8"█████████ █ ▄█ █████████",

u8"█████████ ▀▄ █▀ █████████",

u8"█████████ ▀▄▄▄▄██▀ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"██████████████████████████████████████████████████████████████████",

};

console::output_code_page(65001);

for (auto index = 0ul; index < logo.length(); ++index)

std::cout << (index == 0 || index == logo.length() - 1 ? " " : " ") << background_color(console_color::white) << foreground_color(console_color::dark_blue) << logo[index] << reset_color() << std::endl;

std::cout << foreground_color(console_color::dark_blue) << " Gammasoft " << std::endl;

std::cout << foreground_color(console_color::dark_gray) << " More than thirty years of passion for high technology especially in development" << std::endl;

std::cout << " (c++, c#, objective-c, ...)." << reset_color() << std::endl;

}

// This code produces the following output with colors :

//

// ████████████████████████████████████████████████████████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░██████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░██████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████

// ███████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░█████████████

// ██████████████████████████████████████████████████████████████████████

// ██████████████████████████████████████████████████████████████████████

// ██████████████████████████▀▄▄▄▄▀███████▀▄▄▄▄▀█████████████████████████

// ███████████████████████████▀▀▀▀███████▀▀▀▀▀███████████████████████████

// ██████████████████████████ ▀████ ▀█████████████████████████

// ███████████ ▐ ▀▀ ▐ ██████████

// █████████ ▐ ███ ▌▐ ███ ▐ █████████

// █████████ ▐ █▄▄▌ ▌▐ ▐▄▄█ ▐ █████████

// █████████ ▐▄ ▀▀ ▄▀ ▀▄ ▀▀ ▄▀ █████████

// █████████ ▀▀▄▄▀ ▀▀▄▄▀ █████████

// █████████ █████████

// █████████ █▄ ▌ █████████

// █████████ ▌▀▀▄ ▄██ █████████

// █████████ ▐ ▀▀▄▄▄▄▄▄█▀ █▌ █████████

// █████████ ▐ ▄█ █████████

// █████████ █ ▄█ █████████

// █████████ ▀▄ █▀ █████████

// █████████ ▀▄▄▄▄██▀ █████████

// █████████ █████████

// █████████ █████████

// █████████ █████████

// █████████ █████████

// █████████ █████████

// ██████████████████████████████████████████████████████████████████

// Gammasoft

// More than thirty years of passion for high technology especially in development

// (c++, c#, objective-c, ...).

xtd::background_color
Represent background color output manipulator class.
Definition background_color.hpp:24

xtd::foreground_color
Represent foreground color output manipulator class.
Definition foreground_color.hpp:20

xtd::reset_color
Represent reset color output manipulator class.
Definition reset_color.hpp:20

xtd::console_color::dark_gray
@ dark_gray
The color dark gray.
Definition console_color.hpp:40

◆ foreground_color() [2/2]

auto xtd::console::foreground_color ( console_color color ) -> bool

static

Sets the foreground color of the console.

Parameters

color A console_color that specifies the foreground color of the console; that is, the color of each character that is displayed.

Exceptions

xtd::argument_exception The color specified in a set operation is not a valid member of xtd::console_color.

Examples: The following example saves the values of the console_color enumeration to an array and stores the current values of the background_color and foreground_color properties to variables. It then changes the foreground color to each color in the ConsoleColor enumeration except to the color that matches the current background, and it changes the background color to each color in the console_color enumeration except to the color that matches the current foreground. (If the foreground color is the same as the background color, the text isn't visible.) Finally, it calls the reset_color method to restore the original console colors.
#include <xtd/xtd>

auto main() -> int {

const auto logo = array {

u8"████████████████████████████████████████████████████████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░██████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░██████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████",

u8"██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████",

u8"███████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░█████████████",

u8"██████████████████████████████████████████████████████████████████████",

u8"██████████████████████████████████████████████████████████████████████",

u8"██████████████████████████▀▄▄▄▄▀███████▀▄▄▄▄▀█████████████████████████",

u8"███████████████████████████▀▀▀▀███████▀▀▀▀▀███████████████████████████",

u8"██████████████████████████ ▀████ ▀█████████████████████████",

u8"███████████ ▐ ▀▀ ▐ ██████████",

u8"█████████ ▐ ███ ▌▐ ███ ▐ █████████",

u8"█████████ ▐ █▄▄▌ ▌▐ ▐▄▄█ ▐ █████████",

u8"█████████ ▐▄ ▀▀ ▄▀ ▀▄ ▀▀ ▄▀ █████████",

u8"█████████ ▀▀▄▄▀ ▀▀▄▄▀ █████████",

u8"█████████ █████████",

u8"█████████ █▄ ▌ █████████",

u8"█████████ ▌▀▀▄ ▄██ █████████",

u8"█████████ ▐ ▀▀▄▄▄▄▄▄█▀ █▌ █████████",

u8"█████████ ▐ ▄█ █████████",

u8"█████████ █ ▄█ █████████",

u8"█████████ ▀▄ █▀ █████████",

u8"█████████ ▀▄▄▄▄██▀ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"█████████ █████████",

u8"██████████████████████████████████████████████████████████████████",

};

console::output_code_page(65001);

for (auto index = 0ul; index < logo.length(); ++index)

std::cout << (index == 0 || index == logo.length() - 1 ? " " : " ") << background_color(console_color::white) << foreground_color(console_color::dark_blue) << logo[index] << reset_color() << std::endl;

std::cout << foreground_color(console_color::dark_blue) << " Gammasoft " << std::endl;

std::cout << foreground_color(console_color::dark_gray) << " More than thirty years of passion for high technology especially in development" << std::endl;

std::cout << " (c++, c#, objective-c, ...)." << reset_color() << std::endl;

}

// This code produces the following output with colors :

//

// ████████████████████████████████████████████████████████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░██████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░██████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████

// ██████████████████████████████░░░░░░░░░░░░░░░░░░░░░░████░░████████████

// ███████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░█████████████

// ██████████████████████████████████████████████████████████████████████

// ██████████████████████████████████████████████████████████████████████

// ██████████████████████████▀▄▄▄▄▀███████▀▄▄▄▄▀█████████████████████████

// ███████████████████████████▀▀▀▀███████▀▀▀▀▀███████████████████████████

// ██████████████████████████ ▀████ ▀█████████████████████████

// ███████████ ▐ ▀▀ ▐ ██████████

// █████████ ▐ ███ ▌▐ ███ ▐ █████████

// █████████ ▐ █▄▄▌ ▌▐ ▐▄▄█ ▐ █████████

// █████████ ▐▄ ▀▀ ▄▀ ▀▄ ▀▀ ▄▀ █████████

// █████████ ▀▀▄▄▀ ▀▀▄▄▀ █████████

// █████████ █████████

// █████████ █▄ ▌ █████████

// █████████ ▌▀▀▄ ▄██ █████████

// █████████ ▐ ▀▀▄▄▄▄▄▄█▀ █▌ █████████

// █████████ ▐ ▄█ █████████

// █████████ █ ▄█ █████████

// █████████ ▀▄ █▀ █████████

// █████████ ▀▄▄▄▄██▀ █████████

// █████████ █████████

// █████████ █████████

// █████████ █████████

// █████████ █████████

// █████████ █████████

// ██████████████████████████████████████████████████████████████████

// Gammasoft

// More than thirty years of passion for high technology especially in development

// (c++, c#, objective-c, ...).

◆ input_code_page() [1/2]

auto xtd::console::input_code_page ( ) -> int32

staticnodiscard

Gets the code page the console uses to read input.

Returns: The code page used to read console input.

Exceptions

xtd::io::io_exception An error occurred during the execution of this operation.

Remarks

The following table lists the encodings supported by xtd.

Code page	Name	Display name
1200	utf-16	Unicode
1201	utf-16BE	Unicode (Big endian)
12000	utf-32	Unicode (UTF-32)
12001	utf-32BE	Unicode (UTF-32 Big endian)
20127	us-ascii	US-ASCII
28591	iso-8859-1	Western European (ISO)
65000	utf-7	Unicode (UTF-7)
65001	utf-8	Unicode (UTF-8)

◆ input_code_page() [2/2]

auto xtd::console::input_code_page ( int32 code_page ) -> void

static

Sets the code page the console uses to read input.

Parameters

code_page The code page used to read console input.

Exceptions

xtd::io::io_exception An error occurred during the execution of this operation.

Remarks

The following table lists the encodings supported by xtd.

Code page	Name	Display name
1200	utf-16	Unicode
1201	utf-16BE	Unicode (Big endian)
12000	utf-32	Unicode (UTF-32)
12001	utf-32BE	Unicode (UTF-32 Big endian)
20127	us-ascii	US-ASCII
28591	iso-8859-1	Western European (ISO)
65000	utf-7	Unicode (UTF-7)
65001	utf-8	Unicode (UTF-8)

◆ is_error_redirected()

auto xtd::console::is_error_redirected ( ) -> bool

staticnodiscard

Gets a value that indicates whether the error output stream has been redirected from the standard error stream.

Returns: true if error output is redirected; otherwise, false.

◆ is_input_redirected()

auto xtd::console::is_input_redirected ( ) -> bool

staticnodiscard

Gets a value that indicates whether the input stream has been redirected from the standard input stream.

Returns: true if input is redirected; otherwise, false.

◆ is_output_redirected()

auto xtd::console::is_output_redirected ( ) -> bool

staticnodiscard

Gets a value that indicates whether the output stream has been redirected from the standard output stream.

Returns: true if output is redirected; otherwise, false.

◆ key_available()

auto xtd::console::key_available ( ) -> bool

staticnodiscard

Gets a value indicating whether a key press is available in the input stream.

Returns: true if a key press is available; otherwise, false.

Remarks: The key_available method is returned immediately; that is, the key_available method does not block input until a key press is available.; Use the key_available method in conjunction with only the read_key method, not the read or read_line methods

◆ largest_window_height()

auto xtd::console::largest_window_height ( ) -> int32

staticnodiscard

Gets the largest possible number of console window rows, based on the current font and screen resolution.

Returns: The height of the largest possible console window measured in rows.

◆ largest_window_width()

auto xtd::console::largest_window_width ( ) -> int32

staticnodiscard

Gets the largest possible number of console window columns, based on the current font and screen resolution.

Returns: The width of the largest possible console window measured in columns.

◆ number_lock()

auto xtd::console::number_lock ( ) -> bool

staticnodiscard

Gets a value indicating whether the NUM LOCK keyboard toggle is turned on or turned off.

Returns: true if NUM LOCK is turned on; false if NUM LOCK is turned off.

◆ output_code_page() [1/2]

auto xtd::console::output_code_page ( ) -> int32

staticnodiscard

Gets the code page the console uses to write output.

Returns: The code page used to write console output.

Exceptions

xtd::io::io_exception An error occurred during the execution of this operation.

Remarks

The following table lists the encodings supported by xtd.

Code page	Name	Display name
1200	utf-16	Unicode
1201	utf-16BE	Unicode (Big endian)
12000	utf-32	Unicode (UTF-32)
12001	utf-32BE	Unicode (UTF-32 Big endian)
20127	us-ascii	US-ASCII
28591	iso-8859-1	Western European (ISO)
65000	utf-7	Unicode (UTF-7)
65001	utf-8	Unicode (UTF-8)

◆ output_code_page() [2/2]

auto xtd::console::output_code_page ( int32 code_page ) -> void

static

Sets the code page the console uses to write output.

Parameters

code_page The code page used to write console output.

Exceptions

xtd::io::io_exception An error occurred during the execution of this operation.

Remarks

The following table lists the encodings supported by xtd.

Code page	Name	Display name
1200	utf-16	Unicode
1201	utf-16BE	Unicode (Big endian)
12000	utf-32	Unicode (UTF-32)
12001	utf-32BE	Unicode (UTF-32 Big endian)
20127	us-ascii	US-ASCII
28591	iso-8859-1	Western European (ISO)
65000	utf-7	Unicode (UTF-7)
65001	utf-8	Unicode (UTF-8)

◆ title() [1/2]

auto xtd::console::title ( ) -> xtd::string

staticnodiscard

Gets the title to display in the console title bar.

Returns: The string to be displayed in the title bar of the console. The maximum length of the title string is 24500 characters.

◆ title() [2/2]

auto xtd::console::title ( const xtd::string & title ) -> void

static

Sets the title to display in the console title bar.

Parameters

title The string to be displayed in the title bar of the console. The maximum length of the title string is 24500 characters.

◆ treat_control_c_as_input() [1/2]

auto xtd::console::treat_control_c_as_input ( ) -> bool

staticnodiscard

Gets a value indicating whether the combination of the Control modifier key and C console key (Ctrl+C) is treated as ordinary input or as an interruption that is handled by the operating system.

Returns: true if Ctrl+C is treated as ordinary input; otherwise, false.

Remarks: If the value of the treat_control_c_as_input property is false and Ctrl+C is pressed, the pressed keys are not stored in the input buffer and the operating system terminates the currently executing process. This is the default value.

Warning: Use this property judiciously because setting it to true has such a dramatic effect. Most users expect Ctrl+C to terminate a console application. If you disable the effect of Ctrl+C, the user must remember to use Ctrl+Break to terminate the application, which is a less familiar key combination.

◆ treat_control_c_as_input() [2/2]

auto xtd::console::treat_control_c_as_input ( bool treat_control_c_as_input ) -> void

static

Sets a value indicating whether the combination of the Control modifier key and C console key (Ctrl+C) is treated as ordinary input or as an interruption that is handled by the operating system.

Parameters

treat_control_c_as_input true if Ctrl+C is treated as ordinary input; otherwise, false.

Remarks: If the value of the treat_control_c_as_input property is false and Ctrl+C is pressed, the pressed keys are not stored in the input buffer and the operating system terminates the currently executing process. This is the default value.

Warning: Use this property judiciously because setting it to true has such a dramatic effect. Most users expect Ctrl+C to terminate a console application. If you disable the effect of Ctrl+C, the user must remember to use Ctrl+Break to terminate the application, which is a less familiar key combination.

◆ window_height() [1/2]

auto xtd::console::window_height ( ) -> int32

staticnodiscard

Gets the height of the console window area.

Returns: The height of the console window measured in rows.

◆ window_height() [2/2]

auto xtd::console::window_height ( int32 height ) -> void

static

Sets the height of the console window area.

Parameters

height The height of the console window measured in rows.

◆ window_left() [1/2]

auto xtd::console::window_left ( ) -> int32

staticnodiscard

Gets the left of the console window area.

Returns: The left of the console window measured in columns.

◆ window_left() [2/2]

auto xtd::console::window_left ( int32 left ) -> void

static

Sets the left of the console window area.

Parameters

left	The left of the console window measured in columns.

◆ window_top() [1/2]

auto xtd::console::window_top ( ) -> int32

staticnodiscard

Gets the top of the console window area.

Returns: The top of the console window measured in rows.

◆ window_top() [2/2]

auto xtd::console::window_top ( int32 top ) -> void

static

Sets the top of the console window area.

Parameters

top	The top of the console window measured in rows.

◆ window_width() [1/2]

auto xtd::console::window_width ( ) -> int32

staticnodiscard

Gets the width of the console window area.

Returns: The width of the console window measured in columns.

◆ window_width() [2/2]

auto xtd::console::window_width ( int32 width ) -> void

static

Sets the width of the console window area.

Parameters

width The width of the console window measured in columns.

◆ beep() [1/2]

auto xtd::console::beep ( ) -> void

static

Plays the sound of a beep through the console speaker.

Remarks: By default, the beep plays at a frequency of 800 hertz for a duration of 200 milliseconds

Examples: The following example demonstrates the beep method. The example accepts a number from 1 through 9 as a command line argument, and plays the beep that number of times.
#include <xtd/xtd>

auto main() -> int {

auto beep_count = 0;

if (environment::get_command_line_args().length() != 2 || !int32_object::try_parse(environment::get_command_line_args()[1], beep_count) || beep_count < 1 || beep_count > 9) {

console::write_line("Usage: Enter the number of times (between 1 and 9) to beep.");

return 1;

}

for (auto i = 1; i <= beep_count; ++i) {

console::write_line("Beep number {}.", i);

console::beep();

thread::sleep(300_ms);

}

}

// This code produces the following output if 3 is entered on command line:

//

// Beep number 1.

// Beep number 2.

// Beep number 3.

xtd::box_integer< int32 >::try_parse
static auto try_parse(const xtd::string &value, int32 &result, xtd::number_styles styles) -> bool
Definition box_integer.hpp:97

xtd::console::beep
static auto beep() -> void
Plays the sound of a beep through the console speaker.

xtd::environment::get_command_line_args
static auto get_command_line_args() -> const xtd::argument_collection &
Returns a string array containing the command-line arguments for the current process.

xtd::console_key::i
@ i
The I key.
Definition console_key.hpp:104

xtd::length
constexpr auto length() const noexcept -> size_type
Returns the length of the current read_only_span.
Definition read_only_span.hpp:209

◆ beep() [2/2]

auto xtd::console::beep	(	uint32	frequency,
		uint32	duration ) -> void

static

Plays the sound of a beep of a specified frequency and duration through the console speaker.

Parameters

frequency	The frequency of the beep, ranging from 37 to 32767 hertz
duration	The duration of the beep measured in milliseconds

Examples: This example demonstrates the beep method by playing the first few notes of a song through the console speaker.
#include <xtd/xtd>

// Define the frequencies of notes in an octave, as well as silence (rest).

enum class tone {

rest = 0,

g_below_c = 196,

a = 220,

a_sharp = 233,

b = 247,

c = 262,

c_sharp = 277,

d = 294,

d_sharp = 311,

e = 330,

f = 349,

f_sharp = 370,

g = 392,

g_sharp = 415

};

// Define the duration of a note in units of milliseconds.

enum class duration {

none = 0,

whole = 1600,

half = whole / 2,

quarter = half / 2,

eighth = quarter / 2,

sixteenth = eighth / 2

};

// Define a note as a frequency (tone) and the amount of time (duration) the note plays.

struct note {

// Define properties to return the note's tone and duration.

tone tone = tone::rest;

duration duration = duration::none;

};

// Play the notes in a song.

auto play(const array<note>& tune) {

for (auto [tone, duration] : tune)

console::beep(as<uint32>(tone), as<uint32>(duration));

}

auto main() -> int {

// Declare the first few notes of the song, "Mary Had A Little Lamb" and play it

play({

{tone::b, duration::quarter},

{tone::a, duration::quarter},

{tone::g_below_c, duration::quarter},

{tone::a, duration::quarter},

{tone::b, duration::quarter},

{tone::b, duration::quarter},

{tone::b, duration::half},

{tone::a, duration::quarter},

{tone::a, duration::quarter},

{tone::a, duration::half},

{tone::b, duration::quarter},

{tone::d, duration::quarter},

{tone::d, duration::half}

});

}

xtd::console_modifiers::none
@ none
No modifier key.
Definition console_modifiers.hpp:22

xtd::console_key::a
@ a
The A key.
Definition console_key.hpp:88

xtd::console_key::c
@ c
The C key.
Definition console_key.hpp:92

xtd::console_key::d
@ d
The D key.
Definition console_key.hpp:94

xtd::console_key::f
@ f
The F key.
Definition console_key.hpp:98

xtd::console_key::b
@ b
The B key.
Definition console_key.hpp:90

xtd::console_key::play
@ play
The Play key.
Definition console_key.hpp:302

xtd::console_key::g
@ g
The G key.
Definition console_key.hpp:100

xtd::console_key::e
@ e
The E key.
Definition console_key.hpp:96

◆ clear()

auto xtd::console::clear ( ) -> void

static

Clears the console buffer and corresponding console window of display information.

Remarks: Using the clear method is equivalent invoking the MS-DOS cls command in the command prompt window.; When the Clear method is called, the cursor automatically scrolls to the top-left corner of the window and the contents of the screen buffer are set to blanks using the current foreground background colors.

Examples: The following example uses the clear method to clear the console before it executes a loop, prompts the user to select a foreground and background color and to enter a string to display. If the user chooses not to exit the program, the console's original foreground and background colors are restored and the Clear method is called again before re-executing the loop.
#include <xtd/xtd>

namespace console_clear_example {

class program {

public:

// The main entry point for the application.

static auto main() {

// Save colors so they can be restored when use finishes input.

auto dft_fore_color = console::foreground_color();

auto dft_back_color = console::background_color();

do {

auto new_fore_color = console_color::white;

auto new_back_color = console_color::black;

console::clear();

switch (get_key_press("Select Text Color (B for Blue, R for Red, Y for Yellow): ", { 'B', 'R', 'Y' })) {

case 'B': new_fore_color = console_color::dark_blue; break;

case 'R': new_fore_color = console_color::dark_red; break;

case 'Y': new_fore_color = console_color::dark_yellow; break;

}

switch (get_key_press("Select Background Color (W for White, G for Green, M for Magenta): ", { 'W', 'G', 'M' })) {

case 'W': new_back_color = console_color::white; break;

case 'G': new_back_color = console_color::green; break;

case 'M': new_back_color = console_color::magenta; break;

}

console::write_line();

console::write("Enter a message to display: ");

string text_to_display = console::read_line();

console::write_line();

console::foreground_color(new_fore_color);

console::background_color(new_back_color);

console::write_line(text_to_display);

// Restore the default settings and clear the screen.

console::foreground_color(dft_fore_color);

console::background_color(dft_back_color);

console::write_line();

} while (get_key_press("Display another message (Y/N): ", {'Y', 'N'}) == 'Y');

console::clear();

}

private:

[[nodiscard]] static constexpr auto get_key_press(const string& msg, const array<char32>& valid_chars) noexcept -> char32 {

auto key = char32 {};

console::write_line();

do {

console::write(msg);

key = char32_object::to_upper(console::read_key().key_char());

console::write_line();

} while (!valid_chars.contains(key));

return key;

}

};

}

startup_(console_clear_example::program::main);

xtd::char32
char32_t char32
Represents a 32-bit unicode character.
Definition char32.hpp:23

xtd::console_color::black
@ black
The color black.
Definition console_color.hpp:24

xtd::console_color::dark_red
@ dark_red
The color dark red.
Definition console_color.hpp:32

xtd::console_color::dark_yellow
@ dark_yellow
The color dark yellow (ochre).
Definition console_color.hpp:36

The example relies on a get_key_press method to validate the user's selection of a foreground and background color.

Examples: This example demonstrates the cursor_left and cursor_top properties, and the set_cursor_position and clear methods. The example positions the cursor, which determines where the next write will occur, to draw a 5 character by 5 character rectangle using a combination of "+", "|", and "-" strings. Note that the rectangle could be drawn with fewer steps using a combination of other strings.
#include <xtd/xtd>

namespace console_curosr_example {

class program {

public:

// The main entry point for the application.

static auto main() {

// Clear the screen, then save the top and left coordinates.

console::clear();

orig_row = console::cursor_top();

orig_col = console::cursor_left();

// Draw the left side of a 5x5 rectangle, from top to bottom.

write_at("+", 0, 0);

write_at("|", 0, 1);

write_at("|", 0, 2);

write_at("|", 0, 3);

write_at("+", 0, 4);

// Draw the bottom side, from left to right.

write_at("-", 1, 4); // shortcut: write_at("---", 1, 4)

write_at("-", 2, 4); // ...

write_at("-", 3, 4); // ...

write_at("+", 4, 4);

// Draw the right side, from bottom to top.

write_at("|", 4, 3);

write_at("|", 4, 2);

write_at("|", 4, 1);

write_at("+", 4, 0);

// Draw the top side, from right to left.

write_at("-", 3, 0); // shortcut: write_at("---", 1, 0)

write_at("-", 2, 0); // ...

write_at("-", 1, 0); // ...

//

write_at("All done!", 0, 6);

console::write_line();

}

private:

static auto write_at(const string& s, int x, int y) noexcept -> void {

console::set_cursor_position(orig_col + x, orig_row + y);

console::write(s);

}

static inline auto orig_row = 0;

static inline auto orig_col = 0;

};

}

startup_(console_curosr_example::program::main);

// This code produces the following output :

//

// +---+

// | |

// | |

// | |

// +---+

//

// All done!

◆ get_cursor_position()

auto xtd::console::get_cursor_position ( ) -> xtd::collections::generic::key_value_pair< int32, int32 >

staticnodiscard

Gets the position of the cursor.

Returns: The column and row position of the cursor.

Remarks: Columns are numbered from left to right starting at 0. Rows are numbered from top to bottom starting at 0.

◆ open_standard_error()

auto xtd::console::open_standard_error ( ) -> std::ostream

staticnodiscard

Acquires the standard error stream.

Returns: The standard error stream.

Remarks: This method can be used to reacquire the standard error stream after it has been changed by the set_error method.

◆ open_standard_input()

auto xtd::console::open_standard_input ( ) -> std::istream

staticnodiscard

Acquires the standard input stream.

Returns: The standard input stream.

Remarks: This method can be used to reacquire the standard input stream after it has been changed by the set_int method.

◆ open_standard_output()

auto xtd::console::open_standard_output ( ) -> std::ostream

staticnodiscard

Acquires the standard output stream.

Returns: The standard output stream.

Remarks: This method can be used to reacquire the standard output stream after it has been changed by the set_output method.

◆ read()

auto xtd::console::read ( ) -> int32

staticnodiscard

Reads the next character from the standard input stream.

Returns: int32 The next character from the input stream, or negative one (-1) if there are currently no more characters to be read

Remarks: The Read method blocks its return while you type input characters; it terminates when you press the Enter key.; Pressing Enter appends a platform-dependent line termination sequence to your input (for example, Windows appends a carriage return-linefeed sequence).; Subsequent calls to the Read method retrieve your input one character at a time. After the final character is retrieved, Read blocks its return again and the cycle repeats.; Note that you will not get a property value of -1 unless you perform one of the following actions: simultaneously press the Control modifier key and Z console key (CTRL+Z),; which signals the end-of-file condition; press an equivalent key that signals the end-of-file condition, such as the F6 function key in Windows; or redirect the input stream to a source,; such as a text file, that has an actual end-of-file character.

Example: The following example demonstrates the Read method.
#include <xtd/xtd>

auto main() -> int {

constexpr auto m1 = "\nType a string of text then press Enter. "

"Type '+' anywhere in the text to quit:\n";

constexpr auto m2 = "Character '{0}' is hexadecimal 0x{1:x4}.";

constexpr auto m3 = "Character is hexadecimal 0x{0:x4}.";

auto ch = U'0';

//

console::write_line(m1);

do {

auto x = console::read();

try {

ch = convert::to_char32(x);

if (char_object::is_white_space(ch)) {

console::write_line(m3, x);

if (ch == 0x0a)

console::write_line(m1);

} else

console::write_line(m2, ch, x);

} catch (const overflow_exception& e) {

console::write_line("{0} Value read = {1}.", e.message(), x);

ch = char_object::min_value;

console::write_line(m1);

}

} while (ch != '+');

}

// This code produces the following output :

//

// Type a string of text then press Enter. Type '+' anywhere in the text to quit:

//

// The quick brown fox.

// Character 'T' is hexadecimal 0x0054.

// Character 'h' is hexadecimal 0x0068.

// Character 'e' is hexadecimal 0x0065.

// Character is hexadecimal 0x0020.

// Character 'q' is hexadecimal 0x0071.

// Character 'u' is hexadecimal 0x0075.

// Character 'i' is hexadecimal 0x0069.

// Character 'c' is hexadecimal 0x0063.

// Character 'k' is hexadecimal 0x006b.

// Character is hexadecimal 0x0020.

// Character 'b' is hexadecimal 0x0062.

// Character 'r' is hexadecimal 0x0072.

// Character 'o' is hexadecimal 0x006f.

// Character 'w' is hexadecimal 0x0077.

// Character 'n' is hexadecimal 0x006e.

// Character is hexadecimal 0x0020.

// Character 'f' is hexadecimal 0x0066.

// Character 'o' is hexadecimal 0x006f.

// Character 'x' is hexadecimal 0x0078.

// Character '.' is hexadecimal 0x002e.

// Character is hexadecimal 0x000d.

// Character is hexadecimal 0x000a.

//

// Type a string of text then press Enter. Type '+' anywhere in the text to quit:

//

// ^Z

// Value was either too large or too small for a character. Value read = -1.

//

// Type a string of text then press Enter. Type '+' anywhere in the text to quit:

//

// +

// Character '+' is hexadecimal 0x002b.

xtd::box_char< char >::is_white_space
static auto is_white_space(char c) noexcept -> bool
Definition box_char.hpp:196

xtd::console::read
static auto read() -> int32
Reads the next character from the standard input stream.

xtd::convert::to_char32
static auto to_char32(xtd::any value) -> xtd::char32
Convert xtd::any to char32.

xtd::console_key::x
@ x
The X key.
Definition console_key.hpp:134

◆ read_key() [1/4]

auto xtd::console::read_key ( ) -> console_key_info

static

Obtains the next character or function key pressed by the user. The pressed key is displayed in the console window.

Returns: xtd::console_key_info A xtd::console_key_info object that describes the ConsoleKey constant and Unicode character, if any, that correspond to the pressed console key. The xtd::console_key_info object also describes, in a bitwise combination of ConsoleModifiers values, whether one or more SHIFT, ALT, or CTRL modifier keys was pressed simultaneously with the console key.

◆ read_key() [2/4]

auto xtd::console::read_key ( bool intercept ) -> console_key_info

static

Obtains the next character or function key pressed by the user. The pressed key is optionally displayed in the console window.

Parameters

intercept Determines whether to display the pressed key in the console window. true to not display the pressed key; otherwise, false

Returns: xtd::console_key_info A xtd::console_key_info object that describes the ConsoleKey constant and Unicode character, if any, that correspond to the pressed console key. The xtd::console_key_info object also describes, in a bitwise combination of ConsoleModifiers values, whether one or more SHIFT, ALT, or CTRL modifier keys was pressed simultaneously with the console key.

◆ read_key() [3/4]

auto xtd::console::read_key ( const string & text ) -> console_key_info

static

Obtains the next character or function key pressed by the user. The pressed key is displayed in the console window with specified invit text.

Parameters

text	The invit text to print before read line.

Returns: xtd::console_key_info A xtd::console_key_info object that describes the ConsoleKey constant and Unicode character, if any, that correspond to the pressed console key. The xtd::console_key_info object also describes, in a bitwise combination of ConsoleModifiers values, whether one or more SHIFT, ALT, or CTRL modifier keys was pressed simultaneously with the console key.

◆ read_key() [4/4]

auto xtd::console::read_key	(	const string &	text,
		bool	intercept ) -> console_key_info

static

Obtains the next character or function key pressed by the user. The pressed key is optionally displayed in the console window with specified invit text.

Parameters

text	The invit text to print before read line.
intercept	Determines whether to display the pressed key in the console window. true to not display the pressed key; otherwise, false

Returns: xtd::console_key_info A xtd::console_key_info object that describes the ConsoleKey constant and Unicode character, if any, that correspond to the pressed console key. The xtd::console_key_info object also describes, in a bitwise combination of ConsoleModifiers values, whether one or more SHIFT, ALT, or CTRL modifier keys was pressed simultaneously with the console key.

◆ read_line() [1/4]

auto xtd::console::read_line ( ) -> xtd::string

static

Reads the next line of characters from the standard input stream.

Returns: The next line of characters from the input stream, or "" if no more lines are available.

◆ read_line() [2/4]

auto xtd::console::read_line ( bool intercept ) -> xtd::string

static

Reads the next line of characters from the standard input stream.

Parameters

intercept Determines whether to display the pressed key in the console window. true to not display the pressed key; otherwise, false

Returns: The next line of characters from the input stream, or "" if no more lines are available.

◆ read_line() [3/4]

auto xtd::console::read_line ( const string & text ) -> xtd::string

static

Reads the next line of characters from the standard input stream with specified invit text.

Parameters

text	The invit text to print before read line.

Returns: The next line of characters from the input stream, or "" if no more lines are available.

◆ read_line() [4/4]

auto xtd::console::read_line	(	const string &	text,
		bool	intercept ) -> xtd::string

static

Reads the next line of characters from the standard input stream with specified invit text.

Parameters

text	The invit text to print before read line.
intercept	Determines whether to display the pressed key in the console window. true to not display the pressed key; otherwise, false

Returns: The next line of characters from the input stream, or "" if no more lines are available.

◆ reset_color()

auto xtd::console::reset_color ( ) -> bool

static

Sets the foreground and background console colors to their defaults.

Remarks: The foreground and background colors are restored to the colors that existed when the current process began. For more information, see the foreground_color and background_color properties.

◆ reset_terminal_mode()

auto xtd::console::reset_terminal_mode ( ) -> void

static

Resets terminale mode to default.

Remarks: This method must be used for example if you use xtd::console::key_availlableor xtd::console::read_key and you want to usud std::cin or scanf or other input than xtd.

◆ set_cursor_position()

auto xtd::console::set_cursor_position	(	int32	left,
		int32	top ) -> void

static

Sets the position of the cursor.

Parameters

left	The column position of the cursor. Columns are numbered from left to right starting at 0.
top	The row position of the cursor. Rows are numbered from top to bottom starting at 0.

Exceptions

xtd::argument_out_of_range_exception The left in a set operation is less than zero
-or-
The left in a set operation is greater than or equal to xtd::console::buffer_width
-or-
the top in a set operation is less than zero
-or-
The topo in a set operation is greater than or equal to xtd::console::buffer_height.

Remarks: Use the set_cursor_position method to specify where the next write operation in the console window is to begin. If the specified cursor position is outside the area that is currently visible in the console window, the window origin changes automatically to make the cursor visible.; The cursor automatically moves to the next character position each time a character is written to the console window. If the cursor is at the bottom right character position of the console window, the next write operation causes the console window to scroll so the cursor remains visible. If you want to write a character to the bottom right character position without causing the console window to scroll, use the move_buffer_area method to move a character to that position.

◆ set_error()

auto xtd::console::set_error ( const std::ostream & os ) -> void

static

Sets the error property to the specified std::ostream object.

Parameters

os	A stream that is the new standard error output.

Remarks: By default, the error property is set to the standard error output stream.; A std::ostream that encapsulates a std::ofstream can be used to send error messages to a file.

◆ set_in()

auto xtd::console::set_in ( const std::istream & is ) -> void

static

Sets the int property to the specified std::istream object.

Parameters

os	A stream that is the new standard input.

Remarks: By default, the in property is set to the standard input stream.; A std::istream that encapsulates a std::ifstream can be used to receiver input from a file.

◆ set_out()

auto xtd::console::set_out ( const std::ostream & os ) -> void

static

Sets the out property to the specified std::ostream object.

Parameters

os	A stream that is the new standard output.

Remarks: By default, the out property is set to the standard output stream.; A std::ostream that encapsulates a std::ofstream can be used to send output to a file.

◆ set_window_position()

auto xtd::console::set_window_position	(	int32	left,
		int32	top ) -> void

static

Sets the position of the console window relative to the screen buffer.

Parameters

left	The column position of the upper left corner of the console window.
top	The row position of the upper left corner of the console window.

Exceptions

xtd::argument_out_of_range_exception The left in a set operation is less than zero
-or-
The left in a set operation is greater than or equal to xtd::console::buffer_width
-or-
the top in a set operation is less than zero
-or-
The topo in a set operation is greater than or equal to xtd::console::buffer_height.

◆ set_window_size()

auto xtd::console::set_window_size	(	int32	width,
		int32	height ) -> void

static

Sets the height and width of the console window to the specified values.

Parameters

width	The width of the console window measured in columns.
height	The height of the console window measured in rows.

Exceptions

xtd::argument_out_of_range_exception width or height is less than or equal to zero.
-or-
width plus WindowLeft or height plus WindowTop is greater than or equal to xtd::int16_object.max_value.
-or-
width or height is greater than the largest possible window width or height for the current screen resolution and console font.

Examples: This example demonstrates the SetWindowSize method, and the WindowWidth and WindowHeight properties. You must run the example to see the full effect of changing the console window size. The example reports the dimensions of a console window set to 85 columns and 43 rows, then waits for a key press. When any key is pressed, the dimensions of the console window are halved, the new dimensions are reported, and the example waits for another key press. Finally, when any key is pressed the console window is restored to its original dimensions and the example terminates.
#include <xtd/xtd>

auto main() -> int {

auto orig_width = 0, width = 0;

auto orig_height = 0, height = 0;

constexpr auto m1 = "The current window width is {0}, and the current window height is {1}.";

constexpr auto m2 = "The new window width is {0}, and the new window height is {1}.";

constexpr auto m4 = " (Press any key to continue...)";

//

// Step 1: Get the current window dimensions.

//

orig_width = console::window_width();

orig_height = console::window_height();

console::write_line(m1, console::window_width(), console::window_height());

console::write_line(m4);

console::read_key(true);

//

// Step 2: Cut the window to 1/4 its original size.

//

width = orig_width / 2;

height = orig_height / 2;

console::set_window_size(width, height);

console::write_line(m2, console::window_width(), console::window_height());

console::write_line(m4);

console::read_key(true);

//

// Step 3: Restore the window to its original size.

//

console::set_window_size(orig_width, orig_height);

console::write_line(m1, console::window_width(), console::window_height());}

// This code produces the following output :

//

// The current window width is 100, and the current window height is 60.

// (Press any key to continue...)

// The new window width is 50, and the new window height is 30.

// (Press any key to continue...)

// The current window width is 100, and the current window height is 60.

xtd::console::window_height
static auto window_height() -> int32
Gets the height of the console window area.

xtd::console::set_window_size
static auto set_window_size(int32 width, int32 height) -> void
Sets the height and width of the console window to the specified values.

xtd::console::window_width
static auto window_width() -> int32
Gets the width of the console window area.

◆ write() [1/4]

template<typename arg_t>

auto xtd::console::write ( arg_t && value ) -> void

inlinestatic

Writes the text representation of the specified value to the standard output stream.

Template Parameters

arg_t The type of the value to write.

Parameters

value The value to write,

Examples: culture_info_culture_types.cpp, culture_info_parent.cpp, culture_info_properties.cpp, iformatable.cpp, and iformatable_vs_to_string.cpp.

◆ write() [2/4]

template<typename ... args_t>

auto xtd::console::write	(	const xtd::string &	fmt,
		args_t &&...	values ) -> void

inlinestatic

Writes the text representation of the specified list of values to the standard output stream using the specified format information.

Template Parameters

...args_t Types of the values to write.

Parameters

fmt	A composite format string.
values	Values to write,

◆ write() [3/4]

template<typename arg_t>

auto xtd::console::write	(	const xtd::globalization::culture_info &	culture,
		arg_t &&	value ) -> void

inlinestatic

Writes the text representation of the specified value to the standard output stream.

Template Parameters

arg_t The type of the value to write.

Parameters

culture	The xtd::globalization::culture_info used to print value.
value	The value to write,

◆ write() [4/4]

template<typename ... args_t>

auto xtd::console::write	(	const xtd::globalization::culture_info &	culture,
		const xtd::string &	fmt,
		args_t &&...	values ) -> void

inlinestatic

Writes the text representation of the specified list of values to the standard output stream using the specified format information.

Template Parameters

...args_t Types of the values to write.

Parameters

culture	The xtd::globalization::culture_info used to print value.
fmt	A composite format string.
values	Values to write,

◆ write_line() [1/5]

auto xtd::console::write_line ( ) -> void

static

Writes the current line terminator to the standard output stream using the specified format information.

◆ write_line() [2/5]

template<typename arg_t>

auto xtd::console::write_line ( arg_t && value ) -> void

inlinestatic

Writes the text representation of the specified value, followed by the current line terminator, to the standard output stream.

Template Parameters

arg_t The type of the value to write.

Parameters

value The value to write,

◆ write_line() [3/5]

template<typename ... args_t>

auto xtd::console::write_line	(	const xtd::string &	fmt,
		args_t &&...	values ) -> void

inlinestatic

Writes the text representation of the specified list of values, followed by the current line terminator, to the standard output stream using the specified format information.

Template Parameters

...args_t Types of the values to write.

Parameters

fmt	A composite format string.
values	Values to write,

◆ write_line() [4/5]

template<typename arg_t>

auto xtd::console::write_line	(	const xtd::globalization::culture_info &	culture,
		arg_t &&	value ) -> void

inlinestatic

Writes the text representation of the specified value, followed by the current line terminator, to the standard output stream.

Template Parameters

arg_t The type of the value to write.

Parameters

culture	The xtd::globalization::culture_info used to print value.
value	The value to write,

◆ write_line() [5/5]

template<typename ... args_t>

auto xtd::console::write_line	(	const xtd::globalization::culture_info &	culture,
		const xtd::string &	fmt,
		args_t &&...	values ) -> void

inlinestatic

Writes the text representation of the specified list of values, followed by the current line terminator, to the standard output stream using the specified format information.

Template Parameters

...args_t Types of the values to write.

Parameters

culture	The xtd::globalization::culture_info used to print value.
fmt	A composite format string.
values	Values to write,

Member Data Documentation

◆ error

std::ostream xtd::console::error

static

Gets the error output stream. A std::basic_ostream<char_t> that represents the error output stream.

Examples: collection_assert_all_items_are_instances_of.cpp, collection_assume_all_items_are_instances_of.cpp, and collection_valid_all_items_are_instances_of.cpp.

◆ in

std::istream xtd::console::in

static

Gets the standard input stream. A std::basic_istream<char_t> that represents the standard input stream.

Examples: The following sample illustrates the use of the in property.
#include <xtd/xtd>

auto main() -> int {

auto& is = console::in;

auto& os = console::out;

os << "Ola Mundo!" << environment::new_line;

os << "What is your name: ";

auto name = string::empty_string;

is >> name;

os << "Buenos Dias, " << name << environment::new_line;

}

// This code produces the following output :

//

// Ola Mundo!

// What is your name: James

// Buenos Dias, James!

Examples: collection_assert_all_items_are_instances_of.cpp, collection_assume_all_items_are_instances_of.cpp, and collection_valid_all_items_are_instances_of.cpp.

◆ out

std::ostream xtd::console::out

static

Gets the standard output stream. A std::basic_ostream<char_t> that represents the standard output stream.

Examples: The following sample illustrates the use of the out property.
#include <xtd/xtd>

auto main() -> int {

auto& is = console::in;

auto& os = console::out;

os << "Ola Mundo!" << environment::new_line;

os << "What is your name: ";

auto name = string::empty_string;

is >> name;

os << "Buenos Dias, " << name << environment::new_line;

}

// This code produces the following output :

//

// Ola Mundo!

// What is your name: James

// Buenos Dias, James!

Examples: collection_assert_all_items_are_instances_of.cpp, collection_assume_all_items_are_instances_of.cpp, collection_valid_all_items_are_instances_of.cpp, create_gtest_like_event_listener.cpp, event.cpp, format_class_with_specified_formating.cpp, format_class_with_specified_formating_with_to_string.cpp, format_floating_point.cpp, format_number.cpp, iformatable.cpp, iformatable_vs_to_string.cpp, sprintf_class_with_specified_formating.cpp, and sprintf_class_with_specified_formating_with_to_string.cpp.

◆ cancel_key_press

event<console, console_cancel_event_handler> xtd::console::cancel_key_press

static

Occurs when the Control modifier key (Ctrl) and either the ConsoleKey.C console key (C) or the Break key are pressed simultaneously (Ctrl+C or Ctrl+Break).

Remarks

This event is used in conjunction with xtd::console_cancel_event_handler and xtd::console_cancel_event_args. The cancel_key_press event enables a console application to intercept the Ctrl+C signal so the event handler can decide whether to continue executing or terminate.

For more information about handling events, see Handling and Raising Events.

When the user presses either Ctrl+C or Ctrl+Break, the cancel_key_press event is fired and the application's console_cancel_event_handler event handler is executed. The event handler is passed a console_cancel_event_args object that has two useful properties:

special_key, which allows you to determine whether the handler was invoked as a result of the user pressing Ctrl+C (the property value is console_special_key::control_c) or Ctrl+Break (the property value is console_special_key.control_break).
Cancel, which allows you to determine how to your application should respond to the user pressing Ctrl+C or Ctrl+Break. By default, the cancel property is false, which causes program execution to terminate when the event handler exits. Changing its property to true specifies that the application should continue to execute.

Note: If your application has simple requirements, you can use the treat_control_c_as_input property instead of this event. By setting this property to false, you can ensure that your application always exits if the user presses Ctrl+C. By setting it to true, you can ensure that pressing Ctrl+C will not terminate the application.

Warning: The xtd::signal::interrupt and xtd::console_special_key::control_c use the same signal (SIGINT).; The xtd::signal::interrupt and xtd::console_special_key::control_c can be cancelled with xtd::environment::cancel_signal event or xtd::console::cancel_key_press event. Both of these events are called when SIGINT is raised.

The documentation for this class was generated from the following file:

xtd.core/include/xtd/console.hpp

Definition

Public Fields

Public Static Events

Public Static Properties

Public Static Methods

Member Function Documentation

◆ auto_flush_out() [1/2]

◆ auto_flush_out() [2/2]

◆ background_color() [1/2]

◆ background_color() [2/2]

◆ buffer_height() [1/2]

◆ buffer_height() [2/2]

◆ buffer_width() [1/2]

◆ buffer_width() [2/2]

◆ caps_lock()

◆ cursor_left() [1/2]

◆ cursor_left() [2/2]

◆ cursor_size() [1/2]

◆ cursor_size() [2/2]

◆ cursor_top() [1/2]

◆ cursor_top() [2/2]

◆ cursor_visible() [1/2]

◆ cursor_visible() [2/2]

◆ foreground_color() [1/2]

◆ foreground_color() [2/2]

◆ input_code_page() [1/2]

◆ input_code_page() [2/2]

◆ is_error_redirected()

◆ is_input_redirected()

◆ is_output_redirected()

◆ key_available()

◆ largest_window_height()

◆ largest_window_width()

◆ number_lock()

◆ output_code_page() [1/2]

◆ output_code_page() [2/2]

◆ title() [1/2]

◆ title() [2/2]

◆ treat_control_c_as_input() [1/2]

◆ treat_control_c_as_input() [2/2]

◆ window_height() [1/2]

◆ window_height() [2/2]

◆ window_left() [1/2]

◆ window_left() [2/2]

◆ window_top() [1/2]

◆ window_top() [2/2]

◆ window_width() [1/2]

◆ window_width() [2/2]

◆ beep() [1/2]

◆ beep() [2/2]

◆ clear()

◆ get_cursor_position()

◆ open_standard_error()

◆ open_standard_input()

◆ open_standard_output()

◆ read()

◆ read_key() [1/4]

◆ read_key() [2/4]

◆ read_key() [3/4]

◆ read_key() [4/4]

◆ read_line() [1/4]

◆ read_line() [2/4]

◆ read_line() [3/4]

◆ read_line() [4/4]

◆ reset_color()

◆ reset_terminal_mode()

◆ set_cursor_position()

◆ set_error()

◆ set_in()

◆ set_out()

◆ set_window_position()

◆ set_window_size()

◆ write() [1/4]

◆ write() [2/4]

◆ write() [3/4]

◆ write() [4/4]

◆ write_line() [1/5]

◆ write_line() [2/5]

◆ write_line() [3/5]

◆ write_line() [4/5]