Term::Event Class Reference

#include <cpp-terminal/event.hpp>

Classes
union	container

Public Types
enum class	Type {   Empty , Key , Screen , Cursor ,   Focus , Mouse , CopyPaste }

Public Member Functions
	~Event ()
	Event ()
	Event (const std::string &str)
	Event (const Term::Key &key)
	Event (const Term::Screen &screen)
	Event (const Term::Cursor &cursor)
	Event (const Term::Focus &focus)
	Event (const Term::Mouse &mouse)
	Event (const Term::Event &event)
	Event (Term::Event &&event) noexcept
Event &	operator= (Event &&other) noexcept
Event &	operator= (const Term::Event &event)
bool	empty () const
Type	type () const
	operator Term::Key () const
	operator Term::Screen () const
	operator Term::Cursor () const
	operator Term::Focus () const
	operator Term::Mouse () const
	operator std::string () const
Key *	get_if_key ()
const Key *	get_if_key () const
Screen *	get_if_screen ()
const Screen *	get_if_screen () const
Cursor *	get_if_cursor ()
const Cursor *	get_if_cursor () const
Focus *	get_if_focus ()
const Focus *	get_if_focus () const
Mouse *	get_if_mouse ()
const Mouse *	get_if_mouse () const
std::string *	get_if_copy_paste ()
const std::string *	get_if_copy_paste () const

Private Member Functions
void	parse (const std::string &str)

Private Attributes
Type	m_Type {Type::Empty}
container	m_container

Detailed Description

Definition at line 24 of file event.hpp.

Member Enumeration Documentation

Type

enum class Term::Event::Type

strong

Enumerator
Empty
Key
Screen
Cursor
Focus
Mouse
CopyPaste

Definition at line 27 of file event.hpp.

  {
    Empty,
    Key,
    Screen,
    Cursor,
    Focus,
    Mouse,
    CopyPaste,
  };

Constructor & Destructor Documentation

~Event()

Term::Event::~Event

(

)

Definition at line 138 of file event.cpp.

{
  using std::string;
  if(m_Type == Type::CopyPaste) { m_container.m_string.~string(); }
}

Event() [1/9]

Term::Event::Event ( )

default

Event() [2/9]

Term::Event::Event

(

const std::string &

str

)

Definition at line 205 of file event.cpp.

{ parse(str); }

Event() [3/9]

Term::Event::Event

(

const Term::Key &

key

)

Definition at line 201 of file event.cpp.

: m_Type(Type::Key) { m_container.m_Key = key; }

Event() [4/9]

Term::Event::Event

(

const Term::Screen &

screen

)

Definition at line 199 of file event.cpp.

: m_Type(Type::Screen) { m_container.m_Screen = screen; }

Event() [5/9]

Term::Event::Event

(

const Term::Cursor &

cursor

)

Definition at line 89 of file event.cpp.

: m_Type(Type::Cursor) { m_container.m_Cursor = cursor; }

Event() [6/9]

Term::Event::Event

(

const Term::Focus &

focus

)

Definition at line 120 of file event.cpp.

: m_Type(Type::Focus) { m_container.m_Focus = focus; }

Event() [7/9]

Term::Event::Event

(

const Term::Mouse &

mouse

)

Definition at line 177 of file event.cpp.

: m_Type(Type::Mouse) { m_container.m_Mouse = mouse; }

Event() [8/9]

Term::Event::Event

(

const Term::Event &

event

)

Definition at line 122 of file event.cpp.

{
  m_Type = event.m_Type;
  switch(m_Type)
  {
    case Type::Empty: break;
    case Type::Key: m_container.m_Key = event.m_container.m_Key; break;
    case Type::CopyPaste: new(&this->m_container.m_string) std::string(event.m_container.m_string); break;
    case Type::Cursor: m_container.m_Cursor = event.m_container.m_Cursor; break;
    case Type::Screen: m_container.m_Screen = event.m_container.m_Screen; break;
    case Type::Focus: m_container.m_Focus = event.m_container.m_Focus; break;
    case Type::Mouse: m_container.m_Mouse = event.m_container.m_Mouse; break;
    default: break;
  }
}

Event() [9/9]

Term::Event::Event ( Term::Event && event )

noexcept

