kNCurses/Window.cpp

/**
 * @author Christian Burger (christian@krikkel.de)
 */

#include <NCursesPtyWindow/Window.hpp>
#include "Debug.hpp"

#include <cstdio>
#include <unistd.h>
#include <sys/select.h>
#include <gsl/gsl>
#include <cctype>
#include <termios.h>
#include <fcntl.h>

namespace krikkel::NCursesPtyWindow
{
    using gsl::narrow;
    using std::lock_guard;

    Window::Window(std::mutex *writeToNCursesMutex, int lines, int columns, int y, int x)
            : writeToNCursesMutex(writeToNCursesMutex), NCursesWindow(lines, columns, y, x)
    {
        // to get the original terminal we need to shutdown ncurses for a moment
        /// @todo maybe try `reset_prog_mode()` and `reset_shell_mode()` instead
        ::endwin();
        tcgetattr(STDIN_FILENO, &terminalParameters);
        ::refresh();

        winsize windowSize =
        {
            .ws_row = narrow<short unsigned int>(this->height())
          , .ws_col = narrow<short unsigned int>(this->width())
        };
        openpty(&fdPtyHost, &fdPtyClient, NULL, &terminalParameters, &windowSize);

        pseudoTerminal = vterm_new(windowSize.ws_row, windowSize.ws_col);
        vterm_set_utf8(pseudoTerminal, true);
        pseudoTerminalScreen = vterm_obtain_screen(pseudoTerminal);
        vterm_screen_reset(pseudoTerminalScreen, true);
        vterm_screen_set_callbacks(pseudoTerminalScreen, &screenCallbacks, this);
        vterm_output_set_callback(pseudoTerminal, &staticHandlerOutput, this);
        vterm_screen_enable_altscreen(pseudoTerminalScreen, true);

        //raw(); //— cbreak might suffice
        //noecho(); — already set
        //nodelay(true); — @todo needs some reprogramming
        keypad(true);
        nonl();

        /// @todo block all signals, this thread does not handle any
        readPtyClientThread =
            std::thread(&Window::readFromPtyClientThreadMethod, this);
    }

    Window::~Window()
    {
        close(fdPtyHost);
        close(fdPtyClient);
        vterm_free(pseudoTerminal);
    }

    int Window::getFdPtyClient() const
    {
        return fdPtyClient;
    }

    void Window::writeToClient(const char *output, size_t length)
    {
        lock_guard writeLock(writeToPseudoTerminalMutex);
        write(fdPtyHost, output, length);
        __debug_log("written to PTY client: '" + __debug_make_bytes_printable(std::string(output, length)) + '\'');
    }

    void Window::writeUnicodeCharToClient(wint_t character)
    {
        vterm_keyboard_unichar(pseudoTerminal, character, VTERM_MOD_NONE);
    }

    void Window::writeKeyToClient(VTermKey key)
    {
        __debug_log("writing key: " + std::to_string(key));
        vterm_keyboard_key(pseudoTerminal, key, VTERM_MOD_NONE);
    }

    SingleUserInput Window::readSingleUserInput()
    {
        wint_t input;
        int result = get_wch(&input);
        return SingleUserInput(result, input);
    }

    void Window::readFromPtyClientThreadMethod()
    {
        /// @todo in theory, there is no need for a timeout or select …
        ///       file descriptor is blocking
        while(1)
        {
            readFromPtyClient();
            struct timeval timeout = { .tv_sec = 0, .tv_usec = 200000 };
            fd_set readFds;

            FD_ZERO(&readFds);
            FD_SET(fdPtyHost, &readFds);
            if(select(fdPtyHost + 1, &readFds, NULL, NULL, &timeout) < 0)
                break;
        }
    }

    void Window::readFromPtyClient()
    {
        size_t bytesRead = read(fdPtyHost, ptyClientOutputBuffer, PTY_CLIENT_OUTPUT_BUFFER_SIZE);
        if(bytesRead != -1 && bytesRead != 0)
        {
            lock_guard writeLock(writeToPseudoTerminalMutex);
            vterm_input_write(pseudoTerminal, ptyClientOutputBuffer, bytesRead);
        }
        __debug_log("read from PTY client: '" + __debug_make_bytes_printable(std::string(ptyClientOutputBuffer, bytesRead)) + '\'');
    }

