Term Namespace Reference

Namespaces
namespace	Private
namespace	Version

Classes
class	Argc
class	Arguments
class	Buffer
class	Button
class	Color
class	Columns
class	Cursor
class	Event
class	Exception
class	Focus
	Class to return the focus of the terminal. More...
class	IOStreamInitializer
class	Key
class	MetaKey
class	Model
class	Mouse
class	Options
class	Rows
class	Screen
class	Size
class	Terminal
class	TerminalInitializer
class	Terminfo
class	TIstream
class	TOstream
class	Window
	Represents a rectangular window, as a 2D array of characters and their attributes. More...

Enumerations
enum class	Option : std::int16_t {   Raw = 1 , Cooked = -1 , ClearScreen = 2 , NoClearScreen = -2 ,   SignalKeys = 3 , NoSignalKeys = -3 , Cursor = 4 , NoCursor = -4 }
	Option to set-up the terminal. More...
enum class	Result {   Yes , No , Error , None ,   Abort , Invalid }
enum class	Result_simple { Yes , No , Abort }
enum class	Style : std::uint8_t {   Reset = 0 , Bold = 1 , Dim = 2 , Italic = 3 ,   Underline = 4 , Blink = 5 , BlinkRapid = 6 , Reversed = 7 ,   Conceal = 8 , Crossed = 9 , Font0 = 10 , ResetFont = 10 ,   Font1 = 11 , Font2 = 12 , Font3 = 13 , Font4 = 14 ,   Font5 = 15 , Font6 = 16 , Font7 = 17 , Font8 = 18 ,   Font9 = 19 , Font10 = 20 , DoublyUnderlinedOrNotBold = 21 , ResetBold = 22 ,   ResetDim = 22 , ResetItalic = 23 , ResetUnderline = 24 , ResetBlink = 25 ,   ResetBlinkRapid = 25 , ResetReversed = 27 , ResetConceal = 28 , ResetCrossed = 29 ,   DefaultForegroundColor = 39 , DefaultBackgroundColor = 49 , Frame = 51 , Encircle = 52 ,   Overline = 53 , ResetFrame = 54 , ResetEncircle = 54 , ResetOverline = 55 ,   DefaultUnderlineColor = 59 , BarRight = 60 , DoubleBarRight = 61 , BarLeft = 62 ,   DoubleBarLeft = 63 , StressMarking = 64 , ResetBar = 65 , Superscript = 73 ,   Subscript = 74 , ResetSuperscript = 75 , ResetSubscript = 75 }

Functions
std::string	color_bg (const Term::Color::Name &name)
std::string	color_bg (const std::uint8_t &value)
std::string	color_bg (const std::uint8_t &red, const std::uint8_t &green, const std::uint8_t &blue)
std::string	color_bg (const Color &color)
std::string	color_fg (const Term::Color::Name &name)
std::string	color_fg (const std::uint8_t &value)
std::string	color_fg (const std::uint8_t &red, const std::uint8_t &green, const std::uint8_t &blue)
std::string	color_fg (const Color &color)
Term::Cursor	cursor_position ()
std::string	cursor_move (const std::size_t &row, const std::size_t &column)
std::string	cursor_up (const std::size_t &rows)
std::string	cursor_down (const std::size_t &rows)
std::string	cursor_left (const std::size_t &columns)
std::string	cursor_right (const std::size_t &columns)
std::string	cursor_position_report ()
std::string	cursor_off ()
std::string	cursor_on ()
std::string	clear_eol ()
Term::Event	read_event ()
constexpr bool	operator== (Key l, MetaKey r)
constexpr bool	operator== (MetaKey l, Key r)
constexpr bool	operator< (MetaKey l, Key r)
constexpr bool	operator< (Key l, MetaKey r)
constexpr bool	operator!= (Key l, MetaKey r)
constexpr bool	operator!= (MetaKey l, Key r)
constexpr bool	operator>= (MetaKey l, Key r)
constexpr bool	operator>= (Key l, MetaKey r)
constexpr bool	operator> (MetaKey l, Key r)
constexpr bool	operator> (Key l, MetaKey r)
constexpr bool	operator<= (MetaKey l, Key r)
constexpr bool	operator<= (Key l, MetaKey r)
constexpr Key	operator+ (MetaKey metakey, Key key)
constexpr Key	operator+ (Key key, MetaKey meta)
constexpr Key	operator+ (MetaKey::Value l, Key r)
constexpr Key	operator+ (Key l, MetaKey::Value r)
constexpr Key	operator+ (MetaKey::Value l, Key::value_type r)
constexpr Key	operator+ (Key::value_type l, MetaKey::Value r)
std::uint16_t	returnCode () noexcept
Result	prompt (const std::string &message, const std::string &first_option, const std::string &second_option, const std::string &prompt_indicator, bool)
	A simple yes/no prompt, requires the user to press the ENTER key to continue.
Result_simple	prompt_simple (const std::string &message)
	The most simple prompt possible, requires the user to press enter to continue.
std::string	concat (const std::vector< std::string > &)
std::vector< std::string >	split (const std::string &)
void	print_left_curly_bracket (Term::Window &, const std::size_t &, const std::size_t &, const std::size_t &)
void	render (Term::Window &, const Model &, const std::size_t &)
std::string	prompt_multiline (const std::string &, std::vector< std::string > &, std::function< bool(std::string)> &)
std::string	clear_screen ()
std::string	screen_save ()
std::string	screen_load ()
Screen	screen_size ()
std::string	style (const Term::Style &style)
template<class Stream >
Stream &	operator<< (Stream &stream, const Term::Style &style_type)
Term::TOstream &	operator<< (Term::TOstream &term, const Term::Style &style_type)
std::string	terminal_title (const std::string &title)
std::string	clear_buffer ()
bool	is_stdin_a_tty ()
	Check if stdin is a tty.
