Term::Window Class Reference

Represents a rectangular window, as a 2D array of characters and their attributes. More...

#include <cpp-terminal/window.hpp>

Public Member Functions
	Window (const Size &size)
	Window (const Screen &screen)
const Columns &	columns () const noexcept
const Rows &	rows () const noexcept
void	set_char (const std::size_t &column, const std::size_t &row, const char32_t &character)
void	set_fg_reset (const std::size_t &column, const std::size_t &row)
void	set_bg_reset (const std::size_t &column, const std::size_t &row)
void	set_fg (const std::size_t &column, const std::size_t &row, const Color &color)
void	set_bg (const std::size_t &column, const std::size_t &row, const Color &color)
void	set_style (const std::size_t &column, const std::size_t &row, const Style &style)
void	set_cursor_pos (const std::size_t &column, const std::size_t &row)
void	set_h (const std::size_t &)
void	print_str (const std::size_t &column, const std::size_t &, const std::string &, const std::size_t &=0, bool=false)
void	fill_fg (const std::size_t &column, const std::size_t &, const std::size_t &, const std::size_t &, const Color &)
void	fill_bg (const std::size_t &column, const std::size_t &, const std::size_t &, const std::size_t &, const Color &)
void	fill_style (const std::size_t &column, const std::size_t &, const std::size_t &, const std::size_t &, const Style &)
void	print_border ()
void	print_rect (const std::size_t &column, const std::size_t &, const std::size_t &, const std::size_t &)
void	clear ()
bool	insideWindow (const std::size_t &column, const std::size_t &row) const
std::string	render (const std::size_t &, const std::size_t &, bool)

Private Member Functions
std::size_t	index (const std::size_t &column, const std::size_t &row) const
char32_t	get_char (const std::size_t &column, const std::size_t &row)
bool	get_fg_reset (const std::size_t &column, const std::size_t &row)
bool	get_bg_reset (const std::size_t &column, const std::size_t &row)
Term::Color	get_fg (const std::size_t &column, const std::size_t &row)
Term::Color	get_bg (const std::size_t &column, const std::size_t &row)
Term::Style	get_style (const std::size_t &column, const std::size_t &row)

Private Attributes
Term::Size	m_size
Term::Cursor	m_cursor {1, 1}
std::vector< char32_t >	m_chars
std::vector< Term::Color >	m_fg
std::vector< Term::Color >	m_bg
std::vector< bool >	m_fg_reset
std::vector< bool >	m_bg_reset
std::vector< Style >	m_style

Detailed Description

Represents a rectangular window, as a 2D array of characters and their attributes.

Represents a rectangular window, as a 2D array of characters and their attributes. The render method can convert this internal representation to a string that when printed will show the Window on the screen. The natural way to represent a character in a terminal would be a "unicode grapheme cluster", but due to a lack of a good library for C++ that could handle those, we simply use a Unicode code point as a character.

Definition at line 33 of file window.hpp.

Constructor & Destructor Documentation

Window() [1/2]

Term::Window::Window ( const Size & size )

explicit

Definition at line 26 of file window.cpp.

: m_size(size) { clear(); }

Window() [2/2]

Term::Window::Window ( const Screen & screen )

explicit

Definition at line 28 of file window.cpp.

: m_size({screen.rows(), screen.columns()}) { clear(); }

Member Function Documentation

clear()

void Term::Window::clear

(

)

Definition at line 189 of file window.cpp.

{
  m_style.assign(m_size.area(), Style::Reset);
  m_bg_reset.assign(m_size.area(), true);
  m_bg.assign(m_size.area(), Term::Color::Name::Default);
  m_fg_reset.assign(m_size.area(), true);
  m_fg.assign(m_size.area(), Term::Color::Name::Default);
  m_chars.assign(m_size.area(), ' ');
}

columns()

const Columns & Term::Window::columns ( ) const

noexcept

Definition at line 42 of file window.cpp.

{ return m_size.columns(); }

fill_bg()

void Term::Window::fill_bg	(	const std::size_t &	column,
		const std::size_t &	y1,
		const std::size_t &	x2,
		const std::size_t &	y2,
		const Color &	rgb )

Definition at line 132 of file window.cpp.

