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