bool	is_stdout_a_tty ()
	Check if stdout is a tty.
bool	is_stderr_a_tty ()
	Check if stderr is a tty.
std::string	homepage () noexcept
	Homepage of cpp-terminal.

Variables
TIstream &	cin = reinterpret_cast<Term::TIstream&>(cin_buffer)
TOstream &	cout = reinterpret_cast<Term::TOstream&>(cout_buffer)
TOstream &	cerr = reinterpret_cast<Term::TOstream&>(cerr_buffer)
TOstream &	clog = reinterpret_cast<Term::TOstream&>(clog_buffer)
Term::Terminal &	terminal = reinterpret_cast<Term::Terminal&>(::terminal_buffer)

Enumeration Type Documentation

Option

enum class Term::Option : std::int16_t

strong

Option to set-up the terminal.

Enumerator
Raw	Set terminal in raw mode.
Cooked	Set terminal in cooked mode.
ClearScreen	Clear the screen (and restore its states when the program stops).
NoClearScreen	Doesn't clear the screen.
SignalKeys	Enable the signal keys (Ctrl+C, etc...), if activated these keys will have their default OS behaviour.
NoSignalKeys	Disable the signal keys (Ctrl+C, etc...) will not be processed by the OS and will appears has standard combination keys.
Cursor	Show the cursor.
NoCursor	Hide the cursor (and restore its states when the program stops).

Definition at line 22 of file options.hpp.

{
  Raw           = 1,   
  Cooked        = -1,  
  ClearScreen   = 2,   
  NoClearScreen = -2,  
  SignalKeys    = 3,   
  NoSignalKeys  = -3,  
  Cursor        = 4,   
  NoCursor      = -4   
};

Result

enum class Term::Result

strong

Enumerator
Yes	Returned if the user chose yes.
No	Returned if the user chose no.
Error	Returned if no terminal is attached to the program.
None	Returned if the enter key was pressed without additional input.
Abort	Returned if CTRL+C was pressed.
Invalid	Returned if the given input did not match the case yes of no.

Definition at line 21 of file prompt.hpp.

{
  Yes,     
  No,      
  Error,   
  None,    
  Abort,   
  Invalid  
};

Result_simple

enum class Term::Result_simple

strong

Enumerator
Yes	Returned if the user chose yes.
No	Returned if the user chose no or invalid / no input or if no terminal is attached.
Abort	Returned if CTRL+C was pressed.

Definition at line 44 of file prompt.hpp.

{
 
  Yes,   
  No,    
  Abort  
};

Style

enum class Term::Style : std::uint8_t

strong

Enumerator
Reset	resets all attributes (styles and colors)
Bold	Thick text font.
Dim	lighter, slimmer text font
Italic	slightly bend text font
Underline	draws a line below the text
Blink	Sets blinking to less than 150 times per minute.
BlinkRapid	MS-DOS ANSI.SYS, 150+ per minute; not widely supported.
Reversed	swap foreground and background colors
Conceal	Note: not widely supported.
Crossed	strikes through the text, mostly supported
Font0	Primary or default font.
ResetFont
Font1
Font2
Font3
Font4
Font5
Font6
Font7
Font8
Font9
Font10	Fraktur / Gothic font.
DoublyUnderlinedOrNotBold
ResetBold
ResetDim
ResetItalic
ResetUnderline
ResetBlink
ResetBlinkRapid
ResetReversed
ResetConceal
ResetCrossed
DefaultForegroundColor
DefaultBackgroundColor
Frame
Encircle
Overline
ResetFrame
ResetEncircle
ResetOverline
DefaultUnderlineColor	non standard, implemented in Kitty, VTE, mintty, and iTerm2
BarRight	draw a vertical bar on the right side of the character
DoubleBarRight	draw a double vertical bar to the right
BarLeft	draw a vertical bar on the left side of the character
DoubleBarLeft	draw a double vertical bar to the left
StressMarking	reset all bars left and right double and simple
ResetBar
Superscript
Subscript
ResetSuperscript
ResetSubscript

Definition at line 23 of file style.hpp.