{
  for(std::size_t j = y1; j <= y2; ++j)
  {
    for(std::size_t i = x1; i <= x2; ++i) { set_bg(i, j, rgb); }
  }
}

fill_fg()

void Term::Window::fill_fg	(	const std::size_t &	column,
		const std::size_t &	y1,
		const std::size_t &	x2,
		const std::size_t &	y2,
		const Color &	rgb )

Definition at line 124 of file window.cpp.

{
  for(std::size_t j = y1; j <= y2; ++j)
  {
    for(std::size_t i = x1; i <= x2; ++i) { set_fg(i, j, rgb); }
  }
}

fill_style()

void Term::Window::fill_style	(	const std::size_t &	column,
		const std::size_t &	y1,
		const std::size_t &	x2,
		const std::size_t &	y2,
		const Style &	color )

Definition at line 140 of file window.cpp.

{
  for(std::size_t j = y1; j <= y2; ++j)
  {
    for(std::size_t i = x1; i <= x2; ++i) { set_style(i, j, color); }
  }
}

get_bg()

Term::Color Term::Window::get_bg ( const std::size_t & column, const std::size_t & row )

private

Definition at line 38 of file window.cpp.

{ return m_bg[index(column, row)]; }

get_bg_reset()

bool Term::Window::get_bg_reset ( const std::size_t & column, const std::size_t & row )

private

Definition at line 34 of file window.cpp.

{ return m_bg_reset[index(column, row)]; }

get_char()

char32_t Term::Window::get_char ( const std::size_t & column, const std::size_t & row )

private

Definition at line 30 of file window.cpp.

{ return m_chars[index(column, row)]; }

get_fg()

Term::Color Term::Window::get_fg ( const std::size_t & column, const std::size_t & row )

private

Definition at line 36 of file window.cpp.

{ return m_fg[index(column, row)]; }

get_fg_reset()

bool Term::Window::get_fg_reset ( const std::size_t & column, const std::size_t & row )

private

Definition at line 32 of file window.cpp.

{ return m_fg_reset[index(column, row)]; }

get_style()

Term::Style Term::Window::get_style ( const std::size_t & column, const std::size_t & row )

private

Definition at line 40 of file window.cpp.

{ return m_style[index(column, row)]; }

index()

std::size_t Term::Window::index ( const std::size_t & column, const std::size_t & row ) const

private

Definition at line 299 of file window.cpp.

{
  if(!insideWindow(column, row)) { throw Term::Exception("Cursor out of range"); }
  return ((row - 1) * m_size.columns()) + (column - 1);
}

insideWindow()

bool Term::Window::insideWindow	(	const std::size_t &	column,
		const std::size_t &	row ) const

Definition at line 305 of file window.cpp.

{ return (column >= 1) && (row >= 1) && (column <= m_size.columns()) && (row <= m_size.rows()); }

print_border()

void Term::Window::print_border

(

)

Definition at line 148 of file window.cpp.

{ print_rect(1, 1, m_size.columns(), m_size.rows()); }

print_rect()

void Term::Window::print_rect	(	const std::size_t &	column,
		const std::size_t &	y1,
		const std::size_t &	x2,
		const std::size_t &	y2 )

Definition at line 150 of file window.cpp.

{
  std::u32string border = Private::utf8_to_utf32("│─┌┐└┘");
  if(Term::Terminfo::get(Term::Terminfo::Bool::UTF8))
  {
    for(std::size_t j = y1 + 1; j <= (y2 - 1); ++j)
    {
      set_char(x1, j, border[0]);
      set_char(x2, j, border[0]);
    }
    for(std::size_t i = x1 + 1; i <= (x2 - 1); ++i)
    {
      set_char(i, y1, border[1]);
      set_char(i, y2, border[1]);
    }
    set_char(x1, y1, border[2]);
    set_char(x2, y1, border[3]);
    set_char(x1, y2, border[4]);
    set_char(x2, y2, border[5]);
  }
  else
  {
    for(std::size_t j = y1 + 1; j <= (y2 - 1); ++j)
    {
      set_char(x1, j, '|');
      set_char(x2, j, '|');
    }
    for(std::size_t i = x1 + 1; i <= (x2 - 1); ++i)
    {
      set_char(i, y1, '-');
      set_char(i, y2, '-');
    }
    set_char(x1, y1, '+');
    set_char(x2, y1, '+');
    set_char(x1, y2, '+');
    set_char(x2, y2, '+');
  }
}

