Term::Private::Input Class Reference

#include <cpp-terminal/private/input.hpp>

Public Member Functions
	Input ()
	~Input ()

Static Public Member Functions
static void	startReading ()
static Term::Event	getEvent ()
static Term::Event	getEventBlocking ()

Static Private Member Functions
static void	read_event ()
static void	read_raw ()
static void	read_windows_key (const std::uint16_t &virtual_key_code, const std::uint32_t &control_key_state, const std::size_t &occurrence)
static void	init_thread ()

Static Private Attributes
static std::thread	m_thread {}
static Term::Private::BlockingQueue	m_events
static int	m_poll {-1}

Detailed Description

Definition at line 25 of file input.hpp.

Constructor & Destructor Documentation

Input()

Term::Private::Input::Input

(

)

Definition at line 313 of file input.cpp.

{}

~Input()

Term::Private::Input::~Input

(

)

Definition at line 80 of file input.cpp.

{
  if(m_thread.joinable()) m_thread.join();
}

Member Function Documentation

getEvent()

Term::Event Term::Private::Input::getEvent ( )

static

Definition at line 326 of file input.cpp.

{ return m_events.pop(); }

getEventBlocking()

Term::Event Term::Private::Input::getEventBlocking ( )

static

Definition at line 328 of file input.cpp.

{
  static std::mutex                   cv_m;
  static std::unique_lock<std::mutex> lk(cv_m);
  if(m_events.empty()) m_events.wait_for_events(lk);
  return m_events.pop();
}

init_thread()

void Term::Private::Input::init_thread ( )

staticprivate

Definition at line 91 of file input.cpp.

{
#if defined(__linux__)
  m_poll = {::epoll_create1(EPOLL_CLOEXEC)};
  ::epoll_event signal;
  signal.events  = {EPOLLIN};
  signal.data.fd = {Term::Private::Sigwinch::get()};
  ::epoll_ctl(m_poll, EPOLL_CTL_ADD, Term::Private::Sigwinch::get(), &signal);
  ::epoll_event input;
  input.events  = {EPOLLIN};
  input.data.fd = {Term::Private::in.fd()};
  ::epoll_ctl(m_poll, EPOLL_CTL_ADD, Term::Private::in.fd(), &input);
#endif
  if(m_thread.joinable()) m_thread.join();
  std::thread thread(Term::Private::Input::read_event);
  m_thread.swap(thread);
}

read_event()

void Term::Private::Input::read_event ( )

staticprivate

Definition at line 109 of file input.cpp.

{
  while(true)
  {
#if defined(_WIN32)
    WaitForSingleObject(Term::Private::in.handle(), INFINITE);
    read_raw();
#elif defined(__APPLE__) || defined(__wasm__) || defined(__wasm) || defined(__EMSCRIPTEN__)
    if(Term::Private::Sigwinch::isSigwinch()) m_events.push(screen_size());
    read_raw();
#else
    ::epoll_event ret;
    if(epoll_wait(m_poll, &ret, 1, -1) == 1)
    {
      if(Term::Private::Sigwinch::isSigwinch(ret.data.fd)) m_events.push(Term::Screen(screen_size()));
      else
        read_raw();
    }
#endif
  }
}

read_raw()

void Term::Private::Input::read_raw ( )

staticprivate

Definition at line 211 of file input.cpp.

