3#include "terminalpp/ansi/charset.hpp" 
    4#include "terminalpp/ansi/control_characters.hpp" 
    5#include "terminalpp/ansi/csi.hpp" 
    6#include "terminalpp/ansi/dec_private_mode.hpp" 
    7#include "terminalpp/ansi/graphics.hpp" 
    8#include "terminalpp/ansi/protocol.hpp" 
    9#include "terminalpp/attribute.hpp" 
   10#include "terminalpp/behaviour.hpp" 
   11#include "terminalpp/character_set.hpp" 
   12#include "terminalpp/colour.hpp" 
   13#include "terminalpp/core.hpp" 
   14#include "terminalpp/detail/overloaded.hpp" 
   15#include "terminalpp/effect.hpp" 
   16#include "terminalpp/element.hpp" 
   23namespace terminalpp::detail {
 
   28template <
class WriteContinuation>
 
   30    behaviour 
const & , WriteContinuation &&wc)
 
   32    wc({std::cbegin(ansi::control7::csi), std::cend(ansi::control7::csi)});
 
   38template <
class WriteContinuation>
 
   40    behaviour 
const & , WriteContinuation &&wc)
 
   42    wc({std::cbegin(ansi::control7::osc), std::cend(ansi::control7::osc)});
 
   48template <
class WriteContinuation>
 
   50    behaviour 
const & , WriteContinuation &&wc)
 
   52    wc({std::cbegin(ansi::control7::st), std::cend(ansi::control7::st)});
 
   58template <
class WriteContinuation>
 
   60    behaviour 
const &terminal_behaviour, WriteContinuation &&wc)
 
   62    csi(terminal_behaviour, wc);
 
   64    std::initializer_list<byte> 
const dec_pm{
 
   65        terminalpp::ansi::dec_private_mode[0]};
 
   74template <
class WriteContinuation>
 
   75constexpr void default_attribute(
 
   76    behaviour 
const &terminal_behaviour, WriteContinuation &&wc)
 
   78    std::initializer_list<byte> 
const default_attribute_string = {
 
   79        '0'_tb, terminalpp::ansi::csi::select_graphics_rendition};
 
   81    csi(terminal_behaviour, wc);
 
   82    wc(default_attribute_string);
 
   88template <
class WriteContinuation>
 
   89constexpr void designate_g0_charset(
 
   90    character_set 
const &set,
 
   92    WriteContinuation &&wc)
 
   94    bytes 
const select_g0_charset = {
 
   95        std::cbegin(ansi::set_charset_g0), std::cend(ansi::set_charset_g0)};
 
   97    wc(select_g0_charset);
 
   98    wc(encode_character_set(set));
 
  104template <
class WriteContinuation>
 
  105constexpr void select_utf8_charset(WriteContinuation &&wc)
 
  107    bytes 
const select_utf8_charset_command = {
 
  108        std::cbegin(ansi::select_utf8_character_set),
 
  109        std::cend(ansi::select_utf8_character_set)};
 
  111    wc(select_utf8_charset_command);
 
  117template <
class WriteContinuation>
 
  118constexpr void select_default_charset(WriteContinuation &&wc)
 
  120    bytes 
const select_default_charset_command = {
 
  121        std::cbegin(ansi::select_default_character_set),
 
  122        std::cend(ansi::select_default_character_set)};
 
  124    wc(select_default_charset_command);
 
  131template <
class WriteContinuation>
 
  132constexpr void change_charset(
 
  133    character_set 
const &source,
 
  134    character_set 
const &dest,
 
  135    behaviour 
const &terminal_behaviour,
 
  136    WriteContinuation &&wc)
 
  140        if (dest == charset::utf8)
 
  142            if (!terminal_behaviour.unicode_in_all_charsets)
 
  145                    source, charset::us_ascii, terminal_behaviour, wc);
 
  148            select_utf8_charset(wc);
 
  152            if (source == charset::utf8)
 
  154                select_default_charset(wc);
 
  157            designate_g0_charset(dest, terminal_behaviour, wc);
 
  165template <
class EffectType, 
class WriteContinuation>
 
  166constexpr void change_effect(
 
  167    effect<EffectType> 
const &source,
 
  168    effect<EffectType> 
const &dest,
 
  169    bool &change_appended,
 
  170    WriteContinuation &&wc)
 
  172    std::initializer_list<byte> 