Definition at line 146 of file event.cpp.

                                           : m_Type(event.m_Type)
{
  switch(m_Type)
  {
    case Type::Empty: break;
    case Type::Key: std::swap(m_container.m_Key, event.m_container.m_Key); break;
    case Type::CopyPaste: std::swap(m_container.m_string, event.m_container.m_string); break;
    case Type::Cursor: std::swap(m_container.m_Cursor, event.m_container.m_Cursor); break;
    case Type::Screen: std::swap(m_container.m_Screen, event.m_container.m_Screen); break;
    case Type::Focus: std::swap(m_container.m_Focus, event.m_container.m_Focus); break;
    case Type::Mouse: std::swap(m_container.m_Mouse, event.m_container.m_Mouse); break;
    default: break;
  }
}

Member Function Documentation

empty()

bool Term::Event::empty

(

)

const

Definition at line 179 of file event.cpp.

{ return m_Type == Type::Empty; }

get_if_copy_paste() [1/2]

std::string * Term::Event::get_if_copy_paste

(

)

Definition at line 77 of file event.cpp.

{
  if(m_Type == Type::CopyPaste) return &m_container.m_string;
  return nullptr;
}

get_if_copy_paste() [2/2]

const std::string * Term::Event::get_if_copy_paste

(

)

const

Definition at line 83 of file event.cpp.

{
  if(m_Type == Type::CopyPaste) return &m_container.m_string;
  return nullptr;
}

get_if_cursor() [1/2]

Term::Cursor * Term::Event::get_if_cursor

(

)

Definition at line 65 of file event.cpp.

{
  if(m_Type == Type::Cursor) return &m_container.m_Cursor;
  return nullptr;
}

get_if_cursor() [2/2]

const Term::Cursor * Term::Event::get_if_cursor

(

)

const

Definition at line 71 of file event.cpp.

{
  if(m_Type == Type::Cursor) return &m_container.m_Cursor;
  return nullptr;
}

get_if_focus() [1/2]

Term::Focus * Term::Event::get_if_focus

(

)

Definition at line 91 of file event.cpp.

{
  if(m_Type == Type::Focus) return &m_container.m_Focus;
  return nullptr;
}

get_if_focus() [2/2]

const Term::Focus * Term::Event::get_if_focus

(

)

const

Definition at line 97 of file event.cpp.

{
  if(m_Type == Type::Focus) return &m_container.m_Focus;
  return nullptr;
}

get_if_key() [1/2]

Term::Key * Term::Event::get_if_key

(

)

Definition at line 29 of file event.cpp.

{
  if(m_Type == Type::Key) return &m_container.m_Key;
  return nullptr;
}

get_if_key() [2/2]

const Term::Key * Term::Event::get_if_key

(

)

const

Definition at line 35 of file event.cpp.

{
  if(m_Type == Type::Key) return &m_container.m_Key;
  return nullptr;
}

get_if_mouse() [1/2]

Term::Mouse * Term::Event::get_if_mouse

(

)

Definition at line 47 of file event.cpp.

{
  if(m_Type == Type::Mouse) return &m_container.m_Mouse;
  return nullptr;
}

get_if_mouse() [2/2]

const Term::Mouse * Term::Event::get_if_mouse

(

)

const

Definition at line 53 of file event.cpp.

{
  if(m_Type == Type::Mouse) return &m_container.m_Mouse;
  return nullptr;
}

get_if_screen() [1/2]

Term::Screen * Term::Event::get_if_screen

(

)

Definition at line 41 of file event.cpp.

{
  if(m_Type == Type::Screen) return &m_container.m_Screen;
  return nullptr;
}

get_if_screen() [2/2]

const Term::Screen * Term::Event::get_if_screen

(

)

const

Definition at line 59 of file event.cpp.

{
  if(m_Type == Type::Screen) return &m_container.m_Screen;
  return nullptr;
}

operator std::string()

Term::Event::operator std::string

(

)

const

Definition at line 187 of file event.cpp.

{
  if(m_Type == Type::CopyPaste) { return m_container.m_string; }
  return {};
}

operator Term::Cursor()

Term::Event::operator Term::Cursor

(

)

const

Definition at line 458 of file event.cpp.

{
  if(m_Type == Type::Cursor) { return m_container.m_Cursor; }
  return {};
}

operator Term::Focus()

Term::Event::operator Term::Focus

(

)

const

Definition at line 464 of file event.cpp.

{
  if(m_Type == Type::Focus) { return m_container.m_Focus; }
  return {};
}

operator Term::Key()

Term::Event::operator Term::Key

(

)

const

Definition at line 452 of file event.cpp.

