Term::Terminal Class Reference

#include <cpp-terminal/terminal_impl.hpp>

Public Member Functions
	~Terminal () noexcept
	Terminal () noexcept
	Terminal (const Terminal &)=delete
	Terminal (Terminal &&)=delete
Terminal &	operator= (Terminal &&)=delete
Terminal &	operator= (const Terminal &)=delete
template<typename... Args>
void	setOptions (const Args &&... args)
Term::Options	getOptions () const noexcept
std::string	clear () const noexcept

Private Member Functions
void	setMode () const
	Set mode raw/cooked.
void	setOptions ()
void	applyOptions () const
void	clean ()

Static Private Member Functions
static void	store_and_restore () noexcept
	Store and restore the default state of the terminal.
static std::size_t	setMouseEvents ()
static std::size_t	unsetMouseEvents ()
static std::size_t	setFocusEvents ()
static std::size_t	unsetFocusEvents ()
static void	set_unset_utf8 ()

Private Attributes
Term::Options	m_options

Friends
class	Private::Signals

Detailed Description

Definition at line 26 of file terminal_impl.hpp.

Constructor & Destructor Documentation

~Terminal()

Term::Terminal::~Terminal ( )

noexcept

Definition at line 40 of file terminal_impl.cpp.

{
  clean();
}
catch(...)
{
  ExceptionHandler(Private::ExceptionDestination::StdErr);
}

Terminal() [1/3]

Term::Terminal::Terminal ( )

noexcept

Definition at line 28 of file terminal_impl.cpp.

{
  store_and_restore();
  setMode();  //Save the default cpp-terminal mode done in store_and_restore();
  set_unset_utf8();
}
catch(...)
{
  ExceptionHandler(Private::ExceptionDestination::StdErr);
}

Terminal() [2/3]

Term::Terminal::Terminal ( const Terminal & )

delete

Terminal() [3/3]

Term::Terminal::Terminal ( Terminal && )

delete

Member Function Documentation

applyOptions()

void Term::Terminal::applyOptions ( ) const

private

Definition at line 64 of file terminal_impl.cpp.

{
  if(getOptions().has(Option::ClearScreen)) { Term::Private::out.write(screen_save() + clear() + style(Style::Reset) + cursor_move(1, 1)); }
  if(getOptions().has(Option::NoCursor)) { Term::Private::out.write(cursor_off()); }
  setMode();
}

clean()

void Term::Terminal::clean ( )

private

Definition at line 54 of file terminal_impl.cpp.

{
  unsetFocusEvents();
  unsetMouseEvents();
  if(getOptions().has(Option::NoCursor)) { Term::Private::out.write(cursor_on()); }
  if(getOptions().has(Option::ClearScreen)) { Term::Private::out.write(clear() + style(Style::Reset) + cursor_move(1, 1) + screen_load()); }
  set_unset_utf8();
  store_and_restore();
}

clear()

std::string Term::Terminal::clear ( ) const

noexcept

Definition at line 19 of file terminal_impl.cpp.

{ return "\u001b[3J"; }

getOptions()

Term::Options Term::Terminal::getOptions ( ) const

noexcept

Definition at line 21 of file terminal_impl.cpp.

{ return m_options; }

operator=() [1/2]

Terminal & Term::Terminal::operator= ( const Terminal & )

delete

operator=() [2/2]

Terminal & Term::Terminal::operator= ( Terminal && )

delete

set_unset_utf8()

void Term::Terminal::set_unset_utf8 ( )

staticprivate

Definition at line 36 of file terminal_impl.cpp.

{
  static bool enabled{false};
#if defined(_WIN32)
  static UINT out_code_page{0};
  static UINT in_code_page{0};
  if(!enabled)
  {
    if((out_code_page = GetConsoleOutputCP()) == 0) throw Term::Private::WindowsException(GetLastError(), "GetConsoleOutputCP()");
    if(!SetConsoleOutputCP(CP_UTF8)) throw Term::Private::WindowsException(GetLastError(), "SetConsoleOutputCP(CP_UTF8)");
    if((in_code_page = GetConsoleCP()) == 0) throw Term::Private::WindowsException(GetLastError(), "GetConsoleCP()");
    if(!SetConsoleCP(CP_UTF8)) throw Term::Private::WindowsException(GetLastError(), "SetConsoleCP(CP_UTF8)");
    enabled = true;
  }
  else
  {
    if(!SetConsoleOutputCP(out_code_page)) throw Term::Private::WindowsException(GetLastError(), "SetConsoleOutputCP(out_code_page)");
    if(!SetConsoleCP(in_code_page)) throw Term::Private::WindowsException(GetLastError(), "SetConsoleCP(in_code_page)");
  }
#else
  if(!enabled)
  {
    const Term::Cursor cursor_before{Term::cursor_position()};
    Term::Private::out.write("\u001b%G");  // Try to activate UTF-8 (NOT warranty)
    const std::string  read{Term::Private::in.read()};
    const Term::Cursor cursor_after{Term::cursor_position()};
    const std::size_t  moved{cursor_after.column() - cursor_before.column()};
    std::string        rem;
    rem.reserve(moved * 3);
    for(std::size_t i = 0; i != moved; ++i) { rem += "\b \b"; }
    Term::Private::out.write(rem);
    enabled = 0 == moved;
  }
  else
  {
    // Does not return the original charset but, the default defined by standard ISO 8859-1 (ISO 2022);
    Term::Private::out.write("\u001b%@");
  }
#endif
}

