terminal.h

Go to the documentation of this file.

// Encapsulates terminal control (colors, cursor, ...)
// Author: Max Schwarz <max.schwarz@uni-bonn.de>
 
#ifndef TERMINAL_H
#define TERMINAL_H
 
#include <stdint.h>
#include <chrono>
#include <string>
#include <map>
#include <vector>
 
namespace rosmon
{
 
class Terminal
{
public:
        enum SimpleColor
        {
                Black,
                Red,
                Green,
                Yellow,
                Blue,
                Magenta,
                Cyan,
                White,
                IntenseBlack,
                IntenseRed,
                IntenseGreen,
                IntenseYellow,
                IntenseBlue,
                IntenseMagenta,
                IntenseCyan,
                IntenseWhite,
 
                Grayscale = 0xe8
        };
 
        class Color
        {
        public:
                Color()
                {}
 
                void foreground() { fputs(m_fgString.c_str(), stdout); }
                void background() { fputs(m_bgString.c_str(), stdout); }
 
                const std::string& foregroundCode() const { return m_fgString; }
                const std::string& backgroundCode() const { return m_bgString; }
        private:
                friend class Terminal;
 
                Color(const std::string& fg, const std::string& bg)
                 : m_fgString{fg}, m_bgString{bg}
                {}
 
                std::string m_fgString;
                std::string m_bgString;
        };
 
        class Style
        {
        public:
                Style()
                {}
 
                Style(Color fg, Color bg)
                 : m_fg(std::move(fg)), m_bg(std::move(bg))
                {}
 
                void use()
                {
                        m_fg.foreground();
                        m_bg.background();
                }
        private:
                Color m_fg;
                Color m_bg;
        };
 
        class Parser
        {
        public:
                Parser() {}
                Parser(Terminal* terminal);
 
                bool parse(char c);
 
                void parse(const std::string& str);
 
                void apply();
 
                std::vector<std::string> wrap(const std::string& str, unsigned int columns);
        private:
                void parseSetAttributes(const std::string& str);
 
                enum State
                {
                        STATE_ESCAPE,
                        STATE_TYPE,
                        STATE_CSI
                };
 
                Terminal* m_term = nullptr;
 
                State m_state = STATE_ESCAPE;
                std::string m_buf;
 
                Color m_fgColor;
                Color m_bgColor;
                bool m_bold = false;
        };
 
        Terminal();
 
        Color color(SimpleColor code);
        Color color(uint32_t truecolor, SimpleColor fallback);
 
        void setForegroundColor(uint32_t color);
 
        void setBackgroundColor(uint32_t color);
 
        void setCursorInvisible();
 
        void setCursorVisible();
 
        void setEcho(bool on);
 
        void setBold(bool on);
 
 
        void setSimpleBackground(SimpleColor color);
        void setSimpleForeground(SimpleColor color);
        void setSimplePair(SimpleColor fg, SimpleColor bg);
 
        void setStandardColors();
 
        std::string standardColorCode();
 
        void clearToEndOfLine();
 
        void moveCursorUp(int numLines);
 
        void moveCursorToStartOfLine();
 
        bool getSize(int* columns, int* rows);
 
        bool has256Colors() const;
 
        bool interactive() const
        { return m_valid; }
 
        void setWindowTitle(const std::string& title);
        void clearWindowTitle(const std::string& backup);
 
 
        enum SpecialKey
        {
                SK_F1 = 0x100, SK_F2, SK_F3, SK_F4,
                SK_F5, SK_F6, SK_F7, SK_F8,
                SK_F9, SK_F10, SK_F11, SK_F12,
 
                SK_Backspace,
 
                SK_Up, SK_Down, SK_Left, SK_Right
        };
 
        int readKey();
        int readLeftover();
 
        void setLineWrap(bool on);
 
private:
        bool m_valid;
        bool m_256colors;
        bool m_truecolor;
 
        std::string m_bgColorStr;
        std::string m_fgColorStr;
        std::string m_opStr;
        std::string m_sgr0Str;
        std::string m_elStr;
        std::string m_upStr;
        std::string m_boldStr;
        std::string m_lineWrapOffStr;
        std::string m_lineWrapOnStr;
 
        std::map<std::string, SpecialKey> m_specialKeys;
 
        std::string m_currentEscapeStr;
        std::chrono::steady_clock::time_point m_escapeStartTime;
        bool m_currentEscapeAborted = false;
        unsigned int m_currentEscapeAbortIdx = 0;
};
 
}
 
#endif