{
#ifdef _WIN32
  DWORD to_read{0};
  GetNumberOfConsoleInputEvents(Private::in.handle(), &to_read);
  if(to_read == 0) return;
  DWORD                     read{0};
  std::vector<INPUT_RECORD> events{to_read};
  if(!ReadConsoleInputW(Private::in.handle(), &events[0], to_read, &read) || read != to_read) Term::Exception("ReadFile() failed");
  std::wstring ret;
  bool         need_windows_size{false};
  for(std::size_t i = 0; i != read; ++i)
  {
    switch(events[i].EventType)
    {
      case KEY_EVENT:
      {
        if(events[i].Event.KeyEvent.bKeyDown)
        {
          if(events[i].Event.KeyEvent.uChar.UnicodeChar == 0) read_windows_key(events[i].Event.KeyEvent.wVirtualKeyCode, events[i].Event.KeyEvent.dwControlKeyState, events[i].Event.KeyEvent.wRepeatCount);
          else
            ret.append(events[i].Event.KeyEvent.wRepeatCount, events[i].Event.KeyEvent.uChar.UnicodeChar == Term::Key::Del ? static_cast<wchar_t>(Key(Term::Key::Value::Backspace)) : static_cast<wchar_t>(events[i].Event.KeyEvent.uChar.UnicodeChar));
        }
        break;
      }
      case FOCUS_EVENT:
      {
        sendString(m_events, ret);
        m_events.push(Event(Focus(static_cast<Term::Focus::Type>(events[i].Event.FocusEvent.bSetFocus))));
        break;
      }
      case MENU_EVENT:
      {
        sendString(m_events, ret);
        break;
      }
      case MOUSE_EVENT:
      {
        sendString(m_events, ret);
        static MOUSE_EVENT_RECORD old_state;
        if(events[i].Event.MouseEvent.dwEventFlags == MOUSE_WHEELED || events[i].Event.MouseEvent.dwEventFlags == MOUSE_HWHEELED)
          ;
        else if(old_state.dwButtonState == events[i].Event.MouseEvent.dwButtonState && old_state.dwMousePosition.X == events[i].Event.MouseEvent.dwMousePosition.X && old_state.dwMousePosition.Y == events[i].Event.MouseEvent.dwMousePosition.Y && old_state.dwEventFlags == events[i].Event.MouseEvent.dwEventFlags)
          break;
        std::int32_t state{static_cast<std::int32_t>(events[i].Event.MouseEvent.dwButtonState)};
        switch(events[i].Event.MouseEvent.dwEventFlags)
        {
          case 0:
          {
            m_events.push(Term::Mouse(setButton(static_cast<std::int32_t>(old_state.dwButtonState), state), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.Y), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.X)));
            ;
            break;
          }
          case MOUSE_MOVED:
          {
            m_events.push(Term::Mouse(setButton(static_cast<std::int32_t>(old_state.dwButtonState), state), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.Y), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.X)));
            ;
            break;
          }
          case DOUBLE_CLICK:
          {
            m_events.push(Term::Mouse(Term::Button(setButton(static_cast<std::int32_t>(old_state.dwButtonState), state).type(), Term::Button::Action::DoubleClicked), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.Y), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.X)));
            break;
          }
          case MOUSE_WHEELED:
          {
            if(state > 0) m_events.push(Term::Mouse(Button(Term::Button::Type::Wheel, Term::Button::Action::RolledUp), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.Y), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.X)));
            else
              m_events.push(Term::Mouse(Button(Term::Button::Type::Wheel, Term::Button::Action::RolledDown), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.Y), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.X)));
            break;
          }
          case MOUSE_HWHEELED:
          {
            if(state > 0) m_events.push(Term::Mouse(Button(Term::Button::Type::Wheel, Term::Button::Action::ToRight), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.Y), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.X)));
            else
              m_events.push(Term::Mouse(Button(Term::Button::Type::Wheel, Term::Button::Action::ToLeft), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.Y), static_cast<std::uint16_t>(events[i].Event.MouseEvent.dwMousePosition.X)));
            break;
          }
          default: break;
        }
        old_state = events[i].Event.MouseEvent;
        break;
      }
      case WINDOW_BUFFER_SIZE_EVENT:
      {
        need_windows_size = true;  // if we send directly it's too much generations
        sendString(m_events, ret);
        break;
      }
      default: break;
    }
  }
  sendString(m_events, ret);
  if(need_windows_size == true) { m_events.push(screen_size()); }
