Rose/Color.h

#ifndef ROSE_Color_H
#define ROSE_Color_H

#include <algorithm>
#include <Sawyer/CommandLine.h>
#include <Sawyer/Map.h>
#include <string>
#include <rosedll.h>

// Name space pollution cleanup
#ifdef _MSC_VER
  #undef RGB
#endif

namespace Rose {

namespace Color {

namespace Enabled {                                     // done this way because ROSE must use only C++03
enum Flag {
    OFF,                                                
    ON,                                                 
    AUTO                                                
};
} // namespace

namespace Theme {                                       // done this way because ROSE must use only C++03
enum Flag {
    DARK_ON_LIGHT,                                      
    LIGHT_ON_DARK                                       
};
} // namespace

struct Colorization {
    Sawyer::Optional<Enabled::Flag> enabled;            
    Sawyer::Optional<Theme::Flag> theme;                
    bool isEnabled() const;

    Colorization merge(const Colorization&) const;
};

namespace Layer {
enum Flag {
    NONE,                                               
    FOREGROUND,                                         
    BACKGROUND                                          
};
} // namespace

class ColorizationParser: public Sawyer::CommandLine::ValueParser {
protected:
    ColorizationParser() {}
    ColorizationParser(const Sawyer::CommandLine::ValueSaver::Ptr &valueSaver)
        : Sawyer::CommandLine::ValueParser(valueSaver) {}

public:
    typedef Sawyer::SharedPointer<ColorizationParser> Ptr;

    static Ptr instance() {
        return Ptr(new ColorizationParser);
    }

    static Ptr instance(const Sawyer::CommandLine::ValueSaver::Ptr &valueSaver) {
        return Ptr(new ColorizationParser(valueSaver));
    }

    static std::string docString();

    static Colorization parse(const char *input, const char **rest);

    static Colorization parse(const std::string &input);

private:
    virtual Sawyer::CommandLine::ParsedValue
    operator()(const char *input, const char **rest, const Sawyer::CommandLine::Location &loc) /*override*/;
};

ColorizationParser::Ptr colorizationParser(Colorization &storage);
ColorizationParser::Ptr colorizationParser();

// Used internally to merge colorization command-line switch arguments.
class ColorizationMerge: public Sawyer::CommandLine::ValueAugmenter {
public:
    typedef Sawyer::SharedPointer<ColorizationMerge> Ptr;

    static Ptr instance() {
        return Ptr(new ColorizationMerge);
    }

    virtual Sawyer::CommandLine::ParsedValues
    operator()(const Sawyer::CommandLine::ParsedValues &prev, const Sawyer::CommandLine::ParsedValues &cur) /*OVERRIDE*/;
};

typedef double Component;

template<typename T>
T clip(T c) {
    return std::max(T(0), std::min(c, T(1)));
}

class HSV;

class ROSE_UTIL_API RGB {
    Component r_, g_, b_, a_;

public:
    RGB(): r_(1.0), g_(0.0), b_(0.0), a_(1.0) {}        // bright red

    RGB(Component r, Component g, Component b, Component a=1.0): r_(clip(r)), g_(clip(g)), b_(clip(b)), a_(clip(a)) {}

    RGB(const HSV&);                                    // implicit

    Component r() const { return r_; }
    Component g() const { return g_; }
    Component b() const { return b_; }
    Component a() const { return a_; }
    Component red() const { return r_; }
    Component green() const { return g_; }
    Component blue() const { return b_; }
    Component alpha() const { return a_; }
    std::string toHtml() const;

    std::string toAnsi(Layer::Flag) const;
};

class ROSE_UTIL_API HSV {
    Component h_, s_, v_, a_;
public:

    HSV(): h_(0.0), s_(1.0), v_(0.5), a_(1.0) {}        // bright red

    HSV(Component h, Component s, Component v, Component a=1.0): h_(clip(h)), s_(clip(s)), v_(clip(v)), a_(clip(a)) {}

    HSV(const RGB&);                                    // implicit

    Component h() const { return h_; }
    Component s() const { return s_; }
    Component v() const { return v_; }
    Component a() const { return a_; }
    Component hue() const { return h_; }
    Component saturation() const { return s_; }
    Component value() const { return v_; }
    Component alpha() const { return a_; }
    std::string toHtml() const;

    std::string toAnsi(Layer::Flag) const;
};

//                                      Gradients

class ROSE_UTIL_API Gradient {
public:
    typedef Sawyer::Container::Map<double, HSV> ColorMap;

private:
    ColorMap colors_;
    HSV nanColor_;

public:
    Gradient() {}

    Gradient(const RGB &color) { colors_.insert(0.0, color); } // implicit
    Gradient(const HSV &color) { colors_.insert(0.0, color); } // implicit
    Gradient(const HSV &color1, const HSV &color2) {
        colors_.insert(0.0, color1);
        colors_.insert(1.0, color2);
    }
    
    void clear() { colors_.clear(); }

    const HSV& nanColor() const { return nanColor_; }
    void nanColor(const HSV &c) { nanColor_ = c; }
    void insert(double where, const HSV &color) { colors_.insert(where, color); }

    HSV interpolate(double) const;
    HSV operator()(double x) const { return interpolate(x); }
    const ColorMap& colorMap() const { return colors_; }
    ColorMap& colorMap() { return colors_; }
};

//                                      Operations

HSV invertBrightness(const HSV&);

ROSE_UTIL_API HSV darken(const HSV&, double amount);

ROSE_UTIL_API HSV lighten(const HSV&, double amount);

ROSE_UTIL_API HSV fade(const HSV&, double amount);

HSV terminal(const HSV &color, const Colorization&);

ROSE_UTIL_API std::string toHtml(const RGB&);

ROSE_UTIL_API std::string toAnsi(const RGB&, Layer::Flag layer);

// printing
std::ostream& operator<<(std::ostream&, const RGB&);
std::ostream& operator<<(std::ostream&, const HSV&);
std::ostream& operator<<(std::ostream&, const Gradient&);

//                                      Predefined colors

extern const HSV HSV_CLEAR;                             // my favorite color ;-)
extern const HSV HSV_BLACK;
extern const HSV HSV_WHITE;
extern const HSV HSV_RED;
extern const HSV HSV_GREEN;
extern const HSV HSV_BLUE;
extern const HSV HSV_CYAN;
extern const HSV HSV_MAGENTA;
extern const HSV HSV_YELLOW;
extern const HSV HSV_GRAY;


enum AnsiColor { ANSI_CLEAR, ANSI_RED, ANSI_GREEN, ANSI_YELLOW, ANSI_BLUE, ANSI_MAGENTA, ANSI_CYAN, ANSI_GRAY };

std::string colorName(AnsiColor);

std::string ansiColorEscape(AnsiColor);

} // namespace
} // namespace

#endif