RADTerminal.h

Go to the documentation of this file.

#ifndef RADTERMINAL_H
#define RADTERMINAL_H
 
#pragma once
 
#include <RADCore/RADLicenseGate.h>
 
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <thread>
#include <vector>
 
namespace RADCore {
    class RADPtyProcess;
}
 
namespace RADUi {
 
    struct TerminalColor {
        uint8_t r = 230;
        uint8_t g = 237;
        uint8_t b = 242;
    };
 
    struct TerminalLine {
        std::string text;
        TerminalColor foreground{230, 237, 242};
        TerminalColor background{16, 20, 24};
    };
 
    struct TerminalCursor {
        size_t row = 0;
        size_t column = 0;
        bool visible = true;
    };
 
    class TerminalBuffer {
    public:
        void append(std::string_view bytes);
        std::vector<TerminalLine> snapshot() const;
        std::string plainText() const;
        bool isAlternateScreen() const;
        TerminalCursor cursor() const;
        void setScreenSize(size_t rows, size_t columns);
        void clear();
 
    private:
        enum class State {
            Normal,
            Escape,
            Charset,
            Csi,
            Osc
        };
 
        void consume(unsigned char byte);
        void consumeNormal(unsigned char byte);
        void consumeEscape(unsigned char byte);
        void consumeCsi(unsigned char byte);
        std::vector<int> csiParams(int defaultValue = 0) const;
        bool csiPrivateMode() const;
        int csiParam(size_t index, int defaultValue = 0) const;
        void applySgr();
        void putChar(char ch);
        void newline();
        void carriageReturn();
        void backspace();
        void cursorUp(size_t count);
        void cursorDown(size_t count);
        void cursorForward(size_t count);
        void cursorBack(size_t count);
        void setCursor(size_t row, size_t column);
        void eraseInDisplay(int mode);
        void eraseInLine(int mode);
        void setScrollRegion(size_t top, size_t bottom);
        void resetScrollRegion();
        void scrollRegionUp(size_t top, size_t bottom, size_t count = 1);
        void scrollRegionDown(size_t top, size_t bottom, size_t count = 1);
        void insertLines(size_t count);
        void deleteLines(size_t count);
        void insertChars(size_t count);
        void deleteChars(size_t count);
        void eraseChars(size_t count);
        void setPrivateMode(int mode, bool enabled);
        void enterAlternateScreen();
        void leaveAlternateScreen();
        void ensureCursorLine();
        void trim();
 
        mutable std::mutex mutex_;
        std::vector<TerminalLine> lines_{TerminalLine{}};
        std::vector<TerminalLine> savedLines_;
        TerminalColor currentForeground_{230, 237, 242};
        TerminalColor currentBackground_{16, 20, 24};
        bool bold_ = false;
        bool reverse_ = false;
        bool alternateScreen_ = false;
        bool cursorVisible_ = true;
        size_t cursorColumn_ = 0;
        size_t cursorRow_ = 0;
        size_t savedCursorColumn_ = 0;
        size_t savedCursorRow_ = 0;
        size_t screenRows_ = 30;
        size_t screenColumns_ = 120;
        size_t scrollTop_ = 0;
        size_t scrollBottom_ = 29;
        State state_ = State::Normal;
        std::string csi_;
    };
 
    class PtyTerminalSession {
    public:
        explicit PtyTerminalSession(std::function<void()> changed = {});
        ~PtyTerminalSession();
 
        PtyTerminalSession(const PtyTerminalSession&) = delete;
        PtyTerminalSession& operator=(const PtyTerminalSession&) = delete;
 
        bool start(const std::string& shell = {}, uint16_t rows = 30, uint16_t columns = 120);
        void stop();
        bool isRunning() const;
        bool resize(uint16_t rows, uint16_t columns);
        bool isAlternateScreen() const;
        TerminalCursor cursor() const;
 
        void writeInput(std::string_view input);
        std::vector<TerminalLine> snapshot() const;
        std::string plainText() const;
 
    private:
        void readLoop();
 
        std::atomic<bool> running_{false};
        std::thread reader_;
        TerminalBuffer buffer_;
        std::function<void()> changed_;
        std::unique_ptr<RADCore::RADPtyProcess> process_;
    };
 
    std::string terminalInputSequence(std::string_view text, bool alt = false, bool control = false,
        bool shift = false, bool meta = false);
    std::string terminalSpecialKeySequence(std::string_view key, bool alt = false, bool control = false,
        bool shift = false, bool meta = false);
 
} // namespace RADUi
 
#endif