vt_helper.h

Go to the documentation of this file.

#ifndef OOKII_VT_HELPER_H_
#define OOKII_VT_HELPER_H_
 
#pragma once
 
#include "console_helper.h"
#include "scope_helper.h"
#include <string_view>
#include <locale>
 
namespace ookii::vt
{
    namespace details
    {
        template<typename CharType, typename Traits>
        struct vt_helper
        {
            static constexpr CharType c_escape = '\x1b';
 
            static CharType *find_csi_end(CharType *begin, CharType *end, const std::locale &loc)
            {
                for (auto current = begin; current < end; ++current)
                {
                    auto ch = *current;
                    if (!std::isdigit(ch, loc) && !Traits::eq(ch, ';') && !Traits::eq(ch, ' '))
                    {
                        return current;
                    }
                }
 
                return nullptr;
            }
 
            static CharType *find_osc_end(CharType *begin, CharType *end)
            {
                bool has_escape = false;
                for (auto current = begin; current < end; ++current)
                {
                    auto ch = *current;
                    if (Traits::eq(ch, 0x7))
                    {
                        return current;
                    }
 
                    if (has_escape)
                    {
                        if (Traits::eq(ch, '\\'))
                        {
                            return current;
                        }
 
                        // Invalid next character, just pretend the escape character was the end.
                        return current - 1;
                    }
 
                    if (Traits::eq(ch, c_escape))
                    {
                        has_escape = true;
                    }
                }
 
                return nullptr;
            }
 
            static CharType *find_sequence_end(CharType *begin, CharType *end, const std::locale &loc)
            {
                if (begin == end)
                {
                    return begin;
                }
 
                switch (*begin)
                {
                case '[':
                    return find_csi_end(begin + 1, end, loc);
 
                case ']':
                    return find_osc_end(begin + 1, end);
 
                case '(':
                    ++begin;
                    if (begin != end)
                    {
                        return begin;
                    }
                    else
                    {
                        return nullptr;
                    }
 
                default:
                    return begin;
                }
            }
        };
    }
 
    namespace text_format
    {
        
        constexpr const char *default_format = "\x1b[0m";
        
        constexpr const char *bold_bright = "\x1b[1m";
        
        constexpr const char *no_bold_bright = "\x1b[22m";
        
        constexpr const char *underline = "\x1b[4m";
        
        constexpr const char *no_underline = "\x1b[24m";
        
        constexpr const char *negative = "\x1b[7m";
        
        constexpr const char *positive = "\x1b[27m";
        
        constexpr const char *foreground_black = "\x1b[30m";
        
        constexpr const char *foreground_red = "\x1b[31m";
        
        constexpr const char *foreground_green = "\x1b[32m";
        
        constexpr const char *foreground_yellow = "\x1b[33m";
        
        constexpr const char *foreground_blue = "\x1b[34m";
        
        constexpr const char *foreground_magenta = "\x1b[35m";
        
        constexpr const char *foreground_cyan = "\x1b[36m";
        
        constexpr const char *foreground_white = "\x1b[37m";
        
        constexpr const char *foreground_default = "\x1b[39m";
        
        constexpr const char *background_black = "\x1b[40m";
        
        constexpr const char *background_red = "\x1b[41m";
        
        constexpr const char *background_green = "\x1b[42m";
        
        constexpr const char *background_yellow = "\x1b[43m";
        
        constexpr const char *background_blue = "\x1b[44m";
        
        constexpr const char *background_magenta = "\x1b[45m";
        
        constexpr const char *background_cyan = "\x1b[46m";
        
        constexpr const char *background_white = "\x1b[47m";
        
        constexpr const char *background_default = "\x1b[49m";
        
        constexpr const char *bright_foreground_black = "\x1b[90m";
        
        constexpr const char *bright_foreground_red = "\x1b[91m";
        
        constexpr const char *bright_foreground_green = "\x1b[92m";
        
        constexpr const char *bright_foreground_yellow = "\x1b[93m";
        
        constexpr const char *bright_foreground_blue = "\x1b[94m";
        
        constexpr const char *bright_foreground_magenta = "\x1b[95m";
        
        constexpr const char *bright_foreground_cyan = "\x1b[96m";
        
        constexpr const char *bright_foreground_white = "\x1b[97m";
        
        constexpr const char *bright_background_black = "\x1b[100m";
        
        constexpr const char *bright_background_red = "\x1b[101m";
        
        constexpr const char *bright_background_green = "\x1b[102m";
        
        constexpr const char *bright_background_yellow = "\x1b[103m";
        
        constexpr const char *bright_background_blue = "\x1b[104m";
        
        constexpr const char *bright_background_magenta = "\x1b[105m";
        
        constexpr const char *bright_background_cyan = "\x1b[106m";
        
        constexpr const char *bright_background_white = "\x1b[107m";
 
        
        template<typename CharType = ookii::details::default_char_type>
        inline std::basic_string<CharType> get_extended_color(int red, int green, int blue, bool foreground = true)
        {
            static constexpr auto format_string = literal_cast<CharType>("\x1b[{};2;{};{};{}m");
            return OOKII_FMT_NS format(format_string.data(), (foreground ? 38 : 48), red, green, blue);
        }
    }
 
    class [[nodiscard]] virtual_terminal_support
    {
    public:
        virtual_terminal_support() = default;
 
        virtual_terminal_support(const virtual_terminal_support &) = delete;
        virtual_terminal_support &operator=(const virtual_terminal_support &) = delete;
 
        virtual_terminal_support(virtual_terminal_support &&) = default;
        virtual_terminal_support &operator=(virtual_terminal_support &&) = default;
 
        ~virtual_terminal_support() noexcept
        {
            reset();
        }
 
        static virtual_terminal_support enable(standard_stream stream)
        {
            if ((stream != standard_stream::output && stream != standard_stream::error) ||
                !ookii::details::is_console(stream))
            {
                return {};
            }
 
            bool has_term = false;
#ifdef _WIN32
            char term[10]{};
            size_t required;
            // If the buffer is too small, it can't be equal to "dumb", so we don't care.
            getenv_s(&required, term, "TERM");
            has_term = required > 0;
#else
            auto term = getenv("TERM");
            has_term = term != nullptr;
#endif
 
            // If "TERM=dumb" is set, assume no support.
            if (has_term && strcmp(term, "dumb") == 0)
            {
                return {};
            }
 
#ifndef _WIN32
            // Except on Windows, TERM not set is assumed to mean no support.
            if (!has_term)
            {
                return {};
            }
#endif
 
            return {stream, set_console_vt_support(stream, true)};
        }
 
        static virtual_terminal_support enable_color(standard_stream stream)
        {
            bool has_env;
#ifdef _WIN32
            size_t required;
            getenv_s(&required, nullptr, 0, "NO_COLOR");
            has_env = required > 0;
#else
            has_env = getenv("NO_COLOR") != nullptr;
#endif
            if (has_env)
            {
                return {stream, vt_result::failed};
            }
 
            return enable(stream);
        }
 
        bool is_supported() const noexcept
        {
            return _result != vt_result::failed;
        }
 
        operator bool() const noexcept
        {
            return is_supported();
        }
 
        void reset() noexcept
        {
            if (_result == vt_result::success)
            {
                set_console_vt_support(_stream, false);
 
                // Set to failed to reset() again won't do anything and is_supported will return
                // false.
                _result = vt_result::failed;
            }
        }
 
    private:
        virtual_terminal_support(standard_stream stream, vt_result result) noexcept
            : _stream{stream},
              _result{result}
        {
        }
 
        standard_stream _stream;
        vt_result _result;
    };
}
 
#endif