setFocusEvents()

std::size_t Term::Terminal::setFocusEvents ( )

staticprivate

Definition at line 149 of file terminal_impl.cpp.

{
#if defined(_WIN32)
  return static_cast<std::size_t>(ENABLE_WINDOW_INPUT);
#else
  return Term::Private::out.write("\u001b[?1004h");
#endif
}

setMode()

void Term::Terminal::setMode ( ) const

private

Set mode raw/cooked.

First call is to save the good state set-up by cpp-terminal.

Definition at line 167 of file terminal_impl.cpp.

{
  static bool activated{false};
#if defined(_WIN32)
  static DWORD flags{0};
  if(!activated)
  {
    if(!Private::out.null())
      if(!GetConsoleMode(Private::in.handle(), &flags)) { throw Term::Private::WindowsException(GetLastError()); }
    activated = true;
    return;
  }
  DWORD send = flags;
  if(m_options.has(Option::Raw))
  {
    send &= ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT);
    send |= (setFocusEvents() | setMouseEvents());
  }
  else if(m_options.has(Option::Cooked))
  {
    send |= (ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT);
    send &= ~(setFocusEvents() | setMouseEvents());
  }
  if(m_options.has(Option::NoSignalKeys)) { send &= ~ENABLE_PROCESSED_INPUT; }
  else if(m_options.has(Option::SignalKeys)) { send |= ENABLE_PROCESSED_INPUT; }
  if(!Private::out.null())
    if(!SetConsoleMode(Private::in.handle(), send)) { throw Term::Private::WindowsException(GetLastError()); }
#else
  if(!Private::out.null())
  {
    static ::termios raw = {};
    if(!activated)
    {
      Term::Private::Errno().check_if(tcgetattr(Private::out.fd(), &raw) == -1).throw_exception("tcgetattr(Private::out.fd(), &raw)");
      raw.c_cflag &= ~static_cast<std::size_t>(CSIZE | PARENB);
      raw.c_cflag |= CS8;
      raw.c_cc[VMIN]  = 1;
      raw.c_cc[VTIME] = 0;
      activated       = true;
      return;
    }
    ::termios send = raw;
    if(m_options.has(Option::Raw))
    {
      send.c_iflag &= ~static_cast<std::size_t>(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON | INPCK);
      // 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".
      //send.c_oflag &= ~static_cast<std::size_t>(OPOST);
      send.c_lflag &= ~static_cast<std::size_t>(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
      setMouseEvents();
      setFocusEvents();
    }
    else if(m_options.has(Option::Cooked))
    {
      send = raw;
      unsetMouseEvents();
      unsetFocusEvents();
    }
    if(m_options.has(Option::NoSignalKeys)) { send.c_lflag &= ~static_cast<std::size_t>(ISIG); }  //FIXME need others flags !
    if(m_options.has(Option::SignalKeys)) { send.c_lflag |= ISIG; }
    Term::Private::Errno().check_if(tcsetattr(Private::out.fd(), TCSAFLUSH, &send) == -1).throw_exception("tcsetattr(Private::out.fd(), TCSAFLUSH, &send)");
  }
#endif
}

setMouseEvents()

std::size_t Term::Terminal::setMouseEvents ( )

staticprivate

Definition at line 131 of file terminal_impl.cpp.

{
#if defined(_WIN32)
  return static_cast<std::size_t>(ENABLE_MOUSE_INPUT);
#else
  return Term::Private::out.write("\u001b[?1002h\u001b[?1003h\u001b[?1006h");
#endif
}

setOptions() [1/2]

void Term::Terminal::setOptions ( )

private

setOptions() [2/2]

template<typename... Args>

void Term::Terminal::setOptions ( const Args &&... args )

inline