{
 
  Reset      = 0,  
  Bold       = 1,  
  Dim        = 2,  
  Italic     = 3,  
  Underline  = 4,  
  Blink      = 5,  
  BlinkRapid = 6,  
  Reversed   = 7,  
  Conceal    = 8,  
  Crossed    = 9,  
 
  // different fonts
  Font0     = 10,  
  ResetFont = 10,
  Font1     = 11,
  Font2     = 12,
  Font3     = 13,
  Font4     = 14,
  Font5     = 15,
  Font6     = 16,
  Font7     = 17,
  Font8     = 18,
  Font9     = 19,
  Font10    = 20,  
 
  // Double-underline per ECMA-48,[5] 8.3.117 but instead disables bold intensity on several terminals,
  // including in the Linux kernel's console before version 4.17
  DoublyUnderlinedOrNotBold = 21,
 
  // resets corresponding styles
  ResetBold       = 22,
  ResetDim        = 22,
  ResetItalic     = 23,
  ResetUnderline  = 24,
  ResetBlink      = 25,
  ResetBlinkRapid = 25,
  ResetReversed   = 27,
  ResetConceal    = 28,
  ResetCrossed    = 29,
 
  // sets the foreground and background color to the implementation defined colors
  DefaultForegroundColor = 39,
  DefaultBackgroundColor = 49,
 
  Frame         = 51,
  Encircle      = 52,
  Overline      = 53,  // draw a line over the text, barely supported
  ResetFrame    = 54,
  ResetEncircle = 54,
  ResetOverline = 55,
 
  // sets the underline color to the implementation defined colors
  DefaultUnderlineColor = 59,  
 
  BarRight       = 60,  
  DoubleBarRight = 61,  
  BarLeft        = 62,  
  DoubleBarLeft  = 63,  
  StressMarking  = 64,  
 
  ResetBar = 65,  // resets 60 - 64 inclusive
 
  Superscript      = 73,  // only implemented in mintty
  Subscript        = 74,  // only implemented in mintty
  ResetSuperscript = 75,  // only implemented in mintty
  ResetSubscript   = 75
};

Function Documentation

clear_buffer()

std::string Term::clear_buffer

(

)

Definition at line 23 of file terminal.cpp.

{ return "\u001b[3J"; }

clear_eol()

std::string Term::clear_eol

(

)

Definition at line 44 of file cursor.cpp.

{ return "\u001b[K"; }

clear_screen()

std::string Term::clear_screen

(

)

Definition at line 20 of file screen.cpp.

{ return "\u001b[2J"; }

color_bg() [1/4]

std::string Term::color_bg

(

const Color &

color

)

Definition at line 87 of file color.cpp.

{
  if(color.getType() == Term::Color::Type::Unset || color.getType() == Term::Color::Type::NoColor) return "";
  switch(Term::Terminfo::getColorMode())
  {
    case Term::Terminfo::ColorMode::Unset:
    case Term::Terminfo::ColorMode::NoColor: return {};
    case Term::Terminfo::ColorMode::Bit3: return "\u001b[" + std::to_string(static_cast<uint8_t>(color.to3bits()) + 40) + "m\u001b[K";
    case Term::Terminfo::ColorMode::Bit4: return "\u001b[" + std::to_string(static_cast<uint8_t>(color.to4bits()) + 40) + "m\u001b[K";
    case Term::Terminfo::ColorMode::Bit8:
      if(color.getType() == Term::Color::Type::Bit4 || color.getType() == Term::Color::Type::Bit3) return "\u001b[" + std::to_string(static_cast<uint8_t>(color.to4bits()) + 40) + "m\u001b[K";
      else
        return "\u001b[48;5;" + std::to_string(color.to8bits()) + "m\u001b[K";
    case Term::Terminfo::ColorMode::Bit24:
      if(color.getType() == Term::Color::Type::Bit3 || color.getType() == Term::Color::Type::Bit4) return "\u001b[" + std::to_string(static_cast<uint8_t>(color.to4bits()) + 40) + "m\u001b[K";
      else if(color.getType() == Term::Color::Type::Bit8)
        return "\u001b[48;5;" + std::to_string(color.to8bits()) + "m\u001b[K";
      else
        return "\u001b[48;2;" + std::to_string(color.to24bits()[0]) + ';' + std::to_string(color.to24bits()[1]) + ';' + std::to_string(color.to24bits()[2]) + "m\u001b[K";
    default: return {};
  }
}

color_bg() [2/4]

std::string Term::color_bg	(	const std::uint8_t &	red,
		const std::uint8_t &	green,
		const std::uint8_t &	blue )

Definition at line 83 of file color.cpp.

{ return color_bg(Color(r, g, b)); }

color_bg() [3/4]

std::string Term::color_bg

(

const std::uint8_t &

value

)

Definition at line 81 of file color.cpp.

{ return color_bg(Color(color)); }

color_bg() [4/4]

std::string Term::color_bg

(

const Term::Color::Name &

name

)

Definition at line 79 of file color.cpp.

{ return color_bg(Color(color)); }

color_fg() [1/4]

std::string Term::color_fg

(

const Color &

color

)

Definition at line 116 of file color.cpp.

{
  if(color.getType() == Term::Color::Type::Unset || color.getType() == Term::Color::Type::NoColor) { return {}; }
  switch(Term::Terminfo::getColorMode())
  {
    case Term::Terminfo::ColorMode::Unset:
    case Term::Terminfo::ColorMode::NoColor: return "";
    case Term::Terminfo::ColorMode::Bit3: return "\u001b[" + std::to_string(static_cast<uint8_t>(color.to3bits()) + 30) + "m";
    case Term::Terminfo::ColorMode::Bit4: return "\u001b[" + std::to_string(static_cast<uint8_t>(color.to4bits()) + 30) + "m";
    case Term::Terminfo::ColorMode::Bit8:
      if(color.getType() == Term::Color::Type::Bit4 || color.getType() == Term::Color::Type::Bit3) return "\u001b[" + std::to_string(static_cast<uint8_t>(color.to4bits()) + 30) + "m";
      else
        return "\u001b[38;5;" + std::to_string(color.to8bits()) + "m";
    case Term::Terminfo::ColorMode::Bit24:
      if(color.getType() == Term::Color::Type::Bit3 || color.getType() == Term::Color::Type::Bit4) return "\u001b[" + std::to_string(static_cast<uint8_t>(color.to4bits()) + 30) + "m";
      else if(color.getType() == Term::Color::Type::Bit8)
        return "\u001b[38;5;" + std::to_string(color.to8bits()) + "m";
      else
        return "\u001b[38;2;" + std::to_string(color.to24bits()[0]) + ';' + std::to_string(color.to24bits()[1]) + ';' + std::to_string(color.to24bits()[2]) + "m";
    default: return {};
  }
}

