vcolor.h

Go to the documentation of this file.

/*
Copyright c1997-2014 Trygve Isaacson. All rights reserved.
This file is part of the Code Vault version 4.1
http://www.bombaydigital.com/
License: MIT. See LICENSE.md in the Vault top level directory.
*/

#ifndef vcolor_h
#define vcolor_h

#include "vtypes.h"

#include "vstring.h"
#include "vbinaryiostream.h"

#ifdef VAULT_QT_SUPPORT
#include <QColor>
#endif

class VSettingsNode;

class VColor {
    public:

        // For clarity and speed, we provide constant accessors for the standard CSS colors.
        // These are the fastest way to use this set of colors, because it can avoid unnecessary
        // construction or copying in some use cases.
        static const VColor& AQUA();
        static const VColor& BLACK();
        static const VColor& BLUE();
        static const VColor& FUCHSIA();
        static const VColor& GREEN();
        static const VColor& GRAY();
        static const VColor& LIME();
        static const VColor& MAROON();
        static const VColor& NAVY();
        static const VColor& OLIVE();
        static const VColor& ORANGE();
        static const VColor& PURPLE();
        static const VColor& RED();
        static const VColor& SILVER();
        static const VColor& TEAL();
        static const VColor& WHITE();
        static const VColor& YELLOW();

        VColor() : mRed(0), mGreen(0), mBlue(0), mAlpha(255) {}
        VColor(int r, int g, int b, int alpha = 255) : mRed(VColor::_constrain(r)), mGreen(VColor::_constrain(g)), mBlue(VColor::_constrain(b)), mAlpha(VColor::_constrain(alpha)) {}
        explicit VColor(const VString& cssColor) : mRed(0), mGreen(0), mBlue(0), mAlpha(255) { this->setCSSColor(cssColor); }
        //explicit VColor(const char* cssColor) : mRed(0), mGreen(0), mBlue(0), mAlpha(255) { this->setCSSColor(cssColor); }
        VColor(VBinaryIOStream& stream) : mRed(0), mGreen(0), mBlue(0), mAlpha(255) { this->readFromStream(stream); }
        ~VColor() {}

#ifdef VAULT_QT_SUPPORT
        explicit VColor(const QColor& c) : mRed(VColor::_constrain(c.red())), mGreen(VColor::_constrain(c.green())), mBlue(VColor::_constrain(c.blue())), mAlpha(VColor::_constrain(c.alpha())) {}
#endif

        void readFromStream(VBinaryIOStream& stream) { this->_setStreamValue(stream.readU32()); }
        void writeToStream(VBinaryIOStream& stream) const { stream.writeU32(this->_getStreamValue()); }

        int getRed() const { return static_cast<int>(mRed); }
        int getGreen() const { return static_cast<int>(mGreen); }
        int getBlue() const { return static_cast<int>(mBlue); }
        int getAlpha() const { return static_cast<int>(mAlpha); }
        VDouble getLightness() const; 
        VString getCSSColor() const;
        void setRed(int val) { mRed = VColor::_constrain(val); }
        void setGreen(int val) { mGreen = VColor::_constrain(val); }
        void setBlue(int val) { mBlue = VColor::_constrain(val); }
        void setAlpha(int val) { mAlpha = VColor::_constrain(val); }
        void setValues(int r, int g, int b, int alpha = 255) { this->setRed(r); this->setGreen(g); this->setBlue(b); this->setAlpha(alpha); }
        void setCSSColor(const VString& cssColor); 

        friend inline bool operator==(const VColor& lhs, const VColor& rhs);  // exact equality
        friend inline bool operator!=(const VColor& lhs, const VColor& rhs);  // exact inequality
        // The < operator is needed for to support STL sort(); others provided for completeness.
        // It would be just as valid, perhaps more so, to sort based on HSV values or something like that.
        friend inline bool operator< (const VColor& lhs, const VColor& rhs);
        friend inline bool operator<=(const VColor& lhs, const VColor& rhs);
        friend inline bool operator>=(const VColor& lhs, const VColor& rhs);
        friend inline bool operator> (const VColor& lhs, const VColor& rhs);

#ifdef VAULT_QT_SUPPORT
        void setQColor(const QColor& c) { this->setValues(c.red(), c.blue(), c.green(), c.alpha()); }
        QColor getQColor() const { return QColor(static_cast<int>(mRed), static_cast<int>(mGreen), static_cast<int>(mBlue), static_cast<int>(mAlpha)); }
#endif