const separator = {ansi::ps};
 
  176        if constexpr (effect_has_normal<EffectType>::value)
 
  178            if (source.value_ != EffectType::normal
 
  179                && dest.value_ != EffectType::normal)
 
  181                if (std::exchange(change_appended, 
true))
 
  186                wc(to_bytes(std::format(
"{}", 
int(EffectType::normal))));
 
  190        if (std::exchange(change_appended, 
true))
 
  195        wc(to_bytes(std::format(
"{}", 
int(dest.value_))));
 
  202template <
class WriteContinuation>
 
  203constexpr void change_foreground_colour(
 
  204    colour 
const &source,
 
  206    bool &change_appended,
 
  207    WriteContinuation &&wc)
 
  211        if (std::exchange(change_appended, 
true))
 
  213            std::initializer_list<byte> 
const separator = {ansi::ps};
 
  219                [&wc](low_colour 
const &col) {
 
  220                    wc(to_bytes(std::format(
 
  222                        static_cast<int>(col.value_)
 
  223                            + ansi::graphics::foreground_colour_base)));
 
  225                [&wc](high_colour 
const &col) {
 
  227                        std::format(
"38;5;{}", 
static_cast<int>(col.value_))));
 
  229                [&wc](greyscale_colour 
const &col) {
 
  231                        std::format(
"38;5;{}", 
static_cast<int>(col.shade_))));
 
  233                [&wc](true_colour 
const &col) {
 
  234                    wc(to_bytes(std::format(
 
  236                        static_cast<int>(col.red_),
 
  237                        static_cast<int>(col.green_),
 
  238                        static_cast<int>(col.blue_))));
 
  247template <
class WriteContinuation>
 
  248constexpr void change_background_colour(
 
  249    colour 
const &source,
 
  251    bool &change_appended,
 
  252    WriteContinuation &&wc)
 
  256        if (std::exchange(change_appended, 
true))
 
  258            std::initializer_list<byte> 
const separator = {ansi::ps};
 
  264                [&wc](low_colour 
const &col) {
 
  265                    wc(to_bytes(std::format(
 
  267                        static_cast<int>(col.value_)
 
  268                            + ansi::graphics::background_colour_base)));
 
  270                [&wc](high_colour 
const &col) {
 
  272                        std::format(
"48;5;{}", 
static_cast<int>(col.value_))));
 
  274                [&wc](greyscale_colour 
const &col) {
 
  276                        std::format(
"48;5;{}", 
static_cast<int>(col.shade_))));
 
  278                [&wc](true_colour 
const &col) {
 
  279                    wc(to_bytes(std::format(
 
  281                        static_cast<int>(col.red_),
 
  282                        static_cast<int>(col.green_),
 
  283                        static_cast<int>(col.blue_))));
 
  292template <
class WriteContinuation>
 
  293constexpr void change_attribute(
 
  294    attribute 
const &source,
 
  295    attribute 
const &dest,
 
  296    behaviour 
const &terminal_behaviour,
 
  297    WriteContinuation &&wc)
 
  306        default_attribute(terminal_behaviour, wc);
 
  310    csi(terminal_behaviour, wc);
 
  312    bool change_appended = 
false;
 
  313    change_effect(source.intensity_, dest.intensity_, change_appended, wc);
 
  314    change_effect(source.polarity_, dest.polarity_, change_appended, wc);
 
  315    change_effect(source.underlining_, dest.underlining_, change_appended, wc);
 
  316    change_foreground_colour(
 
  317        source.foreground_colour_,
 
  318        dest.foreground_colour_,
 
  321    change_background_colour(
 
  322        source.background_colour_,
 
  323        dest.background_colour_,
 
  327    std::initializer_list<byte> 
const sgr_trailer = {
 
  328        ansi::csi::select_graphics_rendition};
 
  336template <
class WriteContinuation>
 
  337constexpr void change_to_default_attribute(
 
  338    std::optional<element> &last_element,
 
  339    behaviour 
const &beh,
 
  340    WriteContinuation &&wc)
 
  344        detail::change_attribute(last_element->attribute_, {}, beh, wc);
 
  345        last_element->attribute_ = {};
 
A structure that carries around the presentation attributes of an ANSI element.
Definition attribute.hpp:17