    VTermScreenCallbacks Window::screenCallbacks =
    {
        .damage = staticHandlerDamage,
        .moverect = staticHandlerMoveRect,
        .movecursor = staticHandlerMoveCursor,
        .settermprop = staticHandlerSetTermProp,
        .bell = staticHandlerBell,
        .resize = staticHandlerResize,
        .sb_pushline = staticHandlerPushLine,
        .sb_popline = staticHandlerPopLine,
    };

    int Window::handlerDamage(VTermRect rect)
    {
        for(int x = rect.start_col; x < rect.end_col; ++x)
            for(int y = rect.start_row; y < rect.end_row; ++y)
                copyPtyCellToNCursesWindow(x, y);

        refresh();

        return 0;
    }

    int Window::handlerMoveRect(VTermRect dest, VTermRect src)
    {
        __debug_log("(unimplemented) move content in rectangle from ("
              + std::to_string(src.start_col) + ", "
              + std::to_string(src.start_row) + ", "
              + std::to_string(src.end_col) + ", "
              + std::to_string(src.end_row) + ") "
              + "size: " + std::to_string((src.start_col - src.end_col) * (src.start_row - src.end_row))
              + " to ("
              + std::to_string(dest.start_col) + ", "
              + std::to_string(dest.start_row) + ", "
              + std::to_string(dest.end_col) + ", "
              + std::to_string(dest.end_row) + ") "
              + "size: " + std::to_string((dest.start_col - dest.end_col) * (dest.start_row - dest.end_row)));
        return 0;
    }

    int Window::handlerMoveCursor(VTermPos pos, VTermPos oldpos, int visible)
    {
        /// @todo maybe use `mvcur()` instead?
        cursorX = pos.col;
        cursorY = pos.row;
        refresh();
        return 0;
    }

    int Window::handlerSetTermProp(VTermProp prop, VTermValue *val)
    {
        /// @todo maybe use "vterm_get_prop_type() —> bool, number, string"?
        __debug_stringify_switch_begin(handlerSetTermProp, prop, val);
            __debug_stringify_switch_case(VTERM_PROP_CURSORVISIBLE);
            __debug_stringify_switch_case(VTERM_PROP_CURSORBLINK);
            __debug_stringify_switch_case(VTERM_PROP_ALTSCREEN);
            __debug_stringify_switch_case(VTERM_PROP_REVERSE);
                __debug_stringify_switch_case_end_bool(val->boolean);
            __debug_stringify_switch_case(VTERM_PROP_TITLE);
            __debug_stringify_switch_case(VTERM_PROP_ICONNAME);
                __debug_stringify_switch_case_end_string(val->string);
            __debug_stringify_switch_case(VTERM_PROP_CURSORSHAPE);
            __debug_stringify_switch_case(VTERM_PROP_MOUSE);
                __debug_stringify_switch_case_end_number(val->number);
        __debug_stringify_switch_end(prop);

        __debug_log(std::string("unimplemented handler called: ")
                  + __debug_stringify_get_string(handlerSetTermProp)
                   );
        return 0;
    }

    int Window::handlerBell()
    {
        beep();
        return 0;
    }

    int Window::handlerResize(int rows, int cols)
    {
        __debug_log("unimplemented handler called");
        return 0;
    }

    int Window::handlerPushLine(int cols, const VTermScreenCell *cells)
    {
        __debug_log("(unimplemented) push line with " + std::to_string(cols) + " columns");
        return 0;
    }

    int Window::handlerPopLine(int cols, VTermScreenCell *cells)
    {
        __debug_log("unimplemented handler called");
        return 0;
    }

    attr_t Window::extractAttributesFromVTermCell(VTermScreenCell vTermCell)
    {
        attr_t result = A_NORMAL;
        //__debug_log("unimplemented method called");
        return result;
    }