color_fg() [2/4]

std::string Term::color_fg	(	const std::uint8_t &	red,
		const std::uint8_t &	green,
		const std::uint8_t &	blue )

Definition at line 114 of file color.cpp.

{ return color_fg(Color(red, green, blue)); }

color_fg() [3/4]

std::string Term::color_fg

(

const std::uint8_t &

value

)

Definition at line 112 of file color.cpp.

{ return color_fg(Color(value)); }

color_fg() [4/4]

std::string Term::color_fg

(

const Term::Color::Name &

name

)

Definition at line 110 of file color.cpp.

{ return color_fg(Color(name)); }

concat()

std::string Term::concat

(

const std::vector< std::string > &

lines

)

Definition at line 143 of file prompt.cpp.

{
  std::string s;
  for(auto& line: lines) { s.append(line + "\n"); }
  return s;
}

cursor_down()

std::string Term::cursor_down

(

const std::size_t &

rows

)

Definition at line 36 of file cursor.cpp.

{ return "\u001b[" + std::to_string(rows) + 'B'; }

cursor_left()

std::string Term::cursor_left

(

const std::size_t &

columns

)

Definition at line 40 of file cursor.cpp.

{ return "\u001b[" + std::to_string(columns) + 'D'; }

cursor_move()

std::string Term::cursor_move	(	const std::size_t &	row,
		const std::size_t &	column )

Definition at line 32 of file cursor.cpp.

{ return "\u001b[" + std::to_string(row) + ';' + std::to_string(column) + 'H'; }

cursor_off()

std::string Term::cursor_off

(

)

Definition at line 28 of file cursor.cpp.

{ return "\u001b[?25l"; }

cursor_on()

std::string Term::cursor_on

(

)

Definition at line 30 of file cursor.cpp.

{ return "\u001b[?25h"; }

cursor_position()

Term::Cursor Term::cursor_position

(

)

Definition at line 26 of file cursor.cpp.

{
  static const Term::Private::FileInitializer files_init;
  if(Term::Private::in.null()) { return {}; }
#if defined(_WIN32)
  CONSOLE_SCREEN_BUFFER_INFO inf;
  if(GetConsoleScreenBufferInfo(Private::out.handle(), &inf)) return Term::Cursor(static_cast<std::size_t>(inf.dwCursorPosition.Y + 1), static_cast<std::size_t>(inf.dwCursorPosition.X + 1));
  else
    return Term::Cursor(0, 0);
#else
  std::string ret;
  std::size_t nread{0};
  Term::Private::in.lockIO();
  // Hack to be sure we can do this all the time "Cooked" or "Raw" mode
  ::termios actual;
  if(!Private::out.null())
  {
    if(tcgetattr(Private::out.fd(), &actual) == -1) { return {}; }
  }
  ::termios raw = actual;
  // Put terminal in raw mode
  raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
  // This disables output post-processing, requiring explicit \r\n. We
  // keep it enabled, so that in C++, one can still just use std::endl
  // for EOL instead of "\r\n".
  // raw.c_oflag &= ~(OPOST);
  raw.c_lflag &= ~(ECHO | ICANON | IEXTEN);
  raw.c_lflag &= ~ISIG;
  raw.c_cc[VMIN]  = 1;
  raw.c_cc[VTIME] = 0;
  if(!Private::out.null()) tcsetattr(Private::out.fd(), TCSAFLUSH, &raw);
  Term::Private::out.write(Term::cursor_position_report());
  while(nread == 0) { ::ioctl(Private::in.fd(), FIONREAD, &nread); }
  ret = Term::Private::in.read();
  tcsetattr(Private::out.fd(), TCSAFLUSH, &actual);
  Term::Private::in.unlockIO();
  try
  {
    if(ret[0] == '\033' && ret[1] == '[' && ret[ret.size() - 1] == 'R')
    {
      std::size_t found = ret.find(';', 2);
      if(found != std::string::npos) { return Cursor(std::stoi(ret.substr(2, found - 2)), std::stoi(ret.substr(found + 1, ret.size() - (found + 2)))); }
      return {};
    }
    return {};
  }
  catch(...)
  {
    return {};
  }
#endif
}

cursor_position_report()

std::string Term::cursor_position_report

(

)

Definition at line 42 of file cursor.cpp.

{ return "\u001b[6n"; }

cursor_right()

std::string Term::cursor_right

(

const std::size_t &

columns

)

Definition at line 38 of file cursor.cpp.

{ return "\u001b[" + std::to_string(columns) + 'C'; }

cursor_up()

std::string Term::cursor_up

(

const std::size_t &

rows

)

Definition at line 34 of file cursor.cpp.

{ return "\u001b[" + std::to_string(rows) + 'A'; }

homepage()

std::string Term::homepage ( )

noexcept

Homepage of cpp-terminal.

Returns

std::string return the URL of the cpp-terminal project.

is_stderr_a_tty()

bool Term::is_stderr_a_tty

(

)

Check if stderr is a tty.

Returns