    private:

        static Vu8 _constrain(int val) { return static_cast<Vu8>(V_CONSTRAIN_MINMAX(val, 0, 255)); }
        void _setStreamValue(Vu32 value) { mRed = (Vu8)((value & 0xFF000000) >> 24); mGreen = (Vu8)((value & 0x00FF0000) >> 16); mBlue = (Vu8)((value & 0x0000FF00) >> 8); mAlpha = (Vu8)(value & 0x000000FF); }
        Vu32 _getStreamValue() const { return (mRed << 24) | (mGreen << 16) | (mBlue << 8) | mAlpha; }

        Vu8 mRed;
        Vu8 mGreen;
        Vu8 mBlue;
        Vu8 mAlpha;
};

inline bool operator==(const VColor& lhs, const VColor& rhs) { return lhs.mRed == rhs.mRed && lhs.mGreen == rhs.mGreen && lhs.mBlue == rhs.mBlue && lhs.mAlpha == rhs.mAlpha; }
inline bool operator!=(const VColor& lhs, const VColor& rhs) { return !operator==(lhs, rhs); }
inline bool operator< (const VColor& lhs, const VColor& rhs) { return lhs._getStreamValue() < rhs._getStreamValue(); }
inline bool operator<=(const VColor& lhs, const VColor& rhs) { return !operator>(lhs, rhs); }
inline bool operator>=(const VColor& lhs, const VColor& rhs) { return !operator<(lhs, rhs); }
inline bool operator> (const VColor& lhs, const VColor& rhs) { return  operator<(rhs, lhs); }

// VColorPair -----------------------------------------------------------------

class VColorPair {
    public:

        VColorPair();
        VColorPair(const VColor& bg); // fg set to contrast with bg
        VColorPair(const VColor& bg, const VColor& fg);
        ~VColorPair() {} // non-virtual for space efficiency

        const VColor& getBg() const { return mBg; }
        const VColor& getFg() const { return mFg; }
        const VColor& getColor(bool isBg) const { return isBg ? mBg : mFg; }

        // Mainly for debugging purposes, a string describing the color pair.
        VString getCSSColor() const;

        static VColor generateContrastingForeground(const VColor& bg);
        static VColorPair safeConstructColorPair(const VString& bgCssColor, const VString& fgCssColor);

        friend inline bool operator==(const VColorPair& c1, const VColorPair& c2);  // exact equality
        friend inline bool operator!=(const VColorPair& c1, const VColorPair& c2);  // exact inequality

    private:

        VColor mBg;
        VColor mFg;
};

inline bool operator==(const VColorPair& c1, const VColorPair& c2) { return c1.mBg == c2.mBg && c1.mFg == c2.mFg; }
inline bool operator!=(const VColorPair& c1, const VColorPair& c2) { return c1.mBg != c2.mBg || c1.mFg != c2.mFg; }

// VColorMapper ---------------------------------------------------------------

class VColorMapper {
    public:

        VColorMapper() : mDefaultColors() {}
        virtual ~VColorMapper() {}

        virtual void readColors(const VSettingsNode& mapperNode, VStringVector* errorList);

        virtual VColorPair getColors(const VString& stringValue) const = 0;
        virtual VColorPair getColors(int intValue) const = 0;
        virtual VColorPair getColors(Vs64 int64Value) const = 0;
        virtual VColorPair getColors(VDouble doubleValue) const = 0;

        void setDefaultColors(const VColorPair& defaultColors) { mDefaultColors = defaultColors; }

    protected:

        virtual void _readColorElement(const VSettingsNode& colorNode) = 0; // *Should* throw VException if element is invalid.
        VColorPair _readColorPair(const VSettingsNode& colorNode);

        VColorPair mDefaultColors;
};

