Color.h

#ifndef ROSE_Color_H
#define ROSE_Color_H
#include <RoseFirst.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 {
 
enum class Enabled {
    OFF,                                                
    ON,                                                 
    AUTO                                                
};
 
enum class Theme {
    DARK_ON_LIGHT,                                      
    LIGHT_ON_DARK                                       
};
 
struct Colorization {
    Sawyer::Optional<Enabled> enabled;                  
    Sawyer::Optional<Theme> theme;                      
    bool isEnabled() const;
 
    Colorization merge(const Colorization&) const;
};
 
enum class Layer {
    NONE,                                               
    FOREGROUND,                                         
    BACKGROUND                                          
};
 
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) 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) 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);
 
// 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 class AnsiColor {
    CLEAR,                                              
    RED,                                                
    GREEN,                                              
    YELLOW,                                             
    BLUE,                                               
    MAGENTA,                                            
    CYAN,                                               
    GRAY                                                
};
 
std::string colorName(AnsiColor);
 
std::string ansiColorEscape(AnsiColor);
 
} // namespace
} // namespace
 
#endif