true : stderr is a tty.

false : stderr is not a tty.

Definition at line 36 of file tty.cpp.

{ return ::is_a_tty(stderr); }

is_stdin_a_tty()

bool Term::is_stdin_a_tty

(

)

Check if stdin is a tty.

Returns

true : stdin is a tty.

false : stdin is not a tty.

Definition at line 32 of file tty.cpp.

{ return ::is_a_tty(stdin); }

is_stdout_a_tty()

bool Term::is_stdout_a_tty

(

)

Check if stdout is a tty.

Returns

true : stdout is a tty.

false : stdout is not a tty.

Definition at line 34 of file tty.cpp.

{ return ::is_a_tty(stdout); }

operator!=() [1/2]

bool Term::operator!= ( Key l, MetaKey r )

constexpr

Definition at line 430 of file key.hpp.

{ return static_cast<std::int32_t>(l) != static_cast<std::int32_t>(r); }

operator!=() [2/2]

bool Term::operator!= ( MetaKey l, Key r )

constexpr

Definition at line 431 of file key.hpp.

{ return static_cast<std::int32_t>(l) != static_cast<std::int32_t>(r); }

operator+() [1/6]

Key Term::operator+ ( Key key, MetaKey meta )

constexpr

Definition at line 443 of file key.hpp.

{ return meta + key; }

operator+() [2/6]

Key Term::operator+ ( Key l, MetaKey::Value r )

constexpr

Definition at line 446 of file key.hpp.

{ return l + MetaKey(r); }

operator+() [3/6]

Key Term::operator+ ( Key::value_type l, MetaKey::Value r )

constexpr

Definition at line 448 of file key.hpp.

{ return Key(l) + MetaKey(r); }

operator+() [4/6]

Key Term::operator+ ( MetaKey metakey, Key key )

constexpr

Definition at line 442 of file key.hpp.

{ return Key(key.value + ((metakey == MetaKey::Value::Ctrl && !key.hasCtrlAll() && !key.empty()) ? static_cast<std::int32_t>(MetaKey::Value::Ctrl) : 0) + ((metakey == MetaKey::Value::Alt && !key.hasAlt() && !key.empty()) ? static_cast<std::int32_t>(MetaKey::Value::Alt) : 0)); }

operator+() [5/6]

Key Term::operator+ ( MetaKey::Value l, Key r )

constexpr

Definition at line 445 of file key.hpp.

{ return MetaKey(l) + r; }

operator+() [6/6]

Key Term::operator+ ( MetaKey::Value l, Key::value_type r )

constexpr

Definition at line 447 of file key.hpp.

{ return MetaKey(l) + Key(r); }

operator<() [1/2]

bool Term::operator< ( Key l, MetaKey r )

constexpr

Definition at line 428 of file key.hpp.

{ return static_cast<std::int32_t>(l) < static_cast<std::int32_t>(r); }

operator<() [2/2]

bool Term::operator< ( MetaKey l, Key r )

constexpr

Definition at line 427 of file key.hpp.

{ return static_cast<std::int32_t>(l) < static_cast<std::int32_t>(r); }

operator<<() [1/2]

template<class Stream >

Stream & Term::operator<<	(	Stream &	stream,
		const Term::Style &	style_type )

Definition at line 96 of file style.hpp.

{ return stream << style(style_type); }

operator<<() [2/2]

Term::TOstream & Term::operator<< ( Term::TOstream & term, const Term::Style & style_type )

inline

Definition at line 98 of file style.hpp.

{ return term << style(style_type); }

operator<=() [1/2]

bool Term::operator<= ( Key l, MetaKey r )

constexpr

Definition at line 440 of file key.hpp.

{ return static_cast<std::int32_t>(l) <= static_cast<std::int32_t>(r); }

operator<=() [2/2]

bool Term::operator<= ( MetaKey l, Key r )

constexpr

Definition at line 439 of file key.hpp.

{ return static_cast<std::int32_t>(l) <= static_cast<std::int32_t>(r); }

operator==() [1/2]

bool Term::operator== ( Key l, MetaKey r )

constexpr

Definition at line 424 of file key.hpp.

{ return static_cast<std::int32_t>(l) == static_cast<std::int32_t>(r); }

operator==() [2/2]

bool Term::operator== ( MetaKey l, Key r )

constexpr

Definition at line 425 of file key.hpp.

{ return static_cast<std::int32_t>(l) == static_cast<std::int32_t>(r); }

operator>() [1/2]

bool Term::operator> ( Key l, MetaKey r )

constexpr

Definition at line 437 of file key.hpp.

{ return static_cast<std::int32_t>(l) > static_cast<std::int32_t>(r); }

operator>() [2/2]

bool Term::operator> ( MetaKey l, Key r )

constexpr

Definition at line 436 of file key.hpp.

{ return static_cast<std::int32_t>(l) > static_cast<std::int32_t>(r); }

operator>=() [1/2]

bool Term::operator>= ( Key l, MetaKey r )

constexpr

Definition at line 434 of file key.hpp.

{ return static_cast<std::int32_t>(l) >= static_cast<std::int32_t>(r); }

operator>=() [2/2]

bool Term::operator>= ( MetaKey l, Key r )

constexpr

Definition at line 433 of file key.hpp.

{ return static_cast<std::int32_t>(l) >= static_cast<std::int32_t>(r); }

print_left_curly_bracket()