#else
  Private::in.lockIO();
  std::string ret = Term::Private::in.read();
  Private::in.unlockIO();
  if(!ret.empty()) m_events.push(Event(ret.c_str()));
#endif
}

read_windows_key()

void Term::Private::Input::read_windows_key ( const std::uint16_t & virtual_key_code, const std::uint32_t & control_key_state, const std::size_t & occurrence )

staticprivate

Definition at line 132 of file input.cpp.

{
  // First check if we have ALT etc (CTRL is already done so skip it)
  Term::MetaKey toAdd{Term::MetaKey::Value::None};
  if(((control_key_state & LEFT_ALT_PRESSED) == LEFT_ALT_PRESSED) || ((control_key_state & RIGHT_ALT_PRESSED) == RIGHT_ALT_PRESSED)) toAdd += Term::MetaKey::Value::Alt;
  if(((control_key_state & LEFT_CTRL_PRESSED) == LEFT_CTRL_PRESSED) || ((control_key_state & RIGHT_CTRL_PRESSED) == RIGHT_CTRL_PRESSED)) toAdd += Term::MetaKey::Value::Ctrl;
 
  switch(virtual_key_code)
  {
    case VK_CANCEL:  //??
    case VK_CLEAR:   //??
    case VK_SHIFT:
    case VK_CONTROL:
    case VK_MENU:
    case VK_PAUSE:  //??
    case VK_CAPITAL:
    case VK_KANA:  //??
    //case VK_HANGUL: // Same
    case VK_JUNJA:  // ?
    case VK_FINAL:  // ?
    case VK_HANJA:
    //case VK_KANJI: // Same
    case VK_CONVERT:     // ?
    case VK_NONCONVERT:  // ?
    case VK_ACCEPT:      // ?
    case VK_MODECHANGE:  // ?
      break;
    case VK_PRIOR: m_events.push(std::move(toAdd + Term::Key(Key::Value::PageUp)), occurrence); break;
    case VK_NEXT: m_events.push(std::move(toAdd + Term::Key(Key::Value::PageDown)), occurrence); break;
    case VK_END: m_events.push(std::move(toAdd + Term::Key(Key::Value::End)), occurrence); break;
    case VK_HOME: m_events.push(std::move(toAdd + Term::Key(Key::Value::Home)), occurrence); break;
    case VK_LEFT: m_events.push(std::move(toAdd + Term::Key(Key::Value::ArrowLeft)), occurrence); break;
    case VK_UP: m_events.push(std::move(toAdd + Term::Key(Key::Value::ArrowUp)), occurrence); break;
    case VK_RIGHT: m_events.push(std::move(toAdd + Term::Key(Key::Value::ArrowRight)), occurrence); break;
    case VK_DOWN: m_events.push(std::move(toAdd + Term::Key(Key::Value::ArrowDown)), occurrence); break;
    case VK_SELECT:   //?
    case VK_PRINT:    //?
    case VK_EXECUTE:  //?
      break;
    case VK_SNAPSHOT: m_events.push(std::move(toAdd + Term::Key(Key::Value::PrintScreen)), occurrence); break;
    case VK_INSERT: m_events.push(std::move(toAdd + Term::Key(Key::Value::Insert)), occurrence); break;
    case VK_DELETE: m_events.push(std::move(toAdd + Term::Key(Key::Value::Del)), occurrence); break;
    case VK_HELP:   //?
    case VK_LWIN:   //Maybe allow to detect Windows key Left and right
    case VK_RWIN:   //Maybe allow to detect Windows key Left and right
    case VK_APPS:   //?
    case VK_SLEEP:  //?
      break;
    case VK_F1: m_events.push(std::move(toAdd + Term::Key(Key::Value::F1)), occurrence); break;
    case VK_F2: m_events.push(std::move(toAdd + Term::Key(Key::Value::F2)), occurrence); break;
    case VK_F3: m_events.push(std::move(toAdd + Term::Key(Key::Value::F3)), occurrence); break;
    case VK_F4: m_events.push(std::move(toAdd + Term::Key(Key::Value::F4)), occurrence); break;
    case VK_F5: m_events.push(std::move(toAdd + Term::Key(Key::Value::F5)), occurrence); break;
    case VK_F6: m_events.push(std::move(toAdd + Term::Key(Key::Value::F6)), occurrence); break;
    case VK_F7: m_events.push(std::move(toAdd + Term::Key(Key::Value::F7)), occurrence); break;
    case VK_F8: m_events.push(std::move(toAdd + Term::Key(Key::Value::F8)), occurrence); break;
    case VK_F9: m_events.push(std::move(toAdd + Term::Key(Key::Value::F9)), occurrence); break;
    case VK_F10: m_events.push(std::move(toAdd + Term::Key(Key::Value::F10)), occurrence); break;
    case VK_F11: m_events.push(std::move(toAdd + Term::Key(Key::Value::F11)), occurrence); break;
    case VK_F12: m_events.push(std::move(toAdd + Term::Key(Key::Value::F12)), occurrence); break;
    case VK_F13: m_events.push(std::move(toAdd + Term::Key(Key::Value::F13)), occurrence); break;
    case VK_F14: m_events.push(std::move(toAdd + Term::Key(Key::Value::F14)), occurrence); break;
    case VK_F15: m_events.push(std::move(toAdd + Term::Key(Key::Value::F15)), occurrence); break;
    case VK_F16: m_events.push(std::move(toAdd + Term::Key(Key::Value::F16)), occurrence); break;
    case VK_F17: m_events.push(std::move(toAdd + Term::Key(Key::Value::F17)), occurrence); break;
    case VK_F18: m_events.push(std::move(toAdd + Term::Key(Key::Value::F18)), occurrence); break;
    case VK_F19: m_events.push(std::move(toAdd + Term::Key(Key::Value::F19)), occurrence); break;
    case VK_F20: m_events.push(std::move(toAdd + Term::Key(Key::Value::F20)), occurrence); break;
    case VK_F21: m_events.push(std::move(toAdd + Term::Key(Key::Value::F21)), occurrence); break;
    case VK_F22: m_events.push(std::move(toAdd + Term::Key(Key::Value::F22)), occurrence); break;
    case VK_F23: m_events.push(std::move(toAdd + Term::Key(Key::Value::F23)), occurrence); break;
    case VK_F24: m_events.push(std::move(toAdd + Term::Key(Key::Value::F24)), occurrence); break;
    case VK_NUMLOCK:
    case VK_SCROLL:
    default: break;
  }
}