print_str()

void Term::Window::print_str	(	const std::size_t &	column,
		const std::size_t &	y,
		const std::string &	s,
		const std::size_t &	indent = 0,
		bool	move_cursor = false )

Definition at line 97 of file window.cpp.

{
  std::u32string s2   = Private::utf8_to_utf32(s);
  std::size_t    xpos = x;
  std::size_t    ypos = y;
  for(char32_t i: s2)
  {
    if(i == U'\n')
    {
      xpos = x + indent;
      ypos++;
      if(insideWindow(xpos, ypos))
      {
        for(std::size_t j = 0; j < indent; ++j) { set_char(x + j, ypos, '.'); }
      }
      else { return; }
    }
    else
    {
      if(insideWindow(xpos, ypos)) { set_char(xpos, y, i); }
      else { return; }
      ++xpos;
    }
  }
  if(move_cursor) { m_cursor = {ypos, xpos}; }
}

render()

std::string Term::Window::render	(	const std::size_t &	x0,
		const std::size_t &	y0,
		bool	term )

Definition at line 199 of file window.cpp.

{
  std::string out;
  if(term) { out.append(cursor_off()); }
  Color current_fg       = Term::Color::Name::Default;
  Color current_bg       = Term::Color::Name::Default;
  bool  current_fg_reset = true;
  bool  current_bg_reset = true;
  Style current_style    = Style::Reset;
  for(std::size_t j = 1; j <= m_size.rows(); ++j)
  {
    if(term) { out.append(cursor_move(y0 + j - 1, x0)); }
    for(std::size_t i = 1; i <= m_size.columns(); ++i)
    {
      bool update_fg       = false;
      bool update_bg       = false;
      bool update_fg_reset = false;
      bool update_bg_reset = false;
      bool update_style    = false;
      if(current_fg_reset != get_fg_reset(i, j))
      {
        current_fg_reset = get_fg_reset(i, j);
        if(current_fg_reset)
        {
          update_fg_reset = true;
          current_fg      = {255, 255, 255};
        }
      }
 
      if(current_bg_reset != get_bg_reset(i, j))
      {
        current_bg_reset = get_bg_reset(i, j);
        if(current_bg_reset)
        {
          update_bg_reset = true;
          current_bg      = {255, 255, 255};
        }
      }
 
      if(!current_fg_reset)
      {
        if(!(current_fg == get_fg(i, j)))
        {
          current_fg = get_fg(i, j);
          update_fg  = true;
        }
      }
 
      if(!current_fg_reset)
      {
        if(!(current_bg == get_bg(i, j)))
        {
          current_bg = get_bg(i, j);
          update_bg  = true;
        }
      }
      if(current_style != get_style(i, j))
      {
        current_style = get_style(i, j);
        update_style  = true;
        if(current_style == Style::Reset)
        {
          // style::reset: reset fg and bg colors too, we have to
          // set them again if they are non-default, but if fg or
          // bg colors are reset, we do not update them, as
          // style::reset already did that.
          update_fg = !current_fg_reset;
          update_bg = !current_bg_reset;
        }
      }
      // Set style first, as style::reset will reset colors too
      if(update_style) { out.append(style(get_style(i, j))); }
      if(update_fg_reset) { out.append(color_fg(Term::Color::Name::Default)); }
      else if(update_fg)
      {
        const Term::Color color_tmp = get_fg(i, j);
        out.append(color_fg(color_tmp));
      }
 
      if(update_bg_reset) { out.append(color_bg(Term::Color::Name::Default)); }
      else if(update_bg)
      {
        const Term::Color color_tmp = get_bg(i, j);
        out.append(color_bg(color_tmp));
      }
      out.append(Private::utf32_to_utf8(get_char(i, j)));
    }
    if(j < m_size.rows()) { out.append("\n"); }
  }
  if(!current_fg_reset) { out.append(color_fg(Term::Color::Name::Default)); }
  if(!current_bg_reset) { out.append(color_bg(Term::Color::Name::Default)); }
  if(current_style != Style::Reset) { out.append(style(Style::Reset)); }
  if(term)
  {
    out.append(cursor_move(y0 + (m_cursor.row() - 1), x0 + (m_cursor.column() - 1)));
    out.append(cursor_on());
  }
  return out;
}