void Term::print_left_curly_bracket	(	Term::Window &	scr,
		const std::size_t &	x,
		const std::size_t &	y1,
		const std::size_t &	y2 )

Definition at line 175 of file prompt.cpp.

{
  std::size_t h{y2 - y1 + 1};
  if(h == 1) { scr.set_char(x, y1, UU("]")); }
  else
  {
    scr.set_char(x, y1, UU("┐"));
    for(std::size_t j = y1 + 1; j <= y2 - 1; j++) { scr.set_char(x, j, UU("│")); }
    scr.set_char(x, y2, UU("┘"));
  }
}

prompt()

Term::Result Term::prompt	(	const std::string &	message,
		const std::string &	first_option,
		const std::string &	second_option,
		const std::string &	prompt_indicator,
		bool	immediate )

A simple yes/no prompt, requires the user to press the ENTER key to continue.

The arguments are used like this: 1 [2/3]4 <user Input>. The immediate switch indicates toggles whether pressing enter for confirming the input is required or not.

Parameters

message
first_option
second_option
prompt_indicator

Returns

Result

Definition at line 26 of file prompt.cpp.

{
  Term::terminal.setOptions(Option::NoClearScreen, Option::NoSignalKeys, Option::Cursor, Term::Option::Raw);
  std::cout << message << " [" << first_option << '/' << second_option << ']' << prompt_indicator << ' ' << std::flush;
 
  if(!Term::is_stdin_a_tty())
  {
    std::cout << '\n' << std::flush;
    return Result::Error;
  }
 
  Term::Key key;
 
  if(immediate)
  {
    while(true)
    {
      key = Term::read_event();
      if(key == Term::Key::NoKey) continue;
      if(key == Term::Key::y || key == Term::Key::Y)
      {
        std::cout << '\n' << std::flush;
        return Result::Yes;
      }
      else if(key == Term::Key::n || key == Term::Key::N)
      {
        std::cout << '\n' << std::flush;
        return Result::No;
      }
      else if(key == Term::Key::Ctrl_C || key == Term::Key::Ctrl_D)
      {
        std::cout << '\n' << std::flush;
        return Result::Abort;
      }
      else if(key == Term::Key::Enter)
      {
        std::cout << '\n' << std::flush;
        return Result::None;
      }
      else
      {
        std::cout << '\n' << std::flush;
        return Result::Invalid;
      }
    }
  }
  else
  {
    std::string input;
    while(true)
    {
      key = Term::read_event();
      if(key == Term::Key::NoKey) continue;
      if(key >= 'a' && key <= 'z')
      {
        std::cout << (char)key << std::flush;
        input.push_back(static_cast<char>(key));
      }
      else if(key >= 'A' && key <= 'Z')
      {
        std::cout << (char)key << std::flush;
        input.push_back(static_cast<char>(key.tolower()));  // convert upper case to lowercase
      }
      else if(key == Term::Key::Ctrl_C || key == Term::Key::Ctrl_D)
      {
        std::cout << '\n';
        return Result::Abort;
      }
      else if(key == Term::Key::Backspace)
      {
        if(input.empty() != 0)
        {
          std::cout << "\u001b[D \u001b[D" << std::flush;  // erase last line and move the cursor back
          input.pop_back();
        }
      }
      else if(key == Term::Key::Enter)
      {
        if(input == "y" || input == "yes")
        {
          std::cout << '\n' << std::flush;
          return Result::Yes;
        }
        else if(input == "n" || input == "no")
        {
          std::cout << '\n' << std::flush;
          return Result::No;
        }
        else if(input.empty())
        {
          std::cout << '\n' << std::flush;
          return Result::None;
        }
        else
        {
          std::cout << '\n' << std::flush;
          return Result::Invalid;
        }
      }
    }
  }
}

prompt_multiline()

std::string Term::prompt_multiline	(	const std::string &	prompt_string,
		std::vector< std::string > &	m_history,
		std::function< bool(std::string)> &	iscomplete )

Definition at line 209 of file prompt.cpp.