startReading()

void Term::Private::Input::startReading ( )

static

Definition at line 315 of file input.cpp.

{
  static bool activated{false};
  if(!activated)
  {
    init_thread();
    m_thread.detach();
    activated = true;
  }
}

Member Data Documentation

m_events

Term::Private::BlockingQueue Term::Private::Input::m_events

staticprivate

Definition at line 42 of file input.hpp.

m_poll

int Term::Private::Input::m_poll {-1}

staticprivate

Definition at line 89 of file input.hpp.

m_thread

std::thread Term::Private::Input::m_thread {}

staticprivate

Definition at line 85 of file input.hpp.

{
 
namespace Private
{
 
class BlockingQueue;
 
class Input final
{
public:
  Input();
  ~Input();
  static void        startReading();
  static Term::Event getEvent();
  static Term::Event getEventBlocking();
 
private:
  static void read_event();
  static void read_raw();
#if defined(_WIN32)
  static void read_windows_key(const std::uint16_t& virtual_key_code, const std::uint32_t& control_key_state, const std::size_t& occurrence);
#endif
  static void                         init_thread();
  static std::thread                  m_thread;
  static Term::Private::BlockingQueue m_events;
  static int                          m_poll;  // for linux
};
 
}  // namespace Private
 
}  // namespace Term

---

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

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