palette.h

Go to the documentation of this file.

#pragma once
 
#include "di/types/byte.h"
#include "di/util/to_underlying.h"
#include "di/vocab/array/array.h"
#include "ttx/terminal/color.h"
 
namespace ttx::terminal {
enum class ThemeMode {
    Light,
    Dark,
};
 
constexpr static auto tag_invoke(di::Tag<di::reflect>, di::InPlaceType<ThemeMode>) {
    using enum ThemeMode;
    return di::make_enumerators<"ThemeMode">(di::enumerator<"light", Light>, di::enumerator<"dark", Dark>);
}

enum class PaletteIndex : u16 {
    StaticBegin = 0,
    StaticEnd = 255,
 
    SpecialBegin,
    SpecialBold = SpecialBegin,
    SpecialUnderline,
    SpecialBlink,
    SpecialReverse,
    SpecialItalic,
    SpecialEnd = SpecialItalic,
 
    Foreground,
    Background,
    Cursor,
    CursorText,
    SelectionBackground,
    SelectionForeground,
 
    Count,
    Unknown = Count,
};
 
constexpr static auto tag_invoke(di::Tag<di::reflect>, di::InPlaceType<PaletteIndex>) {
    using enum PaletteIndex;
    return di::make_enumerators<"PaletteIndex">(
        di::enumerator<"SpecialBold", SpecialBold>, di::enumerator<"SpecialUnderline", SpecialUnderline>,
        di::enumerator<"SpecialBlink", SpecialBlink>, di::enumerator<"SpecialReverse", SpecialReverse>,
        di::enumerator<"SpecialItalic", SpecialItalic>, di::enumerator<"Foreground", Foreground>,
        di::enumerator<"Background", Background>, di::enumerator<"Cursor", Cursor>,
        di::enumerator<"CursorText", CursorText>, di::enumerator<"SelectionBackground", SelectionBackground>,
        di::enumerator<"SelectionForeground", SelectionForeground>, di::enumerator<"Unknown", Unknown>);
}

class Palette {
public:
    static auto default_global() -> Palette {
        auto result = Palette();
        result.set(terminal::PaletteIndex::SelectionForeground, terminal::Color(terminal::Color::Type::Dynamic));
        result.set(terminal::PaletteIndex::SelectionBackground, terminal::Color(terminal::Color::Type::Dynamic));
        return result;
    }
 
    auto operator==(Palette const&) const -> bool = default;
 
    auto get(PaletteIndex index) const -> Color { return m_colors[di::to_underlying(index)]; }
    void set(PaletteIndex index, Color value) {
        if (value.is_dynamic() && !supports_dynamic(index)) {
            return;
        }
        if (!value.is_default()) {
            m_modified = true;
        }
        m_colors[di::to_underlying(index)] = value;
    }
 
    auto resolve(Color color) const -> Color {
        if (color.is_palette()) {
            return get(PaletteIndex(color.r)).value_or(color);
        }
        return color;
    }
 
    auto resolve_foreground(Color color) const -> Color {
        color = resolve(color);
        if (color.is_default()) {
            color = get(PaletteIndex::Foreground);
        }
        return color;
    }
 
    auto resolve_background(Color color) const -> Color {
        color = resolve(color);
        if (color.is_default()) {
            color = get(PaletteIndex::Background);
        }
        return color;
    }
 
    static auto supports_dynamic(PaletteIndex index) -> bool {
        switch (index) {
            case PaletteIndex::Cursor:
            case PaletteIndex::CursorText:
            case PaletteIndex::SelectionForeground:
            case PaletteIndex::SelectionBackground:
                return true;
            default:
                return false;
        }
    }
 
    void reset() {
        m_colors = {};
        m_modified = false;
    }
 
    auto modified() const -> bool { return m_modified; }
    void maybe_clear_modifed() { m_modified = di::any_of(m_colors, di::not_fn(&Color::is_default)); }
 
    auto theme_mode() const -> ThemeMode {
        return resolve_background(Color()).brightness() >= 0.5 ? ThemeMode::Light : ThemeMode::Dark;
    }
 
    auto to_string() const -> di::String;
 
private:
    di::Array<Color, di::to_underlying(PaletteIndex::Count)> m_colors;
    bool m_modified { false };
};
}