    short Window::extractColorFromVTermCell(VTermScreenCell vTermCell)
    {
        //__debug_log("unimplemented method called");
        return 0;
    }

    void Window::copyPtyCellToNCursesWindow(int x, int y)
    {
        VTermPos cellPosition = {y, x};
        VTermScreenCell vTermCell;
        cchar_t converted;
        attr_t formatting;
        short colorPair;
        wchar_t character;

        vterm_screen_get_cell(pseudoTerminalScreen, cellPosition, &vTermCell);
        formatting = extractAttributesFromVTermCell(vTermCell);
        colorPair = extractColorFromVTermCell(vTermCell);

        if(vTermCell.chars[0] == 0)
            character = ' ';
        else
            character = *vTermCell.chars;

        {
            lock_guard nCursesLock(*writeToNCursesMutex);
            setcchar(&converted, &character, formatting, colorPair, NULL);
            move(cellPosition.row, cellPosition.col);
            chgat(1, formatting, colorPair, NULL);
            add_wch(&converted);
        }
    }

    int Window::add_wch(const cchar_t *character)
    {
        return ::wadd_wch(w, character);
    }

    int Window::get_wch(wint_t *character)
    {
        return ::wget_wch(w, character);
    }

    int Window::refresh()
    {
        lock_guard nCursesLock(*writeToNCursesMutex);
        move(cursorY, cursorX);
        return NCursesWindow::refresh();
    }

    /// @todo potential racing condition where drawing into terminal while
    ///       resizing?
    int Window::wresize(int rows, int cols)
    {
        lock_guard nCursesLock(*writeToNCursesMutex);
        lock_guard writeLock(writeToPseudoTerminalMutex);
        winsize windowSize =
        {
            .ws_row = narrow<unsigned short>(rows)
          , .ws_col = narrow<unsigned short>(cols)
        };
        ioctl(fdPtyHost, TIOCSWINSZ, &windowSize);
      	vterm_set_size(pseudoTerminal, rows, cols);

        return  NCursesWindow::wresize(rows, cols);
    }

    int Window::staticHandlerDamage(VTermRect rect, void *user)
    {
        Window *instance = static_cast<Window *>(user);
        return instance->handlerDamage(rect);
    }

    int Window::staticHandlerMoveRect(VTermRect dest, VTermRect src, void *user)
    {
        Window *instance = static_cast<Window *>(user);
        return instance->handlerMoveRect(dest, src);
    }

    int Window::staticHandlerMoveCursor(VTermPos pos, VTermPos oldpos, int visible, void *user)
    {
        Window *instance = static_cast<Window *>(user);
        return instance->handlerMoveCursor(pos, oldpos, visible);
    }

    int Window::staticHandlerSetTermProp(VTermProp prop, VTermValue *val, void *user)
    {
        Window *instance = static_cast<Window *>(user);
        return instance->handlerSetTermProp(prop, val);
    }

    int Window::staticHandlerBell(void *user)
    {
        Window *instance = static_cast<Window *>(user);
        return instance->handlerBell();
    }

    int Window::staticHandlerResize(int rows, int cols, void *user)
    {
        Window *instance = static_cast<Window *>(user);
        return instance->handlerResize(rows, cols);
    }

    int Window::staticHandlerPushLine(int cols, const VTermScreenCell *cells, void *user)
    {
        Window *instance = static_cast<Window *>(user);
        return instance->handlerPushLine(cols, cells);
    }

    int Window::staticHandlerPopLine(int cols, VTermScreenCell *cells, void *user)
    {
        Window *instance = static_cast<Window *>(user);
        return instance->handlerPopLine(cols, cells);
    }

    void Window::staticHandlerOutput(const char *s, size_t len, void *user)
    {
        Window *instance = static_cast<Window *>(user);
        __debug_log("output handler writing to client: '" + __debug_make_bytes_printable(std::string(s, len)) + "'");
        instance->writeToClient(s, len);
   }
}