{
  if(m_Type == Type::Key) { return m_container.m_Key; }
  return {};
}

operator Term::Mouse()

Term::Event::operator Term::Mouse

(

)

const

Definition at line 181 of file event.cpp.

{
  if(m_Type == Type::Mouse) { return m_container.m_Mouse; }
  return {};
}

operator Term::Screen()

Term::Event::operator Term::Screen

(

)

const

Definition at line 193 of file event.cpp.

{
  if(m_Type == Type::Screen) { return m_container.m_Screen; }
  return {};
}

operator=() [1/2]

Term::Event & Term::Event::operator=

(

const Term::Event &

event

)

Definition at line 103 of file event.cpp.

{
  m_Type = event.m_Type;
  switch(m_Type)
  {
    case Type::Empty: break;
    case Type::Key: m_container.m_Key = event.m_container.m_Key; break;
    case Type::CopyPaste: new(&this->m_container.m_string) std::string(event.m_container.m_string); break;
    case Type::Cursor: m_container.m_Cursor = event.m_container.m_Cursor; break;
    case Type::Screen: m_container.m_Screen = event.m_container.m_Screen; break;
    case Type::Focus: m_container.m_Focus = event.m_container.m_Focus; break;
    case Type::Mouse: m_container.m_Mouse = event.m_container.m_Mouse; break;
    default: break;
  }
  return *this;
}

operator=() [2/2]

Term::Event & Term::Event::operator= ( Term::Event && other )

noexcept

Definition at line 161 of file event.cpp.

{
  switch(other.m_Type)
  {
    case Type::Empty: break;
    case Type::Key: std::swap(m_container.m_Key, other.m_container.m_Key); break;
    case Type::CopyPaste: std::swap(m_container.m_string, other.m_container.m_string); break;
    case Type::Cursor: std::swap(m_container.m_Cursor, other.m_container.m_Cursor); break;
    case Type::Screen: std::swap(m_container.m_Screen, other.m_container.m_Screen); break;
    case Type::Focus: std::swap(m_container.m_Focus, other.m_container.m_Focus); break;
    case Type::Mouse: std::swap(m_container.m_Mouse, other.m_container.m_Mouse); break;
    default: break;
  }
  return *this;
}

parse()

void Term::Event::parse ( const std::string & str )

private

Definition at line 207 of file event.cpp.