// VColorPalette --------------------------------------------------------------

class VSettingsNode;
typedef std::map<VString, VColorMapper*> VColorPaletteMap;

class VColorPalette {
    public:

        VColorPalette();
        VColorPalette(const VSettingsNode& paletteNode, VStringVector* errorList);
        virtual ~VColorPalette();

        const VString& getName() const { return mName; }
        void setName(const VString& name) { mName = name; }

        void adoptColorMapper(const VString& mapperName, VColorMapper* mapper);
        const VColorMapper* findMapper(const VString& mapperName) const;

        VColorPair getColors(const VString& mapperName, const VString& stringValue) const;
        VColorPair getColors(const VString& mapperName, int intValue) const;
        VColorPair getColors(const VString& mapperName, Vs64 int64Value) const;
        VColorPair getColors(const VString& mapperName, VDouble doubleValue) const;

    private:

        void _addMapper(const VSettingsNode& mapperNode, VStringVector* errorList);
        VColorMapper* _readNewMapper(const VString& mapperType, const VSettingsNode& mapperNode, bool usesPrefixMode, VStringVector* errorList);
        void _addMapperNameAliases(VColorMapper* mapper, const VSettingsNode& mapperNode, VStringVector* errorList);

        VString          mName;
        VColorPaletteMap mColorMappers;
        VStringVector    mAliases; // Tracks aliases in use in map so destructor can *safely* clean up.
};

// VStringColorMapper ---------------------------------------------------------

typedef std::map<VString, VColorPair> VStringColorMap;

class VStringColorMapper : public VColorMapper {
    public:

        VStringColorMapper();
        virtual ~VStringColorMapper();

        virtual void readColors(const VSettingsNode& mapperNode, VStringVector* errorList);

        virtual VColorPair getColors(const VString& stringValue) const;
        virtual VColorPair getColors(int intValue) const;
        virtual VColorPair getColors(Vs64 int64Value) const;
        virtual VColorPair getColors(VDouble doubleValue) const;

        void addColors(const VString& stringValue, const VColorPair& colors);

    protected:

        virtual void _readColorElement(const VSettingsNode& colorNode);

    private:

        VStringColorMap mColorMap;
        bool            mCaseSensitive;
};

// VIntegerColorMapper --------------------------------------------------------

typedef std::map<Vs64, VColorPair> VIntegerColorMap;

class VIntegerColorMapper : public VColorMapper {
    public:

        VIntegerColorMapper();
        virtual ~VIntegerColorMapper();

        virtual VColorPair getColors(const VString& stringValue) const;
        virtual VColorPair getColors(int intValue) const;
        virtual VColorPair getColors(Vs64 int64Value) const;
        virtual VColorPair getColors(VDouble doubleValue) const;

        void addColors(Vs64 intValue, const VColorPair& colors);

    protected:

        virtual void _readColorElement(const VSettingsNode& colorNode);

    private:

        VIntegerColorMap    mColorMap;
};

// VDoubleColorMapper ---------------------------------------------------------

class VDoubleColorMapper : public VColorMapper {
    public:

        VDoubleColorMapper();
        virtual ~VDoubleColorMapper();

        virtual VColorPair getColors(const VString& stringValue) const;
        virtual VColorPair getColors(int intValue) const;
        virtual VColorPair getColors(Vs64 int64Value) const;
        virtual VColorPair getColors(VDouble doubleValue) const;

        void addColors(VDouble doubleValue, const VColorPair& rangeColors);

    protected:

        virtual void _readColorElement(const VSettingsNode& colorNode);

    private:

        VStringColorMap mColorMap;
};

// VStringRangeColorMapper --------------------------------------------------------

class VStringRangeColorElement {
    public:

        VStringRangeColorElement(const VString& rangeMin, const VColorPair& colors) :
            mRangeMin(rangeMin), mColors(colors) {}
        ~VStringRangeColorElement() {}

        VString mRangeMin;
        VColorPair mColors;

        // Required to allow STL to sort objects of this class:
        friend inline bool operator<(const VStringRangeColorElement& e1, const VStringRangeColorElement& e2);
};