Definition at line 36 of file terminal_impl.hpp.

  {
    m_options = {args...};
    applyOptions();
  }

store_and_restore()

void Term::Terminal::store_and_restore ( )

staticprivatenoexcept

Store and restore the default state of the terminal.

Configure the default mode for cpp-terminal.

Definition at line 77 of file terminal_impl.cpp.

{
  static bool enabled{false};
#if defined(_WIN32)
  static DWORD originalOut{0};
  static DWORD originalIn{0};
  if(!enabled)
  {
    Term::Private::WindowsError().check_if(GetConsoleMode(Private::out.handle(), &originalOut) == 0).throw_exception("GetConsoleMode(Private::out.handle(), &originalOut)");
    Term::Private::WindowsError().check_if(GetConsoleMode(Private::in.handle(), &originalIn) == 0).throw_exception("GetConsoleMode(Private::in.handle(), &originalIn)");
    DWORD in{static_cast<DWORD>((originalIn & ~(ENABLE_QUICK_EDIT_MODE | setFocusEvents() | setMouseEvents())) | (ENABLE_EXTENDED_FLAGS))};
    DWORD out{originalOut};
    // Check if ENABLE_VIRTUAL_TERMINAL_PROCESSING | DISABLE_NEWLINE_AUTO_RETURN can be activated, if not we are a legacy terminal.
    DWORD test = out;
    test |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
    if(!SetConsoleMode(Private::out.handle(), test)) { SetConsoleMode(Private::out.handle(), out); }
    else
    {
      out |= ENABLE_VIRTUAL_TERMINAL_PROCESSING | DISABLE_NEWLINE_AUTO_RETURN;
      in |= ENABLE_VIRTUAL_TERMINAL_INPUT;
    }
    if(!SetConsoleMode(Private::out.handle(), out)) { throw Term::Private::WindowsException(GetLastError(), "SetConsoleMode(Private::out.handle()"); }
    if(!SetConsoleMode(Private::in.handle(), in)) { throw Term::Private::WindowsException(GetLastError(), "SetConsoleMode(Private::in.handle(), in)"); }
    enabled = true;
  }
  else
  {
    if(!SetConsoleMode(Private::out.handle(), originalOut)) { throw Term::Private::WindowsException(GetLastError(), "SetConsoleMode(Private::out.handle(), originalOut)"); }
    if(!SetConsoleMode(Private::in.handle(), originalIn)) { throw Term::Private::WindowsException(GetLastError(), "SetConsoleMode(Private::in.handle(), originalIn)"); }
  }
#else
  static termios orig_termios;
  if(!enabled)
  {
    Term::Private::Sigwinch::blockSigwinch();
    Term::Private::Sigwinch::registerSigwinch();
    if(!Private::out.null()) { Term::Private::Errno().check_if(tcgetattr(Private::out.fd(), &orig_termios) == -1).throw_exception("tcgetattr() failed"); }
    enabled = true;
  }
  else
  {
    Term::Private::Sigwinch::unblockSigwinch();
    unsetMouseEvents();
    unsetFocusEvents();
    if(!Private::out.null()) { Term::Private::Errno().check_if(tcsetattr(Private::out.fd(), TCSAFLUSH, &orig_termios) == -1).throw_exception("tcsetattr() failed in destructor"); }
  }
#endif
}
catch(...)
{
  ExceptionHandler(Private::ExceptionDestination::StdErr);
}

unsetFocusEvents()

std::size_t Term::Terminal::unsetFocusEvents ( )

staticprivate

Definition at line 158 of file terminal_impl.cpp.

{
#if defined(_WIN32)
  return static_cast<std::size_t>(ENABLE_WINDOW_INPUT);
#else
  return Term::Private::out.write("\u001b[?1004l");
#endif
}

unsetMouseEvents()

std::size_t Term::Terminal::unsetMouseEvents ( )

staticprivate

Definition at line 140 of file terminal_impl.cpp.

{
#if defined(_WIN32)
  return static_cast<std::size_t>(ENABLE_MOUSE_INPUT);
#else
  return Term::Private::out.write("\u001b[?1006l\u001b[?1003l\u001b[?1002l");
#endif
}

Friends And Related Symbol Documentation

Private::Signals

friend class Private::Signals

friend

Definition at line 29 of file terminal_impl.hpp.

Member Data Documentation

m_options

Term::Options Term::Terminal::m_options

private

Definition at line 66 of file terminal_impl.hpp.

---

The documentation for this class was generated from the following files:

• cpp-terminal/terminal_impl.hpp
• cpp-terminal/private/terminal_impl.cpp
• cpp-terminal/terminal_impl.cpp