{
  if(str.empty()) m_Type = Type::Empty;
  else if(str.size() == 1)
  {
    m_Type            = Type::Key;
    m_container.m_Key = Key(static_cast<Term::Key>(str[0]));
    /* Backspace return 127 CTRL+backspace return 8 */
    if(m_container.m_Key == Term::Key::Del) m_container.m_Key = Key(Term::Key::Backspace);
  }
  else if(str == "\033[I")
  {
    m_Type              = Type::Focus;
    m_container.m_Focus = Term::Focus(Term::Focus::Type::In);
  }
  else if(str == "\033[O")
  {
    m_Type              = Type::Focus;
    m_container.m_Focus = Term::Focus(Term::Focus::Type::Out);
  }
  else if(str.size() == 2 && str[0] == '\033')
  {
    m_container.m_Key = Key(static_cast<Term::Key>(Term::MetaKey::Value::Alt + static_cast<Term::Key>(str[1])));
    m_Type            = Type::Key;
  }
  else if(str[0] == '\033' && str[1] == '[' && str[str.size() - 1] == 'R')
  {
    std::size_t found = str.find(';', 2);
    if(found != std::string::npos)
    {
      m_Type               = Type::Cursor;
      m_container.m_Cursor = Cursor(static_cast<std::uint16_t>(std::stoi(str.substr(2, found - 2))), static_cast<std::uint16_t>(std::stoi(str.substr(found + 1, str.size() - (found + 2)))));
    }
  }
  else if(str[0] == '\033' && str[1] == '[' && str[2] == '<')
  {
    static std::chrono::time_point<std::chrono::system_clock> old;
    bool                                                      not_too_long{false};
    if(std::chrono::system_clock::now() - old <= std::chrono::milliseconds{120}) not_too_long = true;
    m_Type = Type::Mouse;
    std::size_t              pos{3};
    std::size_t              pos2{3};
    std::vector<std::size_t> values;
    while((pos = str.find(';', pos)) != std::string::npos)
    {
      values.push_back(std::stoull(str.substr(pos2, pos - pos2)));
      pos++;
      pos2 = pos;
    }
    values.push_back(std::stoull(str.substr(pos2, str.size() - pos2 - 1)));
    static Term::Mouse   first;
    static Term::Mouse   second;
    Term::Button::Action action;
    if(str[str.size() - 1] == 'm') action = Term::Button::Action::Released;
    else
      action = Term::Button::Action::Pressed;
    Term::Button::Type type;
    switch(values[0])
    {
      case 0:
      {
        type = Term::Button::Type::Right;
        break;
      }
      case 1:
      {
        type = Term::Button::Type::Wheel;
        break;
      }
      case 2:
      {
        type = Term::Button::Type::Left;
        break;
      }
      case 35:
      {
        type   = Term::Button::Type::None;
        action = Term::Button::Action::None;
        break;
      }
      case 64:
      {
        type   = Term::Button::Type::Wheel;
        action = Term::Button::Action::RolledUp;
        break;
      }
      case 65:
      {
        type   = Term::Button::Type::Wheel;
        action = Term::Button::Action::RolledDown;
        break;
      }
      default: break;
    }
    if(not_too_long && first.row() == second.row() && second.row() == values[1] && first.column() == second.column() && second.column() == values[2] && first.getButton().type() == second.getButton().type() && second.getButton().type() == type && first.getButton().action() == Button::Action::Released && second.getButton().action() == Button::Action::Pressed && action == Button::Action::Pressed) action = Term::Button::Action::DoubleClicked;
    second              = first;
    first               = Term::Mouse(Term::Button(type, action), values[1], values[2]);
    m_container.m_Mouse = first;
    old                 = std::chrono::system_clock::now();
  }
  else if(str.size() <= 10)
  {
    //https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
    // CSI = ESC[ SS3 = ESCO
    /*
     * Key            Normal     Application
     * -------------+----------+-------------
     * Cursor Up    | CSI A    | SS3 A
     * Cursor Down  | CSI B    | SS3 B
     * Cursor Right | CSI C    | SS3 C
     * Cursor Left  | CSI D    | SS3 D
     * -------------+----------+-------------
     * Key            Normal/Application
     * -------------+--------------------
     * Cursor Up    | ESC A
     * Cursor Down  | ESC B
     * Cursor Right | ESC C
     * Cursor Left  | ESC D
     * -------------+--------------------
    */
    if((str == "\u001bOA") || (str == "\u001b[A") || (str == "\u001bA")) { m_container.m_Key = Key(Term::Key::ArrowUp); }
    else if((str == "\u001bOB") || (str == "\u001b[B") || (str == "\u001bB")) { m_container.m_Key = Key(Term::Key::ArrowDown); }
    else if((str == "\u001bOC") || (str == "\u001b[C") || (str == "\u001bC")) { m_container.m_Key = Key(Term::Key::ArrowRight); }
    else if((str == "\u001bOD") || (str == "\u001b[D") || (str == "\u001bD")) { m_container.m_Key = Key(Term::Key::ArrowLeft); }
    /*
     * Key        Normal     Application
     * ---------+----------+-------------
     * Home     | CSI H    | SS3 H
     * End      | CSI F    | SS3 F
     * ---------+----------+-------------
    */
    else if((str == "\u001bOH") || (str == "\u001b[H"))
      m_container.m_Key = Key(Term::Key::Home);
    else if(str == "\u001bOF" || str == "\u001b[F")
      m_container.m_Key = Key(Term::Key::End);
    /*
     * Key        Escape Sequence
     * ---------+-----------------
     * F1       | SS3 P
     * F2       | SS3 Q
     * F3       | SS3 R
     * F4       | SS3 S
     * F1       | CSI 1 1 ~
     * F2       | CSI 1 2 ~
     * F3       | CSI 1 3 ~
     * F4       | CSI 1 4 ~
     * F5       | CSI 1 5 ~
     * F6       | CSI 1 7 ~
     * F7       | CSI 1 8 ~
     * F8       | CSI 1 9 ~
     * F9       | CSI 2 0 ~
     * F10      | CSI 2 1 ~
     * F11      | CSI 2 3 ~
     * F12      | CSI 2 4 ~
     * ---------+-----------------
    */
    else if(str == "\u001bOP" || str == "\u001b[11~")
      m_container.m_Key = Key(Term::Key::F1);
    else if(str == "\u001bOQ" || str == "\u001b[12~")
      m_container.m_Key = Key(Term::Key::F2);
    else if(str == "\u001bOR" || str == "\u001b[13~")
      m_container.m_Key = Key(Term::Key::F3);
    else if(str == "\u001bOS" || str == "\u001b[14~")
      m_container.m_Key = Key(Term::Key::F4);
    else if(str == "\u001b[15~")
      m_container.m_Key = Key(Term::Key::F5);
    else if(str == "\u001b[17~")
      m_container.m_Key = Key(Term::Key::F6);
    else if(str == "\u001b[18~")
      m_container.m_Key = Key(Term::Key::F7);
    else if(str == "\u001b[19~")
      m_container.m_Key = Key(Term::Key::F8);
    else if(str == "\u001b[20~")
      m_container.m_Key = Key(Term::Key::F9);
    else if(str == "\u001b[21~")
      m_container.m_Key = Key(Term::Key::F10);
    else if(str == "\u001b[23~")
      m_container.m_Key = Key(Term::Key::F11);
    else if(str == "\u001b[24~")
      m_container.m_Key = Key(Term::Key::F12);
    /*
     * Key        Normal     Application
     * ---------+----------+-------------
     * Insert   | CSI 2 ~  | CSI 2 ~
     * Delete   | CSI 3 ~  | CSI 3 ~
     * Home     | CSI 1 ~  | CSI 1 ~
     * End      | CSI 4 ~  | CSI 4 ~
     * PageUp   | CSI 5 ~  | CSI 5 ~
     * PageDown | CSI 6 ~  | CSI 6 ~
     * ---------+----------+-------------
    */
    else if(str == "\u001b[2~") { m_container.m_Key = Key(Term::Key::Insert); }
    else if(str == "\u001b[3~") { m_container.m_Key = Key(Term::Key::Del); }
    else if(str == "\u001b[1~") { m_container.m_Key = Key(Term::Key::Home); }
    else if(str == "\u001b[4~") { m_container.m_Key = Key(Term::Key::End); }
    else if(str == "\u001b[5~") { m_container.m_Key = Key(Term::Key::PageUp); }
    else if(str == "\u001b[6~") { m_container.m_Key = Key(Term::Key::PageDown); }
    /*
     * Key        Escape Sequence
     * ---------+-----------------
     * F13      | CSI 2 5 ~
     * F14      | CSI 2 6 ~
     * F15      | CSI 2 8 ~
     * F16      | CSI 2 9 ~
     * F17      | CSI 3 1 ~
     * F18      | CSI 3 2 ~
     * F19      | CSI 3 3 ~
     * F20      | CSI 3 4 ~
     * ---------+-----------------
    */
    else if(str == "\u001b[25~")
      m_container.m_Key = Key(Term::Key::F13);
    else if(str == "\u001b[26~")
      m_container.m_Key = Key(Term::Key::F14);
    else if(str == "\u001b[28~")
      m_container.m_Key = Key(Term::Key::F15);
    else if(str == "\u001b[29~")
      m_container.m_Key = Key(Term::Key::F16);
    else if(str == "\u001b[31~")
      m_container.m_Key = Key(Term::Key::F17);
    else if(str == "\u001b[32~")
      m_container.m_Key = Key(Term::Key::F18);
    else if(str == "\u001b[33~")
      m_container.m_Key = Key(Term::Key::F19);
    else if(str == "\u001b[34~")
      m_container.m_Key = Key(Term::Key::F20);
    else if(str == "\u001b[G")
      m_container.m_Key = Key(Term::Key::Value::Numeric5);
    else if(Term::Private::is_valid_utf8_code_unit(str))
      m_container.m_Key = Key(static_cast<Term::Key::Value>(Term::Private::utf8_to_utf32(str)[0]));
    else
    {
      m_Type = Type::CopyPaste;
      new(&this->m_container.m_string) std::string(str);
      return;
    }
    m_Type = Type::Key;
  }
  else
  {
    m_Type = Type::CopyPaste;
    new(&this->m_container.m_string) std::string(str);
  }
}

type()

Term::Event::Type Term::Event::type

(

)

const

Definition at line 203 of file event.cpp.

{ return m_Type; }

Member Data Documentation

m_container

container Term::Event::m_container

private

Definition at line 90 of file event.hpp.

m_Type

Type Term::Event::m_Type {Type::Empty}

private

Definition at line 89 of file event.hpp.

{Type::Empty};

---

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

• cpp-terminal/event.hpp
• cpp-terminal/event.cpp