inline bool operator<(const VStringRangeColorElement& e1, const VStringRangeColorElement& e2) { return e1.mRangeMin < e2.mRangeMin; }

typedef std::vector<VStringRangeColorElement> VStringRangeVector;

class VStringRangeColorMapper : public VColorMapper {
    public:

        VStringRangeColorMapper(bool usesPrefixMode);
        virtual ~VStringRangeColorMapper();

        virtual void readColors(const VSettingsNode& mapperNode, VStringVector* errorList);

        virtual VColorPair getColors(const VString& stringValue) const;
        virtual VColorPair getColors(int intValue) const;
        virtual VColorPair getColors(Vs64 int64Value) const;
        virtual VColorPair getColors(VDouble doubleValue) const;

        void addColors(const VString& rangeMin, const VColorPair& rangeColors);

    protected:

        virtual void _readColorElement(const VSettingsNode& colorNode);

    private:

        VColorPair _getColorsWithPrefixModeCheck(const VColorPair& foundColors) const;

        VStringRangeVector mColorRanges;
        bool               mCaseSensitive;
        bool               mUsesPrefixMode;

        friend class VColorUnit;
};

// VIntegerRangeColorMapper --------------------------------------------------------

class VIntegerRangeColorElement {
    public:

        VIntegerRangeColorElement(Vs64 rangeMin, const VColorPair& colors) :
            mRangeMin(rangeMin), mColors(colors) {}
        ~VIntegerRangeColorElement() {}

        Vs64 mRangeMin;
        VColorPair mColors;

        // Required to allow STL to sort objects of this class:
        friend inline bool operator<(const VIntegerRangeColorElement& e1, const VIntegerRangeColorElement& e2);
};

inline bool operator<(const VIntegerRangeColorElement& e1, const VIntegerRangeColorElement& e2) { return e1.mRangeMin < e2.mRangeMin; }

typedef std::vector<VIntegerRangeColorElement> VIntegerRangeVector;

class VIntegerRangeColorMapper : public VColorMapper {
    public:

        VIntegerRangeColorMapper();
        virtual ~VIntegerRangeColorMapper();

        virtual VColorPair getColors(const VString& stringValue) const;
        virtual VColorPair getColors(int intValue) const;
        virtual VColorPair getColors(Vs64 int64Value) const;
        virtual VColorPair getColors(VDouble doubleValue) const;

        void addColors(Vs64 rangeMin, const VColorPair& rangeColors);

    protected:

        virtual void _readColorElement(const VSettingsNode& colorNode);

    private:

        VIntegerRangeVector mColorRanges;

        friend class VColorUnit;
};

// VDoubleRangeColorMapper --------------------------------------------------------

class VDoubleRangeColorElement {
    public:

        VDoubleRangeColorElement(VDouble rangeMin, const VColorPair& colors) :
            mRangeMin(rangeMin), mColors(colors) {}
        ~VDoubleRangeColorElement() {}

        VDouble mRangeMin;
        VColorPair mColors;

        // Required to allow STL to sort objects of this class:
        friend inline bool operator<(const VDoubleRangeColorElement& e1, const VDoubleRangeColorElement& e2);
};

inline bool operator<(const VDoubleRangeColorElement& e1, const VDoubleRangeColorElement& e2) { return e1.mRangeMin < e2.mRangeMin; }

typedef std::vector<VDoubleRangeColorElement> VDoubleRangeVector;

class VDoubleRangeColorMapper : public VColorMapper {
    public:

        VDoubleRangeColorMapper();
        virtual ~VDoubleRangeColorMapper();

        virtual VColorPair getColors(const VString& stringValue) const;
        virtual VColorPair getColors(int intValue) const;
        virtual VColorPair getColors(Vs64 int64Value) const;
        virtual VColorPair getColors(VDouble doubleValue) const;

        void addColors(VDouble rangeMin, const VColorPair& rangeColors);

    protected:

        virtual void _readColorElement(const VSettingsNode& colorNode);

    private:

        VDoubleRangeVector mColorRanges;

        friend class VColorUnit;
};

#endif /* vcolor_h */