{
  Term::Cursor cursor;
  Term::Screen screen({Term::Rows(25), Term::Columns(80)});
  bool         term_attached = Term::is_stdin_a_tty();
  if(is_stdin_a_tty())
  {
    cursor = cursor_position();
    screen = screen_size();
  }
 
  Model model;
  model.prompt_string = prompt_string;
 
  // Make a local copy of history that can be modified by the user. All
  // changes will be forgotten once a command is submitted.
  std::vector<std::string> history     = m_history;
  std::size_t              history_pos = history.size();
  history.push_back(concat(model.lines));  // Push back empty input
 
  Term::Window scr({Term::Columns(screen.columns()), Term::Rows(1)});
  Term::Key    key;
  render(scr, model, screen.columns());
  std::cout << scr.render(1, cursor.row(), term_attached) << std::flush;
  bool not_complete = true;
  while(not_complete)
  {
    key = Term::read_event();
    if(key == Term::Key::NoKey) continue;
    if(key.isprint())
    {
      std::string before = model.lines[model.cursor_row - 1].substr(0, model.cursor_col - 1);
      std::string newchar;
      newchar.push_back(static_cast<char>(key));
      std::string after                 = model.lines[model.cursor_row - 1].substr(model.cursor_col - 1);
      model.lines[model.cursor_row - 1] = before += newchar += after;
      model.cursor_col++;
    }
    else if(key == Key::Ctrl_D)
    {
      if(model.lines.size() == 1 && model.lines[model.cursor_row - 1].empty())
      {
        model.lines[model.cursor_row - 1].push_back(static_cast<char>(Key::Ctrl_D));
        std::cout << "\n" << std::flush;
        m_history.push_back(model.lines[0]);
        return model.lines[0];
      }
    }
    else
    {
      switch(key)
      {
        case Key::Enter:
          not_complete = !iscomplete(concat(model.lines));
          if(not_complete) key = Key(static_cast<Term::Key>(Term::MetaKey::Value::Alt + Term::Key::Enter));
          else
            break;
          CPP_TERMINAL_FALLTHROUGH;
        case Key::Backspace:
          if(model.cursor_col > 1)
          {
            std::string before                = model.lines[model.cursor_row - 1].substr(0, model.cursor_col - 2);
            std::string after                 = model.lines[model.cursor_row - 1].substr(model.cursor_col - 1);
            model.lines[model.cursor_row - 1] = before + after;
            model.cursor_col--;
          }
          else if(model.cursor_col == 1 && model.cursor_row > 1)
          {
            model.cursor_col = model.lines[model.cursor_row - 2].size() + 1;
            model.lines[model.cursor_row - 2] += model.lines[model.cursor_row - 1];
            model.lines.erase(model.lines.begin() + static_cast<long>(model.cursor_row) - 1);
            model.cursor_row--;
          }
          break;
        case Key::Del:
          if(model.cursor_col <= model.lines[model.cursor_row - 1].size())
          {
            std::string before                = model.lines[model.cursor_row - 1].substr(0, model.cursor_col - 1);
            std::string after                 = model.lines[model.cursor_row - 1].substr(model.cursor_col);
            model.lines[model.cursor_row - 1] = before + after;
          }
          break;
        case Key::ArrowLeft:
          if(model.cursor_col > 1) { model.cursor_col--; }
          break;
        case Key::ArrowRight:
          if(model.cursor_col <= model.lines[model.cursor_row - 1].size()) { model.cursor_col++; }
          break;
        case Key::Home: model.cursor_col = 1; break;
        case Key::End: model.cursor_col = model.lines[model.cursor_row - 1].size() + 1; break;
        case Key::ArrowUp:
          if(model.cursor_row == 1)
          {
            if(history_pos > 0)
            {
              history[history_pos] = concat(model.lines);
              history_pos--;
              model.lines      = split(history[history_pos]);
              model.cursor_row = model.lines.size();
              if(model.cursor_col > model.lines[model.cursor_row - 1].size() + 1) { model.cursor_col = model.lines[model.cursor_row - 1].size() + 1; }
              if(model.lines.size() > scr.columns()) { scr.set_h(model.lines.size()); }
            }
          }
          else
          {
            model.cursor_row--;
            if(model.cursor_col > model.lines[model.cursor_row - 1].size() + 1) { model.cursor_col = model.lines[model.cursor_row - 1].size() + 1; }
          }
          break;
        case Key::ArrowDown:
          if(model.cursor_row == model.lines.size())
          {
            if(history_pos < history.size() - 1)
            {
              history[history_pos] = concat(model.lines);
              history_pos++;
              model.lines      = split(history[history_pos]);
              model.cursor_row = 1;
              if(model.cursor_col > model.lines[model.cursor_row - 1].size() + 1) { model.cursor_col = model.lines[model.cursor_row - 1].size() + 1; }
              if(model.lines.size() > scr.columns()) { scr.set_h(model.lines.size()); }
            }
          }
          else
          {
            model.cursor_row++;
            if(model.cursor_col > model.lines[model.cursor_row - 1].size() + 1) { model.cursor_col = model.lines[model.cursor_row - 1].size() + 1; }
          }
          break;
        case Key::Ctrl_N:
        {
          std::string before                = model.lines[model.cursor_row - 1].substr(0, model.cursor_col - 1);
          std::string after                 = model.lines[model.cursor_row - 1].substr(model.cursor_col - 1);
          model.lines[model.cursor_row - 1] = before;
          if(model.cursor_row < model.lines.size())
          {
            // Not at the bottom row, can't push back
            model.lines.insert(model.lines.begin() + static_cast<long>(model.cursor_row), after);
          }
          else { model.lines.push_back(after); }
          model.cursor_col = 1;
          model.cursor_row++;
          if(model.lines.size() > scr.columns()) { scr.set_h(model.lines.size()); }
          break;
        }
        default: break;
      }
    }
    render(scr, model, screen.columns());
    std::cout << scr.render(1, cursor.row(), term_attached) << std::flush;
    if(cursor.row() + scr.columns() - 1 > screen.rows())
    {
      cursor.setRow(static_cast<std::uint16_t>(screen.rows() - (scr.columns() - 1)));
      std::cout << scr.render(1, cursor.row(), term_attached) << std::flush;
    }
  }
  std::string line_skips;
  for(std::size_t i = 0; i <= model.lines.size() - model.cursor_row; i++) { line_skips += "\n"; }
  std::cout << line_skips << std::flush;
  m_history.push_back(concat(model.lines));
  return concat(model.lines);
}

prompt_simple()

Term::Result_simple Term::prompt_simple

(

const std::string &

message

)

The most simple prompt possible, requires the user to press enter to continue.

The arguments are used like this: 1 [y/N]: Invalid input, errors (like no attached terminal) all result in no as default.

Parameters

message

Returns

Result_simple

Definition at line 129 of file prompt.cpp.

