style.hpp

#pragma once
#include <memory>
#include <ostream>
#include <cairomm/context.h>
namespace creativity { namespace data { namespace graph {

class RGBA final {
    public:
        RGBA() = delete;

        constexpr RGBA(const double &r, const double &g, const double &b, const double &a = 1.0) :
            red  {r < 0 or r > 1 ? throw std::out_of_range("") : r},
            green{g < 0 or g > 1 ? throw std::out_of_range("") : g},
            blue {b < 0 or b > 1 ? throw std::out_of_range("") : b},
            alpha{a < 0 or a > 1 ? throw std::out_of_range("") : a} {}

        explicit constexpr RGBA(const double &i, const double &a = 1.0) : RGBA(i,i,i,a) {}

        RGBA& operator=(const RGBA &copy) { r_(copy.red); g_(copy.green); b_(copy.blue); a_(copy.alpha); return *this; }

        constexpr bool operator==(const RGBA& other) const { return equalsRGB(other) and alpha == other.alpha; }

        constexpr bool operator!=(const RGBA& other) const { return not (*this == other); }

        constexpr bool equalsRGB(const RGBA& other) const { return red == other.red and blue == other.blue and green == other.green; }

        constexpr bool opaque() const { return alpha == 1; }

        constexpr bool transparent() const { return alpha == 0; }

        constexpr operator bool() const { return alpha > 0; }

        RGBA operator*(const RGBA& other) const { return RGBA(*this) *= other; }

        RGBA& operator*=(const RGBA& other) {
            if (other.opaque() or transparent()) *this = other;
            else if (not other.transparent()) {
                double myweight = alpha - alpha*other.alpha;
                double newalpha = other.alpha + myweight;
                r_((myweight*red   + other.alpha*other.red  ) / newalpha);
                g_((myweight*green + other.alpha*other.green) / newalpha);
                b_((myweight*blue  + other.alpha*other.blue ) / newalpha);
                a_(newalpha);
            }
            return *this;
        }

        void applyTo(Cairo::RefPtr<Cairo::Context> ctx) const { ctx->set_source_rgba(red, green, blue, alpha); }

        template <class T, typename = typename std::enable_if<
            std::is_same<double, decltype(T::get_red())>::value and
            std::is_same<double, decltype(T::get_green())>::value and
            std::is_same<double, decltype(T::get_blue())>::value and
            std::is_same<double, decltype(T::get_alpha())>::value>::type>
        RGBA(const T& rgba) : RGBA(rgba.get_red(), rgba.get_blue(), rgba.get_green(), rgba.get_alpha()) {}

        const double red, 
                     green, 
                     blue, 
                     alpha; 

        friend std::ostream& operator<<(std::ostream &os, const RGBA &colour) {
            os << "RGBA(" << colour.red << "," << colour.green << "," << colour.blue << "," << colour.alpha << ")";
            return os;
        }

    private:
        // Private access to set new values.  Values outside [0,1] are truncated.
        void r_(double r) { const_cast<double&>(red)   = r < 0 ? 0 : r > 1 ? 1 : r; }
        void g_(double g) { const_cast<double&>(green) = g < 0 ? 0 : g > 1 ? 1 : g; }
        void b_(double b) { const_cast<double&>(blue)  = b < 0 ? 0 : b > 1 ? 1 : b; }
        void a_(double a) { const_cast<double&>(alpha) = a < 0 ? 0 : a > 1 ? 1 : a; }
};

constexpr RGBA
    Transparent{0, 0}, 
    Black{0}, 
    White{1}; 

class LineStyle {
    public:
        LineStyle(RGBA rgba, double thickness = 1.0, double length = std::numeric_limits<double>::quiet_NaN())
            : colour{std::move(rgba)}, thickness{std::move(thickness)}, length{std::move(length)}
        {}

        void applyTo(Cairo::RefPtr<Cairo::Context> ctx) const { colour.applyTo(ctx); ctx->set_line_width(thickness); }
        RGBA colour;
        double thickness;
        double length;
};

class FillStyle {
    public:
        FillStyle(RGBA fill) : FillStyle(std::move(fill), LineStyle(Transparent, 0)) {};
        FillStyle(RGBA fill, LineStyle border) : fill_colour{std::move(fill)}, border{std::move(border)} {}
        FillStyle(LineStyle border) : FillStyle(Transparent, border) {}
        FillStyle(FillStyle&&) = default;
        FillStyle(const FillStyle&) = default;
        FillStyle& operator=(FillStyle&&) = default;
        FillStyle& operator=(const FillStyle&) = default;

        RGBA fill_colour;

        LineStyle border;
};

class RectangleStyle : public FillStyle {
    public:
        using FillStyle::FillStyle;

        RectangleStyle(RectangleStyle&&) = default;
        RectangleStyle(const RectangleStyle&) = default;
        RectangleStyle& operator=(RectangleStyle&&) = default;
        RectangleStyle& operator=(const RectangleStyle&) = default;

        RectangleStyle(FillStyle f) : FillStyle(std::move(f)) {}

        bool border_top = true, border_right = true, border_bottom = true, border_left = true;

        double borderT() const { return border_top ? border.thickness : 0; }
        double borderR() const { return border_right ? border.thickness : 0; }
        double borderB() const { return border_bottom ? border.thickness : 0; }
        double borderL() const { return border_left ? border.thickness : 0; }
        double borderLR() const { return borderL() + borderR(); }
        double borderTB() const { return borderT() + borderB(); }
};

}}}