rows()

const Rows & Term::Window::rows ( ) const

noexcept

Definition at line 44 of file window.cpp.

{ return m_size.rows(); }

set_bg()

void Term::Window::set_bg	(	const std::size_t &	column,
		const std::size_t &	row,
		const Color &	color )

Definition at line 70 of file window.cpp.

{
  m_bg_reset[index(column, row)] = false;
  m_bg[index(column, row)]       = color;
}

set_bg_reset()

void Term::Window::set_bg_reset	(	const std::size_t &	column,
		const std::size_t &	row )

Definition at line 58 of file window.cpp.

{
  m_bg_reset[index(column, row)] = true;
  m_bg[index(column, row)]       = Term::Color::Name::Default;
}

set_char()

void Term::Window::set_char	(	const std::size_t &	column,
		const std::size_t &	row,
		const char32_t &	character )

Definition at line 46 of file window.cpp.

{
  if(insideWindow(column, row)) { m_chars[index(column, row)] = character; }
  else { throw Term::Exception("set_char(): (x,y) out of bounds"); }
}

set_cursor_pos()

void Term::Window::set_cursor_pos	(	const std::size_t &	column,
		const std::size_t &	row )

Definition at line 78 of file window.cpp.

{ m_cursor = {row, column}; }

set_fg()

void Term::Window::set_fg	(	const std::size_t &	column,
		const std::size_t &	row,
		const Color &	color )

Definition at line 64 of file window.cpp.

{
  m_fg_reset[index(column, row)] = false;
  m_fg[index(column, row)]       = color;
}

set_fg_reset()

void Term::Window::set_fg_reset	(	const std::size_t &	column,
		const std::size_t &	row )

Definition at line 52 of file window.cpp.

{
  m_fg_reset[index(column, row)] = true;
  m_fg[index(column, row)]       = Term::Color::Name::Default;
}

set_h()

void Term::Window::set_h

(

const std::size_t &

new_h

)

Definition at line 80 of file window.cpp.

{
  if(new_h == m_size.rows()) { return; }
  if(new_h > m_size.rows())
  {
    const std::size_t dc = (new_h - m_size.rows()) * m_size.columns();
    m_chars.insert(m_chars.end(), dc, ' ');
    m_fg_reset.insert(m_fg_reset.end(), dc, true);
    m_bg_reset.insert(m_bg_reset.end(), dc, true);
    m_fg.insert(m_fg.end(), dc, {0, 0, 0});
    m_bg.insert(m_bg.end(), dc, {0, 0, 0});
    m_style.insert(m_style.end(), dc, Style::Reset);
    m_size = {Term::Columns(m_size.columns()), Term::Rows(new_h)};
  }
  else { throw Term::Exception("Shrinking height not supported."); }
}

set_style()

void Term::Window::set_style	(	const std::size_t &	column,
		const std::size_t &	row,
		const Style &	style )

Definition at line 76 of file window.cpp.

{ m_style[index(column, row)] = style; }

Member Data Documentation

m_bg

std::vector<Term::Color> Term::Window::m_bg

private

Definition at line 85 of file window.hpp.

m_bg_reset

std::vector<bool> Term::Window::m_bg_reset

private

Definition at line 87 of file window.hpp.

m_chars

std::vector<char32_t> Term::Window::m_chars

private

Definition at line 83 of file window.hpp.

m_cursor

Term::Cursor Term::Window::m_cursor {1, 1}

private

Definition at line 82 of file window.hpp.

{1, 1};

m_fg

std::vector<Term::Color> Term::Window::m_fg

private

Definition at line 84 of file window.hpp.

m_fg_reset

std::vector<bool> Term::Window::m_fg_reset

private

Definition at line 86 of file window.hpp.

m_size

Term::Size Term::Window::m_size

private

Definition at line 81 of file window.hpp.

m_style

std::vector<Style> Term::Window::m_style

private

Definition at line 88 of file window.hpp.

---

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

• cpp-terminal/window.hpp
• cpp-terminal/window.cpp