{
  switch(prompt(message, "y", "N", ":", false))
  {
    case Result::Yes: return Result_simple::Yes;
    case Result::Abort: return Result_simple::Abort;
    case Result::No:     // falls through
    case Result::Error:  // falls through
    case Result::None:   // falls through
    case Result::Invalid:
    default: return Result_simple::No;
  }
}

read_event()

Term::Event Term::read_event

(

)

Definition at line 338 of file input.cpp.

{
  m_input.startReading();
  return m_input.getEventBlocking();
}

render()

void Term::render	(	Term::Window &	scr,
		const Model &	model,
		const std::size_t &	cols )

Definition at line 187 of file prompt.cpp.

{
  scr.clear();
  print_left_curly_bracket(scr, cols, 1, model.lines.size());
  scr.print_str(cols - 6, model.lines.size(), std::to_string(model.cursor_row) + "," + std::to_string(model.cursor_col));
  for(std::size_t j = 0; j < model.lines.size(); j++)
  {
    if(j == 0)
    {
      scr.fill_fg(1, j + 1, model.prompt_string.size(), model.lines.size(), Term::Color::Name::Green);
      scr.fill_style(1, j + 1, model.prompt_string.size(), model.lines.size(), Term::Style::Bold);
      scr.print_str(1, j + 1, model.prompt_string);
    }
    else
    {
      for(std::size_t i = 0; i < model.prompt_string.size() - 1; i++) { scr.set_char(i + 1, j + 1, '.'); }
    }
    scr.print_str(model.prompt_string.size() + 1, j + 1, model.lines[j]);
  }
  scr.set_cursor_pos(model.prompt_string.size() + model.cursor_col, model.cursor_row);
}

returnCode()

std::uint16_t Term::returnCode ( )

noexcept

Definition at line 18 of file return_code.cpp.

{
  static std::uint16_t               code{EXIT_FAILURE};
  const std::pair<bool, std::string> returnCode{Private::getenv("CPP_TERMINAL_BADSTATE")};
  try
  {
    if(returnCode.first && (std::stoi(returnCode.second) != EXIT_SUCCESS)) { code = static_cast<std::uint16_t>(std::stoi(returnCode.second)); }
  }
  catch(...)
  {
    code = EXIT_FAILURE;
  }
  return code;
}

screen_load()

std::string Term::screen_load

(

)

Definition at line 27 of file screen.cpp.

{
  return "\u001b[?1049l\u001b8";  // restores screen, restore current cursor position FIXME
}

screen_save()

std::string Term::screen_save

(

)

Definition at line 22 of file screen.cpp.

{
  return "\u001b7\u001b[?1049h";  // save current cursor position, save screen FIXME
}

screen_size()

Term::Screen Term::screen_size

(

)

Definition at line 24 of file screen.cpp.

{
#ifdef _WIN32
  CONSOLE_SCREEN_BUFFER_INFO inf;
  if(GetConsoleScreenBufferInfo(Private::out.handle(), &inf)) return Term::Screen({Term::Rows(inf.srWindow.Bottom - inf.srWindow.Top + 1), Term::Columns(inf.srWindow.Right - inf.srWindow.Left + 1)});
  return {};
#else
  struct winsize window{0, 0, 0, 0};
  if(ioctl(Private::out.fd(), TIOCGWINSZ, &window) != -1) return Term::Screen({Term::Rows(window.ws_row), Term::Columns(window.ws_col)});
  return {};
#endif
}

split()

std::vector< std::string > Term::split

(

const std::string &

s

)

Definition at line 150 of file prompt.cpp.

{
  std::size_t              j = 0;
  std::vector<std::string> lines;
  lines.emplace_back("");
  if(s[s.size() - 1] != '\n') throw Term::Exception("\\n is required");
  for(std::size_t i = 0; i < s.size() - 1; i++)
  {
    if(s[i] == '\n')
    {
      j++;
      lines.emplace_back("");
    }
    else { lines[j].push_back(s[i]); }
  }
  return lines;
}

style()

std::string Term::style

(

const Term::Style &

style

)

Definition at line 12 of file style.cpp.

{
  //https://unix.stackexchange.com/questions/212933/background-color-whitespace-when-end-of-the-terminal-reached
  std::string ret{"\u001b[" + std::to_string(static_cast<std::uint8_t>(style)) + 'm'};
  if(style == Term::Style::DefaultBackgroundColor) { ret += "\u001b[K"; }
  return ret;
}

terminal_title()

std::string Term::terminal_title

(

const std::string &

title

)

Definition at line 21 of file terminal.cpp.

{ return "\u001b]0;" + title + '\a'; }

Variable Documentation

cerr

Term::TOstream & Term::cerr = reinterpret_cast<Term::TOstream&>(cerr_buffer)

extern

Definition at line 24 of file iostream.cpp.

cin

Term::TIstream & Term::cin = reinterpret_cast<Term::TIstream&>(cin_buffer)

extern

Definition at line 25 of file iostream.cpp.

clog

Term::TOstream & Term::clog = reinterpret_cast<Term::TOstream&>(clog_buffer)

extern

Definition at line 23 of file iostream.cpp.

cout

Term::TOstream & Term::cout = reinterpret_cast<Term::TOstream&>(cout_buffer)

extern

Definition at line 22 of file iostream.cpp.

terminal

Term::Terminal & Term::terminal = reinterpret_cast<Term::Terminal&>(::terminal_buffer)

extern

Definition at line 19 of file terminal.cpp.